// AUTO-GENERATED by script/emit_dts.clj from registry.edn.
// Do not edit by hand. Run `bb gen:dts` to regenerate.

export interface Geometry {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Geometry';

  /**
   * The minimum number of vertices allowed in a valid non-empty ring.
   * Empty rings with 0 vertices are also valid.
   *
   * @see [org.locationtech.jts.geom.LinearRing.MINIMUM_VALID_SIZE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LinearRing.html#MINIMUM_VALID_SIZE)
   */
  MINIMUM_VALID_SIZE: number;
  /**
   * Performs an operation with or on this `Geometry`'s
   * coordinates.
   * If this method modifies any coordinate values,
   * `geometryChanged` must be called to update the geometry state.
   * Note that you cannot use this method to
   * modify this Geometry if its underlying CoordinateSequence's #get method
   * returns a copy of the Coordinate, rather than the actual Coordinate stored
   * (if it even stores Coordinate objects at all).
   *
   * @param filter - the filter to apply to this `Geometry`'s coordinates
   * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.CoordinateFilter-)
   */
  apply(filter: any /* org.locationtech.jts.geom.CoordinateFilter */): any /* void */;
  /**
   * Performs an operation on the coordinates in this `Geometry`'s
   * `CoordinateSequence`s.
   * If the filter reports that a coordinate value has been changed,
   * `geometryChanged` will be called automatically.
   *
   * @param filter - the filter to apply
   * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.CoordinateSequenceFilter-)
   */
  apply(filter: any /* org.locationtech.jts.geom.CoordinateSequenceFilter */): any /* void */;
  /**
   * Performs an operation with or on this Geometry and its
   * component Geometry's.  Only GeometryCollections and
   * Polygons have component Geometry's; for Polygons they are the LinearRings
   * of the shell and holes.
   *
   * @param filter - the filter to apply to this `Geometry`.
   * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.GeometryComponentFilter-)
   */
  apply(filter: any /* org.locationtech.jts.geom.GeometryComponentFilter */): any /* void */;
  /**
   * Performs an operation with or on this `Geometry` and its
   * subelement `Geometry`s (if any).
   * Only GeometryCollections and subclasses
   * have subelement Geometry's.
   *
   * @param filter - the filter to apply to this `Geometry` (and its children, if it is a `GeometryCollection`).
   * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.GeometryFilter-)
   */
  apply(filter: any /* org.locationtech.jts.geom.GeometryFilter */): any /* void */;
  /**
   * Computes a buffer area around this geometry having the given width. The
   * buffer of a Geometry is the Minkowski sum or difference of the geometry
   * with a disc of radius `abs(distance)`.
   *
   * Mathematically-exact buffer area boundaries can contain circular arcs.
   * To represent these arcs using linear geometry they must be approximated with line segments.
   * The buffer geometry is constructed using 8 segments per quadrant to approximate
   * the circular arcs.
   * The end cap style is `CAP_ROUND`.
   *
   * The buffer operation always returns a polygonal result. The negative or
   * zero-distance buffer of lines and points is always an empty `Polygon`.
   * This is also the result for the buffers of degenerate (zero-area) polygons.
   *
   * @param distance - the width of the buffer (may be positive, negative or 0)
   * @returns a polygonal geometry representing the buffer region (which may be empty)
   * @throws TopologyException if a robustness error occurs
   * @see [org.locationtech.jts.geom.Geometry.buffer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#buffer-double-)
   */
  buffer(distance: number): Geometry;
  /**
   * Returns whether this `Geometry` is greater than, equal to,
   * or less than another `Geometry`.
   *
   * If their classes are different, they are compared using the following
   * ordering:
   *
   * - Point (lowest)
   * - MultiPoint
   * - LineString
   * - LinearRing
   * - MultiLineString
   * - Polygon
   * - MultiPolygon
   * - GeometryCollection (highest)
   *
   * If the two `Geometry`s have the same class, their first
   * elements are compared. If those are the same, the second elements are
   * compared, etc.
   *
   * @param o - a `Geometry` with which to compare this `Geometry`
   * @returns a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications
   * @see [org.locationtech.jts.geom.Geometry.compareTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#compareTo-java.lang.Object-)
   */
  compareTo(o: any /* java.lang.Object */): number;
  /**
   * Tests whether this geometry contains the
   * argument geometry.
   *
   * The `contains` predicate has the following equivalent definitions:
   *
   * - Every point of the other geometry is a point of this geometry,
   * and the interiors of the two geometries have at least one point in common.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * the pattern
   * `[T*****FF*]`
   * - `g.within(this) = true`
   *
   * (`contains` is the converse of `within` )
   *
   * An implication of the definition is that "Geometries do not
   * contain their boundary".  In other words, if a geometry A is a subset of
   * the points in the boundary of a geometry B, `B.contains(A) = false`.
   * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
   * For a predicate with similar behaviour but avoiding
   * this subtle limitation, see `covers`.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if this `Geometry` contains `g`
   * @see [org.locationtech.jts.geom.Geometry.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#contains-org.locationtech.jts.geom.Geometry-)
   */
  contains(g: Geometry): boolean;
  /**
   * Computes the smallest convex `Polygon` that contains all the
   * points in the `Geometry`. This obviously applies only to `Geometry`
   * s which contain 3 or more points; the results for degenerate cases are
   * specified as follows:
   *
   * | Number of `Point`s in argument `Geometry` | `Geometry` class of result |
   * | --- | --- |
   * | 0 | empty `GeometryCollection` |
   * | 1 | `Point` |
   * | 2 | `LineString` |
   * | 3 or more | `Polygon` |
   *
   * @returns the minimum-area convex polygon containing this `Geometry`' s points
   * @see [org.locationtech.jts.geom.Geometry.convexHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#convexHull--)
   */
  convexHull(): Geometry;
  /**
   * Creates a deep copy of this `Geometry` object.
   * Coordinate sequences contained in it are copied.
   * All instance fields are copied
   * (i.e. `envelope`, `SRID` and `userData`).
   *
   * **NOTE:** the userData object reference (if present) is copied,
   * but the value itself is not copied.
   * If a deep copy is required this must be performed by the caller.
   *
   * @returns a deep copy of this geometry
   * @see [org.locationtech.jts.geom.Geometry.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#copy--)
   */
  copy(): Geometry;
  /**
   * Tests whether this geometry is covered by the
   * argument geometry.
   *
   * The `coveredBy` predicate has the following equivalent definitions:
   *
   * - Every point of this geometry is a point of the other geometry.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * at least one of the following patterns:
   *
   * - `[T*F**F***]`
   * - `[*TF**F***]`
   * - `[**FT*F***]`
   * - `[**F*TF***]`
   *
   * - `g.covers(this) = true`
   *
   * (`coveredBy` is the converse of `covers`)
   *
   * If either geometry is empty, the value of this predicate is `false`.
   *
   * This predicate is similar to `within`,
   * but is more inclusive (i.e. returns `true` for more cases).
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if this `Geometry` is covered by `g`
   * @see [org.locationtech.jts.geom.Geometry.coveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#coveredBy-org.locationtech.jts.geom.Geometry-)
   */
  coveredBy(g: Geometry): boolean;
  /**
   * Tests whether this geometry covers the
   * argument geometry.
   *
   * The `covers` predicate has the following equivalent definitions:
   *
   * - Every point of the other geometry is a point of this geometry.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * at least one of the following patterns:
   *
   * - `[T*****FF*]`
   * - `[*T****FF*]`
   * - `[***T**FF*]`
   * - `[****T*FF*]`
   *
   * - `g.coveredBy(this) = true`
   *
   * (`covers` is the converse of `coveredBy`)
   *
   * If either geometry is empty, the value of this predicate is `false`.
   *
   * This predicate is similar to `contains`,
   * but is more inclusive (i.e. returns `true` for more cases).
   * In particular, unlike `contains` it does not distinguish between
   * points in the boundary and in the interior of geometries.
   * For most situations, `covers` should be used in preference to `contains`.
   * As an added benefit, `covers` is more amenable to optimization,
   * and hence should be more performant.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if this `Geometry` covers `g`
   * @see [org.locationtech.jts.geom.Geometry.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#covers-org.locationtech.jts.geom.Geometry-)
   */
  covers(g: Geometry): boolean;
  /**
   * Tests whether this geometry crosses the
   * argument geometry.
   *
   * The `crosses` predicate has the following equivalent definitions:
   *
   * - The geometries have some but not all interior points in common.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * one of the following patterns:
   *
   * - `[T*T******]` (for P/L, P/A, and L/A situations)
   * - `[T*****T**]` (for L/P, A/P, and A/L situations)
   * - `[0********]` (for L/L situations)
   *
   * For the A/A and P/P situations this predicate returns `false`.
   *
   * The SFS defined this predicate only for P/L, P/A, L/L, and L/A situations.
   * To make the relation symmetric
   * JTS extends the definition to apply to L/P, A/P and A/L situations as well.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s cross.
   * @see [org.locationtech.jts.geom.Geometry.crosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#crosses-org.locationtech.jts.geom.Geometry-)
   */
  crosses(g: Geometry): boolean;
  /**
   * Computes a `Geometry` representing the closure of the point-set
   * of the points contained in this `Geometry` that are not contained in
   * the `other` Geometry.
   *
   * If the result is empty, it is an atomic geometry
   * with the dimension of the left-hand input.
   *
   * Non-empty `GeometryCollection` arguments are not supported.
   *
   * @param other - the `Geometry` with which to compute the difference
   * @returns a Geometry representing the point-set difference of this `Geometry` with `other`
   * @throws TopologyException if a robustness error occurs
   * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
   * @see [org.locationtech.jts.geom.Geometry.difference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#difference-org.locationtech.jts.geom.Geometry-)
   */
  difference(other: Geometry): Geometry;
  /**
   * Tests whether this geometry is disjoint from the argument geometry.
   *
   * The `disjoint` predicate has the following equivalent definitions:
   *
   * - The two geometries have no point in common
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * `[FF*FF****]`
   * - `! g.intersects(this) = true`
   *
   * (`disjoint` is the inverse of `intersects`)
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s are disjoint
   * @see [org.locationtech.jts.geom.Geometry.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#disjoint-org.locationtech.jts.geom.Geometry-)
   */
  disjoint(g: Geometry): boolean;
  /**
   * Returns the minimum distance between this `Geometry`
   * and another `Geometry`.
   *
   * @param g - the `Geometry` from which to compute the distance
   * @returns the distance between the geometries
   * @throws IllegalArgumentException if g is null
   * @see [org.locationtech.jts.geom.Geometry.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#distance-org.locationtech.jts.geom.Geometry-)
   */
  distance(g: Geometry): number;
  /**
   * Tests whether this geometry is
   * topologically equal to the argument geometry.
   *
   * This method is included for backward compatibility reasons.
   * It has been superseded by the `equalsTopo` method,
   * which has been named to clearly denote its functionality.
   *
   * This method should NOT be confused with the method
   * `equals`, which implements
   * an exact equality comparison.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns true if the two `Geometry`s are topologically equal
   * @see [org.locationtech.jts.geom.Geometry.equals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equals-org.locationtech.jts.geom.Geometry-)
   */
  equals(g: Geometry): boolean;
  /**
   * Returns true if the two `Geometry`s are exactly equal,
   * up to a specified distance tolerance.
   * Two Geometries are exactly equal within a distance tolerance
   * if and only if:
   *
   * - they have the same structure
   * - they have the same values for their vertices,
   * within the given tolerance distance, in exactly the same order.
   *
   * This method does _not_
   * test the values of the `GeometryFactory`, the `SRID`,
   * or the `userData` fields.
   *
   * To properly test equality between different geometries,
   * it is usually necessary to `normalize` them first.
   *
   * @param other - the `Geometry` with which to compare this `Geometry`
   * @param tolerance - distance at or below which two `Coordinate`s are considered equal
   * @returns `true` if this and the other `Geometry` have identical structure and point values, up to the distance tolerance.
   * @see [org.locationtech.jts.geom.Geometry.equalsExact](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsExact-org.locationtech.jts.geom.Geometry-double-)
   */
  equalsExact(other: Geometry, tolerance: number): boolean;
  /**
   * Tests whether two geometries are exactly equal
   * in their normalized forms.
   * This is a convenience method which creates normalized
   * versions of both geometries before computing
   * `equalsExact`.
   *
   * This method is relatively expensive to compute.
   * For maximum performance, the client
   * should instead perform normalization on the individual geometries
   * at an appropriate point during processing.
   *
   * @param g - a Geometry
   * @returns true if the input geometries are exactly equal in their normalized form
   * @see [org.locationtech.jts.geom.Geometry.equalsNorm](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsNorm-org.locationtech.jts.geom.Geometry-)
   */
  equalsNorm(g: Geometry): boolean;
  /**
   * Tests whether this geometry is topologically equal to the argument geometry
   * as defined by the SFS `equals` predicate.
   *
   * The SFS `equals` predicate has the following equivalent definitions:
   *
   * - The two geometries have at least one point in common,
   * and no point of either geometry lies in the exterior of the other geometry.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * the pattern `T*F**FFF*`
   *
   * ```
   * T*F
   * **F
   * FF*
   * ```
   *
   * **Note** that this method computes **topologically equality**.
   * For structural equality, see `equalsExact`.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s are topologically equal
   * @see [org.locationtech.jts.geom.Geometry.equalsTopo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsTopo-org.locationtech.jts.geom.Geometry-)
   */
  equalsTopo(g: Geometry): boolean;
  /**
   * Notifies this geometry that its coordinates have been changed by an external
   * party (for example, via a `CoordinateFilter`).
   * When this method is called the geometry will flush
   * and/or update any derived information it has cached (such as its `Envelope` ).
   * The operation is applied to all component Geometries.
   *
   * @see [org.locationtech.jts.geom.Geometry.geometryChanged](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#geometryChanged--)
   */
  geometryChanged(): any /* void */;
  /**
   * Returns the area of this `Geometry`.
   * Areal Geometries have a non-zero area.
   * They override this function to compute the area.
   * Others return 0.0
   *
   * @returns the area of the Geometry
   * @see [org.locationtech.jts.geom.Geometry.getArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getArea--)
   */
  getArea(): number;
  /**
   * Returns the boundary, or an empty geometry of appropriate dimension
   * if this `Geometry`  is empty.
   * (In the case of zero-dimensional geometries, '
   * an empty GeometryCollection is returned.)
   * For a discussion of this function, see the OpenGIS Simple
   * Features Specification. As stated in SFS Section 2.1.13.1, "the boundary
   * of a Geometry is a set of Geometries of the next lower dimension."
   *
   * @returns the closure of the combinatorial boundary of this `Geometry`
   * @see [org.locationtech.jts.geom.Geometry.getBoundary](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getBoundary--)
   */
  getBoundary(): Geometry;
  /**
   * Returns the dimension of this `Geometry`s inherent boundary.
   *
   * @returns the dimension of the boundary of the class implementing this interface, whether or not this object is the empty geometry. Returns `Dimension.FALSE` if the boundary is the empty geometry.
   * @see [org.locationtech.jts.geom.Geometry.getBoundaryDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getBoundaryDimension--)
   */
  getBoundaryDimension(): number;
  /**
   * Computes the centroid of this `Geometry`.
   * The centroid
   * is equal to the centroid of the set of component Geometries of highest
   * dimension (since the lower-dimension geometries contribute zero
   * "weight" to the centroid).
   *
   * The centroid of an empty geometry is `POINT EMPTY`.
   *
   * @returns a `Point` which is the centroid of this Geometry
   * @see [org.locationtech.jts.geom.Geometry.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getCentroid--)
   */
  getCentroid(): Geometry;
  /**
   * Returns a vertex of this geometry
   * (usually, but not necessarily, the first one),
   * or `null` if the geometry is empty.
   * The returned coordinate should not be assumed
   * to be an actual `Coordinate` object used in
   * the internal representation.
   *
   * @returns a coordinate which is a vertex of this `Geometry`.
   * @see [org.locationtech.jts.geom.Geometry.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getCoordinate--)
   */
  getCoordinate(): Coordinate;
  getCoordinateN(n: number): Coordinate;
  getCoordinateSequence(): CoordinateSequence;
  /**
   * Returns an array containing the values of all the vertices for
   * this geometry.
   * If the geometry is a composite, the array will contain all the vertices
   * for the components, in the order in which the components occur in the geometry.
   *
   * In general, the array cannot be assumed to be the actual internal
   * storage for the vertices.  Thus modifying the array
   * may not modify the geometry itself.
   * Use the `CoordinateSequence.setOrdinate` method
   * (possibly on the components) to modify the underlying data.
   * If the coordinates are modified,
   * `geometryChanged` must be called afterwards.
   *
   * @returns the vertices of this `Geometry`
   * @see [org.locationtech.jts.geom.Geometry.getCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getCoordinates--)
   */
  getCoordinates(): Coordinate[];
  /**
   * Returns the dimension of this geometry.
   * The dimension of a geometry is is the topological
   * dimension of its embedding in the 2-D Euclidean plane.
   * In the JTS spatial model, dimension values are in the set {0,1,2}.
   *
   * Note that this is a different concept to the dimension of
   * the vertex `Coordinate`s.
   * The geometry dimension can never be greater than the coordinate dimension.
   * For example, a 0-dimensional geometry (e.g. a Point)
   * may have a coordinate dimension of 3 (X,Y,Z).
   *
   * @returns the topological dimension of this geometry.
   * @see [org.locationtech.jts.geom.Geometry.getDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getDimension--)
   */
  getDimension(): number;
  getEndPoint(): Geometry;
  /**
   * Gets a Geometry representing the envelope (bounding box) of
   * this `Geometry`.
   *
   * If this `Geometry` is:
   *
   * - empty, returns an empty `Point`.
   * - a point, returns a `Point`.
   * - a line parallel to an axis, a two-vertex `LineString`
   * - otherwise, returns a
   * `Polygon` whose vertices are (minx miny, minx maxy,
   * maxx maxy, maxx miny, minx miny).
   *
   * @returns a Geometry representing the envelope of this Geometry
   * @see [org.locationtech.jts.geom.Geometry.getEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getEnvelope--)
   */
  getEnvelope(): Geometry;
  /**
   * Gets an `Envelope` containing
   * the minimum and maximum x and y values in this `Geometry`.
   * If the geometry is empty, an empty `Envelope`
   * is returned.
   *
   * The returned object is a copy of the one maintained internally,
   * to avoid aliasing issues.
   * For best performance, clients which access this
   * envelope frequently should cache the return value.
   *
   * @returns the envelope of this `Geometry`.
   * @see [org.locationtech.jts.geom.Geometry.getEnvelopeInternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getEnvelopeInternal--)
   */
  getEnvelopeInternal(): Envelope;
  getExteriorRing(): Geometry;
  /**
   * Gets the factory which contains the context in which this geometry was created.
   *
   * @returns the factory for this geometry
   * @see [org.locationtech.jts.geom.Geometry.getFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getFactory--)
   */
  getFactory(): any /* org.locationtech.jts.geom.GeometryFactory */;
  /**
   * Returns an element `Geometry` from a `GeometryCollection`
   * (or `this`, if the geometry is not a collection).
   *
   * @param n - the index of the geometry element
   * @returns the n'th geometry contained in this geometry
   * @see [org.locationtech.jts.geom.Geometry.getGeometryN](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getGeometryN-int-)
   */
  getGeometryN(n: number): Geometry;
  /**
   * Returns the name of this Geometry's actual class.
   *
   * @returns the name of this `Geometry`s actual class
   * @see [org.locationtech.jts.geom.Geometry.getGeometryType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getGeometryType--)
   */
  getGeometryType(): string;
  /**
   * Computes an interior point of this `Geometry`.
   * An interior point is guaranteed to lie in the interior of the Geometry,
   * if it possible to calculate such a point exactly. Otherwise,
   * the point may lie on the boundary of the geometry.
   *
   * The interior point of an empty geometry is `POINT EMPTY`.
   *
   * @returns a `Point` which is in the interior of this Geometry
   * @see [org.locationtech.jts.geom.Geometry.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getInteriorPoint--)
   */
  getInteriorPoint(): Geometry;
  getInteriorRingN(n: number): Geometry;
  /**
   * Returns the length of this `Geometry`.
   * Linear geometries return their length.
   * Areal geometries return their perimeter.
   * They override this function to compute the area.
   * Others return 0.0
   *
   * @returns the length of the Geometry
   * @see [org.locationtech.jts.geom.Geometry.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getLength--)
   */
  getLength(): number;
  /**
   * Returns the number of `Geometry`s in a `GeometryCollection`
   * (or 1, if the geometry is not a collection).
   *
   * @returns the number of geometries contained in this geometry
   * @see [org.locationtech.jts.geom.Geometry.getNumGeometries](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getNumGeometries--)
   */
  getNumGeometries(): number;
  getNumInteriorRing(): number;
  /**
   * Returns the count of this `Geometry`s vertices. The `Geometry`
   * s contained by composite `Geometry`s must be
   * Geometry's; that is, they must implement `getNumPoints`
   *
   * @returns the number of vertices in this `Geometry`
   * @see [org.locationtech.jts.geom.Geometry.getNumPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getNumPoints--)
   */
  getNumPoints(): number;
  getPointN(n: number): Geometry;
  /**
   * Returns the `PrecisionModel` used by the `Geometry`.
   *
   * @returns the specification of the grid of allowable points, for this `Geometry` and all other `Geometry`s
   * @see [org.locationtech.jts.geom.Geometry.getPrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getPrecisionModel--)
   */
  getPrecisionModel(): PrecisionModel;
  /**
   * Returns the ID of the Spatial Reference System used by the `Geometry`.
   *
   * JTS supports Spatial Reference System information in the simple way
   * defined in the SFS. A Spatial Reference System ID (SRID) is present in
   * each `Geometry` object. `Geometry` provides basic
   * accessor operations for this field, but no others. The SRID is represented
   * as an integer.
   *
   * @returns the ID of the coordinate space in which the `Geometry` is defined.
   * @see [org.locationtech.jts.geom.Geometry.getSRID](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getSRID--)
   */
  getSRID(): number;
  getStartPoint(): Geometry;
  /**
   * Gets the user data object for this geometry, if any.
   *
   * @returns the user data object, or `null` if none set
   * @see [org.locationtech.jts.geom.Geometry.getUserData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getUserData--)
   */
  getUserData(): any /* java.lang.Object */;
  getX(): number;
  getY(): number;
  /**
   * Tests whether an atomic geometry or any element of a collection
   * has the specified dimension.
   * In particular, this can be used with mixed-dimension `GeometryCollection`s
   * to test if they contain an element of the specified dimension.
   *
   * @param dim - the dimension to test
   * @returns true if the geometry has or contains an element with the dimension
   * @see [org.locationtech.jts.geom.Geometry.hasDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#hasDimension-int-)
   */
  hasDimension(dim: number): boolean;
  /**
   * Computes a `Geometry` representing the point-set which is
   * common to both this `Geometry` and the `other` Geometry.
   *
   * The intersection of two geometries of different dimension produces a result
   * geometry of dimension less than or equal to the minimum dimension of the input
   * geometries.
   * The result geometry may be a heterogeneous `GeometryCollection`.
   * If the result is empty, it is an atomic geometry
   * with the dimension of the lowest input dimension.
   *
   * Intersection of `GeometryCollection`s is supported
   * only for homogeneous collection types.
   *
   * Non-empty heterogeneous `GeometryCollection` arguments are not supported.
   *
   * @param other - the `Geometry` with which to compute the intersection
   * @returns a Geometry representing the point-set common to the two `Geometry`s
   * @throws TopologyException if a robustness error occurs
   * @throws IllegalArgumentException if the argument is a non-empty heterogeneous `GeometryCollection`
   * @see [org.locationtech.jts.geom.Geometry.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#intersection-org.locationtech.jts.geom.Geometry-)
   */
  intersection(other: Geometry): Geometry;
  /**
   * Tests whether this geometry intersects the argument geometry.
   *
   * The `intersects` predicate has the following equivalent definitions:
   *
   * - The two geometries have at least one point in common
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * at least one of the patterns
   *
   * - `[T********]`
   * - `[*T*******]`
   * - `[***T*****]`
   * - `[****T****]`
   *
   * - `! g.disjoint(this) = true`
   *
   * (`intersects` is the inverse of `disjoint`)
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s intersect
   * @see [org.locationtech.jts.geom.Geometry.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#intersects-org.locationtech.jts.geom.Geometry-)
   */
  intersects(g: Geometry): boolean;
  isClosed(): boolean;
  /**
   * Returns true if the given point is a vertex of this `LineString`.
   *
   * @param pt - the `Coordinate` to check
   * @returns `true` if `pt` is one of this `LineString` 's vertices
   * @see [org.locationtech.jts.geom.LineString.isCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineString.html#isCoordinate-org.locationtech.jts.geom.Coordinate-)
   */
  isCoordinate(pt: Coordinate): boolean;
  /**
   * Tests whether the set of points covered by this `Geometry` is
   * empty.
   *
   * Note this test is for topological emptiness,
   * not structural emptiness.
   * A collection containing only empty elements is reported as empty.
   * To check structural emptiness use `getNumGeometries`.
   *
   * @returns `true` if this `Geometry` does not cover any points
   * @see [org.locationtech.jts.geom.Geometry.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isEmpty--)
   */
  isEmpty(): boolean;
  /**
   * Tests whether this is a rectangular `Polygon`.
   *
   * @returns true if the geometry is a rectangle.
   * @see [org.locationtech.jts.geom.Geometry.isRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isRectangle--)
   */
  isRectangle(): boolean;
  isRing(): boolean;
  /**
   * Tests whether this `Geometry` is simple.
   * The SFS definition of simplicity
   * follows the general rule that a Geometry is simple if it has no points of
   * self-tangency, self-intersection or other anomalous points.
   *
   * Simplicity is defined for each `Geometry` subclass as follows:
   *
   * - Valid polygonal geometries are simple, since their rings
   * must not self-intersect.  `isSimple`
   * tests for this condition and reports `false` if it is not met.
   * (This is a looser test than checking for validity).
   * - Linear rings have the same semantics.
   * - Linear geometries are simple if they do not self-intersect at points
   * other than boundary points.
   * - Zero-dimensional geometries (points) are simple if they have no
   * repeated points.
   * - Empty `Geometry`s are always simple.
   *
   * @returns `true` if this `Geometry` is simple
   * @see [org.locationtech.jts.geom.Geometry.isSimple](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isSimple--)
   */
  isSimple(): boolean;
  /**
   * Tests whether this `Geometry`
   * is topologically valid, according to the OGC SFS specification.
   *
   * For validity rules see the Javadoc for the specific Geometry subclass.
   *
   * @returns `true` if this `Geometry` is valid
   * @see [org.locationtech.jts.geom.Geometry.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isValid--)
   */
  isValid(): boolean;
  /**
   * Tests whether the distance from this `Geometry`
   * to another is less than or equal to a specified value.
   *
   * @param geom - the Geometry to check the distance to
   * @param distance - the distance value to compare
   * @returns `true` if the geometries are less than `distance` apart.
   * @see [org.locationtech.jts.geom.Geometry.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isWithinDistance-org.locationtech.jts.geom.Geometry-double-)
   */
  isWithinDistance(geom: Geometry, distance: number): boolean;
  /**
   * Creates a new Geometry which is a normalized
   * copy of this Geometry.
   *
   * @returns a normalized copy of this geometry.
   * @see [org.locationtech.jts.geom.Geometry.norm](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#norm--)
   */
  norm(): Geometry;
  /**
   * Converts this `Geometry` to **normal form** (or **canonical form** ). Normal form is a unique representation for `Geometry`
   * s. It can be used to test whether two `Geometry`s are equal
   * in a way that is independent of the ordering of the coordinates within
   * them. Normal form equality is a stronger condition than topological
   * equality, but weaker than pointwise equality. The definitions for normal
   * form use the standard lexicographical ordering for coordinates. "Sorted in
   * order of coordinates" means the obvious extension of this ordering to
   * sequences of coordinates.
   *
   * NOTE that this method mutates the value of this geometry in-place.
   * If this is not safe and/or wanted, the geometry should be
   * cloned prior to normalization.
   *
   * @see [org.locationtech.jts.geom.Geometry.normalize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#normalize--)
   */
  normalize(): any /* void */;
  /**
   * Tests whether this geometry overlaps the
   * specified geometry.
   *
   * The `overlaps` predicate has the following equivalent definitions:
   *
   * - The geometries have at least one point each not shared by the other
   * (or equivalently neither covers the other),
   * they have the same dimension,
   * and the intersection of the interiors of the two geometries has
   * the same dimension as the geometries themselves.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * `[T*T***T**]` (for two points or two surfaces)
   * or `[1*T***T**]` (for two curves)
   *
   * If the geometries are of different dimension this predicate returns `false`.
   * This predicate is symmetric.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s overlap.
   * @see [org.locationtech.jts.geom.Geometry.overlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#overlaps-org.locationtech.jts.geom.Geometry-)
   */
  overlaps(g: Geometry): boolean;
  /**
   * Returns the DE-9IM `IntersectionMatrix` for the two `Geometry`s.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns an `IntersectionMatrix` describing the intersections of the interiors, boundaries and exteriors of the two `Geometry`s
   * @see [org.locationtech.jts.geom.Geometry.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#relate-org.locationtech.jts.geom.Geometry-)
   */
  relate(g: Geometry): IntersectionMatrix;
  /**
   * Tests whether the elements in the DE-9IM
   * `IntersectionMatrix` for the two `Geometry`s match the elements in `intersectionPattern`.
   * The pattern is a 9-character string, with symbols drawn from the following set:
   *
   * - 0 (dimension 0)
   * - 1 (dimension 1)
   * - 2 (dimension 2)
   * - T ( matches 0, 1 or 2)
   * - F ( matches FALSE)
   * - * ( matches any value)
   *
   * For more information on the DE-9IM, see the _OpenGIS Simple Features
   * Specification_.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @param intersectionPattern - the pattern against which to check the intersection matrix for the two `Geometry`s
   * @returns `true` if the DE-9IM intersection matrix for the two `Geometry`s match `intersectionPattern`
   * @see [org.locationtech.jts.geom.Geometry.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#relate-org.locationtech.jts.geom.Geometry-java.lang.String-)
   */
  relate(g: Geometry, intersectionPattern: string): boolean;
  /**
   * Computes a new geometry which has all component coordinate sequences
   * in reverse order (opposite orientation) to this one.
   *
   * @returns a reversed geometry
   * @see [org.locationtech.jts.geom.Geometry.reverse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#reverse--)
   */
  reverse(): Geometry;
  /**
   * Sets the ID of the Spatial Reference System used by the `Geometry`.
   *
   * **NOTE:** This method should only be used for exceptional circumstances or
   * for backwards compatibility.  Normally the SRID should be set on the
   * `GeometryFactory` used to create the geometry.
   * SRIDs set using this method will _not_ be propagated to
   * geometries returned by constructive methods.
   *
   * @see [org.locationtech.jts.geom.Geometry.setSRID](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#setSRID-int-)
   */
  setSRID(SRID: number): any /* void */;
  /**
   * A simple scheme for applications to add their own custom data to a Geometry.
   * An example use might be to add an object representing a Coordinate Reference System.
   *
   * Note that user data objects are not present in geometries created by
   * construction methods.
   *
   * @param userData - an object, the semantics for which are defined by the application using this Geometry
   * @see [org.locationtech.jts.geom.Geometry.setUserData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#setUserData-java.lang.Object-)
   */
  setUserData(userData: any /* java.lang.Object */): any /* void */;
  /**
   * Computes a `Geometry` representing the closure of the point-set
   * which is the union of the points in this `Geometry` which are not
   * contained in the `other` Geometry,
   * with the points in the `other` Geometry not contained in this
   * `Geometry`.
   * If the result is empty, it is an atomic geometry
   * with the dimension of the highest input dimension.
   *
   * Non-empty `GeometryCollection` arguments are not supported.
   *
   * @param other - the `Geometry` with which to compute the symmetric difference
   * @returns a Geometry representing the point-set symmetric difference of this `Geometry` with `other`
   * @throws TopologyException if a robustness error occurs
   * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
   * @see [org.locationtech.jts.geom.Geometry.symDifference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#symDifference-org.locationtech.jts.geom.Geometry-)
   */
  symDifference(other: Geometry): Geometry;
  /**
   * Returns the Well-known Text representation of this `Geometry`.
   * For a definition of the Well-known Text format, see the OpenGIS Simple
   * Features Specification.
   *
   * @returns the Well-known Text representation of this `Geometry`
   * @see [org.locationtech.jts.geom.Geometry.toText](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#toText--)
   */
  toText(): string;
  /**
   * Tests whether this geometry touches the
   * argument geometry.
   *
   * The `touches` predicate has the following equivalent definitions:
   *
   * - The geometries have at least one point in common,
   * but their interiors do not intersect.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * at least one of the following patterns
   *
   * - `[FT*******]`
   * - `[F**T*****]`
   * - `[F***T****]`
   *
   * If both geometries have dimension 0, the predicate returns `false`,
   * since points have only interiors.
   * This predicate is symmetric.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if the two `Geometry`s touch; Returns `false` if both `Geometry`s are points
   * @see [org.locationtech.jts.geom.Geometry.touches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#touches-org.locationtech.jts.geom.Geometry-)
   */
  touches(g: Geometry): boolean;
  /**
   * Computes the union of all the elements of this geometry.
   *
   * This method supports
   * `GeometryCollection`s
   * (which the other overlay operations currently do not).
   *
   * The result obeys the following contract:
   *
   * - Unioning a set of `LineString`s has the effect of fully noding
   * and dissolving the linework.
   * - Unioning a set of `Polygon`s always
   * returns a `Polygonal` geometry (unlike `union`,
   * which may return geometries of lower dimension if a topology collapse occurred).
   *
   * @returns the union geometry
   * @throws TopologyException if a robustness error occurs
   * @see [org.locationtech.jts.geom.Geometry.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#union--)
   */
  union(): Geometry;
  /**
   * Computes a `Geometry` representing the point-set
   * which is contained in both this
   * `Geometry` and the `other` Geometry.
   *
   * The union of two geometries of different dimension produces a result
   * geometry of dimension equal to the maximum dimension of the input
   * geometries.
   * The result geometry may be a heterogeneous
   * `GeometryCollection`.
   * If the result is empty, it is an atomic geometry
   * with the dimension of the highest input dimension.
   *
   * Unioning `LineString`s has the effect of
   * **noding** and **dissolving** the input linework. In this context
   * "noding" means that there will be a node or endpoint in the result for
   * every endpoint or line segment crossing in the input. "Dissolving" means
   * that any duplicate (i.e. coincident) line segments or portions of line
   * segments will be reduced to a single line segment in the result.
   * If **merged** linework is required, the `LineMerger`
   * class can be used.
   *
   * Non-empty `GeometryCollection` arguments are not supported.
   *
   * @param other - the `Geometry` with which to compute the union
   * @returns a point-set combining the points of this `Geometry` and the points of `other`
   * @throws TopologyException if a robustness error occurs
   * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
   * @see [org.locationtech.jts.geom.Geometry.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#union-org.locationtech.jts.geom.Geometry-)
   */
  union(other: Geometry): Geometry;
  /**
   * Tests whether this geometry is within the
   * specified geometry.
   *
   * The `within` predicate has the following equivalent definitions:
   *
   * - Every point of this geometry is a point of the other geometry,
   * and the interiors of the two geometries have at least one point in common.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * `[T*F**F***]`
   * - `g.contains(this) = true`
   *
   * (`within` is the converse of `contains`)
   *
   * An implication of the definition is that
   * "The boundary of a Geometry is not within the Geometry".
   * In other words, if a geometry A is a subset of
   * the points in the boundary of a geometry B, `A.within(B) = false`
   * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
   * For a predicate with similar behaviour but avoiding
   * this subtle limitation, see `coveredBy`.
   *
   * @param g - the `Geometry` with which to compare this `Geometry`
   * @returns `true` if this `Geometry` is within `g`
   * @see [org.locationtech.jts.geom.Geometry.within](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#within-org.locationtech.jts.geom.Geometry-)
   */
  within(g: Geometry): boolean;
}

export interface Envelope {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Envelope';

  /**
   * Computes the coordinate of the centre of this envelope (as long as it is non-null
   *
   * @returns the centre coordinate of this envelope `null` if the envelope is null
   * @see [org.locationtech.jts.geom.Envelope.centre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#centre--)
   */
  centre(): Coordinate;
  /**
   * Tests if the given point lies in or on the envelope.
   *
   * Note that this is **not** the same definition as the SFS `contains`,
   * which would exclude the envelope boundary.
   *
   * @param p - the point which this `Envelope` is being checked for containing
   * @returns `true` if the point lies in the interior or on the boundary of this `Envelope`.
   * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-org.locationtech.jts.geom.Coordinate-)
   */
  contains(p: Coordinate): boolean;
  /**
   * Tests if the `Envelope other`
   * lies wholely inside this `Envelope` (inclusive of the boundary).
   *
   * Note that this is **not** the same definition as the SFS `contains`,
   * which would exclude the envelope boundary.
   *
   * @param other - the `Envelope` to check
   * @returns true if `other` is contained in this `Envelope`
   * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-org.locationtech.jts.geom.Envelope-)
   */
  contains(other: Envelope): boolean;
  /**
   * Tests if the given point lies in or on the envelope.
   *
   * Note that this is **not** the same definition as the SFS `contains`,
   * which would exclude the envelope boundary.
   *
   * @param x - the x-coordinate of the point which this `Envelope` is being checked for containing
   * @param y - the y-coordinate of the point which this `Envelope` is being checked for containing
   * @returns `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.
   * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-double-double-)
   */
  contains(x: number, y: number): boolean;
  /**
   * Tests if an envelope is properly contained in this one.
   * The envelope is properly contained if it is contained
   * by this one but not equal to it.
   *
   * @param other - the envelope to test
   * @returns true if the envelope is properly contained
   * @see [org.locationtech.jts.geom.Envelope.containsProperly](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#containsProperly-org.locationtech.jts.geom.Envelope-)
   */
  containsProperly(other: Envelope): boolean;
  /**
   * Creates a copy of this envelope object.
   *
   * @returns a copy of this envelope
   * @see [org.locationtech.jts.geom.Envelope.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#copy--)
   */
  copy(): Envelope;
  /**
   * Tests if the given point lies in or on the envelope.
   *
   * @param p - the point which this `Envelope` is being checked for containing
   * @returns `true` if the point lies in the interior or on the boundary of this `Envelope`.
   * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-org.locationtech.jts.geom.Coordinate-)
   */
  covers(p: Coordinate): boolean;
  /**
   * Tests if the `Envelope other`
   * lies wholely inside this `Envelope` (inclusive of the boundary).
   *
   * @param other - the `Envelope` to check
   * @returns true if this `Envelope` covers the `other`
   * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-org.locationtech.jts.geom.Envelope-)
   */
  covers(other: Envelope): boolean;
  /**
   * Tests if the given point lies in or on the envelope.
   *
   * @param x - the x-coordinate of the point which this `Envelope` is being checked for containing
   * @param y - the y-coordinate of the point which this `Envelope` is being checked for containing
   * @returns `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.
   * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-double-double-)
   */
  covers(x: number, y: number): boolean;
  /**
   * Tests if the region defined by `other`
   * is disjoint from the region of this `Envelope`.
   *
   * A null envelope is always disjoint.
   *
   * @param other - the `Envelope` being checked for disjointness
   * @returns `true` if the `Envelope`s are disjoint
   * @see [org.locationtech.jts.geom.Envelope.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#disjoint-org.locationtech.jts.geom.Envelope-)
   */
  disjoint(other: Envelope): boolean;
  /**
   * Computes the distance between this and another
   * `Envelope`.
   * The distance between overlapping Envelopes is 0.  Otherwise, the
   * distance is the Euclidean distance between the closest points.
   *
   * @see [org.locationtech.jts.geom.Envelope.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#distance-org.locationtech.jts.geom.Envelope-)
   */
  distance(env: Envelope): number;
  /**
   * Expands this envelope by a given distance in all directions.
   * Both positive and negative distances are supported.
   *
   * @param distance - the distance to expand the envelope
   * @see [org.locationtech.jts.geom.Envelope.expandBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandBy-double-)
   */
  expandBy(distance: number): any /* void */;
  /**
   * Expands this envelope by a given distance in all directions.
   * Both positive and negative distances are supported.
   *
   * @param deltaX - the distance to expand the envelope along the the X axis
   * @param deltaY - the distance to expand the envelope along the the Y axis
   * @see [org.locationtech.jts.geom.Envelope.expandBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandBy-double-double-)
   */
  expandBy(deltaX: number, deltaY: number): any /* void */;
  /**
   * Enlarges this `Envelope` so that it contains
   * the given `Coordinate`.
   * Has no effect if the point is already on or within the envelope.
   *
   * @param p - the Coordinate to expand to include
   * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-org.locationtech.jts.geom.Coordinate-)
   */
  expandToInclude(p: Coordinate): any /* void */;
  /**
   * Enlarges this `Envelope` so that it contains
   * the `other` Envelope.
   * Has no effect if `other` is wholly on or
   * within the envelope.
   *
   * @param other - the `Envelope` to expand to include
   * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-org.locationtech.jts.geom.Envelope-)
   */
  expandToInclude(other: Envelope): any /* void */;
  /**
   * Enlarges this `Envelope` so that it contains
   * the given point.
   * Has no effect if the point is already on or within the envelope.
   *
   * @param x - the value to lower the minimum x to or to raise the maximum x to
   * @param y - the value to lower the minimum y to or to raise the maximum y to
   * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-double-double-)
   */
  expandToInclude(x: number, y: number): any /* void */;
  /**
   * Gets the area of this envelope.
   *
   * @returns the area of the envelope
   * @see [org.locationtech.jts.geom.Envelope.getArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getArea--)
   */
  getArea(): number;
  /**
   * Gets the length of the diameter (diagonal) of the envelope.
   *
   * @returns the diameter length
   * @see [org.locationtech.jts.geom.Envelope.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getDiameter--)
   */
  getDiameter(): number;
  /**
   * Returns the difference between the maximum and minimum y values.
   *
   * @returns max y - min y, or 0 if this is a null `Envelope`
   * @see [org.locationtech.jts.geom.Envelope.getHeight](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getHeight--)
   */
  getHeight(): number;
  /**
   * Returns the `Envelope`s maximum x-value. min x > max x
   * indicates that this is a null `Envelope`.
   *
   * @returns the maximum x-coordinate
   * @see [org.locationtech.jts.geom.Envelope.getMaxX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMaxX--)
   */
  getMaxX(): number;
  /**
   * Returns the `Envelope`s maximum y-value. min y > max y
   * indicates that this is a null `Envelope`.
   *
   * @returns the maximum y-coordinate
   * @see [org.locationtech.jts.geom.Envelope.getMaxY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMaxY--)
   */
  getMaxY(): number;
  /**
   * Returns the `Envelope`s minimum x-value. min x > max x
   * indicates that this is a null `Envelope`.
   *
   * @returns the minimum x-coordinate
   * @see [org.locationtech.jts.geom.Envelope.getMinX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMinX--)
   */
  getMinX(): number;
  /**
   * Returns the `Envelope`s minimum y-value. min y > max y
   * indicates that this is a null `Envelope`.
   *
   * @returns the minimum y-coordinate
   * @see [org.locationtech.jts.geom.Envelope.getMinY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMinY--)
   */
  getMinY(): number;
  /**
   * Returns the difference between the maximum and minimum x values.
   *
   * @returns max x - min x, or 0 if this is a null `Envelope`
   * @see [org.locationtech.jts.geom.Envelope.getWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getWidth--)
   */
  getWidth(): number;
  /**
   * Initialize to a null `Envelope`.
   *
   * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init--)
   */
  init(): any /* void */;
  /**
   * Initialize an `Envelope` to a region defined by a single Coordinate.
   *
   * @param p - the coordinate
   * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init-org.locationtech.jts.geom.Coordinate-)
   */
  init(p: Coordinate): any /* void */;
  /**
   * Initialize an `Envelope` from an existing Envelope.
   *
   * @param env - the Envelope to initialize from
   * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init-org.locationtech.jts.geom.Envelope-)
   */
  init(env: Envelope): any /* void */;
  /**
   * Computes the intersection of two `Envelope`s.
   *
   * @param env - the envelope to intersect with
   * @returns a new Envelope representing the intersection of the envelopes (this will be the null envelope if either argument is null, or they do not intersect
   * @see [org.locationtech.jts.geom.Envelope.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersection-org.locationtech.jts.geom.Envelope-)
   */
  intersection(env: Envelope): Envelope;
  /**
   * Tests if the point `p`
   * intersects (lies inside) the region of this `Envelope`.
   *
   * @param p - the `Coordinate` to be tested
   * @returns `true` if the point intersects this `Envelope`
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-)
   */
  intersects(p: Coordinate): boolean;
  /**
   * Tests if the region defined by `other`
   * intersects the region of this `Envelope`.
   *
   * A null envelope never intersects.
   *
   * @param other - the `Envelope` which this `Envelope` is being checked for intersecting
   * @returns `true` if the `Envelope`s intersect
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Envelope-)
   */
  intersects(other: Envelope): boolean;
  /**
   * Check if the point `(x, y)`
   * intersects (lies inside) the region of this `Envelope`.
   *
   * @param x - the x-ordinate of the point
   * @param y - the y-ordinate of the point
   * @returns `true` if the point overlaps this `Envelope`
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-double-double-)
   */
  intersects(x: number, y: number): boolean;
  /**
   * Tests if the extent defined by two extremal points
   * intersects the extent of this `Envelope`.
   *
   * @param a - a point
   * @param b - another point
   * @returns `true` if the extents intersect
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  intersects(a: Coordinate, b: Coordinate): boolean;
  /**
   * Test the point q to see whether it intersects the Envelope defined by p1-p2
   *
   * @param p1 - one extremal point of the envelope
   * @param p2 - another extremal point of the envelope
   * @param q - the point to test for intersection
   * @returns `true` if q intersects the envelope p1-p2
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  intersects(p1: Coordinate, p2: Coordinate, q: Coordinate): boolean;
  /**
   * Tests whether the envelope defined by p1-p2
   * and the envelope defined by q1-q2
   * intersect.
   *
   * @param p1 - one extremal point of the envelope P
   * @param p2 - another extremal point of the envelope P
   * @param q1 - one extremal point of the envelope Q
   * @param q2 - another extremal point of the envelope Q
   * @returns `true` if Q intersects P
   * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  intersects(p1: Coordinate, p2: Coordinate, q1: Coordinate, q2: Coordinate): boolean;
  /**
   * Returns `true` if this `Envelope` is a "null"
   * envelope.
   *
   * @returns `true` if this `Envelope` is uninitialized or is the envelope of the empty geometry.
   * @see [org.locationtech.jts.geom.Envelope.isNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#isNull--)
   */
  isNull(): boolean;
  /**
   * Gets the maximum extent of this envelope across both dimensions.
   *
   * @returns the maximum extent of this envelope
   * @see [org.locationtech.jts.geom.Envelope.maxExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#maxExtent--)
   */
  maxExtent(): number;
  /**
   * Gets the minimum extent of this envelope across both dimensions.
   *
   * @returns the minimum extent of this envelope
   * @see [org.locationtech.jts.geom.Envelope.minExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#minExtent--)
   */
  minExtent(): number;
  overlaps(p: Coordinate): boolean;
  overlaps(other: Envelope): boolean;
  overlaps(x: number, y: number): boolean;
  /**
   * Makes this `Envelope` a "null" envelope, that is, the envelope
   * of the empty geometry.
   *
   * @see [org.locationtech.jts.geom.Envelope.setToNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#setToNull--)
   */
  setToNull(): any /* void */;
  /**
   * Translates this envelope by given amounts in the X and Y direction.
   *
   * @param transX - the amount to translate along the X axis
   * @param transY - the amount to translate along the Y axis
   * @see [org.locationtech.jts.geom.Envelope.translate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#translate-double-double-)
   */
  translate(transX: number, transY: number): any /* void */;
}

export interface Coordinate {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Coordinate';

  /**
   * Standard ordinate index value for, where M is 3.
   *
   * This constant assumes XYZM coordinate sequence definition, please check this assumption
   * using `CoordinateSequence.getDimension` and `CoordinateSequence.getMeasures`
   * before use.
   *
   * @see [org.locationtech.jts.geom.Coordinate.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#M)
   */
  M: number;
  /**
   * The value used to indicate a null or missing ordinate value.
   * In particular, used for the value of ordinates for dimensions
   * greater than the defined dimension of a coordinate.
   *
   * @see [org.locationtech.jts.geom.Coordinate.NULL_ORDINATE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#NULL_ORDINATE)
   */
  NULL_ORDINATE: number;
  /**
   * Standard ordinate index value for, where X is 0
   *
   * @see [org.locationtech.jts.geom.Coordinate.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#X)
   */
  X: number;
  /**
   * Standard ordinate index value for, where Y is 1
   *
   * @see [org.locationtech.jts.geom.Coordinate.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Y)
   */
  Y: number;
  /**
   * Standard ordinate index value for, where Z is 2.
   *
   * This constant assumes XYZM coordinate sequence definition, please check this assumption
   * using `CoordinateSequence.getDimension` and `CoordinateSequence.getMeasures`
   * before use.
   *
   * @see [org.locationtech.jts.geom.Coordinate.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Z)
   */
  Z: number;
  /**
   * Compares this `Coordinate` with the specified `Coordinate` for order.
   * This method ignores the z value when making the comparison.
   * Returns:
   *
   * - -1 : this.x < other.x || ((this.x == other.x) && (this.y < other.y))
   * - 0 : this.x == other.x && this.y = other.y
   * - 1 : this.x > other.x || ((this.x == other.x) && (this.y > other.y))
   *
   * Note: This method assumes that ordinate values
   * are valid numbers.  NaN values are not handled correctly.
   *
   * @param o - the `Coordinate` with which this `Coordinate` is being compared
   * @returns -1, zero, or 1 as this `Coordinate` is less than, equal to, or greater than the specified `Coordinate`
   * @see [org.locationtech.jts.geom.Coordinate.compareTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#compareTo-org.locationtech.jts.geom.Coordinate-)
   */
  compareTo(o: Coordinate): number;
  /**
   * Creates a copy of this Coordinate.
   *
   * @returns a copy of this coordinate.
   * @see [org.locationtech.jts.geom.Coordinate.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#copy--)
   */
  copy(): Coordinate;
  /**
   * Create a new Coordinate of the same type as this Coordinate, but with no values.
   *
   * @returns a new Coordinate
   * @see [org.locationtech.jts.geom.Coordinate.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#create--)
   */
  create(): Coordinate;
  /**
   * Computes the 2-dimensional Euclidean distance to another location.
   * The Z-ordinate is ignored.
   *
   * @param c - a point
   * @returns the 2-dimensional Euclidean distance between the locations
   * @see [org.locationtech.jts.geom.Coordinate.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#distance-org.locationtech.jts.geom.Coordinate-)
   */
  distance(c: Coordinate): number;
  /**
   * Computes the 3-dimensional Euclidean distance to another location.
   *
   * @param c - a coordinate
   * @returns the 3-dimensional Euclidean distance between the locations
   * @see [org.locationtech.jts.geom.Coordinate.distance3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#distance3D-org.locationtech.jts.geom.Coordinate-)
   */
  distance3D(c: Coordinate): number;
  /**
   * Tests if another coordinate has the same value for Z, within a tolerance.
   *
   * @param c - a coordinate
   * @param tolerance - the tolerance value
   * @returns true if the Z ordinates are within the given tolerance
   * @see [org.locationtech.jts.geom.Coordinate.equalInZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equalInZ-org.locationtech.jts.geom.Coordinate-double-)
   */
  equalInZ(c: Coordinate, tolerance: number): boolean;
  /**
   * Returns whether the planar projections of the two `Coordinate`s
   * are equal.
   *
   * @param other - a `Coordinate` with which to do the 2D comparison.
   * @returns `true` if the x- and y-coordinates are equal; the z-coordinates do not have to be equal.
   * @see [org.locationtech.jts.geom.Coordinate.equals2D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals2D-org.locationtech.jts.geom.Coordinate-)
   */
  equals2D(other: Coordinate): boolean;
  /**
   * Tests if another Coordinate has the same values for the X and Y ordinates,
   * within a specified tolerance value.
   * The Z ordinate is ignored.
   *
   * @param c - a `Coordinate` with which to do the 2D comparison.
   * @param tolerance - the tolerance value to use
   * @returns true if `other` is a `Coordinate` with the same values for X and Y.
   * @see [org.locationtech.jts.geom.Coordinate.equals2D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals2D-org.locationtech.jts.geom.Coordinate-double-)
   */
  equals2D(c: Coordinate, tolerance: number): boolean;
  /**
   * Tests if another coordinate has the same values for the X, Y and Z ordinates.
   *
   * @param other - a `Coordinate` with which to do the 3D comparison.
   * @returns true if `other` is a `Coordinate` with the same values for X, Y and Z.
   * @see [org.locationtech.jts.geom.Coordinate.equals3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals3D-org.locationtech.jts.geom.Coordinate-)
   */
  equals3D(other: Coordinate): boolean;
  /**
   * Retrieves the value of the measure, if present.
   * If no measure value is present returns `NaN`.
   *
   * @returns the value of the measure, or `NaN`
   * @see [org.locationtech.jts.geom.Coordinate.getM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getM--)
   */
  getM(): number;
  /**
   * Retrieves the value of the X ordinate.
   *
   * @returns the value of the X ordinate
   * @see [org.locationtech.jts.geom.Coordinate.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getX--)
   */
  getX(): number;
  /**
   * Retrieves the value of the Y ordinate.
   *
   * @returns the value of the Y ordinate
   * @see [org.locationtech.jts.geom.Coordinate.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getY--)
   */
  getY(): number;
  /**
   * Retrieves the value of the Z ordinate, if present.
   * If no Z value is present returns `NaN`.
   *
   * @returns the value of the Z ordinate, or `NaN`
   * @see [org.locationtech.jts.geom.Coordinate.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getZ--)
   */
  getZ(): number;
  /**
   * Computes a hash code for a double value, using the algorithm from
   * Joshua Bloch's book _Effective Java"_
   *
   * @param x - the value to compute for
   * @returns a hashcode for x
   * @see [org.locationtech.jts.geom.Coordinate.hashCode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#hashCode-double-)
   */
  hashCode(x: number): number;
  /**
   * Tests if the coordinate has valid X and Y ordinate values.
   * An ordinate value is valid iff it is finite.
   *
   * @returns true if the coordinate is valid
   * @see [org.locationtech.jts.geom.Coordinate.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#isValid--)
   */
  isValid(): boolean;
}

export interface PrecisionModel {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'PrecisionModel';

  /**
   * Returns the maximum number of significant digits provided by this
   * precision model.
   * Intended for use by routines which need to print out
   * decimal representations of precise values (such as `WKTWriter`).
   *
   * This method would be more correctly called
   * `getMinimumDecimalPlaces`,
   * since it actually computes the number of decimal places
   * that is required to correctly display the full
   * precision of an ordinate value.
   *
   * Since it is difficult to compute the required number of
   * decimal places for scale factors which are not powers of 10,
   * the algorithm uses a very rough approximation in this case.
   * This has the side effect that for scale factors which are
   * powers of 10 the value returned is 1 greater than the true value.
   *
   * @returns the maximum number of decimal places provided by this precision model
   * @see [org.locationtech.jts.geom.PrecisionModel.getMaximumSignificantDigits](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getMaximumSignificantDigits--)
   */
  getMaximumSignificantDigits(): number;
  /**
   * Returns the x-offset used to obtain a precise coordinate.
   *
   * @returns the amount by which to subtract the x-coordinate before multiplying by the scale
   * @see [org.locationtech.jts.geom.PrecisionModel.getOffsetX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getOffsetX--)
   */
  getOffsetX(): number;
  /**
   * Returns the y-offset used to obtain a precise coordinate.
   *
   * @returns the amount by which to subtract the y-coordinate before multiplying by the scale
   * @see [org.locationtech.jts.geom.PrecisionModel.getOffsetY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getOffsetY--)
   */
  getOffsetY(): number;
  /**
   * Returns the scale factor used to specify a fixed precision model.
   * The number of decimal places of precision is
   * equal to the base-10 logarithm of the scale factor.
   * Non-integral and negative scale factors are supported.
   * Negative scale factors indicate that the places
   * of precision is to the left of the decimal point.
   *
   * @returns the scale factor for the fixed precision model
   * @see [org.locationtech.jts.geom.PrecisionModel.getScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getScale--)
   */
  getScale(): number;
  /**
   * Gets the type of this precision model
   *
   * @returns the type of this precision model
   * @see [org.locationtech.jts.geom.PrecisionModel.getType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getType--)
   */
  getType(): any /* org.locationtech.jts.geom.PrecisionModel$Type */;
  /**
   * Computes the grid size for a fixed precision model.
   * This is equal to the reciprocal of the scale factor.
   * If the grid size has been set explicity (via a negative scale factor)
   * it will be returned.
   *
   * @returns the grid size at a fixed precision scale.
   * @see [org.locationtech.jts.geom.PrecisionModel.gridSize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#gridSize--)
   */
  gridSize(): number;
  /**
   * Tests whether the precision model supports floating point
   *
   * @returns `true` if the precision model supports floating point
   * @see [org.locationtech.jts.geom.PrecisionModel.isFloating](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#isFloating--)
   */
  isFloating(): boolean;
  /**
   * Rounds a numeric value to the PrecisionModel grid.
   * Asymmetric Arithmetic Rounding is used, to provide
   * uniform rounding behaviour no matter where the number is
   * on the number line.
   *
   * This method has no effect on NaN values.
   *
   * **Note:** Java's `Math#rint` uses the "Banker's Rounding" algorithm,
   * which is not suitable for precision operations elsewhere in JTS.
   *
   * @see [org.locationtech.jts.geom.PrecisionModel.makePrecise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#makePrecise-double-)
   */
  makePrecise(val: number): number;
  /**
   * Determines which of two `PrecisionModel`s is the most precise
   * (allows the greatest number of significant digits).
   *
   * @param pm1 - a PrecisionModel
   * @param pm2 - a PrecisionModel
   * @returns the PrecisionModel which is most precise
   * @see [org.locationtech.jts.geom.PrecisionModel.mostPrecise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#mostPrecise-org.locationtech.jts.geom.PrecisionModel-org.locationtech.jts.geom.PrecisionModel-)
   */
  mostPrecise(pm1: PrecisionModel, pm2: PrecisionModel): PrecisionModel;
  /**
   * Returns the external representation of `internal`.
   *
   * @param internal - the original coordinate
   * @returns the coordinate whose values will be changed to the external representation of `internal`
   * @see [org.locationtech.jts.geom.PrecisionModel.toExternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#toExternal-org.locationtech.jts.geom.Coordinate-)
   */
  toExternal(internal: Coordinate): Coordinate;
  /**
   * Returns the precise representation of `external`.
   *
   * @param external - the original coordinate
   * @returns the coordinate whose values will be changed to the precise representation of `external`
   * @see [org.locationtech.jts.geom.PrecisionModel.toInternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#toInternal-org.locationtech.jts.geom.Coordinate-)
   */
  toInternal(external: Coordinate): Coordinate;
  toString(): string;
}

export interface Triangle {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Triangle';

  /**
   * Computes the point at which the bisector of the angle ABC cuts the segment
   * AC.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the angle bisector cut point
   * @see [org.locationtech.jts.geom.Triangle.angleBisector](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#angleBisector-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  angleBisector(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
  /**
   * Computes the 2D area of this triangle. The area value is always
   * non-negative.
   *
   * @returns the area of this triangle
   * @see [org.locationtech.jts.geom.Triangle.area](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area--)
   */
  area(): number;
  /**
   * Computes the 2D area of a triangle. The area value is always non-negative.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the area of the triangle
   * @see [org.locationtech.jts.geom.Triangle.area](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  area(a: Coordinate, b: Coordinate, c: Coordinate): number;
  /**
   * Computes the 3D area of this triangle. The value computed is always
   * non-negative.
   *
   * @returns the 3D area of this triangle
   * @see [org.locationtech.jts.geom.Triangle.area3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area3D--)
   */
  area3D(): number;
  /**
   * Computes the 3D area of a triangle. The value computed is always
   * non-negative.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the 3D area of the triangle
   * @see [org.locationtech.jts.geom.Triangle.area3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area3D-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  area3D(a: Coordinate, b: Coordinate, c: Coordinate): number;
  /**
   * Computes the centroid (centre of mass) of this triangle. This is also the
   * point at which the triangle's three medians intersect (a triangle median is
   * the segment from a vertex of the triangle to the midpoint of the opposite
   * side). The centroid divides each median in a ratio of 2:1.
   *
   * The centroid always lies within the triangle.
   *
   * @returns the centroid of this triangle
   * @see [org.locationtech.jts.geom.Triangle.centroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#centroid--)
   */
  centroid(): Coordinate;
  /**
   * Computes the centroid (centre of mass) of a triangle. This is also the
   * point at which the triangle's three medians intersect (a triangle median is
   * the segment from a vertex of the triangle to the midpoint of the opposite
   * side). The centroid divides each median in a ratio of 2:1.
   *
   * The centroid always lies within the triangle.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the centroid of the triangle
   * @see [org.locationtech.jts.geom.Triangle.centroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#centroid-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  centroid(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
  /**
   * Computes the circumcentre of this triangle. The circumcentre is the centre
   * of the circumcircle, the smallest circle which passes through all the triangle vertices.
   * It is also the common intersection point of the perpendicular bisectors of the
   * sides of the triangle, and is the only point which has equal distance to
   * all three vertices of the triangle.
   *
   * The circumcentre does not necessarily lie within the triangle.
   *
   * This method uses an algorithm due to J.R.Shewchuk which uses normalization
   * to the origin to improve the accuracy of computation. (See _Lecture Notes
   * on Geometric Robustness_, Jonathan Richard Shewchuk, 1999).
   *
   * @returns the circumcentre of this triangle
   * @see [org.locationtech.jts.geom.Triangle.circumcentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentre--)
   */
  circumcentre(): Coordinate;
  /**
   * Computes the circumcentre of a triangle. The circumcentre is the centre of
   * the circumcircle, the smallest circle which encloses the triangle. It is
   * also the common intersection point of the perpendicular bisectors of the
   * sides of the triangle, and is the only point which has equal distance to
   * all three vertices of the triangle.
   *
   * The circumcentre does not necessarily lie within the triangle. For example,
   * the circumcentre of an obtuse isosceles triangle lies outside the triangle.
   *
   * This method uses an algorithm due to J.R.Shewchuk which uses normalization
   * to the origin to improve the accuracy of computation. (See _Lecture Notes
   * on Geometric Robustness_, Jonathan Richard Shewchuk, 1999).
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the circumcentre of the triangle
   * @see [org.locationtech.jts.geom.Triangle.circumcentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentre-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  circumcentre(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
  /**
   * Computes the circumcentre of a triangle. The circumcentre is the centre of
   * the circumcircle, the smallest circle which encloses the triangle. It is
   * also the common intersection point of the perpendicular bisectors of the
   * sides of the triangle, and is the only point which has equal distance to
   * all three vertices of the triangle.
   *
   * The circumcentre does not necessarily lie within the triangle. For example,
   * the circumcentre of an obtuse isosceles triangle lies outside the triangle.
   *
   * This method uses `DD` extended-precision arithmetic to
   * provide more accurate results than `Coordinate, Coordinate)`
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the circumcentre of the triangle
   * @see [org.locationtech.jts.geom.Triangle.circumcentreDD](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentreDD-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  circumcentreDD(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
  /**
   * Computes the radius of the circumcircle of a triangle.
   *
   * @returns the triangle circumradius
   * @see [org.locationtech.jts.geom.Triangle.circumradius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumradius--)
   */
  circumradius(): number;
  /**
   * Computes the radius of the circumcircle of a triangle.
   *
   * Formula is as per https://math.stackexchange.com/a/3610959
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the circumradius of the triangle
   * @see [org.locationtech.jts.geom.Triangle.circumradius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumradius-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  circumradius(a: Coordinate, b: Coordinate, c: Coordinate): number;
  /**
   * Computes the incentre of this triangle. The _incentre_ of a triangle
   * is the point which is equidistant from the sides of the triangle. It is
   * also the point at which the bisectors of the triangle's angles meet. It is
   * the centre of the triangle's _incircle_, which is the unique circle
   * that is tangent to each of the triangle's three sides.
   *
   * @returns the point which is the inCentre of this triangle
   * @see [org.locationtech.jts.geom.Triangle.inCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#inCentre--)
   */
  inCentre(): Coordinate;
  /**
   * Computes the incentre of a triangle. The _inCentre_ of a triangle is
   * the point which is equidistant from the sides of the triangle. It is also
   * the point at which the bisectors of the triangle's angles meet. It is the
   * centre of the triangle's _incircle_, which is the unique circle that
   * is tangent to each of the triangle's three sides.
   *
   * The incentre always lies within the triangle.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the point which is the incentre of the triangle
   * @see [org.locationtech.jts.geom.Triangle.inCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#inCentre-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  inCentre(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
  /**
   * Computes the Z-value (elevation) of an XY point on a three-dimensional
   * plane defined by this triangle (whose vertices must have Z-values). This
   * triangle must not be degenerate (in other words, the triangle must enclose
   * a non-zero area), and must not be parallel to the Z-axis.
   *
   * This method can be used to interpolate the Z-value of a point inside this
   * triangle (for example, of a TIN facet with elevations on the vertices).
   *
   * @param p - the point to compute the Z-value of
   * @returns the computed Z-value (elevation) of the point
   * @see [org.locationtech.jts.geom.Triangle.interpolateZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#interpolateZ-org.locationtech.jts.geom.Coordinate-)
   */
  interpolateZ(p: Coordinate): number;
  /**
   * Computes the Z-value (elevation) of an XY point on a three-dimensional
   * plane defined by a triangle whose vertices have Z-values. The defining
   * triangle must not be degenerate (in other words, the triangle must enclose
   * a non-zero area), and must not be parallel to the Z-axis.
   *
   * This method can be used to interpolate the Z-value of a point inside a
   * triangle (for example, of a TIN facet with elevations on the vertices).
   *
   * @param p - the point to compute the Z-value of
   * @param v0 - a vertex of a triangle, with a Z ordinate
   * @param v1 - a vertex of a triangle, with a Z ordinate
   * @param v2 - a vertex of a triangle, with a Z ordinate
   * @returns the computed Z-value (elevation) of the point
   * @see [org.locationtech.jts.geom.Triangle.interpolateZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#interpolateZ-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  interpolateZ(p: Coordinate, v0: Coordinate, v1: Coordinate, v2: Coordinate): number;
  /**
   * Tests whether a triangle intersects a point.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @param p - the point to test
   * @returns true if the triangle intersects the point
   * @see [org.locationtech.jts.geom.Triangle.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  intersects(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
  /**
   * Tests whether this triangle is acute. A triangle is acute if all interior
   * angles are acute. This is a strict test - right triangles will return
   * `false`. A triangle which is not acute is either right or obtuse.
   *
   * Note: this implementation is not robust for angles very close to 90
   * degrees.
   *
   * @returns true if this triangle is acute
   * @see [org.locationtech.jts.geom.Triangle.isAcute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isAcute--)
   */
  isAcute(): boolean;
  /**
   * Tests whether a triangle is acute. A triangle is acute if all interior
   * angles are acute. This is a strict test - right triangles will return
   * `false`. A triangle which is not acute is either right or obtuse.
   *
   * Note: this implementation is not robust for angles very close to 90
   * degrees.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns true if the triangle is acute
   * @see [org.locationtech.jts.geom.Triangle.isAcute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isAcute-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  isAcute(a: Coordinate, b: Coordinate, c: Coordinate): boolean;
  /**
   * Tests whether this triangle is oriented counter-clockwise.
   *
   * @returns true if the triangle orientation is counter-clockwise
   * @see [org.locationtech.jts.geom.Triangle.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isCCW--)
   */
  isCCW(): boolean;
  /**
   * Tests whether a triangle is oriented counter-clockwise.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns true if the triangle orientation is counter-clockwise
   * @see [org.locationtech.jts.geom.Triangle.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isCCW-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  isCCW(a: Coordinate, b: Coordinate, c: Coordinate): boolean;
  /**
   * Computes the length of the perimeter of this triangle.
   *
   * @returns the length of the perimeter
   * @see [org.locationtech.jts.geom.Triangle.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#length--)
   */
  length(): number;
  /**
   * Compute the length of the perimeter of a triangle
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the length of the triangle perimeter
   * @see [org.locationtech.jts.geom.Triangle.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#length-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  length(a: Coordinate, b: Coordinate, c: Coordinate): number;
  /**
   * Computes the length of the longest side of this triangle
   *
   * @returns the length of the longest side of this triangle
   * @see [org.locationtech.jts.geom.Triangle.longestSideLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#longestSideLength--)
   */
  longestSideLength(): number;
  /**
   * Computes the length of the longest side of a triangle
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the length of the longest side of the triangle
   * @see [org.locationtech.jts.geom.Triangle.longestSideLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#longestSideLength-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  longestSideLength(a: Coordinate, b: Coordinate, c: Coordinate): number;
  /**
   * Computes the signed 2D area of this triangle. The area value is positive if
   * the triangle is oriented CW, and negative if it is oriented CCW.
   *
   * The signed area value can be used to determine point orientation, but the
   * implementation in this method is susceptible to round-off errors. Use
   * `Coordinate, Coordinate)`
   * for robust orientation calculation.
   *
   * @returns the signed 2D area of this triangle
   * @see [org.locationtech.jts.geom.Triangle.signedArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#signedArea--)
   */
  signedArea(): number;
  /**
   * Computes the signed 2D area of a triangle. The area value is positive if
   * the triangle is oriented CW, and negative if it is oriented CCW.
   *
   * The signed area value can be used to determine point orientation, but the
   * implementation in this method is susceptible to round-off errors. Use
   * `Coordinate, Coordinate)`
   * for robust orientation calculation.
   *
   * @param a - a vertex of the triangle
   * @param b - a vertex of the triangle
   * @param c - a vertex of the triangle
   * @returns the signed 2D area of the triangle
   * @see [org.locationtech.jts.geom.Triangle.signedArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#signedArea-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  signedArea(a: Coordinate, b: Coordinate, c: Coordinate): number;
}

export interface LineSegment {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'LineSegment';

  /**
   * Computes the angle that the vector defined by this segment
   * makes with the X-axis.
   * The angle will be in the range [ -PI, PI ] radians.
   *
   * @returns the angle this segment makes with the X-axis (in radians)
   * @see [org.locationtech.jts.geom.LineSegment.angle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#angle--)
   */
  angle(): number;
  /**
   * Computes the closest point on this line segment to another point.
   *
   * @param p - the point to find the closest point to
   * @returns a Coordinate which is the closest point on the line segment to the point p
   * @see [org.locationtech.jts.geom.LineSegment.closestPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#closestPoint-org.locationtech.jts.geom.Coordinate-)
   */
  closestPoint(p: Coordinate): Coordinate;
  /**
   * Computes the closest points on two line segments.
   *
   * @param line - the segment to find the closest point to
   * @returns a pair of Coordinates which are the closest points on the line segments
   * @see [org.locationtech.jts.geom.LineSegment.closestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#closestPoints-org.locationtech.jts.geom.LineSegment-)
   */
  closestPoints(line: LineSegment): Coordinate[];
  /**
   * Computes the distance between this line segment and a given point.
   *
   * @returns the distance from this segment to the given point
   * @see [org.locationtech.jts.geom.LineSegment.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distance-org.locationtech.jts.geom.Coordinate-)
   */
  distance(p: Coordinate): number;
  /**
   * Computes the distance between this line segment and another segment.
   *
   * @returns the distance to the other segment
   * @see [org.locationtech.jts.geom.LineSegment.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distance-org.locationtech.jts.geom.LineSegment-)
   */
  distance(ls: LineSegment): number;
  /**
   * Computes the perpendicular distance between the (infinite) line defined
   * by this line segment and a point.
   * If the segment has zero length this returns the distance between
   * the segment and the point.
   *
   * @param p - the point to compute the distance to
   * @returns the perpendicular distance between the line and point
   * @see [org.locationtech.jts.geom.LineSegment.distancePerpendicular](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distancePerpendicular-org.locationtech.jts.geom.Coordinate-)
   */
  distancePerpendicular(p: Coordinate): number;
  /**
   * Computes the oriented perpendicular distance between the (infinite) line
   * defined by this line segment and a point.
   * The oriented distance is positive if the point on the left of the line,
   * and negative if it is on the right.
   * If the segment has zero length this returns the distance between
   * the segment and the point.
   *
   * @param p - the point to compute the distance to
   * @returns the oriented perpendicular distance between the line and point
   * @see [org.locationtech.jts.geom.LineSegment.distancePerpendicularOriented](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distancePerpendicularOriented-org.locationtech.jts.geom.Coordinate-)
   */
  distancePerpendicularOriented(p: Coordinate): number;
  /**
   * Returns `true` if `other` is
   * topologically equal to this LineSegment (e.g. irrespective
   * of orientation).
   *
   * @param other - a `LineSegment` with which to do the comparison.
   * @returns `true` if `other` is a `LineSegment` with the same values for the x and y ordinates.
   * @see [org.locationtech.jts.geom.LineSegment.equalsTopo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#equalsTopo-org.locationtech.jts.geom.LineSegment-)
   */
  equalsTopo(other: LineSegment): boolean;
  getCoordinate(i: number): Coordinate;
  /**
   * Computes the length of the line segment.
   *
   * @returns the length of the line segment
   * @see [org.locationtech.jts.geom.LineSegment.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#getLength--)
   */
  getLength(): number;
  /**
   * Computes an intersection point between two line segments, if there is one.
   * There may be 0, 1 or many intersection points between two segments.
   * If there are 0, null is returned. If there is 1 or more,
   * exactly one of them is returned
   * (chosen at the discretion of the algorithm).
   * If more information is required about the details of the intersection,
   * the `RobustLineIntersector` class should be used.
   *
   * @param line - a line segment
   * @returns an intersection point, or `null` if there is none
   * @see [org.locationtech.jts.geom.LineSegment.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#intersection-org.locationtech.jts.geom.LineSegment-)
   */
  intersection(line: LineSegment): Coordinate;
  /**
   * Tests whether the segment is horizontal.
   *
   * @returns `true` if the segment is horizontal
   * @see [org.locationtech.jts.geom.LineSegment.isHorizontal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#isHorizontal--)
   */
  isHorizontal(): boolean;
  /**
   * Tests whether the segment is vertical.
   *
   * @returns `true` if the segment is vertical
   * @see [org.locationtech.jts.geom.LineSegment.isVertical](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#isVertical--)
   */
  isVertical(): boolean;
  /**
   * Computes the intersection point of the lines of infinite extent defined
   * by two line segments (if there is one).
   * There may be 0, 1 or an infinite number of intersection points
   * between two lines.
   * If there is a unique intersection point, it is returned.
   * Otherwise, `null` is returned.
   * If more information is required about the details of the intersection,
   * the `RobustLineIntersector` class should be used.
   *
   * @param line - a line segment defining an straight line with infinite extent
   * @returns an intersection point, or `null` if there is no point of intersection or an infinite number of intersection points
   * @see [org.locationtech.jts.geom.LineSegment.lineIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#lineIntersection-org.locationtech.jts.geom.LineSegment-)
   */
  lineIntersection(line: LineSegment): Coordinate;
  /**
   * Gets the maximum X ordinate.
   *
   * @returns the maximum X ordinate
   * @see [org.locationtech.jts.geom.LineSegment.maxX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#maxX--)
   */
  maxX(): number;
  /**
   * Gets the maximum Y ordinate.
   *
   * @returns the maximum Y ordinate
   * @see [org.locationtech.jts.geom.LineSegment.maxY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#maxY--)
   */
  maxY(): number;
  /**
   * Computes the midpoint of the segment
   *
   * @returns the midpoint of the segment
   * @see [org.locationtech.jts.geom.LineSegment.midPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#midPoint--)
   */
  midPoint(): Coordinate;
  /**
   * Computes the midpoint of a segment
   *
   * @returns the midpoint of the segment
   * @see [org.locationtech.jts.geom.LineSegment.midPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#midPoint-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
   */
  midPoint(p0: Coordinate, p1: Coordinate): Coordinate;
  /**
   * Gets the minimum X ordinate.
   *
   * @returns the minimum X ordinate
   * @see [org.locationtech.jts.geom.LineSegment.minX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#minX--)
   */
  minX(): number;
  /**
   * Gets the minimum Y ordinate.
   *
   * @returns the minimum Y ordinate
   * @see [org.locationtech.jts.geom.LineSegment.minY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#minY--)
   */
  minY(): number;
  /**
   * Computes the `LineSegment` that is offset from
   * the segment by a given distance.
   * The computed segment is offset to the left of the line if the offset distance is
   * positive, to the right if negative.
   *
   * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
   * @returns a line segment offset by the specified distance
   * @throws IllegalStateException if the segment has zero length
   * @see [org.locationtech.jts.geom.LineSegment.offset](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#offset-double-)
   */
  offset(offsetDistance: number): LineSegment;
  /**
   * Determines the orientation index of a `Coordinate` relative to this segment.
   * The orientation index is as defined in `Coordinate, Coordinate)`.
   *
   * @param p - the coordinate to compare
   * @returns 1 (LEFT) if `p` is to the left of this segment
   * @see [org.locationtech.jts.geom.LineSegment.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#orientationIndex-org.locationtech.jts.geom.Coordinate-)
   */
  orientationIndex(p: Coordinate): number;
  /**
   * Determines the orientation of a LineSegment relative to this segment.
   * The concept of orientation is specified as follows:
   * Given two line segments A and L,
   *
   * - A is to the left of a segment L if A lies wholly in the
   * closed half-plane lying to the left of L
   * - A is to the right of a segment L if A lies wholly in the
   * closed half-plane lying to the right of L
   * - otherwise, A has indeterminate orientation relative to L. This
   * happens if A is collinear with L or if A crosses the line determined by L.
   *
   * @param seg - the LineSegment to compare
   * @returns 1 if `seg` is to the left of this segment
   * @see [org.locationtech.jts.geom.LineSegment.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#orientationIndex-org.locationtech.jts.geom.LineSegment-)
   */
  orientationIndex(seg: LineSegment): number;
  /**
   * Computes the `Coordinate` that lies a given
   * fraction along the line defined by this segment.
   * A fraction of `0.0` returns the start point of the segment;
   * a fraction of `1.0` returns the end point of the segment.
   * If the fraction is < 0.0 or > 1.0 the point returned
   * will lie before the start or beyond the end of the segment.
   *
   * @param segmentLengthFraction - the fraction of the segment length along the line
   * @returns the point at that distance
   * @see [org.locationtech.jts.geom.LineSegment.pointAlong](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#pointAlong-double-)
   */
  pointAlong(segmentLengthFraction: number): Coordinate;
  /**
   * Computes the `Coordinate` that lies a given
   * fraction along the line defined by this segment and offset from
   * the segment by a given distance.
   * A fraction of `0.0` offsets from the start point of the segment;
   * a fraction of `1.0` offsets from the end point of the segment.
   * The computed point is offset to the left of the line if the offset distance is
   * positive, to the right if negative.
   *
   * @param segmentLengthFraction - the fraction of the segment length along the line
   * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
   * @returns the point at that distance and offset
   * @throws IllegalStateException if the segment has zero length
   * @see [org.locationtech.jts.geom.LineSegment.pointAlongOffset](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#pointAlongOffset-double-double-)
   */
  pointAlongOffset(segmentLengthFraction: number, offsetDistance: number): Coordinate;
  /**
   * Compute the projection of a point onto the line determined
   * by this line segment.
   *
   * Note that the projected point
   * may lie outside the line segment.  If this is the case,
   * the projection factor will lie outside the range [0.0, 1.0].
   *
   * @see [org.locationtech.jts.geom.LineSegment.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#project-org.locationtech.jts.geom.Coordinate-)
   */
  project(p: Coordinate): Coordinate;
  /**
   * Project a line segment onto this line segment and return the resulting
   * line segment.  The returned line segment will be a subset of
   * the target line line segment.  This subset may be null, if
   * the segments are oriented in such a way that there is no projection.
   *
   * Note that the returned line may have zero length (i.e. the same endpoints).
   * This can happen for instance if the lines are perpendicular to one another.
   *
   * @param seg - the line segment to project
   * @returns the projected line segment, or `null` if there is no overlap
   * @see [org.locationtech.jts.geom.LineSegment.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#project-org.locationtech.jts.geom.LineSegment-)
   */
  project(seg: LineSegment): LineSegment;
  /**
   * Computes the Projection Factor for the projection of the point p
   * onto this LineSegment.  The Projection Factor is the constant r
   * by which the vector for this segment must be multiplied to
   * equal the vector for the projection of `p` on the line
   * defined by this segment.
   *
   * The projection factor will lie in the range `(-inf, +inf)`,
   * or be `NaN` if the line segment has zero length..
   *
   * @param p - the point to compute the factor for
   * @returns the projection factor for the point
   * @see [org.locationtech.jts.geom.LineSegment.projectionFactor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#projectionFactor-org.locationtech.jts.geom.Coordinate-)
   */
  projectionFactor(p: Coordinate): number;
  /**
   * Computes the reflection of a point in the line defined
   * by this line segment.
   *
   * @param p - the point to reflect
   * @returns the reflected point
   * @see [org.locationtech.jts.geom.LineSegment.reflect](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#reflect-org.locationtech.jts.geom.Coordinate-)
   */
  reflect(p: Coordinate): Coordinate;
  /**
   * Computes the fraction of distance (in `[0.0, 1.0]`)
   * that the projection of a point occurs along this line segment.
   * If the point is beyond either ends of the line segment,
   * the closest fractional value (`0.0` or `1.0`) is returned.
   *
   * Essentially, this is the `projectionFactor` clamped to
   * the range `[0.0, 1.0]`.
   * If the segment has zero length, 1.0 is returned.
   *
   * @param inputPt - the point
   * @returns the fraction along the line segment the projection of the point occurs
   * @see [org.locationtech.jts.geom.LineSegment.segmentFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#segmentFraction-org.locationtech.jts.geom.Coordinate-)
   */
  segmentFraction(inputPt: Coordinate): number;
}

export interface MinimumBoundingCircle {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'MinimumBoundingCircle';

  /**
   * Gets the centre point of the computed Minimum Bounding Circle.
   *
   * @returns the centre point of the Minimum Bounding Circle
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getCentre--)
   */
  getCentre(): Coordinate;
  /**
   * Gets a geometry which represents the Minimum Bounding Circle.
   * If the input is degenerate (empty or a single unique point),
   * this method will return an empty geometry or a single Point geometry.
   * Otherwise, a Polygon will be returned which approximates the
   * Minimum Bounding Circle.
   * (Note that because the computed polygon is only an approximation,
   * it may not precisely contain all the input points.)
   *
   * @returns a Geometry representing the Minimum Bounding Circle.
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getCircle--)
   */
  getCircle(): Geometry;
  /**
   * Gets a geometry representing the diameter of the computed Minimum Bounding
   * Circle.
   *
   * @returns the diameter LineString of the Minimum Bounding Circle
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getDiameter--)
   */
  getDiameter(): Geometry;
  /**
   * Gets a geometry representing a line between the two farthest points
   * in the input.
   *
   * The points are two of the extremal points of the Minimum Bounding Circle.
   * They lie on the convex hull of the input.
   *
   * @returns a LineString between the two farthest points of the input
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getFarthestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getFarthestPoints--)
   */
  getFarthestPoints(): Geometry;
  /**
   * Gets a geometry representing the maximum diameter of the
   * input. The maximum diameter is the longest line segment
   * between any two points of the input.
   *
   * The points are two of the extremal points of the Minimum Bounding Circle.
   * They lie on the convex hull of the input.
   *
   * @returns a LineString between the two farthest points of the input
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getMaximumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getMaximumDiameter--)
   */
  getMaximumDiameter(): Geometry;
  /**
   * Gets the radius of the computed Minimum Bounding Circle.
   *
   * @returns the radius of the Minimum Bounding Circle
   * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getRadius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getRadius--)
   */
  getRadius(): number;
}

export interface MinimumDiameter {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'MinimumDiameter';

  /**
   * Gets a `LineString` which is a minimum diameter
   *
   * @returns a `LineString` which is a minimum diameter
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getDiameter--)
   */
  getDiameter(): Geometry;
  /**
   * Gets the length of the minimum diameter of the input Geometry
   *
   * @returns the length of the minimum diameter
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getLength--)
   */
  getLength(): number;
  /**
   * Gets the length of the minimum diameter enclosing a geometry
   *
   * @param geom - the geometry
   * @returns the length of the minimum diameter of the geometry
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumDiameter-org.locationtech.jts.geom.Geometry-)
   */
  getMinimumDiameter(geom: Geometry): Geometry;
  /**
   * Gets the rectangular `Polygon` which encloses the input geometry
   * and is based on the minimum diameter supporting segment.
   * The rectangle has width equal to the minimum diameter,
   * and a longer length.
   * If the convex hull of the input is degenerate (a line or point)
   * a `LineString` or `Point` is returned.
   *
   * This is not necessarily the enclosing rectangle with minimum area.
   *
   * @returns a rectangle enclosing the input (or a line or point if degenerate)
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumRectangle--)
   */
  getMinimumRectangle(): Geometry;
  /**
   * Gets the minimum-width rectangular `Polygon` which encloses the input geometry
   * and is based along the supporting segment.
   * The rectangle has width equal to the minimum diameter,
   * and a longer length.
   * If the convex hull of the input is degenerate (a line or point)
   * a `LineString` or `Point` is returned.
   *
   * This is not necessarily the rectangle with minimum area.
   * Use `MinimumAreaRectangle` to compute this.
   *
   * @param geom - the geometry
   * @returns the minimum-width rectangle enclosing the geometry
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumRectangle-org.locationtech.jts.geom.Geometry-)
   */
  getMinimumRectangle(geom: Geometry): Geometry;
  /**
   * Gets the segment forming the base of the minimum diameter
   *
   * @returns the segment forming the base of the minimum diameter
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getSupportingSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getSupportingSegment--)
   */
  getSupportingSegment(): Geometry;
  /**
   * Gets the `Coordinate` forming one end of the minimum diameter
   *
   * @returns a coordinate forming one end of the minimum diameter
   * @see [org.locationtech.jts.algorithm.MinimumDiameter.getWidthCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getWidthCoordinate--)
   */
  getWidthCoordinate(): Coordinate;
}

export interface Centroid {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Centroid';

  /**
   * Gets the computed centroid.
   *
   * @returns the computed centroid, or null if the input is empty
   * @see [org.locationtech.jts.algorithm.Centroid.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Centroid.html#getCentroid--)
   */
  getCentroid(): Coordinate;
  /**
   * Computes the centroid point of a geometry.
   *
   * @param geom - the geometry to use
   * @returns the centroid point, or null if the geometry is empty
   * @see [org.locationtech.jts.algorithm.Centroid.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Centroid.html#getCentroid-org.locationtech.jts.geom.Geometry-)
   */
  getCentroid(geom: Geometry): Coordinate;
}

export interface InteriorPointArea {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'InteriorPointArea';

  /**
   * Gets the computed interior point.
   *
   * @returns the coordinate of an interior point or `null` if the input geometry is empty
   * @see [org.locationtech.jts.algorithm.InteriorPointArea.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointArea.html#getInteriorPoint--)
   */
  getInteriorPoint(): Coordinate;
  /**
   * Computes an interior point for the
   * polygonal components of a Geometry.
   *
   * @param geom - the geometry to compute
   * @returns the computed interior point, or `null` if the geometry has no polygonal components
   * @see [org.locationtech.jts.algorithm.InteriorPointArea.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointArea.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
   */
  getInteriorPoint(geom: Geometry): Coordinate;
}

export interface InteriorPointLine {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'InteriorPointLine';

  getInteriorPoint(): Coordinate;
  /**
   * Computes an interior point for the
   * linear components of a Geometry.
   *
   * @param geom - the geometry to compute
   * @returns the computed interior point, or `null` if the geometry has no linear components
   * @see [org.locationtech.jts.algorithm.InteriorPointLine.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointLine.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
   */
  getInteriorPoint(geom: Geometry): Coordinate;
}

export interface InteriorPointPoint {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'InteriorPointPoint';

  getInteriorPoint(): Coordinate;
  /**
   * Computes an interior point for the
   * puntal components of a Geometry.
   *
   * @param geom - the geometry to compute
   * @returns the computed interior point, or `null` if the geometry has no puntal components
   * @see [org.locationtech.jts.algorithm.InteriorPointPoint.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointPoint.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
   */
  getInteriorPoint(geom: Geometry): Coordinate;
}

export interface PreparedGeometryFactory {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'PreparedGeometryFactory';

  /**
   * Creates a new `PreparedGeometry` appropriate for the argument `Geometry`.
   *
   * @param geom - the geometry to prepare
   * @returns the prepared geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometryFactory.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometryFactory.html#create-org.locationtech.jts.geom.Geometry-)
   */
  create(geom: Geometry): PreparedGeometry;
  /**
   * Creates a new `PreparedGeometry` appropriate for the argument `Geometry`.
   *
   * @param geom - the geometry to prepare
   * @returns the prepared geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometryFactory.prepare](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometryFactory.html#prepare-org.locationtech.jts.geom.Geometry-)
   */
  prepare(geom: Geometry): PreparedGeometry;
}

export interface PreparedGeometry {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'PreparedGeometry';

  /**
   * Tests whether the base `Geometry` contains a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry contains the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#contains-org.locationtech.jts.geom.Geometry-)
   */
  contains(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` properly contains a given geometry.
   *
   * The `containsProperly` predicate has the following equivalent definitions:
   *
   * - Every point of the other geometry is a point of this geometry's interior.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   * `[T**FF*FF*]`
   *
   * In other words, if the test geometry has any interaction with the boundary of the target
   * geometry the result of `containsProperly` is `false`.
   * This is different semantics to the `Geometry.contains` predicate,
   * in which test geometries can intersect the target's boundary and still be contained.
   *
   * The advantage of using this predicate is that it can be computed
   * efficiently, since it avoids the need to compute the full topological relationship
   * of the input boundaries in cases where they intersect.
   *
   * An example use case is computing the intersections
   * of a set of geometries with a large polygonal geometry.
   * Since `intersection` is a fairly slow operation, it can be more efficient
   * to use `containsProperly` to filter out test geometries which lie
   * wholly inside the area.  In these cases the intersection is
   * known _a priori_ to be exactly the original test geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry properly contains the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.containsProperly](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#containsProperly-org.locationtech.jts.geom.Geometry-)
   */
  containsProperly(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` is covered by a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry is covered by the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.coveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#coveredBy-org.locationtech.jts.geom.Geometry-)
   */
  coveredBy(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` covers a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry covers the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#covers-org.locationtech.jts.geom.Geometry-)
   */
  covers(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` crosses a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry crosses the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.crosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#crosses-org.locationtech.jts.geom.Geometry-)
   */
  crosses(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` is disjoint from a given geometry.
   * This method supports `GeometryCollection`s as input
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry is disjoint from the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#disjoint-org.locationtech.jts.geom.Geometry-)
   */
  disjoint(geom: Geometry): boolean;
  /**
   * Gets the original `Geometry` which has been prepared.
   *
   * @returns the base geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#getGeometry--)
   */
  getGeometry(): Geometry;
  /**
   * Tests whether the base `Geometry` intersects a given geometry.
   * This method supports `GeometryCollection`s as input
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry intersects the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#intersects-org.locationtech.jts.geom.Geometry-)
   */
  intersects(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` overlaps a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry overlaps the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.overlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#overlaps-org.locationtech.jts.geom.Geometry-)
   */
  overlaps(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` touches a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry touches the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.touches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#touches-org.locationtech.jts.geom.Geometry-)
   */
  touches(geom: Geometry): boolean;
  /**
   * Tests whether the base `Geometry` is within a given geometry.
   *
   * @param geom - the Geometry to test
   * @returns true if this Geometry is within the given Geometry
   * @see [org.locationtech.jts.geom.prep.PreparedGeometry.within](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#within-org.locationtech.jts.geom.Geometry-)
   */
  within(geom: Geometry): boolean;
}

export interface OffsetCurve {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'OffsetCurve';

  /**
   * Gets the computed offset curve lines.
   *
   * @returns the offset curve geometry
   * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve--)
   */
  getCurve(): Geometry;
  /**
   * Computes the offset curve of a geometry at a given distance.
   *
   * @param geom - a geometry
   * @param distance - the offset distance (positive for left, negative for right)
   * @returns the offset curve
   * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve-org.locationtech.jts.geom.Geometry-double-)
   */
  getCurve(geom: Geometry, distance: number): Geometry;
  /**
   * Computes the offset curve of a geometry at a given distance,
   * with specified quadrant segments, join style and mitre limit.
   *
   * @param geom - a geometry
   * @param distance - the offset distance (positive for left, negative for right)
   * @param quadSegs - the quadrant segments (-1 for default)
   * @param joinStyle - the join style (-1 for default)
   * @param mitreLimit - the mitre limit (-1 for default)
   * @returns the offset curve
   * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve-org.locationtech.jts.geom.Geometry-double-int-int-double-)
   */
  getCurve(geom: Geometry, distance: number, quadSegs: number, joinStyle: number, mitreLimit: number): Geometry;
  /**
   * Computes a single curve line for each input linear component,
   * by joining curve sections in order along the raw offset curve.
   * The default mode is to compute separate curve sections.
   *
   * @param isJoined - true if joined mode should be used.
   * @see [org.locationtech.jts.operation.buffer.OffsetCurve.setJoined](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#setJoined-boolean-)
   */
  setJoined(isJoined: boolean): any /* void */;
}

export interface BufferOp {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'BufferOp';

  /**
   * Specifies a butt (or flat) line buffer end cap style.
   *
   * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_BUTT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_BUTT)
   */
  CAP_BUTT: number;
  /**
   * Specifies a butt (or flat) line buffer end cap style.
   *
   * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_FLAT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_FLAT)
   */
  CAP_FLAT: number;
  /**
   * Specifies a round line buffer end cap style.
   *
   * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_ROUND](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_ROUND)
   */
  CAP_ROUND: number;
  /**
   * Specifies a square line buffer end cap style.
   *
   * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_SQUARE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_SQUARE)
   */
  CAP_SQUARE: number;
  /**
   * Computes the buffer for a geometry for a given buffer distance
   * and accuracy of approximation.
   *
   * @param g - the geometry to buffer
   * @param distance - the buffer distance
   * @param params - the buffer parameters to use
   * @returns the buffer of the input geometry
   * @see [org.locationtech.jts.operation.buffer.BufferOp.bufferOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#bufferOp-org.locationtech.jts.geom.Geometry-double-org.locationtech.jts.operation.buffer.BufferParameters-)
   */
  bufferOp(g: Geometry, distance: number, params: any /* org.locationtech.jts.operation.buffer.BufferParameters */): Geometry;
  /**
   * Returns the buffer computed for a geometry for a given buffer distance.
   *
   * @param distance - the buffer distance
   * @returns the buffer of the input geometry
   * @see [org.locationtech.jts.operation.buffer.BufferOp.getResultGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#getResultGeometry-double-)
   */
  getResultGeometry(distance: number): Geometry;
  /**
   * Specifies the end cap style of the generated buffer.
   * The styles supported are `BufferParameters.CAP_ROUND`, `BufferParameters.CAP_FLAT`, and `BufferParameters.CAP_SQUARE`.
   * The default is CAP_ROUND.
   *
   * @param endCapStyle - the end cap style to specify
   * @see [org.locationtech.jts.operation.buffer.BufferOp.setEndCapStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#setEndCapStyle-int-)
   */
  setEndCapStyle(endCapStyle: number): any /* void */;
  /**
   * Sets the number of line segments in a quarter-circle
   * used to approximate angle fillets for round end caps and joins.
   *
   * @param quadrantSegments - the number of segments in a fillet for a quadrant
   * @see [org.locationtech.jts.operation.buffer.BufferOp.setQuadrantSegments](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#setQuadrantSegments-int-)
   */
  setQuadrantSegments(quadrantSegments: number): any /* void */;
}

export interface DistanceOp {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'DistanceOp';

  /**
   * Compute the the closest points of two geometries.
   * The points are presented in the same order as the input Geometries.
   *
   * @param g0 - a `Geometry`
   * @param g1 - another `Geometry`
   * @returns the closest points in the geometries
   * @see [org.locationtech.jts.operation.distance.DistanceOp.closestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#closestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
   */
  closestPoints(g0: Geometry, g1: Geometry): Coordinate[];
  /**
   * Report the distance between the nearest points on the input geometries.
   *
   * @returns the distance between the geometries or 0 if either input geometry is empty
   * @throws IllegalArgumentException if either input geometry is null
   * @see [org.locationtech.jts.operation.distance.DistanceOp.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#distance--)
   */
  distance(): number;
  /**
   * Compute the distance between the nearest points of two geometries.
   *
   * @param g0 - a `Geometry`
   * @param g1 - another `Geometry`
   * @returns the distance between the geometries
   * @see [org.locationtech.jts.operation.distance.DistanceOp.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#distance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
   */
  distance(g0: Geometry, g1: Geometry): number;
  /**
   * Test whether two geometries lie within a given distance of each other.
   *
   * @param g0 - a `Geometry`
   * @param g1 - another `Geometry`
   * @param distance - the distance to test
   * @returns true if g0.distance(g1) <= distance
   * @see [org.locationtech.jts.operation.distance.DistanceOp.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#isWithinDistance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
   */
  isWithinDistance(g0: Geometry, g1: Geometry, distance: number): boolean;
  /**
   * Compute the the nearest points of two geometries.
   * The points are presented in the same order as the input Geometries.
   *
   * @param g0 - a `Geometry`
   * @param g1 - another `Geometry`
   * @returns the nearest points in the geometries
   * @see [org.locationtech.jts.operation.distance.DistanceOp.nearestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#nearestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
   */
  nearestPoints(g0: Geometry, g1: Geometry): Coordinate[];
}

export interface IntersectionMatrix {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'IntersectionMatrix';

  /**
   * Adds one matrix to another.
   * Addition is defined by taking the maximum dimension value of each position
   * in the summand matrices.
   *
   * @param im - the matrix to add
   * @see [org.locationtech.jts.geom.IntersectionMatrix.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#add-org.locationtech.jts.geom.IntersectionMatrix-)
   */
  add(im: IntersectionMatrix): any /* void */;
  /**
   * Returns the value of one of this matrix
   * entries.
   * The value of the provided index is one of the
   * values from the `Location` class.
   * The value returned is a constant
   * from the `Dimension` class.
   *
   * @param row - the row of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the first `Geometry`
   * @param column - the column of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the second `Geometry`
   * @returns the dimension value at the given matrix position.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.get](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#get-int-int-)
   */
  get(row: number, column: number): number;
  /**
   * Tests whether this matrix matches [T*****FF*[.
   *
   * @returns `true` if the first `Geometry` contains the second
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isContains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isContains--)
   */
  isContains(): boolean;
  /**
   * Tests if this matrix matches
   * `[T*F**F***]`
   * or `[*TF**F***]`
   * or `[**FT*F***]`
   * or `[**F*TF***]`
   *
   * @returns `true` if the first `Geometry` is covered by the second
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isCoveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCoveredBy--)
   */
  isCoveredBy(): boolean;
  /**
   * Tests if this matrix matches
   * `[T*****FF*]`
   * or `[*T****FF*]`
   * or `[***T**FF*]`
   * or `[****T*FF*]`
   *
   * @returns `true` if the first `Geometry` covers the second
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isCovers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCovers--)
   */
  isCovers(): boolean;
  /**
   * Tests whether this geometry crosses the
   * specified geometry.
   *
   * The `crosses` predicate has the following equivalent definitions:
   *
   * - The geometries have some but not all interior points in common.
   * - The DE-9IM Intersection Matrix for the two geometries matches
   *
   * - `[T*T******]` (for P/L, P/A, and L/A situations)
   * - `[T*****T**]` (for L/P, L/A, and A/L situations)
   * - `[0********]` (for L/L situations)
   *
   * For any other combination of dimensions this predicate returns `false`.
   *
   * The SFS defined this predicate only for P/L, P/A, L/L, and L/A situations.
   * JTS extends the definition to apply to L/P, A/P and A/L situations as well.
   * This makes the relation symmetric.
   *
   * @param dimensionOfGeometryA - the dimension of the first `Geometry`
   * @param dimensionOfGeometryB - the dimension of the second `Geometry`
   * @returns `true` if the two `Geometry`s related by this matrix cross.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isCrosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCrosses-int-int-)
   */
  isCrosses(dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
  /**
   * Tests if this matrix matches `[FF*FF****]`.
   *
   * @returns `true` if the two `Geometry`s related by this matrix are disjoint
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isDisjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isDisjoint--)
   */
  isDisjoint(): boolean;
  /**
   * Tests whether the argument dimensions are equal and
   * this matrix matches the pattern `[T*F**FFF*]`.
   *
   * **Note:** This pattern differs from the one stated in
   * _Simple feature access - Part 1: Common architecture_.
   * That document states the pattern as `[TFFFTFFFT]`.  This would
   * specify that
   * two identical `POINT`s are not equal, which is not desirable behaviour.
   * The pattern used here has been corrected to compute equality in this situation.
   *
   * @param dimensionOfGeometryA - the dimension of the first `Geometry`
   * @param dimensionOfGeometryB - the dimension of the second `Geometry`
   * @returns `true` if the two `Geometry`s related by this matrix are equal; the `Geometry`s must have the same dimension to be equal
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isEquals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isEquals-int-int-)
   */
  isEquals(dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
  /**
   * Tests if `isDisjoint` returns false.
   *
   * @returns `true` if the two `Geometry`s related by this matrix intersect
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isIntersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isIntersects--)
   */
  isIntersects(): boolean;
  /**
   * Tests if this matrix matches
   *
   * - `[T*T***T**]` (for two points or two surfaces)
   * - `[1*T***T**]` (for two curves)
   *
   * .
   *
   * @param dimensionOfGeometryA - the dimension of the first `Geometry`
   * @param dimensionOfGeometryB - the dimension of the second `Geometry`
   * @returns `true` if the two `Geometry`s related by this matrix overlap. For this function to return `true`, the `Geometry`s must be two points, two curves or two surfaces.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isOverlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isOverlaps-int-int-)
   */
  isOverlaps(dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
  /**
   * Tests if this matrix matches
   * `[FT*******]`, `[F**T*****]` or `[F***T****]`.
   *
   * @param dimensionOfGeometryA - the dimension of the first `Geometry`
   * @param dimensionOfGeometryB - the dimension of the second `Geometry`
   * @returns `true` if the two `Geometry` s related by this matrix touch; Returns false if both `Geometry`s are points.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isTouches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isTouches-int-int-)
   */
  isTouches(dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
  /**
   * Tests if the dimension value matches `TRUE`
   * (i.e.  has value 0, 1, 2 or TRUE).
   *
   * @param actualDimensionValue - a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
   * @returns true if the dimension value matches TRUE
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isTrue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isTrue-int-)
   */
  isTrue(actualDimensionValue: number): boolean;
  /**
   * Tests whether this matrix matches `[T*F**F***]`.
   *
   * @returns `true` if the first `Geometry` is within the second
   * @see [org.locationtech.jts.geom.IntersectionMatrix.isWithin](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isWithin--)
   */
  isWithin(): boolean;
  /**
   * Tests whether this matrix matches the given matrix pattern.
   *
   * @param pattern - A pattern containing nine dimension symbols with which to compare the entries of this matrix. Possible symbol values are `{T, F, * , 0, 1, 2}`.
   * @returns `true` if this matrix matches the pattern
   * @see [org.locationtech.jts.geom.IntersectionMatrix.matches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#matches-java.lang.String-)
   */
  matches(pattern: string): boolean;
  /**
   * Tests if the dimension value satisfies the dimension symbol.
   *
   * @param actualDimensionValue - a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
   * @param requiredDimensionSymbol - a character used in the string representation of an `IntersectionMatrix`. Possible values are `{T, F, * , 0, 1, 2}`.
   * @returns true if the dimension symbol matches the dimension value
   * @see [org.locationtech.jts.geom.IntersectionMatrix.matches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#matches-int-char-)
   */
  matches(actualDimensionValue: number, requiredDimensionSymbol: any /* char */): boolean;
  /**
   * Changes the elements of this `IntersectionMatrix` to the
   * dimension symbols in `dimensionSymbols`.
   *
   * @param dimensionSymbols - nine dimension symbols to which to set this `IntersectionMatrix` s elements. Possible values are `{T, F, * , 0, 1, 2}`
   * @see [org.locationtech.jts.geom.IntersectionMatrix.set](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#set-java.lang.String-)
   */
  set(dimensionSymbols: string): any /* void */;
  /**
   * Changes the value of one of this `IntersectionMatrix`s
   * elements.
   *
   * @param row - the row of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the first `Geometry`
   * @param column - the column of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the second `Geometry`
   * @param dimensionValue - the new value of the element
   * @see [org.locationtech.jts.geom.IntersectionMatrix.set](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#set-int-int-int-)
   */
  set(row: number, column: number, dimensionValue: number): any /* void */;
  /**
   * Changes the elements of this `IntersectionMatrix` to `dimensionValue`
   * .
   *
   * @param dimensionValue - the dimension value to which to set this `IntersectionMatrix` s elements. Possible values `{TRUE, FALSE, DONTCARE, 0, 1, 2}` .
   * @see [org.locationtech.jts.geom.IntersectionMatrix.setAll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAll-int-)
   */
  setAll(dimensionValue: number): any /* void */;
  /**
   * For each element in this `IntersectionMatrix`, changes the
   * element to the corresponding minimum dimension symbol if the element is
   * less.
   *
   * @param minimumDimensionSymbols - nine dimension symbols with which to compare the elements of this `IntersectionMatrix`. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}` .
   * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeast](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeast-java.lang.String-)
   */
  setAtLeast(minimumDimensionSymbols: string): any /* void */;
  /**
   * Changes the specified element to `minimumDimensionValue` if the
   * element is less.
   *
   * @param row - the row of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the first `Geometry`
   * @param column - the column of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the second `Geometry`
   * @param minimumDimensionValue - the dimension value with which to compare the element. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}`.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeast](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeast-int-int-int-)
   */
  setAtLeast(row: number, column: number, minimumDimensionValue: number): any /* void */;
  /**
   * If row >= 0 and column >= 0, changes the specified element to `minimumDimensionValue`
   * if the element is less. Does nothing if row <0 or column < 0.
   *
   * @param row - the row of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the first `Geometry`
   * @param column - the column of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the second `Geometry`
   * @param minimumDimensionValue - the dimension value with which to compare the element. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}`.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeastIfValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeastIfValid-int-int-int-)
   */
  setAtLeastIfValid(row: number, column: number, minimumDimensionValue: number): any /* void */;
  /**
   * Returns a nine-character `String` representation of this `IntersectionMatrix`
   * .
   *
   * @returns the nine dimension symbols of this `IntersectionMatrix` in row-major order.
   * @see [org.locationtech.jts.geom.IntersectionMatrix.toString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#toString--)
   */
  toString(): string;
  /**
   * Transposes this IntersectionMatrix.
   *
   * @returns this `IntersectionMatrix` as a convenience
   * @see [org.locationtech.jts.geom.IntersectionMatrix.transpose](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#transpose--)
   */
  transpose(): IntersectionMatrix;
}

export interface CoordinateSequence {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'CoordinateSequence';

  /**
   * Standard ordinate index value for, where M is 3.
   *
   * This constant assumes XYZM coordinate sequence definition, please check this assumption
   * using `getDimension` and `getMeasures` before use.
   *
   * @see [org.locationtech.jts.geom.CoordinateSequence.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#M)
   */
  M: number;
  /**
   * Standard ordinate index value for, where X is 0
   *
   * @see [org.locationtech.jts.geom.CoordinateSequence.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#X)
   */
  X: number;
  /**
   * Standard ordinate index value for, where Y is 1
   *
   * @see [org.locationtech.jts.geom.CoordinateSequence.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#Y)
   */
  Y: number;
  /**
   * Standard z-ordinate index
   *
   * @see [org.locationtech.jts.geom.CoordinateSequence.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#Z)
   */
  Z: number;
  /**
   * Returns a deep copy of this collection.
   *
   * @returns a copy of the coordinate sequence containing copies of all points
   * @see [org.locationtech.jts.geom.CoordinateSequence.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#copy--)
   */
  copy(): CoordinateSequence;
  /**
   * Creates a coordinate for use in this sequence.
   *
   * The coordinate is created supporting the same number of `getDimension` and `getMeasures`
   * as this sequence and is suitable for use with `Coordinate)`.
   *
   * @returns coordinate for use with this sequence
   * @see [org.locationtech.jts.geom.CoordinateSequence.createCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#createCoordinate--)
   */
  createCoordinate(): Coordinate;
  /**
   * Expands the given `Envelope` to include the coordinates in the sequence.
   * Allows implementing classes to optimize access to coordinate values.
   *
   * @param env - the envelope to expand
   * @returns a ref to the expanded envelope
   * @see [org.locationtech.jts.geom.CoordinateSequence.expandEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#expandEnvelope-org.locationtech.jts.geom.Envelope-)
   */
  expandEnvelope(env: Envelope): Envelope;
  /**
   * Returns (possibly a copy of) the i'th coordinate in this sequence.
   * Whether or not the Coordinate returned is the actual underlying
   * Coordinate or merely a copy depends on the implementation.
   *
   * Note that in the future the semantics of this method may change
   * to guarantee that the Coordinate returned is always a copy.
   * Callers should not to assume that they can modify a CoordinateSequence by
   * modifying the object returned by this method.
   *
   * @param i - the index of the coordinate to retrieve
   * @returns the i'th coordinate in the sequence
   * @see [org.locationtech.jts.geom.CoordinateSequence.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getCoordinate-int-)
   */
  getCoordinate(i: number): Coordinate;
  /**
   * Returns a copy of the i'th coordinate in this sequence.
   * This method optimizes the situation where the caller is
   * going to make a copy anyway - if the implementation
   * has already created a new Coordinate object, no further copy is needed.
   *
   * @param i - the index of the coordinate to retrieve
   * @returns a copy of the i'th coordinate in the sequence
   * @see [org.locationtech.jts.geom.CoordinateSequence.getCoordinateCopy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getCoordinateCopy-int-)
   */
  getCoordinateCopy(i: number): Coordinate;
  /**
   * Returns the dimension (number of ordinates in each coordinate) for this sequence.
   *
   * This total includes any measures, indicated by non-zero `getMeasures`.
   *
   * @returns the dimension of the sequence.
   * @see [org.locationtech.jts.geom.CoordinateSequence.getDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getDimension--)
   */
  getDimension(): number;
  /**
   * Returns ordinate M of the specified coordinate if available.
   *
   * @param index - the coordinate index in the sequence
   * @returns the value of the M ordinate in the index'th coordinate, or Double.NaN if not defined.
   * @see [org.locationtech.jts.geom.CoordinateSequence.getM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getM-int-)
   */
  getM(index: number): number;
  /**
   * Returns the number of measures included in `getDimension` for each coordinate for this
   * sequence.
   *
   * For a measured coordinate sequence a non-zero value is returned.
   *
   * - For XY sequence measures is zero
   * - For XYM sequence measure is one
   * -
   * - For XYZ sequence measure is zero
   * - For XYZM sequence measure is one
   * - Values greater than one are supported
   *
   * @returns the number of measures included in dimension
   * @see [org.locationtech.jts.geom.CoordinateSequence.getMeasures](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getMeasures--)
   */
  getMeasures(): number;
  /**
   * Returns the ordinate of a coordinate in this sequence.
   * Ordinate indices 0 and 1 are assumed to be X and Y.
   *
   * Ordinates indices greater than 1 have user-defined semantics
   * (for instance, they may contain other dimensions or measure
   * values as described by `getDimension` and `getMeasures`).
   *
   * @param index - the coordinate index in the sequence
   * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
   * @returns ordinate value
   * @see [org.locationtech.jts.geom.CoordinateSequence.getOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getOrdinate-int-int-)
   */
  getOrdinate(index: number, ordinateIndex: number): number;
  /**
   * Returns ordinate X (0) of the specified coordinate.
   *
   * @param index - the coordinate index in the sequence
   * @returns the value of the X ordinate in the index'th coordinate
   * @see [org.locationtech.jts.geom.CoordinateSequence.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getX-int-)
   */
  getX(index: number): number;
  /**
   * Returns ordinate Y (1) of the specified coordinate.
   *
   * @param index - the coordinate index in the sequence
   * @returns the value of the Y ordinate in the index'th coordinate
   * @see [org.locationtech.jts.geom.CoordinateSequence.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getY-int-)
   */
  getY(index: number): number;
  /**
   * Returns ordinate Z of the specified coordinate if available.
   *
   * @param index - the coordinate index in the sequence
   * @returns the value of the Z ordinate in the index'th coordinate, or Double.NaN if not defined.
   * @see [org.locationtech.jts.geom.CoordinateSequence.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getZ-int-)
   */
  getZ(index: number): number;
  /**
   * Tests whether the coordinates in the sequence have measures associated with them. Returns true
   * if `getMeasures` `> 0`. See `getMeasures` to determine the number of measures
   * present.
   *
   * @returns true if `getM` is supported.
   * @see [org.locationtech.jts.geom.CoordinateSequence.hasM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#hasM--)
   */
  hasM(): boolean;
  /**
   * Checks `getDimension` and `getMeasures` to determine if `getZ`
   * is supported.
   *
   * @returns true if `getZ` is supported.
   * @see [org.locationtech.jts.geom.CoordinateSequence.hasZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#hasZ--)
   */
  hasZ(): boolean;
  /**
   * Sets the value for a given ordinate of a coordinate in this sequence.
   *
   * @param index - the coordinate index in the sequence
   * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
   * @param value - the new ordinate value
   * @see [org.locationtech.jts.geom.CoordinateSequence.setOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#setOrdinate-int-int-double-)
   */
  setOrdinate(index: number, ordinateIndex: number, value: number): any /* void */;
  /**
   * Returns the number of coordinates in this sequence.
   *
   * @returns the size of the sequence
   * @see [org.locationtech.jts.geom.CoordinateSequence.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#size--)
   */
  size(): number;
}

export interface Densifier {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'Densifier';

}

export interface GeometryFixer {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'GeometryFixer';

}

export interface GeometryPrecisionReducer {
  /** Brand: prevents structural assignment from plain objects. */
  readonly __jtsBrand?: 'GeometryPrecisionReducer';

}

declare global {
  const wasmts: {
    algorithm: {
      Angle: {
        /**
         * Constant representing clockwise orientation
         *
         * @see [org.locationtech.jts.algorithm.Angle.CLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#CLOCKWISE)
         */
        CLOCKWISE: number;
        /**
         * Constant representing counterclockwise orientation
         *
         * @see [org.locationtech.jts.algorithm.Angle.COUNTERCLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#COUNTERCLOCKWISE)
         */
        COUNTERCLOCKWISE: number;
        /**
         * Constant representing no orientation
         *
         * @see [org.locationtech.jts.algorithm.Angle.NONE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#NONE)
         */
        NONE: number;
        /**
         * The value of Pi/2
         *
         * @see [org.locationtech.jts.algorithm.Angle.PI_OVER_2](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#PI_OVER_2)
         */
        PI_OVER_2: number;
        /**
         * The value of Pi/4
         *
         * @see [org.locationtech.jts.algorithm.Angle.PI_OVER_4](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#PI_OVER_4)
         */
        PI_OVER_4: number;
        /**
         * The value of 2*Pi
         *
         * @see [org.locationtech.jts.algorithm.Angle.PI_TIMES_2](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#PI_TIMES_2)
         */
        PI_TIMES_2: number;
        /**
         * Returns the angle of the vector from p0 to p1,
         * relative to the positive X-axis.
         * The angle is normalized to be in the range [ -Pi, Pi ].
         *
         * @param p0 - the initial point of the vector
         * @param p1 - the terminal point of the vector
         * @returns the normalized angle (in radians) that p0-p1 makes with the positive x-axis.
         * @see [org.locationtech.jts.algorithm.Angle.angle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#angle-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        angle(p0: Coordinate, p1: Coordinate): number;
        /**
         * Returns the unoriented smallest angle between two vectors.
         * The computed angle will be in the range [0, Pi).
         *
         * @param tip1 - the tip of one vector
         * @param tail - the tail of each vector
         * @param tip2 - the tip of the other vector
         * @returns the angle between tail-tip1 and tail-tip2
         * @see [org.locationtech.jts.algorithm.Angle.angleBetween](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#angleBetween-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        angleBetween(tip1: Coordinate, tail: Coordinate, tip2: Coordinate): number;
        /**
         * Returns the oriented smallest angle between two vectors.
         * The computed angle will be in the range (-Pi, Pi].
         * A positive result corresponds to a counterclockwise
         * (CCW) rotation
         * from v1 to v2;
         * a negative result corresponds to a clockwise (CW) rotation;
         * a zero result corresponds to no rotation.
         *
         * @param tip1 - the tip of v1
         * @param tail - the tail of each vector
         * @param tip2 - the tip of v2
         * @returns the angle between v1 and v2, relative to v1
         * @see [org.locationtech.jts.algorithm.Angle.angleBetweenOriented](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#angleBetweenOriented-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        angleBetweenOriented(tip1: Coordinate, tail: Coordinate, tip2: Coordinate): number;
        /**
         * Computes the angle of the unoriented bisector
         * of the smallest angle between two vectors.
         * The computed angle will be in the range (-Pi, Pi].
         *
         * @param tip1 - the tip of v1
         * @param tail - the tail of each vector
         * @param tip2 - the tip of v2
         * @returns the angle of the bisector between v1 and v2
         * @see [org.locationtech.jts.algorithm.Angle.bisector](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#bisector-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        bisector(tip1: Coordinate, tail: Coordinate, tip2: Coordinate): number;
        /**
         * Computes cos of an angle, snapping near-zero values to zero.
         *
         * @param ang - the input angle (in radians)
         * @returns the result of the trigonometric function
         * @see [org.locationtech.jts.algorithm.Angle.cosSnap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#cosSnap-double-)
         */
        cosSnap(ang: number): number;
        /**
         * Computes the unoriented smallest difference between two angles.
         * The angles are assumed to be normalized to the range [-Pi, Pi].
         * The result will be in the range [0, Pi].
         *
         * @param ang1 - the angle of one vector (in [-Pi, Pi] )
         * @param ang2 - the angle of the other vector (in range [-Pi, Pi] )
         * @returns the angle (in radians) between the two vectors (in range [0, Pi] )
         * @see [org.locationtech.jts.algorithm.Angle.diff](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#diff-double-double-)
         */
        diff(ang1: number, ang2: number): number;
        /**
         * Returns whether an angle must turn clockwise or counterclockwise
         * to overlap another angle.
         *
         * @param ang1 - an angle (in radians)
         * @param ang2 - an angle (in radians)
         * @returns whether a1 must turn CLOCKWISE, COUNTERCLOCKWISE or NONE to overlap a2.
         * @see [org.locationtech.jts.algorithm.Angle.getTurn](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#getTurn-double-double-)
         */
        getTurn(ang1: number, ang2: number): number;
        /**
         * Computes the interior angle between two segments of a ring. The ring is
         * assumed to be oriented in a clockwise direction. The computed angle will be
         * in the range [0, 2Pi]
         *
         * @param p0 - a point of the ring
         * @param p1 - the next point of the ring
         * @param p2 - the next point of the ring
         * @returns the interior angle based at `p1`
         * @see [org.locationtech.jts.algorithm.Angle.interiorAngle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#interiorAngle-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        interiorAngle(p0: Coordinate, p1: Coordinate, p2: Coordinate): number;
        /**
         * Tests whether the angle between p0-p1-p2 is acute.
         * An angle is acute if it is less than 90 degrees.
         *
         * Note: this implementation is not precise (deterministic) for angles very close to 90 degrees.
         *
         * @param p0 - an endpoint of the angle
         * @param p1 - the base of the angle
         * @param p2 - the other endpoint of the angle
         * @returns true if the angle is acute
         * @see [org.locationtech.jts.algorithm.Angle.isAcute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#isAcute-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isAcute(p0: Coordinate, p1: Coordinate, p2: Coordinate): boolean;
        /**
         * Tests whether the angle between p0-p1-p2 is obtuse.
         * An angle is obtuse if it is greater than 90 degrees.
         *
         * Note: this implementation is not precise (deterministic) for angles very close to 90 degrees.
         *
         * @param p0 - an endpoint of the angle
         * @param p1 - the base of the angle
         * @param p2 - the other endpoint of the angle
         * @returns true if the angle is obtuse
         * @see [org.locationtech.jts.algorithm.Angle.isObtuse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#isObtuse-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isObtuse(p0: Coordinate, p1: Coordinate, p2: Coordinate): boolean;
        /**
         * Computes the normalized value of an angle, which is the
         * equivalent angle in the range ( -Pi, Pi ].
         *
         * @param angle - the angle to normalize
         * @returns an equivalent angle in the range (-Pi, Pi]
         * @see [org.locationtech.jts.algorithm.Angle.normalize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#normalize-double-)
         */
        normalize(angle: number): number;
        /**
         * Computes the normalized positive value of an angle, which is the
         * equivalent angle in the range [ 0, 2*Pi ).
         * E.g.:
         *
         * - normalizePositive(0.0) = 0.0
         * - normalizePositive(-PI) = PI
         * - normalizePositive(-2PI) = 0.0
         * - normalizePositive(-3PI) = PI
         * - normalizePositive(-4PI) = 0
         * - normalizePositive(PI) = PI
         * - normalizePositive(2PI) = 0.0
         * - normalizePositive(3PI) = PI
         * - normalizePositive(4PI) = 0.0
         *
         * @param angle - the angle to normalize, in radians
         * @returns an equivalent positive angle
         * @see [org.locationtech.jts.algorithm.Angle.normalizePositive](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#normalizePositive-double-)
         */
        normalizePositive(angle: number): number;
        /**
         * Projects a point by a given angle and distance.
         *
         * @param p - the point to project
         * @param angle - the angle at which to project
         * @param dist - the distance to project
         * @returns the projected point
         * @see [org.locationtech.jts.algorithm.Angle.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#project-org.locationtech.jts.geom.Coordinate-double-double-)
         */
        project(p: Coordinate, angle: number, dist: number): Coordinate;
        /**
         * Computes sin of an angle, snapping near-zero values to zero.
         *
         * @param ang - the input angle (in radians)
         * @returns the result of the trigonometric function
         * @see [org.locationtech.jts.algorithm.Angle.sinSnap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#sinSnap-double-)
         */
        sinSnap(ang: number): number;
        /**
         * Converts from radians to degrees.
         *
         * @param radians - an angle in radians
         * @returns the angle in degrees
         * @see [org.locationtech.jts.algorithm.Angle.toDegrees](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#toDegrees-double-)
         */
        toDegrees(radians: number): number;
        /**
         * Converts from degrees to radians.
         *
         * @param angleDegrees - an angle in degrees
         * @returns the angle in radians
         * @see [org.locationtech.jts.algorithm.Angle.toRadians](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Angle.html#toRadians-double-)
         */
        toRadians(angleDegrees: number): number;
      };
      Area: {
        /**
         * Computes the area for a ring.
         *
         * @param ring - the coordinates forming the ring
         * @returns the area of the ring
         * @see [org.locationtech.jts.algorithm.Area.ofRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Area.html#ofRing-org.locationtech.jts.geom.Coordinate:A-)
         */
        ofRing(ring: Coordinate[]): number;
        /**
         * Computes the area for a ring.
         *
         * @param ring - the coordinates forming the ring
         * @returns the area of the ring
         * @see [org.locationtech.jts.algorithm.Area.ofRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Area.html#ofRing-org.locationtech.jts.geom.CoordinateSequence-)
         */
        ofRingSeq(ring: CoordinateSequence): number;
        /**
         * Computes the signed area for a ring. The signed area is positive if the
         * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
         * ring is degenerate or flat.
         *
         * @param ring - the coordinates forming the ring
         * @returns the signed area of the ring
         * @see [org.locationtech.jts.algorithm.Area.ofRingSigned](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Area.html#ofRingSigned-org.locationtech.jts.geom.Coordinate:A-)
         */
        ofRingSigned(ring: Coordinate[]): number;
        /**
         * Computes the signed area for a ring. The signed area is:
         *
         * - positive if the ring is oriented CW
         * - negative if the ring is oriented CCW
         * - zero if the ring is degenerate or flat
         *
         * @param ring - the coordinates forming the ring
         * @returns the signed area of the ring
         * @see [org.locationtech.jts.algorithm.Area.ofRingSigned](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Area.html#ofRingSigned-org.locationtech.jts.geom.CoordinateSequence-)
         */
        ofRingSignedSeq(ring: CoordinateSequence): number;
      };
      CGAlgorithms: {
        /**
         * A value that indicates an orientation of clockwise, or a right turn.
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.CLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#CLOCKWISE)
         */
        CLOCKWISE: number;
        /**
         * A value that indicates an orientation of collinear, or no turn (straight).
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.COLLINEAR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#COLLINEAR)
         */
        COLLINEAR: number;
        /**
         * A value that indicates an orientation of counterclockwise, or a left turn.
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.COUNTERCLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#COUNTERCLOCKWISE)
         */
        COUNTERCLOCKWISE: number;
        /**
         * A value that indicates an orientation of counterclockwise, or a left turn.
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.LEFT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#LEFT)
         */
        LEFT: number;
        /**
         * A value that indicates an orientation of clockwise, or a right turn.
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.RIGHT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#RIGHT)
         */
        RIGHT: number;
        /**
         * A value that indicates an orientation of collinear, or no turn (straight).
         *
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.STRAIGHT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#STRAIGHT)
         */
        STRAIGHT: number;
        /**
         * Computes the orientation of a point q to the directed line segment p1-p2.
         * The orientation of a point relative to a directed line segment indicates
         * which way you turn to get to q after travelling from p1 to p2.
         *
         * @param p1 - the first vertex of the line segment
         * @param p2 - the second vertex of the line segment
         * @param q - the point to compute the relative orientation of
         * @returns 1 if q is counter-clockwise from p1-p2, or -1 if q is clockwise from p1-p2, or 0 if q is collinear with p1-p2
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.computeOrientation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#computeOrientation-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        computeOrientation(p1: Coordinate, p2: Coordinate, q: Coordinate): number;
        /**
         * Computes the distance from a line segment AB to a line segment CD
         *
         * Note: NON-ROBUST!
         *
         * @param A - a point of one line
         * @param B - the second point of (must be different to A)
         * @param C - one point of the line
         * @param D - another point of the line (must be different to A)
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.distanceLineLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#distanceLineLine-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        distanceLineLine(A: Coordinate, B: Coordinate, C: Coordinate, D: Coordinate): number;
        /**
         * Computes the distance from a point p to a line segment AB
         *
         * Note: NON-ROBUST!
         *
         * @param p - the point to compute the distance for
         * @param A - one point of the line
         * @param B - another point of the line (must be different to A)
         * @returns the distance from p to line segment AB
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.distancePointLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#distancePointLine-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        distancePointLine(p: Coordinate, A: Coordinate, B: Coordinate): number;
        /**
         * Computes the perpendicular distance from a point p to the (infinite) line
         * containing the points AB
         *
         * @param p - the point to compute the distance for
         * @param A - one point of the line
         * @param B - another point of the line (must be different to A)
         * @returns the distance from p to line AB
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.distancePointLinePerpendicular](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#distancePointLinePerpendicular-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        distancePointLinePerpendicular(p: Coordinate, A: Coordinate, B: Coordinate): number;
        /**
         * Computes whether a ring defined by an array of `Coordinate`s is
         * oriented counter-clockwise.
         *
         * - The list of points is assumed to have the first and last points equal.
         * - This will handle coordinate lists which contain repeated points.
         *
         * This algorithm is **only** guaranteed to work with valid rings. If the
         * ring is invalid (e.g. self-crosses or touches), the computed result may not
         * be correct.
         *
         * @param ring - an array of Coordinates forming a ring
         * @returns true if the ring is oriented counter-clockwise.
         * @throws IllegalArgumentException if there are too few points to determine orientation (< 4)
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#isCCW-org.locationtech.jts.geom.Coordinate:A-)
         */
        isCCW(ring: Coordinate[]): boolean;
        /**
         * Tests whether a point lies on the line segments defined by a list of
         * coordinates.
         *
         * @returns true if the point is a vertex of the line or lies in the interior of a line segment in the linestring
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.isOnLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#isOnLine-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        isOnLine(p: Coordinate, pt: Coordinate[]): boolean;
        /**
         * Tests whether a point lies inside or on a ring. The ring may be oriented in
         * either direction. A point lying exactly on the ring boundary is considered
         * to be inside the ring.
         *
         * This method does _not_ first check the point against the envelope of
         * the ring.
         *
         * @param p - point to check for ring inclusion
         * @param ring - an array of coordinates representing the ring (which must have first point identical to last point)
         * @returns true if p is inside ring
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.isPointInRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#isPointInRing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        isPointInRing(p: Coordinate, ring: Coordinate[]): boolean;
        /**
         * Computes the length of a linestring specified by a sequence of points.
         *
         * @param pts - the points specifying the linestring
         * @returns the length of the linestring
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#length-org.locationtech.jts.geom.CoordinateSequence-)
         */
        length(pts: CoordinateSequence): number;
        /**
         * Determines whether a point lies in the interior, on the boundary, or in the
         * exterior of a ring. The ring may be oriented in either direction.
         *
         * This method does _not_ first check the point against the envelope of
         * the ring.
         *
         * @param p - point to check for ring inclusion
         * @param ring - an array of coordinates representing the ring (which must have first point identical to last point)
         * @returns the `Location` of p relative to the ring
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.locatePointInRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#locatePointInRing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        locatePointInRing(p: Coordinate, ring: Coordinate[]): number;
        /**
         * Returns the index of the direction of the point `q` relative to
         * a vector specified by `p1-p2`.
         *
         * @param p1 - the origin point of the vector
         * @param p2 - the final point of the vector
         * @param q - the point to compute the direction to
         * @returns `1` if q is counter-clockwise (left) from p1-p2 `-1` if q is clockwise (right) from p1-p2 `0` if q is collinear with p1-p2
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#orientationIndex-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        orientationIndex(p1: Coordinate, p2: Coordinate, q: Coordinate): number;
        /**
         * Computes the signed area for a ring. The signed area is positive if the
         * ring is oriented CW, negative if the ring is oriented CCW, and zero if the
         * ring is degenerate or flat.
         *
         * @param ring - the coordinates forming the ring
         * @returns the signed area of the ring
         * @see [org.locationtech.jts.algorithm.CGAlgorithms.signedArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms.html#signedArea-org.locationtech.jts.geom.Coordinate:A-)
         */
        signedArea(ring: Coordinate[]): number;
      };
      CGAlgorithms3D: {
        distance(p0: Coordinate, p1: Coordinate): number;
        distancePointSegment(p: Coordinate, A: Coordinate, B: Coordinate): number;
        /**
         * Computes the distance between two 3D segments.
         *
         * @param A - the start point of the first segment
         * @param B - the end point of the first segment
         * @param C - the start point of the second segment
         * @param D - the end point of the second segment
         * @returns the distance between the segments
         * @see [org.locationtech.jts.algorithm.CGAlgorithms3D.distanceSegmentSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithms3D.html#distanceSegmentSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        distanceSegmentSegment(A: Coordinate, B: Coordinate, C: Coordinate, D: Coordinate): number;
      };
      CGAlgorithmsDD: {
        /**
         * Computes an intersection point between two lines
         * using DD arithmetic.
         * If the lines are parallel (either identical
         * or separate) a null value is returned.
         *
         * @param p1 - an endpoint of line segment 1
         * @param p2 - an endpoint of line segment 1
         * @param q1 - an endpoint of line segment 2
         * @param q2 - an endpoint of line segment 2
         * @returns an intersection point if one exists, or null if the lines are parallel
         * @see [org.locationtech.jts.algorithm.CGAlgorithmsDD.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithmsDD.html#intersection-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersection(p1: Coordinate, p2: Coordinate, q1: Coordinate, q2: Coordinate): Coordinate;
        /**
         * Returns the index of the direction of the point `q` relative to
         * a vector specified by `p1-p2`.
         *
         * @param p1x - the x ordinate of the vector origin point
         * @param p1y - the y ordinate of the vector origin point
         * @param p2x - the x ordinate of the vector final point
         * @param p2y - the y ordinate of the vector final point
         * @param qx - the x ordinate of the query point
         * @param qy - the y ordinate of the query point
         * @returns 1 if q is counter-clockwise (left) from p1-p2 -1 if q is clockwise (right) from p1-p2 0 if q is collinear with p1-p2
         * @see [org.locationtech.jts.algorithm.CGAlgorithmsDD.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithmsDD.html#orientationIndex-double-double-double-double-double-double-)
         */
        orientationIndex(p1x: number, p1y: number, p2x: number, p2y: number, qx: number, qy: number): number;
        /**
         * Computes the sign of the determinant of the 2x2 matrix
         * with the given entries.
         *
         * @returns -1 if the determinant is negative, 1 if the determinant is positive, 0 if the determinant is 0.
         * @see [org.locationtech.jts.algorithm.CGAlgorithmsDD.signOfDet2x2](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/CGAlgorithmsDD.html#signOfDet2x2-double-double-double-double-)
         */
        signOfDet2x2(dx1: number, dy1: number, dx2: number, dy2: number): number;
      };
      Centroid: {
        /**
         * Creates a new instance for computing the centroid of a geometry
         *
         * @see [org.locationtech.jts.algorithm.Centroid.Centroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Centroid.html#Centroid-org.locationtech.jts.geom.Geometry-)
         */
        create1(geom: Geometry): Centroid;
        /**
         * Computes the centroid point of a geometry.
         *
         * @param geom - the geometry to use
         * @returns the centroid point, or null if the geometry is empty
         * @see [org.locationtech.jts.algorithm.Centroid.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Centroid.html#getCentroid-org.locationtech.jts.geom.Geometry-)
         */
        getCentroid(geom: Geometry): Coordinate;
        /**
         * Gets the computed centroid.
         *
         * @returns the computed centroid, or null if the input is empty
         * @see [org.locationtech.jts.algorithm.Centroid.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Centroid.html#getCentroid--)
         */
        getCentroidInstance(centroid: Centroid): Coordinate;
      };
      ConvexHull: {
        /**
         * Create a new convex hull construction for the input `Geometry`.
         *
         * @see [org.locationtech.jts.algorithm.ConvexHull.ConvexHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/ConvexHull.html#ConvexHull-org.locationtech.jts.geom.Geometry-)
         */
        create1(geometry: Geometry): any /* org.locationtech.jts.algorithm.ConvexHull */;
        /**
         * Create a new convex hull construction for the input `Coordinate` array.
         *
         * @see [org.locationtech.jts.algorithm.ConvexHull.ConvexHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/ConvexHull.html#ConvexHull-org.locationtech.jts.geom.Coordinate:A-org.locationtech.jts.geom.GeometryFactory-)
         */
        create2(pts: Coordinate[], geomFactory: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.algorithm.ConvexHull */;
        /**
         * Returns a `Geometry` that represents the convex hull of the input
         * geometry.
         * The returned geometry contains the minimal number of points needed to
         * represent the convex hull.  In particular, no more than two consecutive
         * points will be collinear.
         *
         * @returns if the convex hull contains 3 or more points, a `Polygon`; 2 points, a `LineString`; 1 point, a `Point`; 0 points, an empty `GeometryCollection`.
         * @see [org.locationtech.jts.algorithm.ConvexHull.getConvexHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/ConvexHull.html#getConvexHull--)
         */
        getConvexHull(convexHull: any /* org.locationtech.jts.algorithm.ConvexHull */): Geometry;
      };
      Distance: {
        /**
         * Computes the perpendicular distance from a point p to the (infinite) line
         * containing the points AB
         *
         * @param p - the point to compute the distance for
         * @param A - one point of the line
         * @param B - another point of the line (must be different to A)
         * @returns the distance from p to line AB
         * @see [org.locationtech.jts.algorithm.Distance.pointToLinePerpendicular](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Distance.html#pointToLinePerpendicular-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        pointToLinePerpendicular(p: Coordinate, A: Coordinate, B: Coordinate): number;
        pointToLinePerpendicularSigned(p: Coordinate, A: Coordinate, B: Coordinate): number;
        /**
         * Computes the distance from a point p to a line segment AB
         *
         * Note: NON-ROBUST!
         *
         * @param p - the point to compute the distance for
         * @param A - one point of the line
         * @param B - another point of the line (must be different to A)
         * @returns the distance from p to line segment AB
         * @see [org.locationtech.jts.algorithm.Distance.pointToSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Distance.html#pointToSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        pointToSegment(p: Coordinate, A: Coordinate, B: Coordinate): number;
        /**
         * Computes the distance from a point to a sequence of line segments.
         *
         * @param p - a point
         * @param line - a sequence of contiguous line segments defined by their vertices
         * @returns the minimum distance between the point and the line segments
         * @see [org.locationtech.jts.algorithm.Distance.pointToSegmentString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Distance.html#pointToSegmentString-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        pointToSegmentString(p: Coordinate, line: Coordinate[]): number;
        /**
         * Computes the distance from a line segment AB to a line segment CD
         *
         * Note: NON-ROBUST!
         *
         * @param A - a point of one line
         * @param B - the second point of (must be different to A)
         * @param C - one point of the line
         * @param D - another point of the line (must be different to A)
         * @see [org.locationtech.jts.algorithm.Distance.segmentToSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Distance.html#segmentToSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        segmentToSegment(A: Coordinate, B: Coordinate, C: Coordinate, D: Coordinate): number;
      };
      HCoordinate: {
        create0(): any /* org.locationtech.jts.algorithm.HCoordinate */;
        create1(p: Coordinate): any /* org.locationtech.jts.algorithm.HCoordinate */;
        create2(_x: number, _y: number): any /* org.locationtech.jts.algorithm.HCoordinate */;
        create3(_x: number, _y: number, _w: number): any /* org.locationtech.jts.algorithm.HCoordinate */;
        create4(p1: Coordinate, p2: Coordinate, q1: Coordinate, q2: Coordinate): any /* org.locationtech.jts.algorithm.HCoordinate */;
      };
      InteriorPoint: {
        /**
         * Computes a location of an interior point in a `Geometry`.
         * Handles all geometry types.
         *
         * @param geom - a geometry in which to find an interior point
         * @returns the location of an interior point, or `null` if the input is empty
         * @see [org.locationtech.jts.algorithm.InteriorPoint.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPoint.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
         */
        getInteriorPoint(geom: Geometry): Coordinate;
      };
      InteriorPointArea: {
        /**
         * Creates a new interior point finder for an areal geometry.
         *
         * @param g - an areal geometry
         * @see [org.locationtech.jts.algorithm.InteriorPointArea.InteriorPointArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointArea.html#InteriorPointArea-org.locationtech.jts.geom.Geometry-)
         */
        create1(g: Geometry): InteriorPointArea;
        /**
         * Computes an interior point for the
         * polygonal components of a Geometry.
         *
         * @param geom - the geometry to compute
         * @returns the computed interior point, or `null` if the geometry has no polygonal components
         * @see [org.locationtech.jts.algorithm.InteriorPointArea.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointArea.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
         */
        getInteriorPoint(geom: Geometry): Coordinate;
        /**
         * Gets the computed interior point.
         *
         * @returns the coordinate of an interior point or `null` if the input geometry is empty
         * @see [org.locationtech.jts.algorithm.InteriorPointArea.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointArea.html#getInteriorPoint--)
         */
        getInteriorPointInstance(interiorPointArea: InteriorPointArea): Coordinate;
      };
      InteriorPointLine: {
        create1(g: Geometry): InteriorPointLine;
        /**
         * Computes an interior point for the
         * linear components of a Geometry.
         *
         * @param geom - the geometry to compute
         * @returns the computed interior point, or `null` if the geometry has no linear components
         * @see [org.locationtech.jts.algorithm.InteriorPointLine.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointLine.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
         */
        getInteriorPoint(geom: Geometry): Coordinate;
        getInteriorPointInstance(interiorPointLine: InteriorPointLine): Coordinate;
      };
      InteriorPointPoint: {
        create1(g: Geometry): InteriorPointPoint;
        /**
         * Computes an interior point for the
         * puntal components of a Geometry.
         *
         * @param geom - the geometry to compute
         * @returns the computed interior point, or `null` if the geometry has no puntal components
         * @see [org.locationtech.jts.algorithm.InteriorPointPoint.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/InteriorPointPoint.html#getInteriorPoint-org.locationtech.jts.geom.Geometry-)
         */
        getInteriorPoint(geom: Geometry): Coordinate;
        getInteriorPointInstance(interiorPointPoint: InteriorPointPoint): Coordinate;
      };
      Intersection: {
        /**
         * Computes the intersection point of two lines.
         * If the lines are parallel or collinear this case is detected
         * and `null` is returned.
         *
         * @param p1 - an endpoint of line 1
         * @param p2 - an endpoint of line 1
         * @param q1 - an endpoint of line 2
         * @param q2 - an endpoint of line 2
         * @returns the intersection point between the lines, if there is one, or null if the lines are parallel or collinear
         * @see [org.locationtech.jts.algorithm.Intersection.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Intersection.html#intersection-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersection(p1: Coordinate, p2: Coordinate, q1: Coordinate, q2: Coordinate): Coordinate;
        /**
         * Computes the intersection point of a line and a line segment (if any).
         * There will be no intersection point if:
         *
         * - the segment does not intersect the line
         * - the line or the segment are degenerate (have zero length)
         *
         * If the segment is collinear with the line the first segment endpoint is returned.
         *
         * @param line1 - a point on the line
         * @param line2 - a point on the line
         * @param seg1 - an endpoint of the line segment
         * @param seg2 - an endpoint of the line segment
         * @returns the intersection point, or null if it is not possible to find an intersection
         * @see [org.locationtech.jts.algorithm.Intersection.lineSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Intersection.html#lineSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        lineSegment(line1: Coordinate, line2: Coordinate, seg1: Coordinate, seg2: Coordinate): Coordinate;
      };
      Length: {
        /**
         * Computes the length of a linestring specified by a sequence of points.
         *
         * @param pts - the points specifying the linestring
         * @returns the length of the linestring
         * @see [org.locationtech.jts.algorithm.Length.ofLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Length.html#ofLine-org.locationtech.jts.geom.CoordinateSequence-)
         */
        ofLine(pts: CoordinateSequence): number;
      };
      LineIntersector: {
        COLLINEAR: number;
        /**
         * Indicates that line segments intersect in a line segment
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.COLLINEAR_INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#COLLINEAR_INTERSECTION)
         */
        COLLINEAR_INTERSECTION: number;
        /**
         * These are deprecated, due to ambiguous naming
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.DONT_INTERSECT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#DONT_INTERSECT)
         */
        DONT_INTERSECT: number;
        DO_INTERSECT: number;
        /**
         * Indicates that line segments do not intersect
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.NO_INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#NO_INTERSECTION)
         */
        NO_INTERSECTION: number;
        /**
         * Indicates that line segments intersect in a single point
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.POINT_INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#POINT_INTERSECTION)
         */
        POINT_INTERSECTION: number;
        /**
         * Computes the "edge distance" of an intersection point p along a segment.
         * The edge distance is a metric of the point along the edge.
         * The metric used is a robust and easy to compute metric function.
         * It is **not** equivalent to the usual Euclidean metric.
         * It relies on the fact that either the x or the y ordinates of the
         * points in the edge are unique, depending on whether the edge is longer in
         * the horizontal or vertical direction.
         *
         * NOTE: This function may produce incorrect distances
         * for inputs where p is not precisely on p1-p2
         * (E.g. p = (139,9) p1 = (139,10), p2 = (280,1) produces distance 0.0, which is incorrect.
         *
         * My hypothesis is that the function is safe to use for points which are the
         * result of **rounding** points which lie on the line,
         * but not safe to use for **truncated** points.
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.computeEdgeDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#computeEdgeDistance-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        computeEdgeDistance(p: Coordinate, p0: Coordinate, p1: Coordinate): number;
        /**
         * Computes the intersection of the lines p1-p2 and p3-p4.
         * This function computes both the boolean value of the hasIntersection test
         * and the (approximate) value of the intersection point itself (if there is one).
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.computeIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#computeIntersection-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        computeIntersection(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, p1: Coordinate, p2: Coordinate, p3: Coordinate, p4: Coordinate): any /* void */;
        /**
         * Computes the "edge distance" of an intersection point along the specified input line segment.
         *
         * @param segmentIndex - is 0 or 1
         * @param intIndex - is 0 or 1
         * @returns the edge distance of the intersection point
         * @see [org.locationtech.jts.algorithm.LineIntersector.getEdgeDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getEdgeDistance-int-int-)
         */
        getEdgeDistance(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, segmentIndex: number, intIndex: number): number;
        /**
         * Gets an endpoint of an input segment.
         *
         * @param segmentIndex - the index of the input segment (0 or 1)
         * @param ptIndex - the index of the endpoint (0 or 1)
         * @returns the specified endpoint
         * @see [org.locationtech.jts.algorithm.LineIntersector.getEndpoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getEndpoint-int-int-)
         */
        getEndpoint(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, segmentIndex: number, ptIndex: number): Coordinate;
        /**
         * Computes the index (order) of the intIndex'th intersection point in the direction of
         * a specified input line segment
         *
         * @param segmentIndex - is 0 or 1
         * @param intIndex - is 0 or 1
         * @returns the index of the intersection point along the input segment (0 or 1)
         * @see [org.locationtech.jts.algorithm.LineIntersector.getIndexAlongSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getIndexAlongSegment-int-int-)
         */
        getIndexAlongSegment(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, segmentIndex: number, intIndex: number): number;
        /**
         * Returns the intIndex'th intersection point
         *
         * @param intIndex - is 0 or 1
         * @returns the intIndex'th intersection point
         * @see [org.locationtech.jts.algorithm.LineIntersector.getIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getIntersection-int-)
         */
        getIntersection(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, intIndex: number): Coordinate;
        /**
         * Computes the intIndex'th intersection point in the direction of
         * a specified input line segment
         *
         * @param segmentIndex - is 0 or 1
         * @param intIndex - is 0 or 1
         * @returns the intIndex'th intersection point in the direction of the specified input line segment
         * @see [org.locationtech.jts.algorithm.LineIntersector.getIntersectionAlongSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getIntersectionAlongSegment-int-int-)
         */
        getIntersectionAlongSegment(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, segmentIndex: number, intIndex: number): Coordinate;
        /**
         * Returns the number of intersection points found.  This will be either 0, 1 or 2.
         *
         * @returns the number of intersection points found (0, 1, or 2)
         * @see [org.locationtech.jts.algorithm.LineIntersector.getIntersectionNum](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#getIntersectionNum--)
         */
        getIntersectionNum(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */): number;
        /**
         * Tests whether the input geometries intersect.
         *
         * @returns true if the input geometries intersect
         * @see [org.locationtech.jts.algorithm.LineIntersector.hasIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#hasIntersection--)
         */
        hasIntersection(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */): boolean;
        /**
         * Tests whether either intersection point is an interior point of the specified input segment.
         *
         * @returns `true` if either intersection point is in the interior of the input segment
         * @see [org.locationtech.jts.algorithm.LineIntersector.isInteriorIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#isInteriorIntersection-int-)
         */
        isInteriorIntersection(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, inputLineIndex: number): boolean;
        /**
         * Test whether a point is a intersection point of two line segments.
         * Note that if the intersection is a line segment, this method only tests for
         * equality with the endpoints of the intersection segment.
         * It does **not** return true if
         * the input point is internal to the intersection segment.
         *
         * @returns true if the input point is one of the intersection points.
         * @see [org.locationtech.jts.algorithm.LineIntersector.isIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#isIntersection-org.locationtech.jts.geom.Coordinate-)
         */
        isIntersection(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, pt: Coordinate): boolean;
        /**
         * Tests whether an intersection is proper.
         *
         * The intersection between two line segments is considered proper if
         * they intersect in a single point in the interior of both segments
         * (e.g. the intersection is a single point and is not equal to any of the
         * endpoints).
         *
         * The intersection between a point and a line segment is considered proper
         * if the point lies in the interior of the segment (e.g. is not equal to
         * either of the endpoints).
         *
         * @returns true if the intersection is proper
         * @see [org.locationtech.jts.algorithm.LineIntersector.isProper](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#isProper--)
         */
        isProper(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */): boolean;
        nonRobustComputeEdgeDistance(p: Coordinate, p1: Coordinate, p2: Coordinate): number;
        /**
         * Force computed intersection to be rounded to a given precision model
         *
         * @param precisionModel
         * @see [org.locationtech.jts.algorithm.LineIntersector.setMakePrecise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#setMakePrecise-org.locationtech.jts.geom.PrecisionModel-)
         */
        setMakePrecise(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, precisionModel: PrecisionModel): any /* void */;
        /**
         * Force computed intersection to be rounded to a given precision model.
         * No getter is provided, because the precision model is not required to be specified.
         *
         * @param precisionModel
         * @see [org.locationtech.jts.algorithm.LineIntersector.setPrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#setPrecisionModel-org.locationtech.jts.geom.PrecisionModel-)
         */
        setPrecisionModel(lineIntersector: any /* org.locationtech.jts.algorithm.LineIntersector */, precisionModel: PrecisionModel): any /* void */;
      };
      MinimumAreaRectangle: {
        /**
         * Gets the minimum-area rectangular `Polygon` which encloses the input geometry.
         * If the convex hull of the input is degenerate (a line or point)
         * a `LineString` or `Point` is returned.
         *
         * @param geom - the geometry
         * @returns the minimum rectangle enclosing the geometry
         * @see [org.locationtech.jts.algorithm.MinimumAreaRectangle.getMinimumRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumAreaRectangle.html#getMinimumRectangle-org.locationtech.jts.geom.Geometry-)
         */
        getMinimumRectangle(geom: Geometry): Geometry;
      };
      MinimumBoundingCircle: {
        /**
         * Creates a new object for computing the minimum bounding circle for the
         * point set defined by the vertices of the given geometry.
         *
         * @param geom - the geometry to use to obtain the point set
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.MinimumBoundingCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#MinimumBoundingCircle-org.locationtech.jts.geom.Geometry-)
         */
        create1(geom: Geometry): MinimumBoundingCircle;
        /**
         * Gets the centre point of the computed Minimum Bounding Circle.
         *
         * @returns the centre point of the Minimum Bounding Circle
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getCentre--)
         */
        getCentre(minimumBoundingCircle: MinimumBoundingCircle): Coordinate;
        /**
         * Gets a geometry which represents the Minimum Bounding Circle.
         * If the input is degenerate (empty or a single unique point),
         * this method will return an empty geometry or a single Point geometry.
         * Otherwise, a Polygon will be returned which approximates the
         * Minimum Bounding Circle.
         * (Note that because the computed polygon is only an approximation,
         * it may not precisely contain all the input points.)
         *
         * @returns a Geometry representing the Minimum Bounding Circle.
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getCircle--)
         */
        getCircle(minimumBoundingCircle: MinimumBoundingCircle): Geometry;
        /**
         * Gets a geometry representing the diameter of the computed Minimum Bounding
         * Circle.
         *
         * @returns the diameter LineString of the Minimum Bounding Circle
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getDiameter--)
         */
        getDiameter(minimumBoundingCircle: MinimumBoundingCircle): Geometry;
        /**
         * Gets a geometry representing a line between the two farthest points
         * in the input.
         *
         * The points are two of the extremal points of the Minimum Bounding Circle.
         * They lie on the convex hull of the input.
         *
         * @returns a LineString between the two farthest points of the input
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getFarthestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getFarthestPoints--)
         */
        getFarthestPoints(minimumBoundingCircle: MinimumBoundingCircle): Geometry;
        /**
         * Gets a geometry representing the maximum diameter of the
         * input. The maximum diameter is the longest line segment
         * between any two points of the input.
         *
         * The points are two of the extremal points of the Minimum Bounding Circle.
         * They lie on the convex hull of the input.
         *
         * @returns a LineString between the two farthest points of the input
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getMaximumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getMaximumDiameter--)
         */
        getMaximumDiameter(minimumBoundingCircle: MinimumBoundingCircle): Geometry;
        /**
         * Gets the radius of the computed Minimum Bounding Circle.
         *
         * @returns the radius of the Minimum Bounding Circle
         * @see [org.locationtech.jts.algorithm.MinimumBoundingCircle.getRadius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumBoundingCircle.html#getRadius--)
         */
        getRadius(minimumBoundingCircle: MinimumBoundingCircle): number;
      };
      MinimumDiameter: {
        /**
         * Compute a minimum diameter for a given `Geometry`.
         *
         * @param inputGeom - a Geometry
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.MinimumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#MinimumDiameter-org.locationtech.jts.geom.Geometry-)
         */
        create1(inputGeom: Geometry): MinimumDiameter;
        /**
         * Compute a minimum diameter for a giver `Geometry`,
         * with a hint if
         * the Geometry is convex
         * (e.g. a convex Polygon or LinearRing,
         * or a two-point LineString, or a Point).
         *
         * @param inputGeom - a Geometry which is convex
         * @param isConvex - `true` if the input geometry is convex
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.MinimumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#MinimumDiameter-org.locationtech.jts.geom.Geometry-boolean-)
         */
        create2(inputGeom: Geometry, isConvex: boolean): MinimumDiameter;
        /**
         * Gets a `LineString` which is a minimum diameter
         *
         * @returns a `LineString` which is a minimum diameter
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getDiameter--)
         */
        getDiameter(minimumDiameter: MinimumDiameter): Geometry;
        /**
         * Gets the length of the minimum diameter of the input Geometry
         *
         * @returns the length of the minimum diameter
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getLength--)
         */
        getLength(minimumDiameter: MinimumDiameter): number;
        /**
         * Gets the length of the minimum diameter enclosing a geometry
         *
         * @param geom - the geometry
         * @returns the length of the minimum diameter of the geometry
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumDiameter-org.locationtech.jts.geom.Geometry-)
         */
        getMinimumDiameterStatic(geom: Geometry): Geometry;
        /**
         * Gets the rectangular `Polygon` which encloses the input geometry
         * and is based on the minimum diameter supporting segment.
         * The rectangle has width equal to the minimum diameter,
         * and a longer length.
         * If the convex hull of the input is degenerate (a line or point)
         * a `LineString` or `Point` is returned.
         *
         * This is not necessarily the enclosing rectangle with minimum area.
         *
         * @returns a rectangle enclosing the input (or a line or point if degenerate)
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumRectangle--)
         */
        getMinimumRectangle(minimumDiameter: MinimumDiameter): Geometry;
        /**
         * Gets the minimum-width rectangular `Polygon` which encloses the input geometry
         * and is based along the supporting segment.
         * The rectangle has width equal to the minimum diameter,
         * and a longer length.
         * If the convex hull of the input is degenerate (a line or point)
         * a `LineString` or `Point` is returned.
         *
         * This is not necessarily the rectangle with minimum area.
         * Use `MinimumAreaRectangle` to compute this.
         *
         * @param geom - the geometry
         * @returns the minimum-width rectangle enclosing the geometry
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getMinimumRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getMinimumRectangle-org.locationtech.jts.geom.Geometry-)
         */
        getMinimumRectangleStatic(geom: Geometry): Geometry;
        /**
         * Gets the segment forming the base of the minimum diameter
         *
         * @returns the segment forming the base of the minimum diameter
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getSupportingSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getSupportingSegment--)
         */
        getSupportingSegment(minimumDiameter: MinimumDiameter): Geometry;
        /**
         * Gets the `Coordinate` forming one end of the minimum diameter
         *
         * @returns a coordinate forming one end of the minimum diameter
         * @see [org.locationtech.jts.algorithm.MinimumDiameter.getWidthCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/MinimumDiameter.html#getWidthCoordinate--)
         */
        getWidthCoordinate(minimumDiameter: MinimumDiameter): Coordinate;
      };
      Orientation: {
        /**
         * A value that indicates an orientation of clockwise, or a right turn.
         *
         * @see [org.locationtech.jts.algorithm.Orientation.CLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#CLOCKWISE)
         */
        CLOCKWISE: number;
        /**
         * A value that indicates an orientation of collinear, or no turn (straight).
         *
         * @see [org.locationtech.jts.algorithm.Orientation.COLLINEAR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#COLLINEAR)
         */
        COLLINEAR: number;
        /**
         * A value that indicates an orientation of counterclockwise, or a left turn.
         *
         * @see [org.locationtech.jts.algorithm.Orientation.COUNTERCLOCKWISE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#COUNTERCLOCKWISE)
         */
        COUNTERCLOCKWISE: number;
        /**
         * A value that indicates an orientation of counterclockwise, or a left turn.
         *
         * @see [org.locationtech.jts.algorithm.Orientation.LEFT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#LEFT)
         */
        LEFT: number;
        /**
         * A value that indicates an orientation of clockwise, or a right turn.
         *
         * @see [org.locationtech.jts.algorithm.Orientation.RIGHT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#RIGHT)
         */
        RIGHT: number;
        /**
         * A value that indicates an orientation of collinear, or no turn (straight).
         *
         * @see [org.locationtech.jts.algorithm.Orientation.STRAIGHT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#STRAIGHT)
         */
        STRAIGHT: number;
        /**
         * Returns the orientation index of the direction of the point `q` relative to
         * a directed infinite line specified by `p1-p2`.
         * The index indicates whether the point lies to the `LEFT` or `RIGHT`
         * of the line, or lies on it `COLLINEAR`.
         * The index also indicates the orientation of the triangle formed by the three points
         * ( `COUNTERCLOCKWISE`, `CLOCKWISE`, or `STRAIGHT` )
         *
         * @param p1 - the origin point of the line vector
         * @param p2 - the final point of the line vector
         * @param q - the point to compute the direction to
         * @returns -1 ( `CLOCKWISE` or `RIGHT` ) if q is clockwise (right) from p1-p2; 1 ( `COUNTERCLOCKWISE` or `LEFT` ) if q is counter-clockwise (left) from p1-p2; 0 ( `COLLINEAR` or `STRAIGHT` ) if q is collinear with p1-p2
         * @see [org.locationtech.jts.algorithm.Orientation.index](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#index-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        index(p1: Coordinate, p2: Coordinate, q: Coordinate): number;
        /**
         * Tests if a ring defined by an array of `Coordinate`s is
         * oriented counter-clockwise.
         *
         * - The list of points is assumed to have the first and last points equal.
         * - This handles coordinate lists which contain repeated points.
         * - This handles rings which contain collapsed segments
         * (in particular, along the top of the ring).
         *
         * This algorithm is guaranteed to work with valid rings.
         * It also works with "mildly invalid" rings
         * which contain collapsed (coincident) flat segments along the top of the ring.
         * If the ring is "more" invalid (e.g. self-crosses or touches),
         * the computed result may not be correct.
         *
         * @param ring - an array of Coordinates forming a ring (with first and last point identical)
         * @returns true if the ring is oriented counter-clockwise.
         * @throws IllegalArgumentException if there are too few points to determine orientation (< 4)
         * @see [org.locationtech.jts.algorithm.Orientation.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#isCCW-org.locationtech.jts.geom.Coordinate:A-)
         */
        isCCW(ring: Coordinate[]): boolean;
        /**
         * Tests if a ring defined by an array of `Coordinate`s is
         * oriented counter-clockwise, using the signed area of the ring.
         *
         * - The list of points is assumed to have the first and last points equal.
         * - This handles coordinate lists which contain repeated points.
         * - This handles rings which contain collapsed segments
         * (in particular, along the top of the ring).
         * - This handles rings which are invalid due to self-intersection
         *
         * This algorithm is guaranteed to work with valid rings.
         * For invalid rings (containing self-intersections),
         * the algorithm determines the orientation of
         * the largest enclosed area (including overlaps).
         * This provides a more useful result in some situations, such as buffering.
         *
         * However, this approach may be less accurate in the case of
         * rings with almost zero area.
         * (Note that the orientation of rings with zero area is essentially
         * undefined, and hence non-deterministic.)
         *
         * @param ring - an array of Coordinates forming a ring (with first and last point identical)
         * @returns true if the ring is oriented counter-clockwise.
         * @see [org.locationtech.jts.algorithm.Orientation.isCCWArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#isCCWArea-org.locationtech.jts.geom.Coordinate:A-)
         */
        isCCWArea(ring: Coordinate[]): boolean;
        /**
         * Tests if a ring defined by a `CoordinateSequence` is
         * oriented counter-clockwise.
         *
         * - The list of points is assumed to have the first and last points equal.
         * - This handles coordinate lists which contain repeated points.
         * - This handles rings which contain collapsed segments
         * (in particular, along the top of the ring).
         *
         * This algorithm is guaranteed to work with valid rings.
         * It also works with "mildly invalid" rings
         * which contain collapsed (coincident) flat segments along the top of the ring.
         * If the ring is "more" invalid (e.g. self-crosses or touches),
         * the computed result may not be correct.
         *
         * @param ring - a CoordinateSequence forming a ring (with first and last point identical)
         * @returns true if the ring is oriented counter-clockwise.
         * @see [org.locationtech.jts.algorithm.Orientation.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/Orientation.html#isCCW-org.locationtech.jts.geom.CoordinateSequence-)
         */
        isCCWSeq(ring: CoordinateSequence): boolean;
      };
      PointLocation: {
        /**
         * Tests whether a point lies inside or on a ring. The ring may be oriented in
         * either direction. A point lying exactly on the ring boundary is considered
         * to be inside the ring.
         *
         * This method does _not_ first check the point against the envelope of
         * the ring.
         *
         * @param p - point to check for ring inclusion
         * @param ring - an array of coordinates representing the ring (which must have first point identical to last point)
         * @returns true if p is inside ring
         * @see [org.locationtech.jts.algorithm.PointLocation.isInRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocation.html#isInRing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        isInRing(p: Coordinate, ring: Coordinate[]): boolean;
        /**
         * Tests whether a point lies on the line defined by a list of
         * coordinates.
         *
         * @param p - the point to test
         * @param line - the line coordinates
         * @returns true if the point is a vertex of the line or lies in the interior of a line segment in the line
         * @see [org.locationtech.jts.algorithm.PointLocation.isOnLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocation.html#isOnLine-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        isOnLine(p: Coordinate, line: Coordinate[]): boolean;
        /**
         * Tests whether a point lies on the line defined by a
         * `CoordinateSequence`.
         *
         * @param p - the point to test
         * @param line - the line coordinates
         * @returns true if the point is a vertex of the line or lies in the interior of a line segment in the line
         * @see [org.locationtech.jts.algorithm.PointLocation.isOnLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocation.html#isOnLine-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.CoordinateSequence-)
         */
        isOnLineSeq(p: Coordinate, line: CoordinateSequence): boolean;
        /**
         * Tests whether a point lies on a line segment.
         *
         * @param p - the point to test
         * @param p0 - a point of the line segment
         * @param p1 - a point of the line segment
         * @returns true if the point lies on the line segment
         * @see [org.locationtech.jts.algorithm.PointLocation.isOnSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocation.html#isOnSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isOnSegment(p: Coordinate, p0: Coordinate, p1: Coordinate): boolean;
        /**
         * Determines whether a point lies in the interior, on the boundary, or in the
         * exterior of a ring. The ring may be oriented in either direction.
         *
         * This method does _not_ first check the point against the envelope of
         * the ring.
         *
         * @param p - point to check for ring inclusion
         * @param ring - an array of coordinates representing the ring (which must have first point identical to last point)
         * @returns the `Location` of p relative to the ring
         * @see [org.locationtech.jts.algorithm.PointLocation.locateInRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocation.html#locateInRing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        locateInRing(p: Coordinate, ring: Coordinate[]): number;
      };
      PointLocator: {
        create0(): any /* org.locationtech.jts.algorithm.PointLocator */;
        /**
         * Convenience method to test a point for intersection with
         * a Geometry
         *
         * @param p - the coordinate to test
         * @param geom - the Geometry to test
         * @returns `true` if the point is in the interior or boundary of the Geometry
         * @see [org.locationtech.jts.algorithm.PointLocator.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocator.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Geometry-)
         */
        intersects(pointLocator: any /* org.locationtech.jts.algorithm.PointLocator */, p: Coordinate, geom: Geometry): boolean;
        /**
         * Computes the topological relationship (`Location`) of a single point
         * to a Geometry.
         * It handles both single-element
         * and multi-element Geometries.
         * The algorithm for multi-part Geometries
         * takes into account the SFS Boundary Determination Rule.
         *
         * @returns the `Location` of the point relative to the input Geometry
         * @see [org.locationtech.jts.algorithm.PointLocator.locate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PointLocator.html#locate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Geometry-)
         */
        locate(pointLocator: any /* org.locationtech.jts.algorithm.PointLocator */, p: Coordinate, geom: Geometry): number;
      };
      PolygonNodeTopology: {
        /**
         * Check if four segments at a node cross.
         * Typically the segments lie in two different rings, or different sections of one ring.
         * The node is topologically valid if the rings do not cross.
         * If any segments are collinear, the test returns false.
         *
         * @param nodePt - the node location
         * @param a0 - the previous segment endpoint in a ring
         * @param a1 - the next segment endpoint in a ring
         * @param b0 - the previous segment endpoint in the other ring
         * @param b1 - the next segment endpoint in the other ring
         * @returns true if the rings cross at the node
         * @see [org.locationtech.jts.algorithm.PolygonNodeTopology.isCrossing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/PolygonNodeTopology.html#isCrossing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isCrossing(nodePt: Coordinate, a0: Coordinate, a1: Coordinate, b0: Coordinate, b1: Coordinate): boolean;
      };
      RayCrossingCounter: {
        /**
         * Counts a segment
         *
         * @param p1 - an endpoint of the segment
         * @param p2 - another endpoint of the segment
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.countSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#countSegment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        countSegment(rayCrossingCounter: any /* org.locationtech.jts.algorithm.RayCrossingCounter */, p1: Coordinate, p2: Coordinate): any /* void */;
        create1(p: Coordinate): any /* org.locationtech.jts.algorithm.RayCrossingCounter */;
        /**
         * Gets the count of crossings.
         *
         * @returns the crossing count
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.getCount](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#getCount--)
         */
        getCount(rayCrossingCounter: any /* org.locationtech.jts.algorithm.RayCrossingCounter */): number;
        /**
         * Gets the `Location` of the point relative to
         * the ring, polygon
         * or multipolygon from which the processed segments were provided.
         *
         * This method only determines the correct location
         * if **all** relevant segments must have been processed.
         *
         * @returns the Location of the point
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.getLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#getLocation--)
         */
        getLocation(rayCrossingCounter: any /* org.locationtech.jts.algorithm.RayCrossingCounter */): number;
        /**
         * Reports whether the point lies exactly on one of the supplied segments.
         * This method may be called at any time as segments are processed.
         * If the result of this method is `true`,
         * no further segments need be supplied, since the result
         * will never change again.
         *
         * @returns true if the point lies exactly on a segment
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.isOnSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#isOnSegment--)
         */
        isOnSegment(rayCrossingCounter: any /* org.locationtech.jts.algorithm.RayCrossingCounter */): boolean;
        /**
         * Tests whether the point lies in or on
         * the ring, polygon
         * or multipolygon from which the processed segments were provided.
         *
         * This method only determines the correct location
         * if **all** relevant segments must have been processed.
         *
         * @returns true if the point lies in or on the supplied polygon
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.isPointInPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#isPointInPolygon--)
         */
        isPointInPolygon(rayCrossingCounter: any /* org.locationtech.jts.algorithm.RayCrossingCounter */): boolean;
        /**
         * Determines the `Location` of a point in a ring.
         *
         * @param p - the point to test
         * @param ring - a coordinate sequence forming a ring
         * @returns the location of the point in the ring
         * @see [org.locationtech.jts.algorithm.RayCrossingCounter.locatePointInRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RayCrossingCounter.html#locatePointInRing-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.CoordinateSequence-)
         */
        locatePointInRing(p: Coordinate, ring: CoordinateSequence): number;
      };
      RectangleLineIntersector: {
        /**
         * Creates a new intersector for the given query rectangle,
         * specified as an `Envelope`.
         *
         * @param rectEnv - the query rectangle, specified as an Envelope
         * @see [org.locationtech.jts.algorithm.RectangleLineIntersector.RectangleLineIntersector](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RectangleLineIntersector.html#RectangleLineIntersector-org.locationtech.jts.geom.Envelope-)
         */
        create1(rectEnv: Envelope): any /* org.locationtech.jts.algorithm.RectangleLineIntersector */;
        /**
         * Tests whether the query rectangle intersects a
         * given line segment.
         *
         * @param p0 - the first endpoint of the segment
         * @param p1 - the second endpoint of the segment
         * @returns true if the rectangle intersects the segment
         * @see [org.locationtech.jts.algorithm.RectangleLineIntersector.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RectangleLineIntersector.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersects(rectangleLineIntersector: any /* org.locationtech.jts.algorithm.RectangleLineIntersector */, p0: Coordinate, p1: Coordinate): boolean;
      };
      RobustDeterminant: {
        /**
         * Returns the index of the direction of the point `q` relative to
         * a vector specified by `p1-p2`.
         *
         * @param p1 - the origin point of the vector
         * @param p2 - the final point of the vector
         * @param q - the point to compute the direction to
         * @returns 1 if q is counter-clockwise (left) from p1-p2
         * @see [org.locationtech.jts.algorithm.RobustDeterminant.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/RobustDeterminant.html#orientationIndex-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        orientationIndex(p1: Coordinate, p2: Coordinate, q: Coordinate): number;
        signOfDet2x2(x1: number, y1: number, x2: number, y2: number): number;
      };
      RobustLineIntersector: {
        /**
         * Compute the intersection of a point p and the line p1-p2.
         * This function computes the boolean value of the hasIntersection test.
         * The actual value of the intersection (if there is one)
         * is equal to the value of `p`.
         *
         * @see [org.locationtech.jts.algorithm.LineIntersector.computeIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/LineIntersector.html#computeIntersection-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        computeIntersection(robustLineIntersector: any /* org.locationtech.jts.algorithm.RobustLineIntersector */, p: Coordinate, p1: Coordinate, p2: Coordinate): any /* void */;
        create0(): any /* org.locationtech.jts.algorithm.RobustLineIntersector */;
      };
      construct: {
        LargestEmptyCircle: {
          /**
           * Creates a new instance of a Largest Empty Circle construction,
           * interior-disjoint to a set of obstacle geometries
           * and having its center within a polygonal boundary.
           * The obstacles may be any collection of points, lines and polygons.
           * If the boundary is null or empty the convex hull
           * of the obstacles is used as the boundary.
           *
           * @param obstacles - a non-empty geometry representing the obstacles
           * @param boundary - a polygonal geometry (may be null or empty)
           * @param tolerance - a distance tolerance for computing the circle center point (a positive value)
           * @see [org.locationtech.jts.algorithm.construct.LargestEmptyCircle.LargestEmptyCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/LargestEmptyCircle.html#LargestEmptyCircle-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          create3(obstacles: Geometry, boundary: Geometry, tolerance: number): any /* org.locationtech.jts.algorithm.construct.LargestEmptyCircle */;
          /**
           * Computes the center point of the Largest Empty Circle
           * interior-disjoint to a set of obstacles and within a polygonal boundary,
           * with accuracy to a given tolerance distance.
           * The obstacles may be any collection of points, lines and polygons.
           * The center of the LEC lies within the given boundary.
           *
           * @param obstacles - a geometry representing the obstacles
           * @param boundary - a polygonal geometry to contain the LEC center
           * @param tolerance - the distance tolerance for computing the center point
           * @returns the center point of the Largest Empty Circle
           * @see [org.locationtech.jts.algorithm.construct.LargestEmptyCircle.getCenter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/LargestEmptyCircle.html#getCenter-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          getCenter(obstacles: Geometry, boundary: Geometry, tolerance: number): Geometry;
          /**
           * Computes a radius line of the Largest Empty Circle
           * interior-disjoint to a set of obstacles and within a polygonal boundary,
           * with accuracy to a given tolerance distance.
           * The obstacles may be any collection of points, lines and polygons.
           * The center of the LEC lies within the given boundary.
           *
           * @param obstacles - a geometry representing the obstacles
           * @param boundary - a polygonal geometry to contain the LEC center
           * @param tolerance - the distance tolerance for computing the center point
           * @returns a line from the center of the circle to a point on the edge
           * @see [org.locationtech.jts.algorithm.construct.LargestEmptyCircle.getRadiusLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/LargestEmptyCircle.html#getRadiusLine-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          getRadiusLine(obstacles: Geometry, boundary: Geometry, tolerance: number): Geometry;
          /**
           * Gets a point defining the radius of the Largest Empty Circle.
           * This is a point on the obstacles which is
           * nearest to the computed center of the Largest Empty Circle.
           * The line segment from the center to this point
           * is a radius of the constructed circle, and this point
           * lies on the boundary of the circle.
           *
           * @returns a point defining the radius of the Largest Empty Circle
           * @see [org.locationtech.jts.algorithm.construct.LargestEmptyCircle.getRadiusPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/LargestEmptyCircle.html#getRadiusPoint--)
           */
          getRadiusPoint(largestEmptyCircle: any /* org.locationtech.jts.algorithm.construct.LargestEmptyCircle */): Geometry;
        };
        MaximumInscribedCircle: {
          /**
           * Creates a new instance of a Maximum Inscribed Circle computation.
           *
           * @param polygonal - an areal geometry
           * @param tolerance - the distance tolerance for computing the centre point (must be positive)
           * @throws IllegalArgumentException if the tolerance is non-positive, or the input geometry is non-polygonal or empty.
           * @see [org.locationtech.jts.algorithm.construct.MaximumInscribedCircle.MaximumInscribedCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/MaximumInscribedCircle.html#MaximumInscribedCircle-org.locationtech.jts.geom.Geometry-double-)
           */
          create2(polygonal: Geometry, tolerance: number): any /* org.locationtech.jts.algorithm.construct.MaximumInscribedCircle */;
          /**
           * Computes the center point of the Maximum Inscribed Circle
           * of a polygonal geometry, up to a given tolerance distance.
           *
           * @param polygonal - a polygonal geometry
           * @param tolerance - the distance tolerance for computing the center point
           * @returns the center point of the maximum inscribed circle
           * @see [org.locationtech.jts.algorithm.construct.MaximumInscribedCircle.getCenter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/MaximumInscribedCircle.html#getCenter-org.locationtech.jts.geom.Geometry-double-)
           */
          getCenter(polygonal: Geometry, tolerance: number): Geometry;
          /**
           * Computes a radius line of the Maximum Inscribed Circle
           * of a polygonal geometry, up to a given tolerance distance.
           *
           * @param polygonal - a polygonal geometry
           * @param tolerance - the distance tolerance for computing the center point
           * @returns a line from the center to a point on the circle
           * @see [org.locationtech.jts.algorithm.construct.MaximumInscribedCircle.getRadiusLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/MaximumInscribedCircle.html#getRadiusLine-org.locationtech.jts.geom.Geometry-double-)
           */
          getRadiusLine(polygonal: Geometry, tolerance: number): Geometry;
          /**
           * Gets a point defining the radius of the Maximum Inscribed Circle.
           * This is a point on the boundary which is
           * nearest to the computed center of the Maximum Inscribed Circle.
           * The line segment from the center to this point
           * is a radius of the constructed circle, and this point
           * lies on the boundary of the circle.
           *
           * @returns a point defining the radius of the Maximum Inscribed Circle
           * @see [org.locationtech.jts.algorithm.construct.MaximumInscribedCircle.getRadiusPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/construct/MaximumInscribedCircle.html#getRadiusPoint--)
           */
          getRadiusPoint(maximumInscribedCircle: any /* org.locationtech.jts.algorithm.construct.MaximumInscribedCircle */): Geometry;
        };
      };
      distance: {
        DiscreteFrechetDistance: {
          /**
           * Creates an instance of this class using the provided geometries.
           *
           * @param g0 - a geometry
           * @param g1 - a geometry
           * @see [org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance.DiscreteFrechetDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistance.html#DiscreteFrechetDistance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance */;
          /**
           * Computes the Discrete Fréchet Distance between two `Geometry`s
           * using a `Cartesian` distance computation function.
           *
           * @param g0 - the 1st geometry
           * @param g1 - the 2nd geometry
           * @returns the cartesian distance between {#g0} and {#g1}
           * @see [org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistance.html#distance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          distance(g0: Geometry, g1: Geometry): number;
          /**
           * Gets the pair of `Coordinate`s at which the distance is obtained.
           *
           * @returns the pair of Coordinates at which the distance is obtained
           * @see [org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance.getCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistance.html#getCoordinates--)
           */
          getCoordinates(discreteFrechetDistance: any /* org.locationtech.jts.algorithm.distance.DiscreteFrechetDistance */): Coordinate[];
        };
        DiscreteHausdorffDistance: {
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance */;
          distance(g0: Geometry, g1: Geometry, densifyFrac: number): number;
          getCoordinates(discreteHausdorffDistance: any /* org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance */): Coordinate[];
          orientedDistance(discreteHausdorffDistance: any /* org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance */): number;
          /**
           * Sets the fraction by which to densify each segment.
           * Each segment will be (virtually) split into a number of equal-length
           * subsegments, whose fraction of the total length is closest
           * to the given fraction.
           *
           * @param densifyFrac
           * @see [org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance.setDensifyFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/DiscreteHausdorffDistance.html#setDensifyFraction-double-)
           */
          setDensifyFraction(discreteHausdorffDistance: any /* org.locationtech.jts.algorithm.distance.DiscreteHausdorffDistance */, densifyFrac: number): any /* void */;
        };
        DistanceToPoint: {
          computeDistance(poly: Geometry, pt: Coordinate, ptDist: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */): any /* void */;
        };
        PointPairDistance: {
          /**
           * Creates an instance of this class
           *
           * @see [org.locationtech.jts.algorithm.distance.PointPairDistance.PointPairDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/PointPairDistance.html#PointPairDistance--)
           */
          create0(): any /* org.locationtech.jts.algorithm.distance.PointPairDistance */;
          /**
           * Gets one of the paired points
           *
           * @param i - the index of the paired point (0 or 1)
           * @returns A point
           * @see [org.locationtech.jts.algorithm.distance.PointPairDistance.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/PointPairDistance.html#getCoordinate-int-)
           */
          getCoordinate(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */, i: number): Coordinate;
          /**
           * Gets the paired points
           *
           * @returns the paired points
           * @see [org.locationtech.jts.algorithm.distance.PointPairDistance.getCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/PointPairDistance.html#getCoordinates--)
           */
          getCoordinates(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */): Coordinate[];
          /**
           * Gets the distance between the paired points
           *
           * @returns the distance between the paired points
           * @see [org.locationtech.jts.algorithm.distance.PointPairDistance.getDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/PointPairDistance.html#getDistance--)
           */
          getDistance(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */): number;
          /**
           * Initializes the points, computing the distance between them.
           *
           * @param p0 - the 1st point
           * @param p1 - the 2nd point
           * @see [org.locationtech.jts.algorithm.distance.PointPairDistance.initialize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/distance/PointPairDistance.html#initialize-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          initialize(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */, p0: Coordinate, p1: Coordinate): any /* void */;
          setMaximum(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */, p0: Coordinate, p1: Coordinate): any /* void */;
          setMinimum(pointPairDistance: any /* org.locationtech.jts.algorithm.distance.PointPairDistance */, p0: Coordinate, p1: Coordinate): any /* void */;
        };
      };
      hull: {
        ConcaveHull: {
          /**
           * Computes the alpha shape of a geometry as a polygon.
           * The alpha parameter is the radius of the eroding disc.
           *
           * @param geom - the input geometry
           * @param alpha - the radius of the eroding disc
           * @param isHolesAllowed - whether holes are allowed in the result
           * @returns the alpha shape polygon
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.alphaShape](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#alphaShape-org.locationtech.jts.geom.Geometry-double-boolean-)
           */
          alphaShape(geom: Geometry, alpha: number, isHolesAllowed: boolean): Geometry;
          /**
           * Computes a concave hull of the vertices in a geometry
           * using the target criterion of maximum edge length,
           * and optionally allowing holes.
           *
           * @param geom - the input geometry
           * @param maxLength - the target maximum edge length
           * @param isHolesAllowed - whether holes are allowed in the result
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.concaveHullByLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#concaveHullByLength-org.locationtech.jts.geom.Geometry-double-boolean-)
           */
          concaveHullByLength(geom: Geometry, maxLength: number, isHolesAllowed: boolean): Geometry;
          /**
           * Computes a concave hull of the vertices in a geometry
           * using the target criterion of maximum edge length factor,
           * and optionally allowing holes.
           * The edge length factor is a fraction of the length difference
           * between the longest and shortest edges
           * in the Delaunay Triangulation of the input points.
           *
           * @param geom - the input geometry
           * @param lengthRatio - the target maximum edge length
           * @param isHolesAllowed - whether holes are allowed in the result
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.concaveHullByLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#concaveHullByLengthRatio-org.locationtech.jts.geom.Geometry-double-boolean-)
           */
          concaveHullByLengthRatio(geom: Geometry, lengthRatio: number, isHolesAllowed: boolean): Geometry;
          /**
           * Creates a new instance for a given geometry.
           *
           * @param geom - the input geometry
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.ConcaveHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#ConcaveHull-org.locationtech.jts.geom.Geometry-)
           */
          create1(geom: Geometry): any /* org.locationtech.jts.algorithm.hull.ConcaveHull */;
          /**
           * Gets the computed concave hull.
           *
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.getHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#getHull--)
           */
          getHull(concaveHull: any /* org.locationtech.jts.algorithm.hull.ConcaveHull */): Geometry;
          /**
           * Sets the alpha parameter to compute an alpha shape of the input.
           * Alpha is the radius of the eroding disc.
           * Border triangles with circumradius greater than alpha are removed.
           *
           * @param alpha - the alpha radius
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.setAlpha](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#setAlpha-double-)
           */
          setAlpha(concaveHull: any /* org.locationtech.jts.algorithm.hull.ConcaveHull */, alpha: number): any /* void */;
          /**
           * Sets whether holes are allowed in the concave hull polygon.
           *
           * @param isHolesAllowed - true if holes are allowed in the result
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.setHolesAllowed](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#setHolesAllowed-boolean-)
           */
          setHolesAllowed(concaveHull: any /* org.locationtech.jts.algorithm.hull.ConcaveHull */, isHolesAllowed: boolean): any /* void */;
          /**
           * Sets the target maximum edge length for the concave hull.
           * The length value must be zero or greater.
           *
           * - The value 0.0 produces the concave hull of smallest area
           * that is still connected.
           * - Larger values produce less concave results.
           * A value equal or greater than the longest Delaunay Triangulation edge length
           * produces the convex hull.
           *
           * The `uniformGridEdgeLength` value may be used as
           * the basis for estimating an appropriate target maximum edge length.
           *
           * @param edgeLength - a non-negative length
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.setMaximumEdgeLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#setMaximumEdgeLength-double-)
           */
          setMaximumEdgeLength(concaveHull: any /* org.locationtech.jts.algorithm.hull.ConcaveHull */, edgeLength: number): any /* void */;
          /**
           * Sets the target maximum edge length ratio for the concave hull.
           * The edge length ratio is a fraction of the difference
           * between the longest and shortest edge lengths
           * in the Delaunay Triangulation of the input points.
           * It is a value in the range 0 to 1.
           *
           * - The value 0.0 produces a concave hull of minimum area
           * that is still connected.
           * - The value 1.0 produces the convex hull.
           *
           * @param edgeLengthRatio - a length factor value between 0 and 1
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.setMaximumEdgeLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#setMaximumEdgeLengthRatio-double-)
           */
          setMaximumEdgeLengthRatio(concaveHull: any /* org.locationtech.jts.algorithm.hull.ConcaveHull */, edgeLengthRatio: number): any /* void */;
          /**
           * Computes the approximate edge length of
           * a uniform square grid having the same number of
           * points as a geometry and the same area as its convex hull.
           * This value can be used to determine a suitable length threshold value
           * for computing a concave hull.
           * A value from 2 to 4 times the uniform grid length
           * seems to produce reasonable results.
           *
           * @param geom - a geometry
           * @returns the approximate uniform grid length
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHull.uniformGridEdgeLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHull.html#uniformGridEdgeLength-org.locationtech.jts.geom.Geometry-)
           */
          uniformGridEdgeLength(geom: Geometry): number;
        };
        ConcaveHullOfPolygons: {
          /**
           * Computes a concave fill area between a set of polygons,
           * using the target criterion of maximum edge length.
           *
           * @param polygons - the input polygons
           * @param maxLength - the target maximum edge length
           * @returns the concave fill
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.concaveFillByLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#concaveFillByLength-org.locationtech.jts.geom.Geometry-double-)
           */
          concaveFillByLength(polygons: Geometry, maxLength: number): Geometry;
          /**
           * Computes a concave fill area between a set of polygons,
           * using the target criterion of maximum edge length ratio.
           *
           * @param polygons - the input polygons
           * @param lengthRatio - the target maximum edge length ratio
           * @returns the concave fill
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.concaveFillByLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#concaveFillByLengthRatio-org.locationtech.jts.geom.Geometry-double-)
           */
          concaveFillByLengthRatio(polygons: Geometry, lengthRatio: number): Geometry;
          /**
           * Computes a concave hull of set of polygons
           * using the target criterion of maximum edge length,
           * and allowing control over whether the hull boundary is tight
           * and can contain holes.
           *
           * @param polygons - the input polygons
           * @param maxLength - the target maximum edge length
           * @param isTight - true if the hull should be tight to the outside of the polygons
           * @param isHolesAllowed - true if holes are allowed in the hull polygon
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.concaveHullByLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#concaveHullByLength-org.locationtech.jts.geom.Geometry-double-boolean-boolean-)
           */
          concaveHullByLength(polygons: Geometry, maxLength: number, isTight: boolean, isHolesAllowed: boolean): Geometry;
          /**
           * Computes a concave hull of set of polygons
           * using the target criterion of maximum edge length ratio,
           * and allowing control over whether the hull boundary is tight
           * and can contain holes.
           *
           * @param polygons - the input polygons
           * @param lengthRatio - the target maximum edge length ratio
           * @param isTight - true if the hull should be tight to the outside of the polygons
           * @param isHolesAllowed - true if holes are allowed in the hull polygon
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.concaveHullByLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#concaveHullByLengthRatio-org.locationtech.jts.geom.Geometry-double-boolean-boolean-)
           */
          concaveHullByLengthRatio(polygons: Geometry, lengthRatio: number, isTight: boolean, isHolesAllowed: boolean): Geometry;
          /**
           * Creates a new instance for a given geometry.
           *
           * @param polygons - the input geometry
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.ConcaveHullOfPolygons](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#ConcaveHullOfPolygons-org.locationtech.jts.geom.Geometry-)
           */
          create1(polygons: Geometry): any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */;
          /**
           * Gets the concave fill, which is the area between the input polygons,
           * subject to the concaveness control parameter.
           *
           * @returns the concave fill
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.getFill](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#getFill--)
           */
          getFill(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */): Geometry;
          /**
           * Gets the computed concave hull.
           *
           * @returns the concave hull
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.getHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#getHull--)
           */
          getHull(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */): Geometry;
          /**
           * Sets whether holes are allowed in the concave hull polygon.
           *
           * @param isHolesAllowed - true if holes are allowed in the result
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.setHolesAllowed](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#setHolesAllowed-boolean-)
           */
          setHolesAllowed(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */, isHolesAllowed: boolean): any /* void */;
          /**
           * Sets the target maximum edge length for the concave hull.
           * The length value must be zero or greater.
           *
           * - The value 0.0 produces the input polygons.
           * - Larger values produce less concave results.
           * Above a certain large value the result is the convex hull of the input.
           *
           * The edge length ratio provides a scale-free parameter which
           * is intended to produce similar concave results for a variety of inputs.
           *
           * @param edgeLength - a non-negative length
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.setMaximumEdgeLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#setMaximumEdgeLength-double-)
           */
          setMaximumEdgeLength(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */, edgeLength: number): any /* void */;
          /**
           * Sets the target maximum edge length ratio for the concave hull.
           * The edge length ratio is a fraction of the difference
           * between the longest and shortest edge lengths
           * in the Delaunay Triangulation of the area between the input polygons.
           * (Roughly speaking, it is a fraction of the difference between
           * the shortest and longest distances between the input polygons.)
           * It is a value in the range 0 to 1.
           *
           * - The value 0.0 produces the original input polygons.
           * - The value 1.0 produces the convex hull.
           *
           * @param edgeLengthRatio - a length factor value between 0 and 1
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.setMaximumEdgeLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#setMaximumEdgeLengthRatio-double-)
           */
          setMaximumEdgeLengthRatio(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */, edgeLengthRatio: number): any /* void */;
          /**
           * Sets whether the boundary of the hull polygon is kept
           * tight to the outer edges of the input polygons.
           *
           * @param isTight - true if the boundary is kept tight
           * @see [org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons.setTight](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/hull/ConcaveHullOfPolygons.html#setTight-boolean-)
           */
          setTight(concaveHullOfPolygons: any /* org.locationtech.jts.algorithm.hull.ConcaveHullOfPolygons */, isTight: boolean): any /* void */;
        };
      };
      locate: {
        IndexedPointInAreaLocator: {
          /**
           * Creates a new locator for a given `Geometry`.
           * Geometries containing `Polygon`s and `LinearRing` geometries
           * are supported.
           *
           * @param g - the Geometry to locate in
           * @see [org.locationtech.jts.algorithm.locate.IndexedPointInAreaLocator.IndexedPointInAreaLocator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/IndexedPointInAreaLocator.html#IndexedPointInAreaLocator-org.locationtech.jts.geom.Geometry-)
           */
          create1(g: Geometry): any /* org.locationtech.jts.algorithm.locate.IndexedPointInAreaLocator */;
          /**
           * Determines the `Location` of a point in an areal `Geometry`.
           *
           * @param p - the point to test
           * @returns the location of the point in the geometry
           * @see [org.locationtech.jts.algorithm.locate.IndexedPointInAreaLocator.locate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/IndexedPointInAreaLocator.html#locate-org.locationtech.jts.geom.Coordinate-)
           */
          locate(indexedPointInAreaLocator: any /* org.locationtech.jts.algorithm.locate.IndexedPointInAreaLocator */, p: Coordinate): number;
        };
        SimplePointInAreaLocator: {
          /**
           * Determines whether a point lies in a `Polygon`.
           * If the point lies on the polygon boundary it is
           * considered to be inside.
           *
           * @param p - the point to test
           * @param poly - the geometry to test
           * @returns true if the point lies in or on the polygon
           * @see [org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator.containsPointInPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/SimplePointInAreaLocator.html#containsPointInPolygon-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Polygon-)
           */
          containsPointInPolygon(p: Coordinate, poly: Geometry): boolean;
          /**
           * Create an instance of a point-in-area locator,
           * using the provided areal geometry.
           *
           * @param geom - the areal geometry to locate in
           * @see [org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator.SimplePointInAreaLocator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/SimplePointInAreaLocator.html#SimplePointInAreaLocator-org.locationtech.jts.geom.Geometry-)
           */
          create1(geom: Geometry): any /* org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator */;
          /**
           * Determines whether a point is contained in a `Geometry`,
           * or lies on its boundary.
           * This is a convenience method for
           *
           * ```
           * Location.EXTERIOR != locate(p, geom)
           * ```
           *
           * @param p - the point to test
           * @param geom - the geometry to test
           * @returns true if the point lies in or on the geometry
           * @see [org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator.isContained](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/SimplePointInAreaLocator.html#isContained-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Geometry-)
           */
          isContained(p: Coordinate, geom: Geometry): boolean;
          /**
           * Determines the `Location` of a point in an areal `Geometry`.
           * The return value is one of:
           *
           * - `Location.INTERIOR` if the point is in the geometry interior
           * - `Location.BOUNDARY` if the point lies exactly on the boundary
           * - `Location.EXTERIOR` if the point is outside the geometry
           *
           * @param p - the point to test
           * @param geom - the areal geometry to test
           * @returns the Location of the point in the geometry
           * @see [org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator.locate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/SimplePointInAreaLocator.html#locate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Geometry-)
           */
          locate(p: Coordinate, geom: Geometry): number;
          /**
           * Determines the `Location` of a point in a `Polygon`.
           * The return value is one of:
           *
           * - `Location.INTERIOR` if the point is in the geometry interior
           * - `Location.BOUNDARY` if the point lies exactly on the boundary
           * - `Location.EXTERIOR` if the point is outside the geometry
           *
           * This method is provided for backwards compatibility only.
           * Use `Geometry)` instead.
           *
           * @param p - the point to test
           * @param poly - the geometry to test
           * @returns the Location of the point in the polygon
           * @see [org.locationtech.jts.algorithm.locate.SimplePointInAreaLocator.locatePointInPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/locate/SimplePointInAreaLocator.html#locatePointInPolygon-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Polygon-)
           */
          locatePointInPolygon(p: Coordinate, poly: Geometry): number;
        };
      };
      match: {
        AreaSimilarityMeasure: {
          /**
           * Creates a new instance.
           *
           * @see [org.locationtech.jts.algorithm.match.AreaSimilarityMeasure.AreaSimilarityMeasure](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/match/AreaSimilarityMeasure.html#AreaSimilarityMeasure--)
           */
          create0(): any /* org.locationtech.jts.algorithm.match.AreaSimilarityMeasure */;
          /**
           * Computes the similarity measure between two geometries
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @returns the value of the similarity measure, in [0.0, 1.0]
           * @see [org.locationtech.jts.algorithm.match.SimilarityMeasure.measure](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/match/SimilarityMeasure.html#measure-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          measure(areaSimilarityMeasure: any /* org.locationtech.jts.algorithm.match.AreaSimilarityMeasure */, g1: Geometry, g2: Geometry): number;
        };
        FrechetSimilarityMeasure: {
          /**
           * Creates an instance of this class.
           *
           * @see [org.locationtech.jts.algorithm.match.FrechetSimilarityMeasure.FrechetSimilarityMeasure](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/match/FrechetSimilarityMeasure.html#FrechetSimilarityMeasure--)
           */
          create0(): any /* org.locationtech.jts.algorithm.match.FrechetSimilarityMeasure */;
          /**
           * Computes the similarity measure between two geometries
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @returns the value of the similarity measure, in [0.0, 1.0]
           * @see [org.locationtech.jts.algorithm.match.SimilarityMeasure.measure](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/match/SimilarityMeasure.html#measure-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          measure(frechetSimilarityMeasure: any /* org.locationtech.jts.algorithm.match.FrechetSimilarityMeasure */, g1: Geometry, g2: Geometry): number;
        };
        HausdorffSimilarityMeasure: {
          create0(): any /* org.locationtech.jts.algorithm.match.HausdorffSimilarityMeasure */;
          diagonalSize(env: Envelope): number;
          /**
           * Computes the similarity measure between two geometries
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @returns the value of the similarity measure, in [0.0, 1.0]
           * @see [org.locationtech.jts.algorithm.match.SimilarityMeasure.measure](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/algorithm/match/SimilarityMeasure.html#measure-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          measure(hausdorffSimilarityMeasure: any /* org.locationtech.jts.algorithm.match.HausdorffSimilarityMeasure */, g1: Geometry, g2: Geometry): number;
        };
        SimilarityMeasureCombiner: {
          combine(measure1: number, measure2: number): number;
        };
      };
    };
    awt: {
      FontGlyphReader: {
        /**
         * Converts text rendered in the given font and pointsize to a `Geometry`
         * using a standard flatness factor.
         *
         * @param text - the text to render
         * @param fontName - the name of the font
         * @param pointSize - the pointSize to render at
         * @param geomFact - the geometryFactory to use to create the result
         * @returns a polygonal geometry representing the rendered text
         * @see [org.locationtech.jts.awt.FontGlyphReader.read](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/awt/FontGlyphReader.html#read-java.lang.String-java.lang.String-int-org.locationtech.jts.geom.GeometryFactory-)
         */
        read(text: string, fontName: string, pointSize: number, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
      };
      GeometryCollectionShape: {
        contains(geometryCollectionShape: any /* org.locationtech.jts.awt.GeometryCollectionShape */, x: number, y: number, w: number, h: number): boolean;
        create0(): any /* org.locationtech.jts.awt.GeometryCollectionShape */;
        intersects(geometryCollectionShape: any /* org.locationtech.jts.awt.GeometryCollectionShape */, x: number, y: number, w: number, h: number): boolean;
      };
      IdentityPointTransformation: {
        create0(): any /* org.locationtech.jts.awt.IdentityPointTransformation */;
      };
      PolygonShape: {
        contains(polygonShape: any /* org.locationtech.jts.awt.PolygonShape */, x: number, y: number, w: number, h: number): boolean;
        create0(): any /* org.locationtech.jts.awt.PolygonShape */;
        intersects(polygonShape: any /* org.locationtech.jts.awt.PolygonShape */, x: number, y: number, w: number, h: number): boolean;
      };
      ShapeWriter: {
        /**
         * Creates a new ShapeWriter with the default (identity) point transformation.
         *
         * @see [org.locationtech.jts.awt.ShapeWriter.ShapeWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/awt/ShapeWriter.html#ShapeWriter--)
         */
        create0(): any /* org.locationtech.jts.awt.ShapeWriter */;
        /**
         * Sets the decimation distance used to determine
         * whether vertices of the input geometry are
         * considered to be duplicate and thus removed.
         * The distance is axis distance, not Euclidean distance.
         * The distance is specified in the input geometry coordinate system
         * (NOT the transformed output coordinate system).
         *
         * When rendering to a screen image, a suitably small distance should be used
         * to avoid obvious rendering defects.
         * A distance equivalent to the equivalent of 1.5 pixels or less is recommended
         * (and perhaps even smaller to avoid any chance of visible artifacts).
         *
         * The default distance is 0.0, which disables decimation.
         *
         * @param decimationDistance - the distance below which vertices are considered to be duplicates
         * @see [org.locationtech.jts.awt.ShapeWriter.setDecimation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/awt/ShapeWriter.html#setDecimation-double-)
         */
        setDecimation(shapeWriter: any /* org.locationtech.jts.awt.ShapeWriter */, decimationDistance: number): any /* void */;
        /**
         * Sets whether duplicate consecutive points should be eliminated.
         * This can reduce the size of the generated Shapes
         * and improve rendering speed, especially in situations
         * where a transform reduces the extent of the geometry.
         *
         * The default is `false`.
         *
         * @param doRemoveDuplicatePoints - whether decimation is to be used to remove duplicate points
         * @see [org.locationtech.jts.awt.ShapeWriter.setRemoveDuplicatePoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/awt/ShapeWriter.html#setRemoveDuplicatePoints-boolean-)
         */
        setRemoveDuplicatePoints(shapeWriter: any /* org.locationtech.jts.awt.ShapeWriter */, doRemoveDuplicatePoints: boolean): any /* void */;
      };
    };
    coverage: {
      CoverageGapFinder: {
        /**
         * Creates a new polygonal coverage gap finder.
         *
         * @param coverage - a set of polygons forming a polygonal coverage
         * @see [org.locationtech.jts.coverage.CoverageGapFinder.CoverageGapFinder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageGapFinder.html#CoverageGapFinder-org.locationtech.jts.geom.Geometry:A-)
         */
        create1(coverage: Geometry[]): any /* org.locationtech.jts.coverage.CoverageGapFinder */;
        /**
         * Finds gaps in a polygonal coverage.
         * Returns lines indicating the locations of the gaps.
         *
         * @param coverage - a set of polygons forming a polygonal coverage
         * @param gapWidth - the maximum width of gap to detect
         * @returns a geometry indicating the locations of gaps (which is empty if no gaps were found), or null if the coverage was empty
         * @see [org.locationtech.jts.coverage.CoverageGapFinder.findGaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageGapFinder.html#findGaps-org.locationtech.jts.geom.Geometry:A-double-)
         */
        findGaps(coverage: Geometry[], gapWidth: number): Geometry;
      };
      CoveragePolygonValidator: {
        /**
         * Create a new validator.
         *
         * If the gap width is specified, the set of surrounding polygons
         * should include all polygons which
         * are within the gap width distance of the target polygon.
         *
         * @param geom - the geometry to validate
         * @param adjGeoms - the adjacent polygons in the polygonal coverage
         * @see [org.locationtech.jts.coverage.CoveragePolygonValidator.CoveragePolygonValidator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoveragePolygonValidator.html#CoveragePolygonValidator-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry:A-)
         */
        create2(geom: Geometry, adjGeoms: Geometry[]): any /* org.locationtech.jts.coverage.CoveragePolygonValidator */;
        /**
         * Sets the maximum gap width, if narrow gaps are to be detected.
         *
         * @param gapWidth - the maximum width of gaps to detect
         * @see [org.locationtech.jts.coverage.CoveragePolygonValidator.setGapWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoveragePolygonValidator.html#setGapWidth-double-)
         */
        setGapWidth(coveragePolygonValidator: any /* org.locationtech.jts.coverage.CoveragePolygonValidator */, gapWidth: number): any /* void */;
        /**
         * Validates that a polygon is coverage-valid against the
         * surrounding polygons in a polygonal coverage,
         * and forms no gaps narrower than a specified width.
         *
         * The set of surrounding polygons should include all polygons which
         * are within the gap width distance of the target polygon.
         *
         * @param targetPolygon - the polygon to validate
         * @param adjPolygons - a collection of the adjacent polygons
         * @param gapWidth - the maximum width of invalid gaps
         * @returns a linear geometry containing the segments causing invalidity (if any)
         * @see [org.locationtech.jts.coverage.CoveragePolygonValidator.validate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoveragePolygonValidator.html#validate-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry:A-double-)
         */
        validate(targetPolygon: Geometry, adjPolygons: Geometry[], gapWidth: number): Geometry;
      };
      CoverageSimplifier: {
        /**
         * Create a new coverage simplifier instance.
         *
         * @param coverage - a set of polygonal geometries forming a coverage
         * @see [org.locationtech.jts.coverage.CoverageSimplifier.CoverageSimplifier](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageSimplifier.html#CoverageSimplifier-org.locationtech.jts.geom.Geometry:A-)
         */
        create1(coverage: Geometry[]): any /* org.locationtech.jts.coverage.CoverageSimplifier */;
        /**
         * Sets the factor applied to the area tolerance to determine
         * if small rings should be removed.
         * Larger values cause more rings to be removed.
         * A value of 0 prevents rings from being removed.
         *
         * @param removableSizeFactor - the factor to determine ring size to remove
         * @see [org.locationtech.jts.coverage.CoverageSimplifier.setRemovableRingSizeFactor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageSimplifier.html#setRemovableRingSizeFactor-double-)
         */
        setRemovableRingSizeFactor(coverageSimplifier: any /* org.locationtech.jts.coverage.CoverageSimplifier */, removableSizeFactor: number): any /* void */;
        /**
         * Sets the weight influencing how smooth the simplification should be.
         * The weight must be between 0 and 1.
         * Larger values increase the smoothness of the simplified edges.
         *
         * @param smoothWeight - a value between 0 and 1
         * @see [org.locationtech.jts.coverage.CoverageSimplifier.setSmoothWeight](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageSimplifier.html#setSmoothWeight-double-)
         */
        setSmoothWeight(coverageSimplifier: any /* org.locationtech.jts.coverage.CoverageSimplifier */, smoothWeight: number): any /* void */;
        /**
         * Computes the simplified coverage using separate distance tolerances
         * for inner and outer edges,
         * preserving the coverage topology.
         *
         * @param toleranceInner - the distance tolerance for inner edges
         * @param toleranceOuter - the distance tolerance for outer edges
         * @returns the simplified coverage polygons
         * @see [org.locationtech.jts.coverage.CoverageSimplifier.simplify](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageSimplifier.html#simplify-double-double-)
         */
        simplify(coverageSimplifier: any /* org.locationtech.jts.coverage.CoverageSimplifier */, toleranceInner: number, toleranceOuter: number): Geometry[];
      };
      CoverageUnion: {
        /**
         * Unions a polygonal coverage.
         *
         * @param coverage - the polygons in the coverage
         * @returns the union of the coverage polygons
         * @see [org.locationtech.jts.coverage.CoverageUnion.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageUnion.html#union-org.locationtech.jts.geom.Geometry:A-)
         */
        union(coverage: Geometry[]): Geometry;
      };
      CoverageValidator: {
        /**
         * Creates a new coverage validator
         *
         * @param coverage - a array of polygons representing a polygonal coverage
         * @see [org.locationtech.jts.coverage.CoverageValidator.CoverageValidator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageValidator.html#CoverageValidator-org.locationtech.jts.geom.Geometry:A-)
         */
        create1(coverage: Geometry[]): any /* org.locationtech.jts.coverage.CoverageValidator */;
        /**
         * Tests if some element of an array of geometries is a coverage invalidity
         * indicator.
         *
         * @param validateResult - an array produced by a polygonal coverage validation
         * @returns true if the result has at least one invalid indicator
         * @see [org.locationtech.jts.coverage.CoverageValidator.hasInvalidResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageValidator.html#hasInvalidResult-org.locationtech.jts.geom.Geometry:A-)
         */
        hasInvalidResult(validateResult: Geometry[]): boolean;
        /**
         * Tests whether a polygonal coverage is valid.
         *
         * @param coverage - an array of polygons forming a coverage
         * @returns true if the coverage is valid
         * @see [org.locationtech.jts.coverage.CoverageValidator.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageValidator.html#isValid-org.locationtech.jts.geom.Geometry:A-)
         */
        isValid(coverage: Geometry[]): boolean;
        /**
         * Sets the maximum gap width, if narrow gaps are to be detected.
         *
         * @param gapWidth - the maximum width of gaps to detect
         * @see [org.locationtech.jts.coverage.CoverageValidator.setGapWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageValidator.html#setGapWidth-double-)
         */
        setGapWidth(coverageValidator: any /* org.locationtech.jts.coverage.CoverageValidator */, gapWidth: number): any /* void */;
        /**
         * Validates that a set of polygons forms a valid polygonal coverage
         * and contains no gaps narrower than a specified width.
         * The result is an array of linear geometries indicating the locations of invalidities,
         * or null if the polygon is coverage-valid.
         *
         * @param coverage - an array of polygons forming a coverage
         * @param gapWidth - the maximum width of invalid gaps
         * @returns an array of linear geometries indicating coverage errors, or nulls
         * @see [org.locationtech.jts.coverage.CoverageValidator.validate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/coverage/CoverageValidator.html#validate-org.locationtech.jts.geom.Geometry:A-double-)
         */
        validate(coverage: Geometry[], gapWidth: number): Geometry[];
      };
    };
    densify: {
      Densifier: {
        /**
         * Creates a new densifier instance.
         *
         * @param inputGeom
         * @see [org.locationtech.jts.densify.Densifier.Densifier](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/densify/Densifier.html#Densifier-org.locationtech.jts.geom.Geometry-)
         */
        create(inputGeom: Geometry): Densifier;
        /**
         * Densifies a geometry using a given distance tolerance,
         * and respecting the input geometry's `PrecisionModel`.
         *
         * @param geom - the geometry to densify
         * @param distanceTolerance - the distance tolerance to densify
         * @returns the densified geometry
         * @see [org.locationtech.jts.densify.Densifier.densify](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/densify/Densifier.html#densify-org.locationtech.jts.geom.Geometry-double-)
         */
        densify(geom: Geometry, distanceTolerance: number): Geometry;
        /**
         * Gets the densified geometry.
         *
         * @returns the densified geometry
         * @see [org.locationtech.jts.densify.Densifier.getResultGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/densify/Densifier.html#getResultGeometry--)
         */
        getResultGeometry(densifier: Densifier): Geometry;
        /**
         * Sets the distance tolerance for the densification. All line segments
         * in the densified geometry will be no longer than the distance tolerance.
         * The distance tolerance must be positive.
         *
         * @param distanceTolerance - the densification tolerance to use
         * @see [org.locationtech.jts.densify.Densifier.setDistanceTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/densify/Densifier.html#setDistanceTolerance-double-)
         */
        setDistanceTolerance(densifier: Densifier, distanceTolerance: number): any /* void */;
        /**
         * Sets whether polygonal results are processed to ensure they are valid.
         *
         * @param isValidated - true if the results should be validated
         * @see [org.locationtech.jts.densify.Densifier.setValidate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/densify/Densifier.html#setValidate-boolean-)
         */
        setValidate(densifier: Densifier, isValidated: boolean): any /* void */;
      };
    };
    dissolve: {
      LineDissolver: {
        /**
         * Adds a `Geometry` to be dissolved.
         * Any number of geometries may be added by calling this method multiple times.
         * Any type of Geometry may be added.  The constituent linework will be
         * extracted to be dissolved.
         *
         * @param geometry - geometry to be line-merged
         * @see [org.locationtech.jts.dissolve.LineDissolver.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/dissolve/LineDissolver.html#add-org.locationtech.jts.geom.Geometry-)
         */
        add(lineDissolver: any /* org.locationtech.jts.dissolve.LineDissolver */, geometry: Geometry): any /* void */;
        create0(): any /* org.locationtech.jts.dissolve.LineDissolver */;
        /**
         * Dissolves the linear components in a geometry.
         *
         * @param g - the geometry to dissolve
         * @returns the dissolved lines
         * @see [org.locationtech.jts.dissolve.LineDissolver.dissolve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/dissolve/LineDissolver.html#dissolve-org.locationtech.jts.geom.Geometry-)
         */
        dissolve(g: Geometry): Geometry;
        /**
         * Gets the dissolved result as a MultiLineString.
         *
         * @returns the dissolved lines
         * @see [org.locationtech.jts.dissolve.LineDissolver.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/dissolve/LineDissolver.html#getResult--)
         */
        getResult(lineDissolver: any /* org.locationtech.jts.dissolve.LineDissolver */): Geometry;
      };
    };
    edgegraph: {
      EdgeGraph: {
        /**
         * Adds an edge between the coordinates orig and dest
         * to this graph.
         * Only valid edges can be added (in particular, zero-length segments cannot be added)
         *
         * @param orig - the edge origin location
         * @param dest - the edge destination location.
         * @returns the created edge
         * @see [org.locationtech.jts.edgegraph.EdgeGraph.addEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/EdgeGraph.html#addEdge-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        addEdge(edgeGraph: any /* org.locationtech.jts.edgegraph.EdgeGraph */, orig: Coordinate, dest: Coordinate): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        create0(): any /* org.locationtech.jts.edgegraph.EdgeGraph */;
        /**
         * Finds an edge in this graph with the given origin
         * and destination, if one exists.
         *
         * @param orig - the origin location
         * @param dest - the destination location.
         * @returns an edge with the given orig and dest, or null if none exists
         * @see [org.locationtech.jts.edgegraph.EdgeGraph.findEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/EdgeGraph.html#findEdge-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        findEdge(edgeGraph: any /* org.locationtech.jts.edgegraph.EdgeGraph */, orig: Coordinate, dest: Coordinate): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Tests if the given coordinates form a valid edge (with non-zero length).
         *
         * @param orig - the start coordinate
         * @param dest - the end coordinate
         * @returns true if the edge formed is valid
         * @see [org.locationtech.jts.edgegraph.EdgeGraph.isValidEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/EdgeGraph.html#isValidEdge-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isValidEdge(orig: Coordinate, dest: Coordinate): boolean;
      };
      EdgeGraphBuilder: {
        /**
         * Adds the edges of a Geometry to the graph.
         * May be called multiple times.
         * Any dimension of Geometry may be added; the constituent edges are
         * extracted.
         *
         * @param geometry - geometry to be added
         * @see [org.locationtech.jts.edgegraph.EdgeGraphBuilder.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/EdgeGraphBuilder.html#add-org.locationtech.jts.geom.Geometry-)
         */
        add(edgeGraphBuilder: any /* org.locationtech.jts.edgegraph.EdgeGraphBuilder */, geometry: Geometry): any /* void */;
        create0(): any /* org.locationtech.jts.edgegraph.EdgeGraphBuilder */;
        getGraph(edgeGraphBuilder: any /* org.locationtech.jts.edgegraph.EdgeGraphBuilder */): any /* org.locationtech.jts.edgegraph.EdgeGraph */;
      };
      HalfEdge: {
        /**
         * Implements the total order relation:
         *
         * The angle of edge a is greater than the angle of edge b,
         * where the angle of an edge is the angle made by
         * the first segment of the edge with the positive x-axis
         *
         * When applied to a list of edges originating at the same point,
         * this produces a CCW ordering of the edges around the point.
         *
         * Using the obvious algorithm of computing the angle is not robust,
         * since the angle calculation is susceptible to roundoff error.
         * A robust algorithm is:
         *
         * - First, compare the quadrants the edge vectors lie in.
         * If the quadrants are different,
         * it is trivial to determine which edge has a greater angle.
         * - if the vectors lie in the same quadrant, the
         * `Coordinate, Coordinate)` function
         * can be used to determine the relative orientation of the vectors.
         *
         * @see [org.locationtech.jts.edgegraph.HalfEdge.compareAngularDirection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#compareAngularDirection-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        compareAngularDirection(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */, e: any /* org.locationtech.jts.edgegraph.HalfEdge */): number;
        /**
         * Creates a HalfEdge pair representing an edge
         * between two vertices located at coordinates p0 and p1.
         *
         * @param p0 - a vertex coordinate
         * @param p1 - a vertex coordinate
         * @returns the HalfEdge with origin at p0
         * @see [org.locationtech.jts.edgegraph.HalfEdge.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#create-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create(p0: Coordinate, p1: Coordinate): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Creates a half-edge originating from a given coordinate.
         *
         * @param orig - the origin coordinate
         * @see [org.locationtech.jts.edgegraph.HalfEdge.HalfEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#HalfEdge-org.locationtech.jts.geom.Coordinate-)
         */
        create1(orig: Coordinate): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Computes the degree of the origin vertex.
         * The degree is the number of edges
         * originating from the vertex.
         *
         * @returns the degree of the origin vertex
         * @see [org.locationtech.jts.edgegraph.HalfEdge.degree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#degree--)
         */
        degree(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): number;
        /**
         * Gets the destination coordinate of this edge.
         *
         * @returns the destination coordinate
         * @see [org.locationtech.jts.edgegraph.HalfEdge.dest](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#dest--)
         */
        dest(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): Coordinate;
        /**
         * Tests whether this edge has the given orig and dest vertices.
         *
         * @param p0 - the origin vertex to test
         * @param p1 - the destination vertex to test
         * @returns true if the vertices are equal to the ones of this edge
         * @see [org.locationtech.jts.edgegraph.HalfEdge.equals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#equals-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        equals(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */, p0: Coordinate, p1: Coordinate): boolean;
        /**
         * Finds the edge starting at the origin of this edge
         * with the given dest vertex,
         * if any.
         *
         * @param dest - the dest vertex to search for
         * @returns the edge with the required dest vertex, if it exists, or null
         * @see [org.locationtech.jts.edgegraph.HalfEdge.find](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#find-org.locationtech.jts.geom.Coordinate-)
         */
        find(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */, dest: Coordinate): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Inserts an edge
         * into the ring of edges around the origin vertex of this edge,
         * ensuring that the edges remain ordered CCW.
         * The inserted edge must have the same origin as this edge.
         *
         * @param eAdd - the edge to insert
         * @see [org.locationtech.jts.edgegraph.HalfEdge.insert](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#insert-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        insert(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */, eAdd: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* void */;
        /**
         * Tests whether the edges around the origin
         * are sorted correctly.
         * Note that edges must be strictly increasing,
         * which implies no two edges can have the same direction point.
         *
         * @returns true if the origin edges are sorted correctly
         * @see [org.locationtech.jts.edgegraph.HalfEdge.isEdgesSorted](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#isEdgesSorted--)
         */
        isEdgesSorted(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): boolean;
        /**
         * Links this edge with its sym (opposite) edge.
         * This must be done for each pair of edges created.
         *
         * @param sym - the sym edge to link.
         * @see [org.locationtech.jts.edgegraph.HalfEdge.link](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#link-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        link(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */, sym: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* void */;
        /**
         * Gets the next edge CCW around the
         * destination vertex of this edge,
         * originating at that vertex.
         * If the destination vertex has degree 1 then this is the **sym** edge.
         *
         * @returns the next outgoing edge CCW around the destination vertex
         * @see [org.locationtech.jts.edgegraph.HalfEdge.next](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#next--)
         */
        next(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Gets the next edge CCW around the origin of this edge,
         * with the same origin.
         * If the origin vertex has degree 1 then this is the edge itself.
         *
         * `e.oNext()` is equal to `e.sym().next()`
         *
         * @returns the next edge around the origin
         * @see [org.locationtech.jts.edgegraph.HalfEdge.oNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#oNext--)
         */
        oNext(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Gets the origin coordinate of this edge.
         *
         * @returns the origin coordinate
         * @see [org.locationtech.jts.edgegraph.HalfEdge.orig](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#orig--)
         */
        orig(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): Coordinate;
        /**
         * Gets the previous edge CW around the origin
         * vertex of this edge,
         * with that vertex being its destination.
         *
         * It is always true that `e.next().prev() == e`
         *
         * Note that this requires a scan of the origin edges,
         * so may not be efficient for some uses.
         *
         * @returns the previous edge CW around the origin vertex
         * @see [org.locationtech.jts.edgegraph.HalfEdge.prev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#prev--)
         */
        prev(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Finds the first node previous to this edge, if any.
         * A node has degree `<> 2`.
         * If no such node exists (i.e. the edge is part of a ring)
         * then null is returned.
         *
         * @returns an edge originating at the node prior to this edge, if any, or null if no node exists
         * @see [org.locationtech.jts.edgegraph.HalfEdge.prevNode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#prevNode--)
         */
        prevNode(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Gets the symmetric pair edge of this edge.
         *
         * @returns the symmetric pair edge
         * @see [org.locationtech.jts.edgegraph.HalfEdge.sym](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#sym--)
         */
        sym(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* org.locationtech.jts.edgegraph.HalfEdge */;
        /**
         * Provides a string representation of the edges around
         * the origin node of this edge.
         * Uses the subclass representation for each edge.
         *
         * @returns a string showing the edges around the origin
         * @see [org.locationtech.jts.edgegraph.HalfEdge.toStringNode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/HalfEdge.html#toStringNode--)
         */
        toStringNode(halfEdge: any /* org.locationtech.jts.edgegraph.HalfEdge */): string;
      };
      MarkHalfEdge: {
        /**
         * Creates a new marked edge.
         *
         * @param orig - the coordinate of the edge origin
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.MarkHalfEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#MarkHalfEdge-org.locationtech.jts.geom.Coordinate-)
         */
        create1(orig: Coordinate): any /* org.locationtech.jts.edgegraph.MarkHalfEdge */;
        /**
         * Tests whether the given edge is marked.
         *
         * @param e - the edge to test
         * @returns true if the edge is marked
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.isMarked](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#isMarked-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        isMarked(e: any /* org.locationtech.jts.edgegraph.HalfEdge */): boolean;
        /**
         * Marks the given edge.
         *
         * @param e - the edge to mark
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.mark](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#mark-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        mark(e: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* void */;
        /**
         * Marks the edges in a pair.
         *
         * @param e - an edge of the pair to mark
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.markBoth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#markBoth-org.locationtech.jts.edgegraph.HalfEdge-)
         */
        markBoth(e: any /* org.locationtech.jts.edgegraph.HalfEdge */): any /* void */;
        /**
         * Sets the mark for the given edge to a boolean value.
         *
         * @param e - the edge to set
         * @param isMarked - the mark value
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.setMark](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#setMark-org.locationtech.jts.edgegraph.HalfEdge-boolean-)
         */
        setMark(e: any /* org.locationtech.jts.edgegraph.HalfEdge */, isMarked: boolean): any /* void */;
        /**
         * Sets the mark for the given edge pair to a boolean value.
         *
         * @param e - an edge of the pair to update
         * @param isMarked - the mark value to set
         * @see [org.locationtech.jts.edgegraph.MarkHalfEdge.setMarkBoth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/edgegraph/MarkHalfEdge.html#setMarkBoth-org.locationtech.jts.edgegraph.HalfEdge-boolean-)
         */
        setMarkBoth(e: any /* org.locationtech.jts.edgegraph.HalfEdge */, isMarked: boolean): any /* void */;
      };
    };
    geom: {
      Coordinate: {
        /**
         * Standard ordinate index value for, where M is 3.
         *
         * This constant assumes XYZM coordinate sequence definition, please check this assumption
         * using `CoordinateSequence.getDimension` and `CoordinateSequence.getMeasures`
         * before use.
         *
         * @see [org.locationtech.jts.geom.Coordinate.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#M)
         */
        M: number;
        /**
         * The value used to indicate a null or missing ordinate value.
         * In particular, used for the value of ordinates for dimensions
         * greater than the defined dimension of a coordinate.
         *
         * @see [org.locationtech.jts.geom.Coordinate.NULL_ORDINATE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#NULL_ORDINATE)
         */
        NULL_ORDINATE: number;
        /**
         * Standard ordinate index value for, where X is 0
         *
         * @see [org.locationtech.jts.geom.Coordinate.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#X)
         */
        X: number;
        /**
         * Standard ordinate index value for, where Y is 1
         *
         * @see [org.locationtech.jts.geom.Coordinate.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Y)
         */
        Y: number;
        /**
         * Standard ordinate index value for, where Z is 2.
         *
         * This constant assumes XYZM coordinate sequence definition, please check this assumption
         * using `CoordinateSequence.getDimension` and `CoordinateSequence.getMeasures`
         * before use.
         *
         * @see [org.locationtech.jts.geom.Coordinate.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Z)
         */
        Z: number;
        /**
         * Compares this `Coordinate` with the specified `Coordinate` for order.
         * This method ignores the z value when making the comparison.
         * Returns:
         *
         * - -1 : this.x < other.x || ((this.x == other.x) && (this.y < other.y))
         * - 0 : this.x == other.x && this.y = other.y
         * - 1 : this.x > other.x || ((this.x == other.x) && (this.y > other.y))
         *
         * Note: This method assumes that ordinate values
         * are valid numbers.  NaN values are not handled correctly.
         *
         * @param o - the `Coordinate` with which this `Coordinate` is being compared
         * @returns -1, zero, or 1 as this `Coordinate` is less than, equal to, or greater than the specified `Coordinate`
         * @see [org.locationtech.jts.geom.Coordinate.compareTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#compareTo-org.locationtech.jts.geom.Coordinate-)
         */
        compareTo(coordinate: Coordinate, o: Coordinate): number;
        /**
         * Creates a copy of this Coordinate.
         *
         * @returns a copy of this coordinate.
         * @see [org.locationtech.jts.geom.Coordinate.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#copy--)
         */
        copy(coordinate: Coordinate): Coordinate;
        /**
         * Create a new Coordinate of the same type as this Coordinate, but with no values.
         *
         * @returns a new Coordinate
         * @see [org.locationtech.jts.geom.Coordinate.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#create--)
         */
        create(coordinate: Coordinate): Coordinate;
        /**
         * Constructs a `Coordinate` at (0,0,NaN).
         *
         * @see [org.locationtech.jts.geom.Coordinate.Coordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Coordinate--)
         */
        create0(): Coordinate;
        /**
         * Constructs a `Coordinate` having the same (x,y,z) values as
         * `other`.
         *
         * @param c - the `Coordinate` to copy.
         * @see [org.locationtech.jts.geom.Coordinate.Coordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create1(c: Coordinate): Coordinate;
        /**
         * Constructs a `Coordinate` at (x,y,NaN).
         *
         * @param x - the x-value
         * @param y - the y-value
         * @see [org.locationtech.jts.geom.Coordinate.Coordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Coordinate-double-double-)
         */
        create2(x: number, y: number): Coordinate;
        /**
         * Constructs a `Coordinate` at (x,y,z).
         *
         * @param x - the x-ordinate
         * @param y - the y-ordinate
         * @param z - the z-ordinate
         * @see [org.locationtech.jts.geom.Coordinate.Coordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#Coordinate-double-double-double-)
         */
        create3(x: number, y: number, z: number): Coordinate;
        /**
         * Computes the 2-dimensional Euclidean distance to another location.
         * The Z-ordinate is ignored.
         *
         * @param c - a point
         * @returns the 2-dimensional Euclidean distance between the locations
         * @see [org.locationtech.jts.geom.Coordinate.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#distance-org.locationtech.jts.geom.Coordinate-)
         */
        distance(coordinate: Coordinate, c: Coordinate): number;
        /**
         * Computes the 3-dimensional Euclidean distance to another location.
         *
         * @param c - a coordinate
         * @returns the 3-dimensional Euclidean distance between the locations
         * @see [org.locationtech.jts.geom.Coordinate.distance3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#distance3D-org.locationtech.jts.geom.Coordinate-)
         */
        distance3D(coordinate: Coordinate, c: Coordinate): number;
        /**
         * Tests if another coordinate has the same value for Z, within a tolerance.
         *
         * @param c - a coordinate
         * @param tolerance - the tolerance value
         * @returns true if the Z ordinates are within the given tolerance
         * @see [org.locationtech.jts.geom.Coordinate.equalInZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equalInZ-org.locationtech.jts.geom.Coordinate-double-)
         */
        equalInZ(coordinate: Coordinate, c: Coordinate, tolerance: number): boolean;
        /**
         * Returns whether the planar projections of the two `Coordinate`s
         * are equal.
         *
         * @param other - a `Coordinate` with which to do the 2D comparison.
         * @returns `true` if the x- and y-coordinates are equal; the z-coordinates do not have to be equal.
         * @see [org.locationtech.jts.geom.Coordinate.equals2D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals2D-org.locationtech.jts.geom.Coordinate-)
         */
        equals2D(coordinate: Coordinate, other: Coordinate): boolean;
        /**
         * Tests if another Coordinate has the same values for the X and Y ordinates,
         * within a specified tolerance value.
         * The Z ordinate is ignored.
         *
         * @param c - a `Coordinate` with which to do the 2D comparison.
         * @param tolerance - the tolerance value to use
         * @returns true if `other` is a `Coordinate` with the same values for X and Y.
         * @see [org.locationtech.jts.geom.Coordinate.equals2D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals2D-org.locationtech.jts.geom.Coordinate-double-)
         */
        equals2DTolerance(coordinate: Coordinate, c: Coordinate, tolerance: number): boolean;
        /**
         * Tests if another coordinate has the same values for the X, Y and Z ordinates.
         *
         * @param other - a `Coordinate` with which to do the 3D comparison.
         * @returns true if `other` is a `Coordinate` with the same values for X, Y and Z.
         * @see [org.locationtech.jts.geom.Coordinate.equals3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#equals3D-org.locationtech.jts.geom.Coordinate-)
         */
        equals3D(coordinate: Coordinate, other: Coordinate): boolean;
        /**
         * Retrieves the value of the measure, if present.
         * If no measure value is present returns `NaN`.
         *
         * @returns the value of the measure, or `NaN`
         * @see [org.locationtech.jts.geom.Coordinate.getM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getM--)
         */
        getM(coordinate: Coordinate): number;
        /**
         * Retrieves the value of the X ordinate.
         *
         * @returns the value of the X ordinate
         * @see [org.locationtech.jts.geom.Coordinate.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getX--)
         */
        getX(coordinate: Coordinate): number;
        /**
         * Retrieves the value of the Y ordinate.
         *
         * @returns the value of the Y ordinate
         * @see [org.locationtech.jts.geom.Coordinate.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getY--)
         */
        getY(coordinate: Coordinate): number;
        /**
         * Retrieves the value of the Z ordinate, if present.
         * If no Z value is present returns `NaN`.
         *
         * @returns the value of the Z ordinate, or `NaN`
         * @see [org.locationtech.jts.geom.Coordinate.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#getZ--)
         */
        getZ(coordinate: Coordinate): number;
        /**
         * Computes a hash code for a double value, using the algorithm from
         * Joshua Bloch's book _Effective Java"_
         *
         * @param x - the value to compute for
         * @returns a hashcode for x
         * @see [org.locationtech.jts.geom.Coordinate.hashCode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#hashCode-double-)
         */
        hashCode(x: number): number;
        /**
         * Tests if the coordinate has valid X and Y ordinate values.
         * An ordinate value is valid iff it is finite.
         *
         * @returns true if the coordinate is valid
         * @see [org.locationtech.jts.geom.Coordinate.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinate.html#isValid--)
         */
        isValid(coordinate: Coordinate): boolean;
      };
      CoordinateArrays: {
        /**
         * Compares two `Coordinate` arrays
         * in the forward direction of their coordinates,
         * using lexicographic ordering.
         *
         * @param pts1
         * @param pts2
         * @returns an integer indicating the order
         * @see [org.locationtech.jts.geom.CoordinateArrays.compare](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#compare-org.locationtech.jts.geom.Coordinate:A-org.locationtech.jts.geom.Coordinate:A-)
         */
        compare(pts1: Coordinate[], pts2: Coordinate[]): number;
        /**
         * Creates a deep copy of the argument `Coordinate` array.
         *
         * @param coordinates - an array of Coordinates
         * @returns a deep copy of the input
         * @see [org.locationtech.jts.geom.CoordinateArrays.copyDeep](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#copyDeep-org.locationtech.jts.geom.Coordinate:A-)
         */
        copyDeep(coordinates: Coordinate[]): Coordinate[];
        /**
         * Determine dimension based on subclass of `Coordinate`.
         *
         * @param pts - supplied coordinates
         * @returns number of ordinates recorded
         * @see [org.locationtech.jts.geom.CoordinateArrays.dimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#dimension-org.locationtech.jts.geom.Coordinate:A-)
         */
        dimension(pts: Coordinate[]): number;
        /**
         * Utility method ensuring array contents are of the specified dimension and measures.
         *
         * Array is returned unmodified if consistent, or a copy of the array is made with
         * each inconsistent coordinate duplicated into an instance of the correct dimension and measures.</>
         *
         * @param array - coordinate array
         * @param dimension
         * @param measures
         * @returns array returned, or copy created if required to enforce consistency.
         * @see [org.locationtech.jts.geom.CoordinateArrays.enforceConsistency](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#enforceConsistency-org.locationtech.jts.geom.Coordinate:A-int-int-)
         */
        enforceConsistency(array: Coordinate[], dimension: number, measures: number): Coordinate[];
        /**
         * Computes the envelope of the coordinates.
         *
         * @param coordinates - the coordinates to scan
         * @returns the envelope of the coordinates
         * @see [org.locationtech.jts.geom.CoordinateArrays.envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#envelope-org.locationtech.jts.geom.Coordinate:A-)
         */
        envelope(coordinates: Coordinate[]): Envelope;
        /**
         * Returns true if the two arrays are identical, both null, or pointwise
         * equal (as compared using Coordinate#equals)
         *
         * @see [org.locationtech.jts.geom.CoordinateArrays.equals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#equals-org.locationtech.jts.geom.Coordinate:A-org.locationtech.jts.geom.Coordinate:A-)
         */
        equals(coord1: Coordinate[], coord2: Coordinate[]): boolean;
        /**
         * Extracts a subsequence of the input `Coordinate` array
         * from indices `start` to
         * `end` (inclusive).
         * The input indices are clamped to the array size;
         * If the end index is less than the start index,
         * the extracted array will be empty.
         *
         * @param pts - the input array
         * @param start - the index of the start of the subsequence to extract
         * @param end - the index of the end of the subsequence to extract
         * @returns a subsequence of the input array
         * @see [org.locationtech.jts.geom.CoordinateArrays.extract](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#extract-org.locationtech.jts.geom.Coordinate:A-int-int-)
         */
        extract(pts: Coordinate[], start: number, end: number): Coordinate[];
        /**
         * Tests whether an array has any repeated or invalid coordinates.
         *
         * @param coord - an array of coordinates
         * @returns true if the array contains repeated or invalid coordinates
         * @see [org.locationtech.jts.geom.CoordinateArrays.hasRepeatedOrInvalidPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#hasRepeatedOrInvalidPoints-org.locationtech.jts.geom.Coordinate:A-)
         */
        hasRepeatedOrInvalidPoints(coord: Coordinate[]): boolean;
        /**
         * Tests whether `Coordinate.equals` returns true for any two consecutive Coordinates
         * in the given array.
         *
         * @param coord - an array of coordinates
         * @returns true if the array has repeated points
         * @see [org.locationtech.jts.geom.CoordinateArrays.hasRepeatedPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#hasRepeatedPoints-org.locationtech.jts.geom.Coordinate:A-)
         */
        hasRepeatedPoints(coord: Coordinate[]): boolean;
        /**
         * Determines which orientation of the `Coordinate` array
         * is (overall) increasing.
         * In other words, determines which end of the array is "smaller"
         * (using the standard ordering on `Coordinate`).
         * Returns an integer indicating the increasing direction.
         * If the sequence is a palindrome, it is defined to be
         * oriented in a positive direction.
         *
         * @param pts - the array of Coordinates to test
         * @returns `1` if the array is smaller at the start or is a palindrome, `-1` if smaller at the end
         * @see [org.locationtech.jts.geom.CoordinateArrays.increasingDirection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#increasingDirection-org.locationtech.jts.geom.Coordinate:A-)
         */
        increasingDirection(pts: Coordinate[]): number;
        /**
         * Returns the index of `coordinate` in `coordinates`.
         * The first position is 0; the second, 1; etc.
         *
         * @param coordinate - the `Coordinate` to search for
         * @param coordinates - the array to search
         * @returns the position of `coordinate`, or -1 if it is not found
         * @see [org.locationtech.jts.geom.CoordinateArrays.indexOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#indexOf-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate:A-)
         */
        indexOf(coordinate: Coordinate, coordinates: Coordinate[]): number;
        /**
         * Extracts the coordinates which intersect an `Envelope`.
         *
         * @param coordinates - the coordinates to scan
         * @param env - the envelope to intersect with
         * @returns an array of the coordinates which intersect the envelope
         * @see [org.locationtech.jts.geom.CoordinateArrays.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#intersection-org.locationtech.jts.geom.Coordinate:A-org.locationtech.jts.geom.Envelope-)
         */
        intersection(coordinates: Coordinate[], env: Envelope): Coordinate[];
        /**
         * Tests whether an array of `Coordinate`s forms a ring,
         * by checking length and closure.
         * Self-intersection is not checked.
         *
         * @param pts - an array of Coordinates
         * @returns true if the coordinate form a ring.
         * @see [org.locationtech.jts.geom.CoordinateArrays.isRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#isRing-org.locationtech.jts.geom.Coordinate:A-)
         */
        isRing(pts: Coordinate[]): boolean;
        /**
         * Determine number of measures based on subclass of `Coordinate`.
         *
         * @param pts - supplied coordinates
         * @returns number of measures recorded
         * @see [org.locationtech.jts.geom.CoordinateArrays.measures](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#measures-org.locationtech.jts.geom.Coordinate:A-)
         */
        measures(pts: Coordinate[]): number;
        /**
         * Collapses a coordinate array to remove all null elements.
         *
         * @param coord - the coordinate array to collapse
         * @returns an array containing only non-null elements
         * @see [org.locationtech.jts.geom.CoordinateArrays.removeNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#removeNull-org.locationtech.jts.geom.Coordinate:A-)
         */
        removeNull(coord: Coordinate[]): Coordinate[];
        /**
         * If the coordinate array argument has repeated or invalid points,
         * constructs a new array containing no repeated points.
         * Otherwise, returns the argument.
         *
         * @param coord - an array of coordinates
         * @returns the array with repeated and invalid coordinates removed
         * @see [org.locationtech.jts.geom.CoordinateArrays.removeRepeatedOrInvalidPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#removeRepeatedOrInvalidPoints-org.locationtech.jts.geom.Coordinate:A-)
         */
        removeRepeatedOrInvalidPoints(coord: Coordinate[]): Coordinate[];
        /**
         * If the coordinate array argument has repeated points,
         * constructs a new array containing no repeated points.
         * Otherwise, returns the argument.
         *
         * @param coord - an array of coordinates
         * @returns the array with repeated coordinates removed
         * @see [org.locationtech.jts.geom.CoordinateArrays.removeRepeatedPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateArrays.html#removeRepeatedPoints-org.locationtech.jts.geom.Coordinate:A-)
         */
        removeRepeatedPoints(coord: Coordinate[]): Coordinate[];
      };
      CoordinateList: {
        /**
         * Adds a section of an array of coordinates to the list.
         *
         * @param coord - The coordinates
         * @param allowRepeated - if set to false, repeated coordinates are collapsed
         * @param start - the index to start from
         * @param end - the index to add up to but not including
         * @returns true (as by general collection contract)
         * @see [org.locationtech.jts.geom.CoordinateList.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#add-org.locationtech.jts.geom.Coordinate:A-boolean-int-int-)
         */
        add(coordinateList: any /* org.locationtech.jts.geom.CoordinateList */, coord: Coordinate[], allowRepeated: boolean, start: number, end: number): boolean;
        /**
         * Add an array of coordinates
         *
         * @param coll - The coordinates
         * @param allowRepeated - if set to false, repeated coordinates are collapsed
         * @returns true (as by general collection contract)
         * @see [org.locationtech.jts.geom.CoordinateList.addAll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#addAll-java.util.Collection-boolean-)
         */
        addAll(coordinateList: any /* org.locationtech.jts.geom.CoordinateList */, coll: any /* java.util.Collection */, allowRepeated: boolean): boolean;
        /**
         * Ensure this coordList is a ring, by adding the start point if necessary
         *
         * @see [org.locationtech.jts.geom.CoordinateList.closeRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#closeRing--)
         */
        closeRing(coordinateList: any /* org.locationtech.jts.geom.CoordinateList */): any /* void */;
        /**
         * Constructs a new list without any coordinates
         *
         * @see [org.locationtech.jts.geom.CoordinateList.CoordinateList](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#CoordinateList--)
         */
        create0(): any /* org.locationtech.jts.geom.CoordinateList */;
        /**
         * Constructs a new list from an array of Coordinates, allowing repeated points.
         * (I.e. this constructor produces a `CoordinateList` with exactly the same set of points
         * as the input array.)
         *
         * @param coord - the initial coordinates
         * @see [org.locationtech.jts.geom.CoordinateList.CoordinateList](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#CoordinateList-org.locationtech.jts.geom.Coordinate:A-)
         */
        create1(coord: Coordinate[]): any /* org.locationtech.jts.geom.CoordinateList */;
        /**
         * Constructs a new list from an array of Coordinates,
         * allowing caller to specify if repeated points are to be removed.
         *
         * @param coord - the array of coordinates to load into the list
         * @param allowRepeated - if `false`, repeated points are removed
         * @see [org.locationtech.jts.geom.CoordinateList.CoordinateList](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#CoordinateList-org.locationtech.jts.geom.Coordinate:A-boolean-)
         */
        create2(coord: Coordinate[], allowRepeated: boolean): any /* org.locationtech.jts.geom.CoordinateList */;
        getCoordinate(coordinateList: any /* org.locationtech.jts.geom.CoordinateList */, i: number): Coordinate;
        /**
         * Creates an array containing the coordinates in this list,
         * oriented in the given direction (forward or reverse).
         *
         * @param isForward - true if the direction is forward, false for reverse
         * @returns an oriented array of coordinates
         * @see [org.locationtech.jts.geom.CoordinateList.toCoordinateArray](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateList.html#toCoordinateArray-boolean-)
         */
        toCoordinateArray(coordinateList: any /* org.locationtech.jts.geom.CoordinateList */, isForward: boolean): Coordinate[];
      };
      CoordinateSequence: {
        /**
         * Standard ordinate index value for, where M is 3.
         *
         * This constant assumes XYZM coordinate sequence definition, please check this assumption
         * using `getDimension` and `getMeasures` before use.
         *
         * @see [org.locationtech.jts.geom.CoordinateSequence.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#M)
         */
        M: number;
        /**
         * Standard ordinate index value for, where X is 0
         *
         * @see [org.locationtech.jts.geom.CoordinateSequence.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#X)
         */
        X: number;
        /**
         * Standard ordinate index value for, where Y is 1
         *
         * @see [org.locationtech.jts.geom.CoordinateSequence.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#Y)
         */
        Y: number;
        /**
         * Standard z-ordinate index
         *
         * @see [org.locationtech.jts.geom.CoordinateSequence.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#Z)
         */
        Z: number;
        /**
         * Returns a deep copy of this collection.
         *
         * @returns a copy of the coordinate sequence containing copies of all points
         * @see [org.locationtech.jts.geom.CoordinateSequence.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#copy--)
         */
        copy(coordinateSequence: CoordinateSequence): CoordinateSequence;
        /**
         * Creates a coordinate for use in this sequence.
         *
         * The coordinate is created supporting the same number of `getDimension` and `getMeasures`
         * as this sequence and is suitable for use with `Coordinate)`.
         *
         * @returns coordinate for use with this sequence
         * @see [org.locationtech.jts.geom.CoordinateSequence.createCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#createCoordinate--)
         */
        createCoordinate(coordinateSequence: CoordinateSequence): Coordinate;
        /**
         * Expands the given `Envelope` to include the coordinates in the sequence.
         * Allows implementing classes to optimize access to coordinate values.
         *
         * @param env - the envelope to expand
         * @returns a ref to the expanded envelope
         * @see [org.locationtech.jts.geom.CoordinateSequence.expandEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#expandEnvelope-org.locationtech.jts.geom.Envelope-)
         */
        expandEnvelope(coordinateSequence: CoordinateSequence, env: Envelope): Envelope;
        /**
         * Returns (possibly a copy of) the i'th coordinate in this sequence.
         * Whether or not the Coordinate returned is the actual underlying
         * Coordinate or merely a copy depends on the implementation.
         *
         * Note that in the future the semantics of this method may change
         * to guarantee that the Coordinate returned is always a copy.
         * Callers should not to assume that they can modify a CoordinateSequence by
         * modifying the object returned by this method.
         *
         * @param i - the index of the coordinate to retrieve
         * @returns the i'th coordinate in the sequence
         * @see [org.locationtech.jts.geom.CoordinateSequence.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getCoordinate-int-)
         */
        getCoordinate(coordinateSequence: CoordinateSequence, i: number): Coordinate;
        /**
         * Returns a copy of the i'th coordinate in this sequence.
         * This method optimizes the situation where the caller is
         * going to make a copy anyway - if the implementation
         * has already created a new Coordinate object, no further copy is needed.
         *
         * @param i - the index of the coordinate to retrieve
         * @returns a copy of the i'th coordinate in the sequence
         * @see [org.locationtech.jts.geom.CoordinateSequence.getCoordinateCopy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getCoordinateCopy-int-)
         */
        getCoordinateCopy(coordinateSequence: CoordinateSequence, i: number): Coordinate;
        /**
         * Returns the dimension (number of ordinates in each coordinate) for this sequence.
         *
         * This total includes any measures, indicated by non-zero `getMeasures`.
         *
         * @returns the dimension of the sequence.
         * @see [org.locationtech.jts.geom.CoordinateSequence.getDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getDimension--)
         */
        getDimension(coordinateSequence: CoordinateSequence): number;
        /**
         * Returns ordinate M of the specified coordinate if available.
         *
         * @param index - the coordinate index in the sequence
         * @returns the value of the M ordinate in the index'th coordinate, or Double.NaN if not defined.
         * @see [org.locationtech.jts.geom.CoordinateSequence.getM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getM-int-)
         */
        getM(coordinateSequence: CoordinateSequence, index: number): number;
        /**
         * Returns the number of measures included in `getDimension` for each coordinate for this
         * sequence.
         *
         * For a measured coordinate sequence a non-zero value is returned.
         *
         * - For XY sequence measures is zero
         * - For XYM sequence measure is one
         * -
         * - For XYZ sequence measure is zero
         * - For XYZM sequence measure is one
         * - Values greater than one are supported
         *
         * @returns the number of measures included in dimension
         * @see [org.locationtech.jts.geom.CoordinateSequence.getMeasures](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getMeasures--)
         */
        getMeasures(coordinateSequence: CoordinateSequence): number;
        /**
         * Returns the ordinate of a coordinate in this sequence.
         * Ordinate indices 0 and 1 are assumed to be X and Y.
         *
         * Ordinates indices greater than 1 have user-defined semantics
         * (for instance, they may contain other dimensions or measure
         * values as described by `getDimension` and `getMeasures`).
         *
         * @param index - the coordinate index in the sequence
         * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
         * @returns ordinate value
         * @see [org.locationtech.jts.geom.CoordinateSequence.getOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getOrdinate-int-int-)
         */
        getOrdinate(coordinateSequence: CoordinateSequence, index: number, ordinateIndex: number): number;
        /**
         * Returns ordinate X (0) of the specified coordinate.
         *
         * @param index - the coordinate index in the sequence
         * @returns the value of the X ordinate in the index'th coordinate
         * @see [org.locationtech.jts.geom.CoordinateSequence.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getX-int-)
         */
        getX(coordinateSequence: CoordinateSequence, index: number): number;
        /**
         * Returns ordinate Y (1) of the specified coordinate.
         *
         * @param index - the coordinate index in the sequence
         * @returns the value of the Y ordinate in the index'th coordinate
         * @see [org.locationtech.jts.geom.CoordinateSequence.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getY-int-)
         */
        getY(coordinateSequence: CoordinateSequence, index: number): number;
        /**
         * Returns ordinate Z of the specified coordinate if available.
         *
         * @param index - the coordinate index in the sequence
         * @returns the value of the Z ordinate in the index'th coordinate, or Double.NaN if not defined.
         * @see [org.locationtech.jts.geom.CoordinateSequence.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getZ-int-)
         */
        getZ(coordinateSequence: CoordinateSequence, index: number): number;
        /**
         * Tests whether the coordinates in the sequence have measures associated with them. Returns true
         * if `getMeasures` `> 0`. See `getMeasures` to determine the number of measures
         * present.
         *
         * @returns true if `getM` is supported.
         * @see [org.locationtech.jts.geom.CoordinateSequence.hasM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#hasM--)
         */
        hasM(coordinateSequence: CoordinateSequence): boolean;
        /**
         * Checks `getDimension` and `getMeasures` to determine if `getZ`
         * is supported.
         *
         * @returns true if `getZ` is supported.
         * @see [org.locationtech.jts.geom.CoordinateSequence.hasZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#hasZ--)
         */
        hasZ(coordinateSequence: CoordinateSequence): boolean;
        /**
         * Sets the value for a given ordinate of a coordinate in this sequence.
         *
         * @param index - the coordinate index in the sequence
         * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
         * @param value - the new ordinate value
         * @see [org.locationtech.jts.geom.CoordinateSequence.setOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#setOrdinate-int-int-double-)
         */
        setOrdinate(coordinateSequence: CoordinateSequence, index: number, ordinateIndex: number, value: number): any /* void */;
        /**
         * Returns the number of coordinates in this sequence.
         *
         * @returns the size of the sequence
         * @see [org.locationtech.jts.geom.CoordinateSequence.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#size--)
         */
        size(coordinateSequence: CoordinateSequence): number;
      };
      CoordinateSequenceComparator: {
        /**
         * Creates a comparator which will test all dimensions.
         *
         * @see [org.locationtech.jts.geom.CoordinateSequenceComparator.CoordinateSequenceComparator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequenceComparator.html#CoordinateSequenceComparator--)
         */
        create0(): any /* org.locationtech.jts.geom.CoordinateSequenceComparator */;
        /**
         * Creates a comparator which will test only the specified number of dimensions.
         *
         * @param dimensionLimit - the number of dimensions to test
         * @see [org.locationtech.jts.geom.CoordinateSequenceComparator.CoordinateSequenceComparator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequenceComparator.html#CoordinateSequenceComparator-int-)
         */
        create1(dimensionLimit: number): any /* org.locationtech.jts.geom.CoordinateSequenceComparator */;
      };
      CoordinateSequences: {
        /**
         * Copies a section of a `CoordinateSequence` to another `CoordinateSequence`.
         * The sequences may have different dimensions;
         * in this case only the common dimensions are copied.
         *
         * @param src - the sequence to copy from
         * @param srcPos - the position in the source sequence to start copying at
         * @param dest - the sequence to copy to
         * @param destPos - the position in the destination sequence to copy to
         * @param length - the number of coordinates to copy
         * @see [org.locationtech.jts.geom.CoordinateSequences.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#copy-org.locationtech.jts.geom.CoordinateSequence-int-org.locationtech.jts.geom.CoordinateSequence-int-int-)
         */
        copy(src: CoordinateSequence, srcPos: number, dest: CoordinateSequence, destPos: number, length: number): any /* void */;
        /**
         * Copies a coordinate of a `CoordinateSequence` to another `CoordinateSequence`.
         * The sequences may have different dimensions;
         * in this case only the common dimensions are copied.
         *
         * @param src - the sequence to copy from
         * @param srcPos - the source coordinate to copy
         * @param dest - the sequence to copy to
         * @param destPos - the destination coordinate to copy to
         * @see [org.locationtech.jts.geom.CoordinateSequences.copyCoord](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#copyCoord-org.locationtech.jts.geom.CoordinateSequence-int-org.locationtech.jts.geom.CoordinateSequence-int-)
         */
        copyCoord(src: CoordinateSequence, srcPos: number, dest: CoordinateSequence, destPos: number): any /* void */;
        /**
         * Returns the index of `coordinate` in a `CoordinateSequence`
         * The first position is 0; the second, 1; etc.
         *
         * @param coordinate - the `Coordinate` to search for
         * @param seq - the coordinate sequence to search
         * @returns the position of `coordinate`, or -1 if it is not found
         * @see [org.locationtech.jts.geom.CoordinateSequences.indexOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#indexOf-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.CoordinateSequence-)
         */
        indexOf(coordinate: Coordinate, seq: CoordinateSequence): number;
        /**
         * Tests whether two `CoordinateSequence`s are equal.
         * To be equal, the sequences must be the same length.
         * They do not need to be of the same dimension,
         * but the ordinate values for the smallest dimension of the two
         * must be equal.
         * Two `NaN` ordinates values are considered to be equal.
         *
         * @param cs1 - a CoordinateSequence
         * @param cs2 - a CoordinateSequence
         * @returns true if the sequences are equal in the common dimensions
         * @see [org.locationtech.jts.geom.CoordinateSequences.isEqual](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#isEqual-org.locationtech.jts.geom.CoordinateSequence-org.locationtech.jts.geom.CoordinateSequence-)
         */
        isEqual(cs1: CoordinateSequence, cs2: CoordinateSequence): boolean;
        /**
         * Tests whether a `CoordinateSequence` forms a valid `LinearRing`,
         * by checking the sequence length and closure
         * (whether the first and last points are identical in 2D).
         * Self-intersection is not checked.
         *
         * @param seq - the sequence to test
         * @returns true if the sequence is a ring
         * @see [org.locationtech.jts.geom.CoordinateSequences.isRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#isRing-org.locationtech.jts.geom.CoordinateSequence-)
         */
        isRing(seq: CoordinateSequence): boolean;
        /**
         * Returns the minimum coordinate, using the usual lexicographic comparison.
         *
         * @param seq - the coordinate sequence to search
         * @returns the minimum coordinate in the sequence, found using `compareTo`
         * @see [org.locationtech.jts.geom.CoordinateSequences.minCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#minCoordinate-org.locationtech.jts.geom.CoordinateSequence-)
         */
        minCoordinate(seq: CoordinateSequence): Coordinate;
        /**
         * Returns the index of the minimum coordinate of a part of
         * the coordinate sequence (defined by `from` and `to`,
         * using the usual lexicographic comparison.
         *
         * @param seq - the coordinate sequence to search
         * @param from - the lower search index
         * @param to - the upper search index
         * @returns the index of the minimum coordinate in the sequence, found using `compareTo`
         * @see [org.locationtech.jts.geom.CoordinateSequences.minCoordinateIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#minCoordinateIndex-org.locationtech.jts.geom.CoordinateSequence-int-int-)
         */
        minCoordinateIndex(seq: CoordinateSequence, from: number, to: number): number;
        /**
         * Reverses the coordinates in a sequence in-place.
         *
         * @param seq - the coordinate sequence to reverse
         * @see [org.locationtech.jts.geom.CoordinateSequences.reverse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#reverse-org.locationtech.jts.geom.CoordinateSequence-)
         */
        reverse(seq: CoordinateSequence): any /* void */;
        /**
         * Shifts the positions of the coordinates until the coordinate at  `firstCoordinateIndex`
         * is first.
         *
         * @param seq - the coordinate sequence to rearrange
         * @param indexOfFirstCoordinate - the index of the coordinate to make first
         * @param ensureRing - makes sure that will be a closed ring upon exit
         * @see [org.locationtech.jts.geom.CoordinateSequences.scroll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#scroll-org.locationtech.jts.geom.CoordinateSequence-int-boolean-)
         */
        scroll(seq: CoordinateSequence, indexOfFirstCoordinate: number, ensureRing: boolean): any /* void */;
        /**
         * Swaps two coordinates in a sequence.
         *
         * @param seq - the sequence to modify
         * @param i - the index of a coordinate to swap
         * @param j - the index of a coordinate to swap
         * @see [org.locationtech.jts.geom.CoordinateSequences.swap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#swap-org.locationtech.jts.geom.CoordinateSequence-int-int-)
         */
        swap(seq: CoordinateSequence, i: number, j: number): any /* void */;
        /**
         * Creates a string representation of a `CoordinateSequence`.
         * The format is:
         *
         * ```
         * ( ord0,ord1.. ord0,ord1,...  ... )
         * ```
         *
         * @param cs - the sequence to output
         * @returns the string representation of the sequence
         * @see [org.locationtech.jts.geom.CoordinateSequences.toString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequences.html#toString-org.locationtech.jts.geom.CoordinateSequence-)
         */
        toString(cs: CoordinateSequence): string;
      };
      CoordinateXY: {
        /**
         * CoordinateXY does not support M measures.
         *
         * @see [org.locationtech.jts.geom.CoordinateXY.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXY.html#M)
         */
        M: number;
        /**
         * Standard ordinate index value for X
         *
         * @see [org.locationtech.jts.geom.CoordinateXY.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXY.html#X)
         */
        X: number;
        /**
         * Standard ordinate index value for Y
         *
         * @see [org.locationtech.jts.geom.CoordinateXY.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXY.html#Y)
         */
        Y: number;
        /**
         * CoordinateXY does not support Z values.
         *
         * @see [org.locationtech.jts.geom.CoordinateXY.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXY.html#Z)
         */
        Z: number;
      };
      CoordinateXYM: {
        /**
         * Standard ordinate index value for M in XYM sequences.
         *
         * This constant assumes XYM coordinate sequence definition.  Check this assumption using
         * `CoordinateSequence.getDimension` and `CoordinateSequence.getMeasures` before use.
         *
         * @see [org.locationtech.jts.geom.CoordinateXYM.M](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXYM.html#M)
         */
        M: number;
        /**
         * Standard ordinate index value for X
         *
         * @see [org.locationtech.jts.geom.CoordinateXYM.X](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXYM.html#X)
         */
        X: number;
        /**
         * Standard ordinate index value for Y
         *
         * @see [org.locationtech.jts.geom.CoordinateXYM.Y](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXYM.html#Y)
         */
        Y: number;
        /**
         * CoordinateXYM does not support Z values.
         *
         * @see [org.locationtech.jts.geom.CoordinateXYM.Z](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateXYM.html#Z)
         */
        Z: number;
      };
      Coordinates: {
        /**
         * Factory method providing access to common Coordinate implementations.
         *
         * @param dimension
         * @param measures
         * @returns created coordinate
         * @see [org.locationtech.jts.geom.Coordinates.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinates.html#create-int-int-)
         */
        create(dimension: number, measures: number): Coordinate;
        /**
         * Determine dimension based on subclass of `Coordinate`.
         *
         * @param coordinate - supplied coordinate
         * @returns number of ordinates recorded
         * @see [org.locationtech.jts.geom.Coordinates.dimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinates.html#dimension-org.locationtech.jts.geom.Coordinate-)
         */
        dimension(coordinate: Coordinate): number;
        /**
         * Check if coordinate can store Z valye, based on subclass of `Coordinate`.
         *
         * @param coordinate - supplied coordinate
         * @returns true if setZ is available
         * @see [org.locationtech.jts.geom.Coordinates.hasZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinates.html#hasZ-org.locationtech.jts.geom.Coordinate-)
         */
        hasZ(coordinate: Coordinate): boolean;
        /**
         * Determine number of measures based on subclass of `Coordinate`.
         *
         * @param coordinate - supplied coordinate
         * @returns number of measures recorded
         * @see [org.locationtech.jts.geom.Coordinates.measures](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Coordinates.html#measures-org.locationtech.jts.geom.Coordinate-)
         */
        measures(coordinate: Coordinate): number;
      };
      Dimension: {
        /**
         * Dimension value of a surface (2).
         *
         * @see [org.locationtech.jts.geom.Dimension.A](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#A)
         */
        A: number;
        /**
         * Dimension value for any dimension (= {FALSE, TRUE}).
         *
         * @see [org.locationtech.jts.geom.Dimension.DONTCARE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#DONTCARE)
         */
        DONTCARE: number;
        /**
         * Dimension value of the empty geometry (-1).
         *
         * @see [org.locationtech.jts.geom.Dimension.FALSE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#FALSE)
         */
        FALSE: number;
        /**
         * Dimension value of a curve (1).
         *
         * @see [org.locationtech.jts.geom.Dimension.L](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#L)
         */
        L: number;
        /**
         * Dimension value of a point (0).
         *
         * @see [org.locationtech.jts.geom.Dimension.P](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#P)
         */
        P: number;
        /**
         * Symbol for the A (dimension 2) pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_A](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_A)
         */
        SYM_A: string;
        /**
         * Symbol for the DONTCARE pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_DONTCARE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_DONTCARE)
         */
        SYM_DONTCARE: string;
        /**
         * Symbol for the FALSE pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_FALSE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_FALSE)
         */
        SYM_FALSE: string;
        /**
         * Symbol for the L (dimension 1) pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_L](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_L)
         */
        SYM_L: string;
        /**
         * Symbol for the P (dimension 0) pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_P](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_P)
         */
        SYM_P: string;
        /**
         * Symbol for the TRUE pattern matrix entry
         *
         * @see [org.locationtech.jts.geom.Dimension.SYM_TRUE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#SYM_TRUE)
         */
        SYM_TRUE: string;
        /**
         * Dimension value of non-empty geometries (= {P, L, A}).
         *
         * @see [org.locationtech.jts.geom.Dimension.TRUE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#TRUE)
         */
        TRUE: number;
        /**
         * Converts the dimension value to a dimension symbol, for example, `TRUE => 'T'`
         * .
         *
         * @param dimensionValue - a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
         * @returns a character for use in the string representation of an `IntersectionMatrix`. Possible values are `{T, F, * , 0, 1, 2}` .
         * @see [org.locationtech.jts.geom.Dimension.toDimensionSymbol](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#toDimensionSymbol-int-)
         */
        toDimensionSymbol(dimensionValue: number): any /* char */;
        /**
         * Converts the dimension symbol to a dimension value, for example, `'*' => DONTCARE`
         * .
         *
         * @param dimensionSymbol - a character for use in the string representation of an `IntersectionMatrix`. Possible values are `{T, F, * , 0, 1, 2}` .
         * @returns a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
         * @see [org.locationtech.jts.geom.Dimension.toDimensionValue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Dimension.html#toDimensionValue-char-)
         */
        toDimensionValue(dimensionSymbol: any /* char */): number;
      };
      Envelope: {
        /**
         * Computes the coordinate of the centre of this envelope (as long as it is non-null
         *
         * @returns the centre coordinate of this envelope `null` if the envelope is null
         * @see [org.locationtech.jts.geom.Envelope.centre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#centre--)
         */
        centre(envelope: Envelope): Coordinate;
        /**
         * Tests if the `Envelope other`
         * lies wholely inside this `Envelope` (inclusive of the boundary).
         *
         * Note that this is **not** the same definition as the SFS `contains`,
         * which would exclude the envelope boundary.
         *
         * @param other - the `Envelope` to check
         * @returns true if `other` is contained in this `Envelope`
         * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-org.locationtech.jts.geom.Envelope-)
         */
        contains(envelope: Envelope, other: Envelope): boolean;
        /**
         * Tests if the given point lies in or on the envelope.
         *
         * Note that this is **not** the same definition as the SFS `contains`,
         * which would exclude the envelope boundary.
         *
         * @param p - the point which this `Envelope` is being checked for containing
         * @returns `true` if the point lies in the interior or on the boundary of this `Envelope`.
         * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-org.locationtech.jts.geom.Coordinate-)
         */
        containsCoord(envelope: Envelope, p: Coordinate): boolean;
        /**
         * Tests if an envelope is properly contained in this one.
         * The envelope is properly contained if it is contained
         * by this one but not equal to it.
         *
         * @param other - the envelope to test
         * @returns true if the envelope is properly contained
         * @see [org.locationtech.jts.geom.Envelope.containsProperly](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#containsProperly-org.locationtech.jts.geom.Envelope-)
         */
        containsProperly(envelope: Envelope, other: Envelope): boolean;
        /**
         * Tests if the given point lies in or on the envelope.
         *
         * Note that this is **not** the same definition as the SFS `contains`,
         * which would exclude the envelope boundary.
         *
         * @param x - the x-coordinate of the point which this `Envelope` is being checked for containing
         * @param y - the y-coordinate of the point which this `Envelope` is being checked for containing
         * @returns `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.
         * @see [org.locationtech.jts.geom.Envelope.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#contains-double-double-)
         */
        containsXY(envelope: Envelope, x: number, y: number): boolean;
        /**
         * Creates a copy of this envelope object.
         *
         * @returns a copy of this envelope
         * @see [org.locationtech.jts.geom.Envelope.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#copy--)
         */
        copy(envelope: Envelope): Envelope;
        /**
         * Tests if the `Envelope other`
         * lies wholely inside this `Envelope` (inclusive of the boundary).
         *
         * @param other - the `Envelope` to check
         * @returns true if this `Envelope` covers the `other`
         * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-org.locationtech.jts.geom.Envelope-)
         */
        covers(envelope: Envelope, other: Envelope): boolean;
        /**
         * Tests if the given point lies in or on the envelope.
         *
         * @param p - the point which this `Envelope` is being checked for containing
         * @returns `true` if the point lies in the interior or on the boundary of this `Envelope`.
         * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-org.locationtech.jts.geom.Coordinate-)
         */
        coversCoord(envelope: Envelope, p: Coordinate): boolean;
        /**
         * Tests if the given point lies in or on the envelope.
         *
         * @param x - the x-coordinate of the point which this `Envelope` is being checked for containing
         * @param y - the y-coordinate of the point which this `Envelope` is being checked for containing
         * @returns `true` if `(x, y)` lies in the interior or on the boundary of this `Envelope`.
         * @see [org.locationtech.jts.geom.Envelope.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#covers-double-double-)
         */
        coversXY(envelope: Envelope, x: number, y: number): boolean;
        /**
         * Creates a null `Envelope`.
         *
         * @see [org.locationtech.jts.geom.Envelope.Envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#Envelope--)
         */
        create0(): Envelope;
        /**
         * Creates an `Envelope` for a region defined by two Coordinates.
         *
         * @param p1 - the first Coordinate
         * @param p2 - the second Coordinate
         * @see [org.locationtech.jts.geom.Envelope.Envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#Envelope-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create2(p1: Coordinate, p2: Coordinate): Envelope;
        /**
         * Creates an `Envelope` for a region defined by maximum and minimum values.
         *
         * @param x1 - the first x-value
         * @param x2 - the second x-value
         * @param y1 - the first y-value
         * @param y2 - the second y-value
         * @see [org.locationtech.jts.geom.Envelope.Envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#Envelope-double-double-double-double-)
         */
        create4(x1: number, x2: number, y1: number, y2: number): Envelope;
        /**
         * Tests if the region defined by `other`
         * is disjoint from the region of this `Envelope`.
         *
         * A null envelope is always disjoint.
         *
         * @param other - the `Envelope` being checked for disjointness
         * @returns `true` if the `Envelope`s are disjoint
         * @see [org.locationtech.jts.geom.Envelope.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#disjoint-org.locationtech.jts.geom.Envelope-)
         */
        disjoint(envelope: Envelope, other: Envelope): boolean;
        /**
         * Computes the distance between this and another
         * `Envelope`.
         * The distance between overlapping Envelopes is 0.  Otherwise, the
         * distance is the Euclidean distance between the closest points.
         *
         * @see [org.locationtech.jts.geom.Envelope.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#distance-org.locationtech.jts.geom.Envelope-)
         */
        distance(envelope: Envelope, env: Envelope): number;
        /**
         * Expands this envelope by a given distance in all directions.
         * Both positive and negative distances are supported.
         *
         * @param deltaX - the distance to expand the envelope along the the X axis
         * @param deltaY - the distance to expand the envelope along the the Y axis
         * @see [org.locationtech.jts.geom.Envelope.expandBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandBy-double-double-)
         */
        expandBy(envelope: Envelope, deltaX: number, deltaY: number): any /* void */;
        /**
         * Expands this envelope by a given distance in all directions.
         * Both positive and negative distances are supported.
         *
         * @param distance - the distance to expand the envelope
         * @see [org.locationtech.jts.geom.Envelope.expandBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandBy-double-)
         */
        expandByUniform(envelope: Envelope, distance: number): any /* void */;
        /**
         * Enlarges this `Envelope` so that it contains
         * the given `Coordinate`.
         * Has no effect if the point is already on or within the envelope.
         *
         * @param p - the Coordinate to expand to include
         * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-org.locationtech.jts.geom.Coordinate-)
         */
        expandToInclude(envelope: Envelope, p: Coordinate): any /* void */;
        /**
         * Enlarges this `Envelope` so that it contains
         * the `other` Envelope.
         * Has no effect if `other` is wholly on or
         * within the envelope.
         *
         * @param other - the `Envelope` to expand to include
         * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-org.locationtech.jts.geom.Envelope-)
         */
        expandToIncludeEnvelope(envelope: Envelope, other: Envelope): any /* void */;
        /**
         * Enlarges this `Envelope` so that it contains
         * the given point.
         * Has no effect if the point is already on or within the envelope.
         *
         * @param x - the value to lower the minimum x to or to raise the maximum x to
         * @param y - the value to lower the minimum y to or to raise the maximum y to
         * @see [org.locationtech.jts.geom.Envelope.expandToInclude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#expandToInclude-double-double-)
         */
        expandToIncludeXY(envelope: Envelope, x: number, y: number): any /* void */;
        /**
         * Creates an `Envelope` for a region defined by a single Coordinate.
         *
         * @param p - the Coordinate
         * @see [org.locationtech.jts.geom.Envelope.Envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#Envelope-org.locationtech.jts.geom.Coordinate-)
         */
        fromCoord(p: Coordinate): Envelope;
        /**
         * Create an `Envelope` from an existing Envelope.
         *
         * @param env - the Envelope to initialize from
         * @see [org.locationtech.jts.geom.Envelope.Envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#Envelope-org.locationtech.jts.geom.Envelope-)
         */
        fromCopy(env: Envelope): Envelope;
        /**
         * Gets the area of this envelope.
         *
         * @returns the area of the envelope
         * @see [org.locationtech.jts.geom.Envelope.getArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getArea--)
         */
        getArea(envelope: Envelope): number;
        /**
         * Gets the length of the diameter (diagonal) of the envelope.
         *
         * @returns the diameter length
         * @see [org.locationtech.jts.geom.Envelope.getDiameter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getDiameter--)
         */
        getDiameter(envelope: Envelope): number;
        /**
         * Returns the difference between the maximum and minimum y values.
         *
         * @returns max y - min y, or 0 if this is a null `Envelope`
         * @see [org.locationtech.jts.geom.Envelope.getHeight](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getHeight--)
         */
        getHeight(envelope: Envelope): number;
        /**
         * Returns the `Envelope`s maximum x-value. min x > max x
         * indicates that this is a null `Envelope`.
         *
         * @returns the maximum x-coordinate
         * @see [org.locationtech.jts.geom.Envelope.getMaxX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMaxX--)
         */
        getMaxX(envelope: Envelope): number;
        /**
         * Returns the `Envelope`s maximum y-value. min y > max y
         * indicates that this is a null `Envelope`.
         *
         * @returns the maximum y-coordinate
         * @see [org.locationtech.jts.geom.Envelope.getMaxY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMaxY--)
         */
        getMaxY(envelope: Envelope): number;
        /**
         * Returns the `Envelope`s minimum x-value. min x > max x
         * indicates that this is a null `Envelope`.
         *
         * @returns the minimum x-coordinate
         * @see [org.locationtech.jts.geom.Envelope.getMinX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMinX--)
         */
        getMinX(envelope: Envelope): number;
        /**
         * Returns the `Envelope`s minimum y-value. min y > max y
         * indicates that this is a null `Envelope`.
         *
         * @returns the minimum y-coordinate
         * @see [org.locationtech.jts.geom.Envelope.getMinY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getMinY--)
         */
        getMinY(envelope: Envelope): number;
        /**
         * Returns the difference between the maximum and minimum x values.
         *
         * @returns max x - min x, or 0 if this is a null `Envelope`
         * @see [org.locationtech.jts.geom.Envelope.getWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#getWidth--)
         */
        getWidth(envelope: Envelope): number;
        /**
         * Initialize to a null `Envelope`.
         *
         * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init--)
         */
        init(envelope: Envelope): any /* void */;
        /**
         * Initialize an `Envelope` to a region defined by a single Coordinate.
         *
         * @param p - the coordinate
         * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init-org.locationtech.jts.geom.Coordinate-)
         */
        initCoord(envelope: Envelope, p: Coordinate): any /* void */;
        /**
         * Initialize an `Envelope` from an existing Envelope.
         *
         * @param env - the Envelope to initialize from
         * @see [org.locationtech.jts.geom.Envelope.init](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#init-org.locationtech.jts.geom.Envelope-)
         */
        initEnvelope(envelope: Envelope, env: Envelope): any /* void */;
        /**
         * Computes the intersection of two `Envelope`s.
         *
         * @param env - the envelope to intersect with
         * @returns a new Envelope representing the intersection of the envelopes (this will be the null envelope if either argument is null, or they do not intersect
         * @see [org.locationtech.jts.geom.Envelope.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersection-org.locationtech.jts.geom.Envelope-)
         */
        intersection(envelope: Envelope, env: Envelope): Envelope;
        /**
         * Tests if the region defined by `other`
         * intersects the region of this `Envelope`.
         *
         * A null envelope never intersects.
         *
         * @param other - the `Envelope` which this `Envelope` is being checked for intersecting
         * @returns `true` if the `Envelope`s intersect
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Envelope-)
         */
        intersects(envelope: Envelope, other: Envelope): boolean;
        /**
         * Tests if the point `p`
         * intersects (lies inside) the region of this `Envelope`.
         *
         * @param p - the `Coordinate` to be tested
         * @returns `true` if the point intersects this `Envelope`
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-)
         */
        intersectsCoord(envelope: Envelope, p: Coordinate): boolean;
        /**
         * Tests whether the envelope defined by p1-p2
         * and the envelope defined by q1-q2
         * intersect.
         *
         * @param p1 - one extremal point of the envelope P
         * @param p2 - another extremal point of the envelope P
         * @param q1 - one extremal point of the envelope Q
         * @param q2 - another extremal point of the envelope Q
         * @returns `true` if Q intersects P
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersectsQuad(p1: Coordinate, p2: Coordinate, q1: Coordinate, q2: Coordinate): boolean;
        /**
         * Tests if the extent defined by two extremal points
         * intersects the extent of this `Envelope`.
         *
         * @param a - a point
         * @param b - another point
         * @returns `true` if the extents intersect
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersectsSegment(envelope: Envelope, a: Coordinate, b: Coordinate): boolean;
        /**
         * Test the point q to see whether it intersects the Envelope defined by p1-p2
         *
         * @param p1 - one extremal point of the envelope
         * @param p2 - another extremal point of the envelope
         * @param q - the point to test for intersection
         * @returns `true` if q intersects the envelope p1-p2
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersectsTriangle(p1: Coordinate, p2: Coordinate, q: Coordinate): boolean;
        /**
         * Check if the point `(x, y)`
         * intersects (lies inside) the region of this `Envelope`.
         *
         * @param x - the x-ordinate of the point
         * @param y - the y-ordinate of the point
         * @returns `true` if the point overlaps this `Envelope`
         * @see [org.locationtech.jts.geom.Envelope.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#intersects-double-double-)
         */
        intersectsXY(envelope: Envelope, x: number, y: number): boolean;
        /**
         * Returns `true` if this `Envelope` is a "null"
         * envelope.
         *
         * @returns `true` if this `Envelope` is uninitialized or is the envelope of the empty geometry.
         * @see [org.locationtech.jts.geom.Envelope.isNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#isNull--)
         */
        isNull(envelope: Envelope): boolean;
        /**
         * Gets the maximum extent of this envelope across both dimensions.
         *
         * @returns the maximum extent of this envelope
         * @see [org.locationtech.jts.geom.Envelope.maxExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#maxExtent--)
         */
        maxExtent(envelope: Envelope): number;
        /**
         * Gets the minimum extent of this envelope across both dimensions.
         *
         * @returns the minimum extent of this envelope
         * @see [org.locationtech.jts.geom.Envelope.minExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#minExtent--)
         */
        minExtent(envelope: Envelope): number;
        overlaps(envelope: Envelope, other: Envelope): boolean;
        overlapsCoord(envelope: Envelope, p: Coordinate): boolean;
        overlapsXY(envelope: Envelope, x: number, y: number): boolean;
        /**
         * Makes this `Envelope` a "null" envelope, that is, the envelope
         * of the empty geometry.
         *
         * @see [org.locationtech.jts.geom.Envelope.setToNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#setToNull--)
         */
        setToNull(envelope: Envelope): any /* void */;
        /**
         * Translates this envelope by given amounts in the X and Y direction.
         *
         * @param transX - the amount to translate along the X axis
         * @param transY - the amount to translate along the Y axis
         * @see [org.locationtech.jts.geom.Envelope.translate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Envelope.html#translate-double-double-)
         */
        translate(envelope: Envelope, transX: number, transY: number): any /* void */;
      };
      GeometryCollectionIterator: {
        /**
         * Constructs an iterator over the given `Geometry`.
         *
         * @param parent - the geometry over which to iterate; also, the first element returned by the iterator.
         * @see [org.locationtech.jts.geom.GeometryCollectionIterator.GeometryCollectionIterator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryCollectionIterator.html#GeometryCollectionIterator-org.locationtech.jts.geom.Geometry-)
         */
        create1(parent: Geometry): any /* org.locationtech.jts.geom.GeometryCollectionIterator */;
        /**
         * Tests whether any geometry elements remain to be returned.
         *
         * @returns true if more geometry elements remain
         * @see [org.locationtech.jts.geom.GeometryCollectionIterator.hasNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryCollectionIterator.html#hasNext--)
         */
        hasNext(geometryCollectionIterator: any /* org.locationtech.jts.geom.GeometryCollectionIterator */): boolean;
        /**
         * Removal is not supported.
         *
         * @throws UnsupportedOperationException This method is not implemented.
         * @see [org.locationtech.jts.geom.GeometryCollectionIterator.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryCollectionIterator.html#remove--)
         */
        remove(geometryCollectionIterator: any /* org.locationtech.jts.geom.GeometryCollectionIterator */): any /* void */;
      };
      GeometryFactory: {
        /**
         * Build an appropriate `Geometry`, `MultiGeometry`, or
         * `GeometryCollection` to contain the `Geometry`s in
         * it.
         * For example:
         *
         * - If `geomList` contains a single `Polygon`,
         * the `Polygon` is returned.
         * - If `geomList` contains several `Polygon`s, a
         * `MultiPolygon` is returned.
         * - If `geomList` contains some `Polygon`s and
         * some `LineString`s, a `GeometryCollection` is
         * returned.
         * - If `geomList` is empty, an empty `GeometryCollection`
         * is returned
         *
         * Note that this method does not "flatten" Geometries in the input, and hence if
         * any MultiGeometries are contained in the input a GeometryCollection containing
         * them will be returned.
         *
         * @param geomList - the `Geometry`s to combine
         * @returns a `Geometry` of the "smallest", "most type-specific" class that can contain the elements of `geomList` .
         * @see [org.locationtech.jts.geom.GeometryFactory.buildGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#buildGeometry-java.util.Collection-)
         */
        buildGeometry(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, geomList: any /* java.util.Collection */): Geometry;
        /**
         * Constructs a GeometryFactory that generates Geometries having a floating
         * PrecisionModel and a spatial-reference ID of 0.
         *
         * @see [org.locationtech.jts.geom.GeometryFactory.GeometryFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#GeometryFactory--)
         */
        create0(): any /* org.locationtech.jts.geom.GeometryFactory */;
        /**
         * Constructs a GeometryFactory that generates Geometries having the given
         * `PrecisionModel` and the default CoordinateSequence
         * implementation.
         *
         * @param precisionModel - the PrecisionModel to use
         * @see [org.locationtech.jts.geom.GeometryFactory.GeometryFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#GeometryFactory-org.locationtech.jts.geom.PrecisionModel-)
         */
        create1(precisionModel: PrecisionModel): any /* org.locationtech.jts.geom.GeometryFactory */;
        /**
         * Constructs a GeometryFactory that generates Geometries having the given
         * `PrecisionModel` and spatial-reference ID, and the default CoordinateSequence
         * implementation.
         *
         * @param precisionModel - the PrecisionModel to use
         * @param SRID - the SRID to use
         * @see [org.locationtech.jts.geom.GeometryFactory.GeometryFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#GeometryFactory-org.locationtech.jts.geom.PrecisionModel-int-)
         */
        create2(precisionModel: PrecisionModel, SRID: number): any /* org.locationtech.jts.geom.GeometryFactory */;
        /**
         * Creates an empty atomic geometry of the given dimension.
         * If passed a dimension of -1 will create an empty `GeometryCollection`.
         *
         * @param dimension - the required dimension (-1, 0, 1 or 2)
         * @returns an empty atomic geometry of given dimension
         * @see [org.locationtech.jts.geom.GeometryFactory.createEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createEmpty-int-)
         */
        createEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, dimension: number): Geometry;
        /**
         * Creates a GeometryCollection using the given Geometries; a null or empty
         * array will create an empty GeometryCollection.
         *
         * @param geometries - an array of Geometries, each of which may be empty but not null, or null
         * @returns the created GeometryCollection
         * @see [org.locationtech.jts.geom.GeometryFactory.createGeometryCollection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createGeometryCollection-org.locationtech.jts.geom.Geometry:A-)
         */
        createGeometryCollection(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, geometries: Geometry[]): Geometry;
        /**
         * Constructs an empty `GeometryCollection` geometry.
         *
         * @returns an empty GeometryCollection
         * @see [org.locationtech.jts.geom.GeometryFactory.createGeometryCollection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createGeometryCollection--)
         */
        createGeometryCollectionEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a LineString using the given Coordinates.
         * A null or empty array creates an empty LineString.
         *
         * @param coordinates - an array without null elements, or an empty array, or null
         * @see [org.locationtech.jts.geom.GeometryFactory.createLineString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createLineString-org.locationtech.jts.geom.Coordinate:A-)
         */
        createLineString(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, coordinates: Coordinate[]): Geometry;
        /**
         * Constructs an empty `LineString` geometry.
         *
         * @returns an empty LineString
         * @see [org.locationtech.jts.geom.GeometryFactory.createLineString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createLineString--)
         */
        createLineStringEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a `LinearRing` using the given `Coordinate`s.
         * A null or empty array creates an empty LinearRing.
         * The points must form a closed and simple linestring.
         *
         * @param coordinates - an array without null elements, or an empty array, or null
         * @returns the created LinearRing
         * @throws IllegalArgumentException if the ring is not closed, or has too few points
         * @see [org.locationtech.jts.geom.GeometryFactory.createLinearRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createLinearRing-org.locationtech.jts.geom.Coordinate:A-)
         */
        createLinearRing(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, coordinates: Coordinate[]): Geometry;
        /**
         * Constructs an empty `LinearRing` geometry.
         *
         * @returns an empty LinearRing
         * @see [org.locationtech.jts.geom.GeometryFactory.createLinearRing](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createLinearRing--)
         */
        createLinearRingEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a MultiLineString using the given LineStrings; a null or empty
         * array will create an empty MultiLineString.
         *
         * @param lineStrings - LineStrings, each of which may be empty but not null
         * @returns the created MultiLineString
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiLineString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiLineString-org.locationtech.jts.geom.LineString:A-)
         */
        createMultiLineString(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, lineStrings: Geometry[]): Geometry;
        /**
         * Constructs an empty `MultiLineString` geometry.
         *
         * @returns an empty MultiLineString
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiLineString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiLineString--)
         */
        createMultiLineStringEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a `MultiPoint` using the given `Point`s.
         * A null or empty array will create an empty MultiPoint.
         *
         * @param point - an array of Points (without null elements), or an empty array, or `null`
         * @returns a MultiPoint object
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPoint-org.locationtech.jts.geom.Point:A-)
         */
        createMultiPoint(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, point: Geometry[]): Geometry;
        /**
         * Creates a `MultiPoint` using the given `Coordinate`s.
         * A null or empty array will create an empty MultiPoint.
         *
         * @param coordinates - an array (without null elements), or an empty array, or `null`
         * @returns a MultiPoint object
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPoint-org.locationtech.jts.geom.Coordinate:A-)
         */
        createMultiPointDeprecated(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, coordinates: Coordinate[]): Geometry;
        /**
         * Constructs an empty `MultiPoint` geometry.
         *
         * @returns an empty MultiPoint
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPoint--)
         */
        createMultiPointEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a `MultiPoint` using the given `Coordinate`s.
         * A null or empty array will create an empty MultiPoint.
         *
         * @param coordinates - an array (without null elements), or an empty array, or `null`
         * @returns a MultiPoint object
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPointFromCoords](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPointFromCoords-org.locationtech.jts.geom.Coordinate:A-)
         */
        createMultiPointFromCoords(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, coordinates: Coordinate[]): Geometry;
        /**
         * Creates a MultiPolygon using the given Polygons; a null or empty array
         * will create an empty Polygon. The polygons must conform to the
         * assertions specified in the [OpenGIS Simple Features
         * Specification for SQL](http://www.opengis.org/techno/specs.htm).
         *
         * @param polygons - Polygons, each of which may be empty but not null
         * @returns the created MultiPolygon
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPolygon-org.locationtech.jts.geom.Polygon:A-)
         */
        createMultiPolygon(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, polygons: Geometry[]): Geometry;
        /**
         * Constructs an empty `MultiPolygon` geometry.
         *
         * @returns an empty MultiPolygon
         * @see [org.locationtech.jts.geom.GeometryFactory.createMultiPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createMultiPolygon--)
         */
        createMultiPolygonEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Creates a Point using the given Coordinate.
         * A null Coordinate creates an empty Geometry.
         *
         * @param coordinate - a Coordinate, or null
         * @returns the created Point
         * @see [org.locationtech.jts.geom.GeometryFactory.createPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPoint-org.locationtech.jts.geom.Coordinate-)
         */
        createPoint(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, coordinate: Coordinate): Geometry;
        /**
         * Constructs an empty `Point` geometry.
         *
         * @returns an empty Point
         * @see [org.locationtech.jts.geom.GeometryFactory.createPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPoint--)
         */
        createPointEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Constructs a `Polygon` with the given exterior boundary.
         *
         * @param shell - the outer boundary of the new `Polygon`, or `null` or an empty `LinearRing` if the empty geometry is to be created.
         * @throws IllegalArgumentException if the boundary ring is invalid
         * @see [org.locationtech.jts.geom.GeometryFactory.createPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPolygon-org.locationtech.jts.geom.Coordinate:A-)
         */
        createPolygon(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, shell: Coordinate[]): Geometry;
        /**
         * Constructs an empty `Polygon` geometry.
         *
         * @returns an empty polygon
         * @see [org.locationtech.jts.geom.GeometryFactory.createPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPolygon--)
         */
        createPolygonEmpty(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Constructs a `Polygon` with the given exterior boundary.
         *
         * @param shell - the outer boundary of the new `Polygon`, or `null` or an empty `LinearRing` if the empty geometry is to be created.
         * @throws IllegalArgumentException if the boundary ring is invalid
         * @see [org.locationtech.jts.geom.GeometryFactory.createPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPolygon-org.locationtech.jts.geom.LinearRing-)
         */
        createPolygonFromShell(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, shell: Geometry): Geometry;
        /**
         * Constructs a `Polygon` with the given exterior boundary and
         * interior boundaries.
         *
         * @param shell - the outer boundary of the new `Polygon`, or `null` or an empty `LinearRing` if the empty geometry is to be created.
         * @param holes - the inner boundaries of the new `Polygon`, or `null` or empty `LinearRing` s if the empty geometry is to be created.
         * @throws IllegalArgumentException if a ring is invalid
         * @see [org.locationtech.jts.geom.GeometryFactory.createPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#createPolygon-org.locationtech.jts.geom.LinearRing-org.locationtech.jts.geom.LinearRing:A-)
         */
        createPolygonWithHoles(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, shell: Geometry, holes: Geometry[]): Geometry;
        /**
         * Returns the PrecisionModel that Geometries created by this factory
         * will be associated with.
         *
         * @returns the PrecisionModel for this factory
         * @see [org.locationtech.jts.geom.GeometryFactory.getPrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#getPrecisionModel--)
         */
        getPrecisionModel(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): PrecisionModel;
        /**
         * Gets the SRID value defined for this factory.
         *
         * @returns the factory SRID value
         * @see [org.locationtech.jts.geom.GeometryFactory.getSRID](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#getSRID--)
         */
        getSRID(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */): number;
        /**
         * Creates a `Geometry` with the same extent as the given envelope.
         * The Geometry returned is guaranteed to be valid.
         * To provide this behaviour, the following cases occur:
         *
         * If the `Envelope` is:
         *
         * - null : returns an empty `Point`
         * - a point : returns a non-empty `Point`
         * - a line : returns a two-point `LineString`
         * - a rectangle : returns a `Polygon` whose points are (minx, miny),
         * (minx, maxy), (maxx, maxy), (maxx, miny), (minx, miny).
         *
         * @param envelope - the `Envelope` to convert
         * @returns an empty `Point` (for null `Envelope`s), a `Point` (when min x = max x and min y = max y) or a `Polygon` (in all other cases)
         * @see [org.locationtech.jts.geom.GeometryFactory.toGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/GeometryFactory.html#toGeometry-org.locationtech.jts.geom.Envelope-)
         */
        toGeometry(geometryFactory: any /* org.locationtech.jts.geom.GeometryFactory */, envelope: Envelope): Geometry;
      };
      IntersectionMatrix: {
        /**
         * Adds one matrix to another.
         * Addition is defined by taking the maximum dimension value of each position
         * in the summand matrices.
         *
         * @param im - the matrix to add
         * @see [org.locationtech.jts.geom.IntersectionMatrix.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#add-org.locationtech.jts.geom.IntersectionMatrix-)
         */
        add(intersectionMatrix: IntersectionMatrix, im: IntersectionMatrix): any /* void */;
        /**
         * Creates an `IntersectionMatrix` with `FALSE`
         * dimension values.
         *
         * @see [org.locationtech.jts.geom.IntersectionMatrix.IntersectionMatrix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#IntersectionMatrix--)
         */
        create0(): IntersectionMatrix;
        /**
         * Creates an `IntersectionMatrix` with the same elements as
         * `other`.
         *
         * @param other - an `IntersectionMatrix` to copy
         * @see [org.locationtech.jts.geom.IntersectionMatrix.IntersectionMatrix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#IntersectionMatrix-org.locationtech.jts.geom.IntersectionMatrix-)
         */
        fromCopy(other: IntersectionMatrix): IntersectionMatrix;
        /**
         * Creates an `IntersectionMatrix` with the given dimension
         * symbols.
         *
         * @param elements - a String of nine dimension symbols in row major order
         * @see [org.locationtech.jts.geom.IntersectionMatrix.IntersectionMatrix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#IntersectionMatrix-java.lang.String-)
         */
        fromString(elements: string): IntersectionMatrix;
        /**
         * Returns the value of one of this matrix
         * entries.
         * The value of the provided index is one of the
         * values from the `Location` class.
         * The value returned is a constant
         * from the `Dimension` class.
         *
         * @param row - the row of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the first `Geometry`
         * @param column - the column of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the second `Geometry`
         * @returns the dimension value at the given matrix position.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.get](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#get-int-int-)
         */
        get(intersectionMatrix: IntersectionMatrix, row: number, column: number): number;
        /**
         * Tests whether this matrix matches [T*****FF*[.
         *
         * @returns `true` if the first `Geometry` contains the second
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isContains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isContains--)
         */
        isContains(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests if this matrix matches
         * `[T*F**F***]`
         * or `[*TF**F***]`
         * or `[**FT*F***]`
         * or `[**F*TF***]`
         *
         * @returns `true` if the first `Geometry` is covered by the second
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isCoveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCoveredBy--)
         */
        isCoveredBy(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests if this matrix matches
         * `[T*****FF*]`
         * or `[*T****FF*]`
         * or `[***T**FF*]`
         * or `[****T*FF*]`
         *
         * @returns `true` if the first `Geometry` covers the second
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isCovers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCovers--)
         */
        isCovers(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests whether this geometry crosses the
         * specified geometry.
         *
         * The `crosses` predicate has the following equivalent definitions:
         *
         * - The geometries have some but not all interior points in common.
         * - The DE-9IM Intersection Matrix for the two geometries matches
         *
         * - `[T*T******]` (for P/L, P/A, and L/A situations)
         * - `[T*****T**]` (for L/P, L/A, and A/L situations)
         * - `[0********]` (for L/L situations)
         *
         * For any other combination of dimensions this predicate returns `false`.
         *
         * The SFS defined this predicate only for P/L, P/A, L/L, and L/A situations.
         * JTS extends the definition to apply to L/P, A/P and A/L situations as well.
         * This makes the relation symmetric.
         *
         * @param dimensionOfGeometryA - the dimension of the first `Geometry`
         * @param dimensionOfGeometryB - the dimension of the second `Geometry`
         * @returns `true` if the two `Geometry`s related by this matrix cross.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isCrosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isCrosses-int-int-)
         */
        isCrosses(intersectionMatrix: IntersectionMatrix, dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
        /**
         * Tests if this matrix matches `[FF*FF****]`.
         *
         * @returns `true` if the two `Geometry`s related by this matrix are disjoint
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isDisjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isDisjoint--)
         */
        isDisjoint(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests whether the argument dimensions are equal and
         * this matrix matches the pattern `[T*F**FFF*]`.
         *
         * **Note:** This pattern differs from the one stated in
         * _Simple feature access - Part 1: Common architecture_.
         * That document states the pattern as `[TFFFTFFFT]`.  This would
         * specify that
         * two identical `POINT`s are not equal, which is not desirable behaviour.
         * The pattern used here has been corrected to compute equality in this situation.
         *
         * @param dimensionOfGeometryA - the dimension of the first `Geometry`
         * @param dimensionOfGeometryB - the dimension of the second `Geometry`
         * @returns `true` if the two `Geometry`s related by this matrix are equal; the `Geometry`s must have the same dimension to be equal
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isEquals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isEquals-int-int-)
         */
        isEquals(intersectionMatrix: IntersectionMatrix, dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
        /**
         * Tests if `isDisjoint` returns false.
         *
         * @returns `true` if the two `Geometry`s related by this matrix intersect
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isIntersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isIntersects--)
         */
        isIntersects(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests if this matrix matches
         *
         * - `[T*T***T**]` (for two points or two surfaces)
         * - `[1*T***T**]` (for two curves)
         *
         * .
         *
         * @param dimensionOfGeometryA - the dimension of the first `Geometry`
         * @param dimensionOfGeometryB - the dimension of the second `Geometry`
         * @returns `true` if the two `Geometry`s related by this matrix overlap. For this function to return `true`, the `Geometry`s must be two points, two curves or two surfaces.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isOverlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isOverlaps-int-int-)
         */
        isOverlaps(intersectionMatrix: IntersectionMatrix, dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
        /**
         * Tests if this matrix matches
         * `[FT*******]`, `[F**T*****]` or `[F***T****]`.
         *
         * @param dimensionOfGeometryA - the dimension of the first `Geometry`
         * @param dimensionOfGeometryB - the dimension of the second `Geometry`
         * @returns `true` if the two `Geometry` s related by this matrix touch; Returns false if both `Geometry`s are points.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isTouches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isTouches-int-int-)
         */
        isTouches(intersectionMatrix: IntersectionMatrix, dimensionOfGeometryA: number, dimensionOfGeometryB: number): boolean;
        /**
         * Tests if the dimension value matches `TRUE`
         * (i.e.  has value 0, 1, 2 or TRUE).
         *
         * @param actualDimensionValue - a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
         * @returns true if the dimension value matches TRUE
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isTrue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isTrue-int-)
         */
        isTrue(actualDimensionValue: number): boolean;
        /**
         * Tests whether this matrix matches `[T*F**F***]`.
         *
         * @returns `true` if the first `Geometry` is within the second
         * @see [org.locationtech.jts.geom.IntersectionMatrix.isWithin](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#isWithin--)
         */
        isWithin(intersectionMatrix: IntersectionMatrix): boolean;
        /**
         * Tests if the dimension value satisfies the dimension symbol.
         *
         * @param actualDimensionValue - a number that can be stored in the `IntersectionMatrix` . Possible values are `{TRUE, FALSE, DONTCARE, 0, 1, 2}`.
         * @param requiredDimensionSymbol - a character used in the string representation of an `IntersectionMatrix`. Possible values are `{T, F, * , 0, 1, 2}`.
         * @returns true if the dimension symbol matches the dimension value
         * @see [org.locationtech.jts.geom.IntersectionMatrix.matches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#matches-int-char-)
         */
        matches(actualDimensionValue: number, requiredDimensionSymbol: any /* char */): boolean;
        /**
         * Tests whether this matrix matches the given matrix pattern.
         *
         * @param pattern - A pattern containing nine dimension symbols with which to compare the entries of this matrix. Possible symbol values are `{T, F, * , 0, 1, 2}`.
         * @returns `true` if this matrix matches the pattern
         * @see [org.locationtech.jts.geom.IntersectionMatrix.matches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#matches-java.lang.String-)
         */
        matchesPattern(intersectionMatrix: IntersectionMatrix, pattern: string): boolean;
        /**
         * Changes the value of one of this `IntersectionMatrix`s
         * elements.
         *
         * @param row - the row of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the first `Geometry`
         * @param column - the column of this `IntersectionMatrix`, indicating the interior, boundary or exterior of the second `Geometry`
         * @param dimensionValue - the new value of the element
         * @see [org.locationtech.jts.geom.IntersectionMatrix.set](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#set-int-int-int-)
         */
        set(intersectionMatrix: IntersectionMatrix, row: number, column: number, dimensionValue: number): any /* void */;
        /**
         * Changes the elements of this `IntersectionMatrix` to `dimensionValue`
         * .
         *
         * @param dimensionValue - the dimension value to which to set this `IntersectionMatrix` s elements. Possible values `{TRUE, FALSE, DONTCARE, 0, 1, 2}` .
         * @see [org.locationtech.jts.geom.IntersectionMatrix.setAll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAll-int-)
         */
        setAll(intersectionMatrix: IntersectionMatrix, dimensionValue: number): any /* void */;
        /**
         * Changes the specified element to `minimumDimensionValue` if the
         * element is less.
         *
         * @param row - the row of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the first `Geometry`
         * @param column - the column of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the second `Geometry`
         * @param minimumDimensionValue - the dimension value with which to compare the element. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}`.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeast](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeast-int-int-int-)
         */
        setAtLeast(intersectionMatrix: IntersectionMatrix, row: number, column: number, minimumDimensionValue: number): any /* void */;
        /**
         * For each element in this `IntersectionMatrix`, changes the
         * element to the corresponding minimum dimension symbol if the element is
         * less.
         *
         * @param minimumDimensionSymbols - nine dimension symbols with which to compare the elements of this `IntersectionMatrix`. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}` .
         * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeast](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeast-java.lang.String-)
         */
        setAtLeastFromString(intersectionMatrix: IntersectionMatrix, minimumDimensionSymbols: string): any /* void */;
        /**
         * If row >= 0 and column >= 0, changes the specified element to `minimumDimensionValue`
         * if the element is less. Does nothing if row <0 or column < 0.
         *
         * @param row - the row of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the first `Geometry`
         * @param column - the column of this `IntersectionMatrix` , indicating the interior, boundary or exterior of the second `Geometry`
         * @param minimumDimensionValue - the dimension value with which to compare the element. The order of dimension values from least to greatest is `{DONTCARE, TRUE, FALSE, 0, 1, 2}`.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.setAtLeastIfValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#setAtLeastIfValid-int-int-int-)
         */
        setAtLeastIfValid(intersectionMatrix: IntersectionMatrix, row: number, column: number, minimumDimensionValue: number): any /* void */;
        /**
         * Changes the elements of this `IntersectionMatrix` to the
         * dimension symbols in `dimensionSymbols`.
         *
         * @param dimensionSymbols - nine dimension symbols to which to set this `IntersectionMatrix` s elements. Possible values are `{T, F, * , 0, 1, 2}`
         * @see [org.locationtech.jts.geom.IntersectionMatrix.set](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#set-java.lang.String-)
         */
        setFromString(intersectionMatrix: IntersectionMatrix, dimensionSymbols: string): any /* void */;
        /**
         * Returns a nine-character `String` representation of this `IntersectionMatrix`
         * .
         *
         * @returns the nine dimension symbols of this `IntersectionMatrix` in row-major order.
         * @see [org.locationtech.jts.geom.IntersectionMatrix.toString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#toString--)
         */
        toString(intersectionMatrix: IntersectionMatrix): string;
        /**
         * Transposes this IntersectionMatrix.
         *
         * @returns this `IntersectionMatrix` as a convenience
         * @see [org.locationtech.jts.geom.IntersectionMatrix.transpose](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/IntersectionMatrix.html#transpose--)
         */
        transpose(intersectionMatrix: IntersectionMatrix): IntersectionMatrix;
      };
      LineSegment: {
        /**
         * Computes the angle that the vector defined by this segment
         * makes with the X-axis.
         * The angle will be in the range [ -PI, PI ] radians.
         *
         * @returns the angle this segment makes with the X-axis (in radians)
         * @see [org.locationtech.jts.geom.LineSegment.angle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#angle--)
         */
        angle(lineSegment: LineSegment): number;
        /**
         * Computes the closest point on this line segment to another point.
         *
         * @param p - the point to find the closest point to
         * @returns a Coordinate which is the closest point on the line segment to the point p
         * @see [org.locationtech.jts.geom.LineSegment.closestPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#closestPoint-org.locationtech.jts.geom.Coordinate-)
         */
        closestPoint(lineSegment: LineSegment, p: Coordinate): Coordinate;
        /**
         * Computes the closest points on two line segments.
         *
         * @param line - the segment to find the closest point to
         * @returns a pair of Coordinates which are the closest points on the line segments
         * @see [org.locationtech.jts.geom.LineSegment.closestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#closestPoints-org.locationtech.jts.geom.LineSegment-)
         */
        closestPoints(lineSegment: LineSegment, line: LineSegment): Coordinate[];
        create0(): LineSegment;
        create1(ls: LineSegment): LineSegment;
        create2(p0: Coordinate, p1: Coordinate): LineSegment;
        create4(x0: number, y0: number, x1: number, y1: number): LineSegment;
        /**
         * Computes the distance between this line segment and a given point.
         *
         * @returns the distance from this segment to the given point
         * @see [org.locationtech.jts.geom.LineSegment.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distance-org.locationtech.jts.geom.Coordinate-)
         */
        distance(lineSegment: LineSegment, p: Coordinate): number;
        /**
         * Computes the perpendicular distance between the (infinite) line defined
         * by this line segment and a point.
         * If the segment has zero length this returns the distance between
         * the segment and the point.
         *
         * @param p - the point to compute the distance to
         * @returns the perpendicular distance between the line and point
         * @see [org.locationtech.jts.geom.LineSegment.distancePerpendicular](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distancePerpendicular-org.locationtech.jts.geom.Coordinate-)
         */
        distancePerpendicular(lineSegment: LineSegment, p: Coordinate): number;
        /**
         * Computes the oriented perpendicular distance between the (infinite) line
         * defined by this line segment and a point.
         * The oriented distance is positive if the point on the left of the line,
         * and negative if it is on the right.
         * If the segment has zero length this returns the distance between
         * the segment and the point.
         *
         * @param p - the point to compute the distance to
         * @returns the oriented perpendicular distance between the line and point
         * @see [org.locationtech.jts.geom.LineSegment.distancePerpendicularOriented](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distancePerpendicularOriented-org.locationtech.jts.geom.Coordinate-)
         */
        distancePerpendicularOriented(lineSegment: LineSegment, p: Coordinate): number;
        /**
         * Computes the distance between this line segment and another segment.
         *
         * @returns the distance to the other segment
         * @see [org.locationtech.jts.geom.LineSegment.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#distance-org.locationtech.jts.geom.LineSegment-)
         */
        distanceSegment(lineSegment: LineSegment, ls: LineSegment): number;
        /**
         * Returns `true` if `other` is
         * topologically equal to this LineSegment (e.g. irrespective
         * of orientation).
         *
         * @param other - a `LineSegment` with which to do the comparison.
         * @returns `true` if `other` is a `LineSegment` with the same values for the x and y ordinates.
         * @see [org.locationtech.jts.geom.LineSegment.equalsTopo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#equalsTopo-org.locationtech.jts.geom.LineSegment-)
         */
        equalsTopo(lineSegment: LineSegment, other: LineSegment): boolean;
        getCoordinate(lineSegment: LineSegment, i: number): Coordinate;
        /**
         * Computes the length of the line segment.
         *
         * @returns the length of the line segment
         * @see [org.locationtech.jts.geom.LineSegment.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#getLength--)
         */
        getLength(lineSegment: LineSegment): number;
        /**
         * Computes an intersection point between two line segments, if there is one.
         * There may be 0, 1 or many intersection points between two segments.
         * If there are 0, null is returned. If there is 1 or more,
         * exactly one of them is returned
         * (chosen at the discretion of the algorithm).
         * If more information is required about the details of the intersection,
         * the `RobustLineIntersector` class should be used.
         *
         * @param line - a line segment
         * @returns an intersection point, or `null` if there is none
         * @see [org.locationtech.jts.geom.LineSegment.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#intersection-org.locationtech.jts.geom.LineSegment-)
         */
        intersection(lineSegment: LineSegment, line: LineSegment): Coordinate;
        /**
         * Tests whether the segment is horizontal.
         *
         * @returns `true` if the segment is horizontal
         * @see [org.locationtech.jts.geom.LineSegment.isHorizontal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#isHorizontal--)
         */
        isHorizontal(lineSegment: LineSegment): boolean;
        /**
         * Tests whether the segment is vertical.
         *
         * @returns `true` if the segment is vertical
         * @see [org.locationtech.jts.geom.LineSegment.isVertical](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#isVertical--)
         */
        isVertical(lineSegment: LineSegment): boolean;
        /**
         * Computes the intersection point of the lines of infinite extent defined
         * by two line segments (if there is one).
         * There may be 0, 1 or an infinite number of intersection points
         * between two lines.
         * If there is a unique intersection point, it is returned.
         * Otherwise, `null` is returned.
         * If more information is required about the details of the intersection,
         * the `RobustLineIntersector` class should be used.
         *
         * @param line - a line segment defining an straight line with infinite extent
         * @returns an intersection point, or `null` if there is no point of intersection or an infinite number of intersection points
         * @see [org.locationtech.jts.geom.LineSegment.lineIntersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#lineIntersection-org.locationtech.jts.geom.LineSegment-)
         */
        lineIntersection(lineSegment: LineSegment, line: LineSegment): Coordinate;
        /**
         * Gets the maximum X ordinate.
         *
         * @returns the maximum X ordinate
         * @see [org.locationtech.jts.geom.LineSegment.maxX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#maxX--)
         */
        maxX(lineSegment: LineSegment): number;
        /**
         * Gets the maximum Y ordinate.
         *
         * @returns the maximum Y ordinate
         * @see [org.locationtech.jts.geom.LineSegment.maxY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#maxY--)
         */
        maxY(lineSegment: LineSegment): number;
        /**
         * Computes the midpoint of the segment
         *
         * @returns the midpoint of the segment
         * @see [org.locationtech.jts.geom.LineSegment.midPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#midPoint--)
         */
        midPoint(lineSegment: LineSegment): Coordinate;
        /**
         * Computes the midpoint of a segment
         *
         * @returns the midpoint of the segment
         * @see [org.locationtech.jts.geom.LineSegment.midPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#midPoint-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        midPointStatic(p0: Coordinate, p1: Coordinate): Coordinate;
        /**
         * Gets the minimum X ordinate.
         *
         * @returns the minimum X ordinate
         * @see [org.locationtech.jts.geom.LineSegment.minX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#minX--)
         */
        minX(lineSegment: LineSegment): number;
        /**
         * Gets the minimum Y ordinate.
         *
         * @returns the minimum Y ordinate
         * @see [org.locationtech.jts.geom.LineSegment.minY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#minY--)
         */
        minY(lineSegment: LineSegment): number;
        /**
         * Computes the `LineSegment` that is offset from
         * the segment by a given distance.
         * The computed segment is offset to the left of the line if the offset distance is
         * positive, to the right if negative.
         *
         * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
         * @returns a line segment offset by the specified distance
         * @throws IllegalStateException if the segment has zero length
         * @see [org.locationtech.jts.geom.LineSegment.offset](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#offset-double-)
         */
        offset(lineSegment: LineSegment, offsetDistance: number): LineSegment;
        /**
         * Determines the orientation index of a `Coordinate` relative to this segment.
         * The orientation index is as defined in `Coordinate, Coordinate)`.
         *
         * @param p - the coordinate to compare
         * @returns 1 (LEFT) if `p` is to the left of this segment
         * @see [org.locationtech.jts.geom.LineSegment.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#orientationIndex-org.locationtech.jts.geom.Coordinate-)
         */
        orientationIndex(lineSegment: LineSegment, p: Coordinate): number;
        /**
         * Determines the orientation of a LineSegment relative to this segment.
         * The concept of orientation is specified as follows:
         * Given two line segments A and L,
         *
         * - A is to the left of a segment L if A lies wholly in the
         * closed half-plane lying to the left of L
         * - A is to the right of a segment L if A lies wholly in the
         * closed half-plane lying to the right of L
         * - otherwise, A has indeterminate orientation relative to L. This
         * happens if A is collinear with L or if A crosses the line determined by L.
         *
         * @param seg - the LineSegment to compare
         * @returns 1 if `seg` is to the left of this segment
         * @see [org.locationtech.jts.geom.LineSegment.orientationIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#orientationIndex-org.locationtech.jts.geom.LineSegment-)
         */
        orientationIndexSegment(lineSegment: LineSegment, seg: LineSegment): number;
        /**
         * Computes the `Coordinate` that lies a given
         * fraction along the line defined by this segment.
         * A fraction of `0.0` returns the start point of the segment;
         * a fraction of `1.0` returns the end point of the segment.
         * If the fraction is < 0.0 or > 1.0 the point returned
         * will lie before the start or beyond the end of the segment.
         *
         * @param segmentLengthFraction - the fraction of the segment length along the line
         * @returns the point at that distance
         * @see [org.locationtech.jts.geom.LineSegment.pointAlong](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#pointAlong-double-)
         */
        pointAlong(lineSegment: LineSegment, segmentLengthFraction: number): Coordinate;
        /**
         * Computes the `Coordinate` that lies a given
         * fraction along the line defined by this segment and offset from
         * the segment by a given distance.
         * A fraction of `0.0` offsets from the start point of the segment;
         * a fraction of `1.0` offsets from the end point of the segment.
         * The computed point is offset to the left of the line if the offset distance is
         * positive, to the right if negative.
         *
         * @param segmentLengthFraction - the fraction of the segment length along the line
         * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
         * @returns the point at that distance and offset
         * @throws IllegalStateException if the segment has zero length
         * @see [org.locationtech.jts.geom.LineSegment.pointAlongOffset](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#pointAlongOffset-double-double-)
         */
        pointAlongOffset(lineSegment: LineSegment, segmentLengthFraction: number, offsetDistance: number): Coordinate;
        /**
         * Compute the projection of a point onto the line determined
         * by this line segment.
         *
         * Note that the projected point
         * may lie outside the line segment.  If this is the case,
         * the projection factor will lie outside the range [0.0, 1.0].
         *
         * @see [org.locationtech.jts.geom.LineSegment.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#project-org.locationtech.jts.geom.Coordinate-)
         */
        project(lineSegment: LineSegment, p: Coordinate): Coordinate;
        /**
         * Project a line segment onto this line segment and return the resulting
         * line segment.  The returned line segment will be a subset of
         * the target line line segment.  This subset may be null, if
         * the segments are oriented in such a way that there is no projection.
         *
         * Note that the returned line may have zero length (i.e. the same endpoints).
         * This can happen for instance if the lines are perpendicular to one another.
         *
         * @param seg - the line segment to project
         * @returns the projected line segment, or `null` if there is no overlap
         * @see [org.locationtech.jts.geom.LineSegment.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#project-org.locationtech.jts.geom.LineSegment-)
         */
        projectSegment(lineSegment: LineSegment, seg: LineSegment): LineSegment;
        /**
         * Computes the Projection Factor for the projection of the point p
         * onto this LineSegment.  The Projection Factor is the constant r
         * by which the vector for this segment must be multiplied to
         * equal the vector for the projection of `p` on the line
         * defined by this segment.
         *
         * The projection factor will lie in the range `(-inf, +inf)`,
         * or be `NaN` if the line segment has zero length..
         *
         * @param p - the point to compute the factor for
         * @returns the projection factor for the point
         * @see [org.locationtech.jts.geom.LineSegment.projectionFactor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#projectionFactor-org.locationtech.jts.geom.Coordinate-)
         */
        projectionFactor(lineSegment: LineSegment, p: Coordinate): number;
        /**
         * Computes the reflection of a point in the line defined
         * by this line segment.
         *
         * @param p - the point to reflect
         * @returns the reflected point
         * @see [org.locationtech.jts.geom.LineSegment.reflect](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#reflect-org.locationtech.jts.geom.Coordinate-)
         */
        reflect(lineSegment: LineSegment, p: Coordinate): Coordinate;
        /**
         * Computes the fraction of distance (in `[0.0, 1.0]`)
         * that the projection of a point occurs along this line segment.
         * If the point is beyond either ends of the line segment,
         * the closest fractional value (`0.0` or `1.0`) is returned.
         *
         * Essentially, this is the `projectionFactor` clamped to
         * the range `[0.0, 1.0]`.
         * If the segment has zero length, 1.0 is returned.
         *
         * @param inputPt - the point
         * @returns the fraction along the line segment the projection of the point occurs
         * @see [org.locationtech.jts.geom.LineSegment.segmentFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineSegment.html#segmentFraction-org.locationtech.jts.geom.Coordinate-)
         */
        segmentFraction(lineSegment: LineSegment, inputPt: Coordinate): number;
      };
      Location: {
        /**
         * The location value for the boundary of a geometry.
         * Also, DE-9IM row index of the boundary of the first geometry and column index of
         * the boundary of the second geometry.
         *
         * @see [org.locationtech.jts.geom.Location.BOUNDARY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Location.html#BOUNDARY)
         */
        BOUNDARY: number;
        /**
         * The location value for the exterior of a geometry.
         * Also, DE-9IM row index of the exterior of the first geometry and column index of
         * the exterior of the second geometry.
         *
         * @see [org.locationtech.jts.geom.Location.EXTERIOR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Location.html#EXTERIOR)
         */
        EXTERIOR: number;
        /**
         * The location value for the interior of a geometry.
         * Also, DE-9IM row index of the interior of the first geometry and column index of
         * the interior of the second geometry.
         *
         * @see [org.locationtech.jts.geom.Location.INTERIOR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Location.html#INTERIOR)
         */
        INTERIOR: number;
        /**
         * Used for uninitialized location values.
         *
         * @see [org.locationtech.jts.geom.Location.NONE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Location.html#NONE)
         */
        NONE: number;
        /**
         * Converts the location value to a location symbol, for example, `EXTERIOR => 'e'`
         * .
         *
         * @param locationValue - either EXTERIOR, BOUNDARY, INTERIOR or NONE
         * @returns either 'e', 'b', 'i' or '-'
         * @see [org.locationtech.jts.geom.Location.toLocationSymbol](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Location.html#toLocationSymbol-int-)
         */
        toLocationSymbol(locationValue: number): any /* char */;
      };
      /**
       * The minimum number of vertices allowed in a valid non-empty ring.
       * Empty rings with 0 vertices are also valid.
       *
       * @see [org.locationtech.jts.geom.LinearRing.MINIMUM_VALID_SIZE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LinearRing.html#MINIMUM_VALID_SIZE)
       */
      MINIMUM_VALID_SIZE: number;
      OctagonalEnvelope: {
        contains(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */, other: any /* org.locationtech.jts.geom.OctagonalEnvelope */): boolean;
        /**
         * Creates a new null bounding octagon
         *
         * @see [org.locationtech.jts.geom.OctagonalEnvelope.OctagonalEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/OctagonalEnvelope.html#OctagonalEnvelope--)
         */
        create0(): any /* org.locationtech.jts.geom.OctagonalEnvelope */;
        /**
         * Creates a new null bounding octagon bounding an `OctagonalEnvelope`
         * (the copy constructor).
         *
         * @see [org.locationtech.jts.geom.OctagonalEnvelope.OctagonalEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/OctagonalEnvelope.html#OctagonalEnvelope-org.locationtech.jts.geom.OctagonalEnvelope-)
         */
        create1(oct: any /* org.locationtech.jts.geom.OctagonalEnvelope */): any /* org.locationtech.jts.geom.OctagonalEnvelope */;
        /**
         * Creates a new null bounding octagon bounding a pair of `Coordinate`s
         *
         * @param p0 - a coordinate to bound
         * @param p1 - a coordinate to bound
         * @see [org.locationtech.jts.geom.OctagonalEnvelope.OctagonalEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/OctagonalEnvelope.html#OctagonalEnvelope-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create2(p0: Coordinate, p1: Coordinate): any /* org.locationtech.jts.geom.OctagonalEnvelope */;
        expandBy(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */, distance: number): any /* void */;
        expandToInclude(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */, x: number, y: number): any /* org.locationtech.jts.geom.OctagonalEnvelope */;
        getMaxA(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMaxB(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMaxX(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMaxY(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMinA(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMinB(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMinX(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        getMinY(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): number;
        intersects(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */, other: any /* org.locationtech.jts.geom.OctagonalEnvelope */): boolean;
        isNull(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): boolean;
        /**
         * Gets the octagonal envelope of a geometry
         *
         * @param geom - the geometry
         * @returns the octagonal envelope of the geometry
         * @see [org.locationtech.jts.geom.OctagonalEnvelope.octagonalEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/OctagonalEnvelope.html#octagonalEnvelope-org.locationtech.jts.geom.Geometry-)
         */
        octagonalEnvelope(geom: Geometry): Geometry;
        /**
         * Sets the value of this object to the null value
         *
         * @see [org.locationtech.jts.geom.OctagonalEnvelope.setToNull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/OctagonalEnvelope.html#setToNull--)
         */
        setToNull(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */): any /* void */;
        toGeometry(octagonalEnvelope: any /* org.locationtech.jts.geom.OctagonalEnvelope */, geomFactory: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
      };
      Position: {
        /**
         * Specifies that a location is to the _left_ of a component
         *
         * @see [org.locationtech.jts.geom.Position.LEFT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Position.html#LEFT)
         */
        LEFT: number;
        /**
         * Specifies that a location is _on_ a component
         *
         * @see [org.locationtech.jts.geom.Position.ON](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Position.html#ON)
         */
        ON: number;
        /**
         * Specifies that a location is to the _right_ of a component
         *
         * @see [org.locationtech.jts.geom.Position.RIGHT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Position.html#RIGHT)
         */
        RIGHT: number;
        /**
         * Returns LEFT if the position is RIGHT, RIGHT if the position is LEFT, or the position
         * otherwise.
         *
         * @see [org.locationtech.jts.geom.Position.opposite](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Position.html#opposite-int-)
         */
        opposite(position: number): number;
      };
      PrecisionModel: {
        /**
         * Creates a `PrecisionModel` with a default precision
         * of FLOATING.
         *
         * @see [org.locationtech.jts.geom.PrecisionModel.PrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#PrecisionModel--)
         */
        create0(): PrecisionModel;
        /**
         * Creates a `PrecisionModel` that specifies Fixed precision.
         * Fixed-precision coordinates are represented as precise internal coordinates,
         * which are rounded to the grid defined by the scale factor.
         *
         * @param scale - amount by which to multiply a coordinate after subtracting the offset, to obtain a precise coordinate
         * @param offsetX - not used.
         * @param offsetY - not used.
         * @see [org.locationtech.jts.geom.PrecisionModel.PrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#PrecisionModel-double-double-double-)
         */
        create3(scale: number, offsetX: number, offsetY: number): PrecisionModel;
        /**
         * Copy constructor to create a new `PrecisionModel`
         * from an existing one.
         *
         * @see [org.locationtech.jts.geom.PrecisionModel.PrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#PrecisionModel-org.locationtech.jts.geom.PrecisionModel-)
         */
        fromCopy(pm: PrecisionModel): PrecisionModel;
        /**
         * Creates a `PrecisionModel` that specifies Fixed precision.
         * Fixed-precision coordinates are represented as precise internal coordinates,
         * which are rounded to the grid defined by the scale factor.
         * The provided scale may be negative, to specify an exact grid size.
         * The scale is then computed as the reciprocal.
         *
         * @param scale - amount by which to multiply a coordinate after subtracting the offset, to obtain a precise coordinate. Must be non-zero.
         * @see [org.locationtech.jts.geom.PrecisionModel.PrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#PrecisionModel-double-)
         */
        fromScale(scale: number): PrecisionModel;
        /**
         * Creates a `PrecisionModel` that specifies
         * an explicit precision model type.
         * If the model type is FIXED the scale factor will default to 1.
         *
         * @param modelType - the type of the precision model
         * @see [org.locationtech.jts.geom.PrecisionModel.PrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#PrecisionModel-org.locationtech.jts.geom.PrecisionModel.Type-)
         */
        fromType(modelType: any /* org.locationtech.jts.geom.PrecisionModel$Type */): PrecisionModel;
        /**
         * Returns the maximum number of significant digits provided by this
         * precision model.
         * Intended for use by routines which need to print out
         * decimal representations of precise values (such as `WKTWriter`).
         *
         * This method would be more correctly called
         * `getMinimumDecimalPlaces`,
         * since it actually computes the number of decimal places
         * that is required to correctly display the full
         * precision of an ordinate value.
         *
         * Since it is difficult to compute the required number of
         * decimal places for scale factors which are not powers of 10,
         * the algorithm uses a very rough approximation in this case.
         * This has the side effect that for scale factors which are
         * powers of 10 the value returned is 1 greater than the true value.
         *
         * @returns the maximum number of decimal places provided by this precision model
         * @see [org.locationtech.jts.geom.PrecisionModel.getMaximumSignificantDigits](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getMaximumSignificantDigits--)
         */
        getMaximumSignificantDigits(precisionModel: PrecisionModel): number;
        /**
         * Returns the x-offset used to obtain a precise coordinate.
         *
         * @returns the amount by which to subtract the x-coordinate before multiplying by the scale
         * @see [org.locationtech.jts.geom.PrecisionModel.getOffsetX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getOffsetX--)
         */
        getOffsetX(precisionModel: PrecisionModel): number;
        /**
         * Returns the y-offset used to obtain a precise coordinate.
         *
         * @returns the amount by which to subtract the y-coordinate before multiplying by the scale
         * @see [org.locationtech.jts.geom.PrecisionModel.getOffsetY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getOffsetY--)
         */
        getOffsetY(precisionModel: PrecisionModel): number;
        /**
         * Returns the scale factor used to specify a fixed precision model.
         * The number of decimal places of precision is
         * equal to the base-10 logarithm of the scale factor.
         * Non-integral and negative scale factors are supported.
         * Negative scale factors indicate that the places
         * of precision is to the left of the decimal point.
         *
         * @returns the scale factor for the fixed precision model
         * @see [org.locationtech.jts.geom.PrecisionModel.getScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getScale--)
         */
        getScale(precisionModel: PrecisionModel): number;
        /**
         * Gets the type of this precision model
         *
         * @returns the type of this precision model
         * @see [org.locationtech.jts.geom.PrecisionModel.getType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#getType--)
         */
        getType(precisionModel: PrecisionModel): any /* org.locationtech.jts.geom.PrecisionModel$Type */;
        /**
         * Computes the grid size for a fixed precision model.
         * This is equal to the reciprocal of the scale factor.
         * If the grid size has been set explicity (via a negative scale factor)
         * it will be returned.
         *
         * @returns the grid size at a fixed precision scale.
         * @see [org.locationtech.jts.geom.PrecisionModel.gridSize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#gridSize--)
         */
        gridSize(precisionModel: PrecisionModel): number;
        /**
         * Tests whether the precision model supports floating point
         *
         * @returns `true` if the precision model supports floating point
         * @see [org.locationtech.jts.geom.PrecisionModel.isFloating](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#isFloating--)
         */
        isFloating(precisionModel: PrecisionModel): boolean;
        /**
         * Rounds a numeric value to the PrecisionModel grid.
         * Asymmetric Arithmetic Rounding is used, to provide
         * uniform rounding behaviour no matter where the number is
         * on the number line.
         *
         * This method has no effect on NaN values.
         *
         * **Note:** Java's `Math#rint` uses the "Banker's Rounding" algorithm,
         * which is not suitable for precision operations elsewhere in JTS.
         *
         * @see [org.locationtech.jts.geom.PrecisionModel.makePrecise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#makePrecise-double-)
         */
        makePrecise(precisionModel: PrecisionModel, val: number): number;
        /**
         * Determines which of two `PrecisionModel`s is the most precise
         * (allows the greatest number of significant digits).
         *
         * @param pm1 - a PrecisionModel
         * @param pm2 - a PrecisionModel
         * @returns the PrecisionModel which is most precise
         * @see [org.locationtech.jts.geom.PrecisionModel.mostPrecise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#mostPrecise-org.locationtech.jts.geom.PrecisionModel-org.locationtech.jts.geom.PrecisionModel-)
         */
        mostPrecise(pm1: PrecisionModel, pm2: PrecisionModel): PrecisionModel;
        /**
         * Returns the external representation of `internal`.
         *
         * @param internal - the original coordinate
         * @returns the coordinate whose values will be changed to the external representation of `internal`
         * @see [org.locationtech.jts.geom.PrecisionModel.toExternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#toExternal-org.locationtech.jts.geom.Coordinate-)
         */
        toExternal(precisionModel: PrecisionModel, internal: Coordinate): Coordinate;
        /**
         * Returns the precise representation of `external`.
         *
         * @param external - the original coordinate
         * @returns the coordinate whose values will be changed to the precise representation of `external`
         * @see [org.locationtech.jts.geom.PrecisionModel.toInternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/PrecisionModel.html#toInternal-org.locationtech.jts.geom.Coordinate-)
         */
        toInternal(precisionModel: PrecisionModel, external: Coordinate): Coordinate;
        toString(precisionModel: PrecisionModel): string;
      };
      Quadrant: {
        NE: number;
        NW: number;
        SE: number;
        SW: number;
        /**
         * Returns the right-hand quadrant of the halfplane defined by the two quadrants,
         * or -1 if the quadrants are opposite, or the quadrant if they are identical.
         *
         * @see [org.locationtech.jts.geom.Quadrant.commonHalfPlane](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Quadrant.html#commonHalfPlane-int-int-)
         */
        commonHalfPlane(quad1: number, quad2: number): number;
        /**
         * Returns whether the given quadrant lies within the given halfplane (specified
         * by its right-hand quadrant).
         *
         * @see [org.locationtech.jts.geom.Quadrant.isInHalfPlane](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Quadrant.html#isInHalfPlane-int-int-)
         */
        isInHalfPlane(quad: number, halfPlane: number): boolean;
        /**
         * Returns true if the given quadrant is 0 or 1.
         *
         * @see [org.locationtech.jts.geom.Quadrant.isNorthern](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Quadrant.html#isNorthern-int-)
         */
        isNorthern(quad: number): boolean;
        /**
         * Returns true if the quadrants are 1 and 3, or 2 and 4
         *
         * @see [org.locationtech.jts.geom.Quadrant.isOpposite](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Quadrant.html#isOpposite-int-int-)
         */
        isOpposite(quad1: number, quad2: number): boolean;
        /**
         * Returns the quadrant of a directed line segment from p0 to p1.
         *
         * @throws IllegalArgumentException if the points are equal
         * @see [org.locationtech.jts.geom.Quadrant.quadrant](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Quadrant.html#quadrant-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        quadrant(p0: Coordinate, p1: Coordinate): number;
      };
      TopologyException: {
        create1(msg: string): any /* org.locationtech.jts.geom.TopologyException */;
        create2(msg: string, pt: Coordinate): any /* org.locationtech.jts.geom.TopologyException */;
        getCoordinate(topologyException: any /* org.locationtech.jts.geom.TopologyException */): Coordinate;
      };
      Triangle: {
        /**
         * Computes the point at which the bisector of the angle ABC cuts the segment
         * AC.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the angle bisector cut point
         * @see [org.locationtech.jts.geom.Triangle.angleBisector](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#angleBisector-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        angleBisector(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
        /**
         * Computes the 2D area of this triangle. The area value is always
         * non-negative.
         *
         * @returns the area of this triangle
         * @see [org.locationtech.jts.geom.Triangle.area](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area--)
         */
        area(triangle: Triangle): number;
        /**
         * Computes the 3D area of this triangle. The value computed is always
         * non-negative.
         *
         * @returns the 3D area of this triangle
         * @see [org.locationtech.jts.geom.Triangle.area3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area3D--)
         */
        area3D(triangle: Triangle): number;
        /**
         * Computes the 3D area of a triangle. The value computed is always
         * non-negative.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the 3D area of the triangle
         * @see [org.locationtech.jts.geom.Triangle.area3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area3D-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        area3DStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
        /**
         * Computes the 2D area of a triangle. The area value is always non-negative.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the area of the triangle
         * @see [org.locationtech.jts.geom.Triangle.area](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#area-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        areaStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
        /**
         * Computes the centroid (centre of mass) of this triangle. This is also the
         * point at which the triangle's three medians intersect (a triangle median is
         * the segment from a vertex of the triangle to the midpoint of the opposite
         * side). The centroid divides each median in a ratio of 2:1.
         *
         * The centroid always lies within the triangle.
         *
         * @returns the centroid of this triangle
         * @see [org.locationtech.jts.geom.Triangle.centroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#centroid--)
         */
        centroid(triangle: Triangle): Coordinate;
        /**
         * Computes the centroid (centre of mass) of a triangle. This is also the
         * point at which the triangle's three medians intersect (a triangle median is
         * the segment from a vertex of the triangle to the midpoint of the opposite
         * side). The centroid divides each median in a ratio of 2:1.
         *
         * The centroid always lies within the triangle.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the centroid of the triangle
         * @see [org.locationtech.jts.geom.Triangle.centroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#centroid-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        centroidStatic(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
        /**
         * Computes the circumcentre of this triangle. The circumcentre is the centre
         * of the circumcircle, the smallest circle which passes through all the triangle vertices.
         * It is also the common intersection point of the perpendicular bisectors of the
         * sides of the triangle, and is the only point which has equal distance to
         * all three vertices of the triangle.
         *
         * The circumcentre does not necessarily lie within the triangle.
         *
         * This method uses an algorithm due to J.R.Shewchuk which uses normalization
         * to the origin to improve the accuracy of computation. (See _Lecture Notes
         * on Geometric Robustness_, Jonathan Richard Shewchuk, 1999).
         *
         * @returns the circumcentre of this triangle
         * @see [org.locationtech.jts.geom.Triangle.circumcentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentre--)
         */
        circumcentre(triangle: Triangle): Coordinate;
        /**
         * Computes the circumcentre of a triangle. The circumcentre is the centre of
         * the circumcircle, the smallest circle which encloses the triangle. It is
         * also the common intersection point of the perpendicular bisectors of the
         * sides of the triangle, and is the only point which has equal distance to
         * all three vertices of the triangle.
         *
         * The circumcentre does not necessarily lie within the triangle. For example,
         * the circumcentre of an obtuse isosceles triangle lies outside the triangle.
         *
         * This method uses `DD` extended-precision arithmetic to
         * provide more accurate results than `Coordinate, Coordinate)`
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the circumcentre of the triangle
         * @see [org.locationtech.jts.geom.Triangle.circumcentreDD](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentreDD-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        circumcentreDD(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
        /**
         * Computes the circumcentre of a triangle. The circumcentre is the centre of
         * the circumcircle, the smallest circle which encloses the triangle. It is
         * also the common intersection point of the perpendicular bisectors of the
         * sides of the triangle, and is the only point which has equal distance to
         * all three vertices of the triangle.
         *
         * The circumcentre does not necessarily lie within the triangle. For example,
         * the circumcentre of an obtuse isosceles triangle lies outside the triangle.
         *
         * This method uses an algorithm due to J.R.Shewchuk which uses normalization
         * to the origin to improve the accuracy of computation. (See _Lecture Notes
         * on Geometric Robustness_, Jonathan Richard Shewchuk, 1999).
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the circumcentre of the triangle
         * @see [org.locationtech.jts.geom.Triangle.circumcentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumcentre-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        circumcentreStatic(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
        /**
         * Computes the radius of the circumcircle of a triangle.
         *
         * @returns the triangle circumradius
         * @see [org.locationtech.jts.geom.Triangle.circumradius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumradius--)
         */
        circumradius(triangle: Triangle): number;
        /**
         * Computes the radius of the circumcircle of a triangle.
         *
         * Formula is as per https://math.stackexchange.com/a/3610959
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the circumradius of the triangle
         * @see [org.locationtech.jts.geom.Triangle.circumradius](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#circumradius-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        circumradiusStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
        /**
         * Creates a new triangle with the given vertices.
         *
         * @param p0 - a vertex
         * @param p1 - a vertex
         * @param p2 - a vertex
         * @see [org.locationtech.jts.geom.Triangle.Triangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#Triangle-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create3(p0: Coordinate, p1: Coordinate, p2: Coordinate): Triangle;
        /**
         * Computes the incentre of this triangle. The _incentre_ of a triangle
         * is the point which is equidistant from the sides of the triangle. It is
         * also the point at which the bisectors of the triangle's angles meet. It is
         * the centre of the triangle's _incircle_, which is the unique circle
         * that is tangent to each of the triangle's three sides.
         *
         * @returns the point which is the inCentre of this triangle
         * @see [org.locationtech.jts.geom.Triangle.inCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#inCentre--)
         */
        inCentre(triangle: Triangle): Coordinate;
        /**
         * Computes the incentre of a triangle. The _inCentre_ of a triangle is
         * the point which is equidistant from the sides of the triangle. It is also
         * the point at which the bisectors of the triangle's angles meet. It is the
         * centre of the triangle's _incircle_, which is the unique circle that
         * is tangent to each of the triangle's three sides.
         *
         * The incentre always lies within the triangle.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the point which is the incentre of the triangle
         * @see [org.locationtech.jts.geom.Triangle.inCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#inCentre-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        inCentreStatic(a: Coordinate, b: Coordinate, c: Coordinate): Coordinate;
        /**
         * Computes the Z-value (elevation) of an XY point on a three-dimensional
         * plane defined by this triangle (whose vertices must have Z-values). This
         * triangle must not be degenerate (in other words, the triangle must enclose
         * a non-zero area), and must not be parallel to the Z-axis.
         *
         * This method can be used to interpolate the Z-value of a point inside this
         * triangle (for example, of a TIN facet with elevations on the vertices).
         *
         * @param p - the point to compute the Z-value of
         * @returns the computed Z-value (elevation) of the point
         * @see [org.locationtech.jts.geom.Triangle.interpolateZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#interpolateZ-org.locationtech.jts.geom.Coordinate-)
         */
        interpolateZ(triangle: Triangle, p: Coordinate): number;
        /**
         * Computes the Z-value (elevation) of an XY point on a three-dimensional
         * plane defined by a triangle whose vertices have Z-values. The defining
         * triangle must not be degenerate (in other words, the triangle must enclose
         * a non-zero area), and must not be parallel to the Z-axis.
         *
         * This method can be used to interpolate the Z-value of a point inside a
         * triangle (for example, of a TIN facet with elevations on the vertices).
         *
         * @param p - the point to compute the Z-value of
         * @param v0 - a vertex of a triangle, with a Z ordinate
         * @param v1 - a vertex of a triangle, with a Z ordinate
         * @param v2 - a vertex of a triangle, with a Z ordinate
         * @returns the computed Z-value (elevation) of the point
         * @see [org.locationtech.jts.geom.Triangle.interpolateZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#interpolateZ-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        interpolateZStatic(p: Coordinate, v0: Coordinate, v1: Coordinate, v2: Coordinate): number;
        /**
         * Tests whether a triangle intersects a point.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @param p - the point to test
         * @returns true if the triangle intersects the point
         * @see [org.locationtech.jts.geom.Triangle.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#intersects-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        intersects(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
        /**
         * Tests whether this triangle is acute. A triangle is acute if all interior
         * angles are acute. This is a strict test - right triangles will return
         * `false`. A triangle which is not acute is either right or obtuse.
         *
         * Note: this implementation is not robust for angles very close to 90
         * degrees.
         *
         * @returns true if this triangle is acute
         * @see [org.locationtech.jts.geom.Triangle.isAcute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isAcute--)
         */
        isAcute(triangle: Triangle): boolean;
        /**
         * Tests whether a triangle is acute. A triangle is acute if all interior
         * angles are acute. This is a strict test - right triangles will return
         * `false`. A triangle which is not acute is either right or obtuse.
         *
         * Note: this implementation is not robust for angles very close to 90
         * degrees.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns true if the triangle is acute
         * @see [org.locationtech.jts.geom.Triangle.isAcute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isAcute-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isAcuteStatic(a: Coordinate, b: Coordinate, c: Coordinate): boolean;
        /**
         * Tests whether this triangle is oriented counter-clockwise.
         *
         * @returns true if the triangle orientation is counter-clockwise
         * @see [org.locationtech.jts.geom.Triangle.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isCCW--)
         */
        isCCW(triangle: Triangle): boolean;
        /**
         * Tests whether a triangle is oriented counter-clockwise.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns true if the triangle orientation is counter-clockwise
         * @see [org.locationtech.jts.geom.Triangle.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#isCCW-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        isCCWStatic(a: Coordinate, b: Coordinate, c: Coordinate): boolean;
        /**
         * Computes the length of the perimeter of this triangle.
         *
         * @returns the length of the perimeter
         * @see [org.locationtech.jts.geom.Triangle.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#length--)
         */
        length(triangle: Triangle): number;
        /**
         * Compute the length of the perimeter of a triangle
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the length of the triangle perimeter
         * @see [org.locationtech.jts.geom.Triangle.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#length-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        lengthStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
        /**
         * Computes the length of the longest side of this triangle
         *
         * @returns the length of the longest side of this triangle
         * @see [org.locationtech.jts.geom.Triangle.longestSideLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#longestSideLength--)
         */
        longestSideLength(triangle: Triangle): number;
        /**
         * Computes the length of the longest side of a triangle
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the length of the longest side of the triangle
         * @see [org.locationtech.jts.geom.Triangle.longestSideLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#longestSideLength-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        longestSideLengthStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
        /**
         * Computes the signed 2D area of this triangle. The area value is positive if
         * the triangle is oriented CW, and negative if it is oriented CCW.
         *
         * The signed area value can be used to determine point orientation, but the
         * implementation in this method is susceptible to round-off errors. Use
         * `Coordinate, Coordinate)`
         * for robust orientation calculation.
         *
         * @returns the signed 2D area of this triangle
         * @see [org.locationtech.jts.geom.Triangle.signedArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#signedArea--)
         */
        signedArea(triangle: Triangle): number;
        /**
         * Computes the signed 2D area of a triangle. The area value is positive if
         * the triangle is oriented CW, and negative if it is oriented CCW.
         *
         * The signed area value can be used to determine point orientation, but the
         * implementation in this method is susceptible to round-off errors. Use
         * `Coordinate, Coordinate)`
         * for robust orientation calculation.
         *
         * @param a - a vertex of the triangle
         * @param b - a vertex of the triangle
         * @param c - a vertex of the triangle
         * @returns the signed 2D area of the triangle
         * @see [org.locationtech.jts.geom.Triangle.signedArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Triangle.html#signedArea-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        signedAreaStatic(a: Coordinate, b: Coordinate, c: Coordinate): number;
      };
      /**
       * Performs an operation on the coordinates in this `Geometry`'s
       * `CoordinateSequence`s.
       * If the filter reports that a coordinate value has been changed,
       * `geometryChanged` will be called automatically.
       *
       * @param filter - the filter to apply
       * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.CoordinateSequenceFilter-)
       */
      apply(geometry: Geometry, filter: any /* org.locationtech.jts.geom.CoordinateSequenceFilter */): any /* void */;
      /**
       * Performs an operation with or on this Geometry and its
       * component Geometry's.  Only GeometryCollections and
       * Polygons have component Geometry's; for Polygons they are the LinearRings
       * of the shell and holes.
       *
       * @param filter - the filter to apply to this `Geometry`.
       * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.GeometryComponentFilter-)
       */
      applyComponent(geometry: Geometry, filter: any /* org.locationtech.jts.geom.GeometryComponentFilter */): any /* void */;
      /**
       * Performs an operation with or on this `Geometry`'s
       * coordinates.
       * If this method modifies any coordinate values,
       * `geometryChanged` must be called to update the geometry state.
       * Note that you cannot use this method to
       * modify this Geometry if its underlying CoordinateSequence's #get method
       * returns a copy of the Coordinate, rather than the actual Coordinate stored
       * (if it even stores Coordinate objects at all).
       *
       * @param filter - the filter to apply to this `Geometry`'s coordinates
       * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.CoordinateFilter-)
       */
      applyCoord(geometry: Geometry, filter: any /* org.locationtech.jts.geom.CoordinateFilter */): any /* void */;
      applyCoordinates(geometry: Geometry, coords: Float64Array | number[], stride: number): Geometry;
      /**
       * Performs an operation with or on this `Geometry` and its
       * subelement `Geometry`s (if any).
       * Only GeometryCollections and subclasses
       * have subelement Geometry's.
       *
       * @param filter - the filter to apply to this `Geometry` (and its children, if it is a `GeometryCollection`).
       * @see [org.locationtech.jts.geom.Geometry.apply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#apply-org.locationtech.jts.geom.GeometryFilter-)
       */
      applyGeometry(geometry: Geometry, filter: any /* org.locationtech.jts.geom.GeometryFilter */): any /* void */;
      /**
       * Computes a buffer area around this geometry having the given width. The
       * buffer of a Geometry is the Minkowski sum or difference of the geometry
       * with a disc of radius `abs(distance)`.
       *
       * Mathematically-exact buffer area boundaries can contain circular arcs.
       * To represent these arcs using linear geometry they must be approximated with line segments.
       * The buffer geometry is constructed using 8 segments per quadrant to approximate
       * the circular arcs.
       * The end cap style is `CAP_ROUND`.
       *
       * The buffer operation always returns a polygonal result. The negative or
       * zero-distance buffer of lines and points is always an empty `Polygon`.
       * This is also the result for the buffers of degenerate (zero-area) polygons.
       *
       * @param distance - the width of the buffer (may be positive, negative or 0)
       * @returns a polygonal geometry representing the buffer region (which may be empty)
       * @throws TopologyException if a robustness error occurs
       * @see [org.locationtech.jts.geom.Geometry.buffer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#buffer-double-)
       */
      buffer(geometry: Geometry, distance: number): Geometry;
      /**
       * Returns whether this `Geometry` is greater than, equal to,
       * or less than another `Geometry`.
       *
       * If their classes are different, they are compared using the following
       * ordering:
       *
       * - Point (lowest)
       * - MultiPoint
       * - LineString
       * - LinearRing
       * - MultiLineString
       * - Polygon
       * - MultiPolygon
       * - GeometryCollection (highest)
       *
       * If the two `Geometry`s have the same class, their first
       * elements are compared. If those are the same, the second elements are
       * compared, etc.
       *
       * @param o - a `Geometry` with which to compare this `Geometry`
       * @returns a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications
       * @see [org.locationtech.jts.geom.Geometry.compareTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#compareTo-java.lang.Object-)
       */
      compareTo(geometry: Geometry, o: any /* java.lang.Object */): number;
      /**
       * Tests whether this geometry contains the
       * argument geometry.
       *
       * The `contains` predicate has the following equivalent definitions:
       *
       * - Every point of the other geometry is a point of this geometry,
       * and the interiors of the two geometries have at least one point in common.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * the pattern
       * `[T*****FF*]`
       * - `g.within(this) = true`
       *
       * (`contains` is the converse of `within` )
       *
       * An implication of the definition is that "Geometries do not
       * contain their boundary".  In other words, if a geometry A is a subset of
       * the points in the boundary of a geometry B, `B.contains(A) = false`.
       * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
       * For a predicate with similar behaviour but avoiding
       * this subtle limitation, see `covers`.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if this `Geometry` contains `g`
       * @see [org.locationtech.jts.geom.Geometry.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#contains-org.locationtech.jts.geom.Geometry-)
       */
      contains(geometry: Geometry, g: Geometry): boolean;
      /**
       * Computes the smallest convex `Polygon` that contains all the
       * points in the `Geometry`. This obviously applies only to `Geometry`
       * s which contain 3 or more points; the results for degenerate cases are
       * specified as follows:
       *
       * | Number of `Point`s in argument `Geometry` | `Geometry` class of result |
       * | --- | --- |
       * | 0 | empty `GeometryCollection` |
       * | 1 | `Point` |
       * | 2 | `LineString` |
       * | 3 or more | `Polygon` |
       *
       * @returns the minimum-area convex polygon containing this `Geometry`' s points
       * @see [org.locationtech.jts.geom.Geometry.convexHull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#convexHull--)
       */
      convexHull(geometry: Geometry): Geometry;
      /**
       * Creates a deep copy of this `Geometry` object.
       * Coordinate sequences contained in it are copied.
       * All instance fields are copied
       * (i.e. `envelope`, `SRID` and `userData`).
       *
       * **NOTE:** the userData object reference (if present) is copied,
       * but the value itself is not copied.
       * If a deep copy is required this must be performed by the caller.
       *
       * @returns a deep copy of this geometry
       * @see [org.locationtech.jts.geom.Geometry.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#copy--)
       */
      copy(geometry: Geometry): Geometry;
      /**
       * Tests whether this geometry is covered by the
       * argument geometry.
       *
       * The `coveredBy` predicate has the following equivalent definitions:
       *
       * - Every point of this geometry is a point of the other geometry.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * at least one of the following patterns:
       *
       * - `[T*F**F***]`
       * - `[*TF**F***]`
       * - `[**FT*F***]`
       * - `[**F*TF***]`
       *
       * - `g.covers(this) = true`
       *
       * (`coveredBy` is the converse of `covers`)
       *
       * If either geometry is empty, the value of this predicate is `false`.
       *
       * This predicate is similar to `within`,
       * but is more inclusive (i.e. returns `true` for more cases).
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if this `Geometry` is covered by `g`
       * @see [org.locationtech.jts.geom.Geometry.coveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#coveredBy-org.locationtech.jts.geom.Geometry-)
       */
      coveredBy(geometry: Geometry, g: Geometry): boolean;
      /**
       * Tests whether this geometry covers the
       * argument geometry.
       *
       * The `covers` predicate has the following equivalent definitions:
       *
       * - Every point of the other geometry is a point of this geometry.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * at least one of the following patterns:
       *
       * - `[T*****FF*]`
       * - `[*T****FF*]`
       * - `[***T**FF*]`
       * - `[****T*FF*]`
       *
       * - `g.coveredBy(this) = true`
       *
       * (`covers` is the converse of `coveredBy`)
       *
       * If either geometry is empty, the value of this predicate is `false`.
       *
       * This predicate is similar to `contains`,
       * but is more inclusive (i.e. returns `true` for more cases).
       * In particular, unlike `contains` it does not distinguish between
       * points in the boundary and in the interior of geometries.
       * For most situations, `covers` should be used in preference to `contains`.
       * As an added benefit, `covers` is more amenable to optimization,
       * and hence should be more performant.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if this `Geometry` covers `g`
       * @see [org.locationtech.jts.geom.Geometry.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#covers-org.locationtech.jts.geom.Geometry-)
       */
      covers(geometry: Geometry, g: Geometry): boolean;
      /**
       * Tests whether this geometry crosses the
       * argument geometry.
       *
       * The `crosses` predicate has the following equivalent definitions:
       *
       * - The geometries have some but not all interior points in common.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * one of the following patterns:
       *
       * - `[T*T******]` (for P/L, P/A, and L/A situations)
       * - `[T*****T**]` (for L/P, A/P, and A/L situations)
       * - `[0********]` (for L/L situations)
       *
       * For the A/A and P/P situations this predicate returns `false`.
       *
       * The SFS defined this predicate only for P/L, P/A, L/L, and L/A situations.
       * To make the relation symmetric
       * JTS extends the definition to apply to L/P, A/P and A/L situations as well.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s cross.
       * @see [org.locationtech.jts.geom.Geometry.crosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#crosses-org.locationtech.jts.geom.Geometry-)
       */
      crosses(geometry: Geometry, g: Geometry): boolean;
      /**
       * Computes a `Geometry` representing the closure of the point-set
       * of the points contained in this `Geometry` that are not contained in
       * the `other` Geometry.
       *
       * If the result is empty, it is an atomic geometry
       * with the dimension of the left-hand input.
       *
       * Non-empty `GeometryCollection` arguments are not supported.
       *
       * @param other - the `Geometry` with which to compute the difference
       * @returns a Geometry representing the point-set difference of this `Geometry` with `other`
       * @throws TopologyException if a robustness error occurs
       * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
       * @see [org.locationtech.jts.geom.Geometry.difference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#difference-org.locationtech.jts.geom.Geometry-)
       */
      difference(geometry: Geometry, other: Geometry): Geometry;
      /**
       * Tests whether this geometry is disjoint from the argument geometry.
       *
       * The `disjoint` predicate has the following equivalent definitions:
       *
       * - The two geometries have no point in common
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * `[FF*FF****]`
       * - `! g.intersects(this) = true`
       *
       * (`disjoint` is the inverse of `intersects`)
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s are disjoint
       * @see [org.locationtech.jts.geom.Geometry.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#disjoint-org.locationtech.jts.geom.Geometry-)
       */
      disjoint(geometry: Geometry, g: Geometry): boolean;
      /**
       * Returns the minimum distance between this `Geometry`
       * and another `Geometry`.
       *
       * @param g - the `Geometry` from which to compute the distance
       * @returns the distance between the geometries
       * @throws IllegalArgumentException if g is null
       * @see [org.locationtech.jts.geom.Geometry.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#distance-org.locationtech.jts.geom.Geometry-)
       */
      distance(geometry: Geometry, g: Geometry): number;
      /**
       * Tests whether this geometry is
       * topologically equal to the argument geometry.
       *
       * This method is included for backward compatibility reasons.
       * It has been superseded by the `equalsTopo` method,
       * which has been named to clearly denote its functionality.
       *
       * This method should NOT be confused with the method
       * `equals`, which implements
       * an exact equality comparison.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns true if the two `Geometry`s are topologically equal
       * @see [org.locationtech.jts.geom.Geometry.equals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equals-org.locationtech.jts.geom.Geometry-)
       */
      equals(geometry: Geometry, g: Geometry): boolean;
      /**
       * Returns true if the two `Geometry`s are exactly equal,
       * up to a specified distance tolerance.
       * Two Geometries are exactly equal within a distance tolerance
       * if and only if:
       *
       * - they have the same structure
       * - they have the same values for their vertices,
       * within the given tolerance distance, in exactly the same order.
       *
       * This method does _not_
       * test the values of the `GeometryFactory`, the `SRID`,
       * or the `userData` fields.
       *
       * To properly test equality between different geometries,
       * it is usually necessary to `normalize` them first.
       *
       * @param other - the `Geometry` with which to compare this `Geometry`
       * @param tolerance - distance at or below which two `Coordinate`s are considered equal
       * @returns `true` if this and the other `Geometry` have identical structure and point values, up to the distance tolerance.
       * @see [org.locationtech.jts.geom.Geometry.equalsExact](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsExact-org.locationtech.jts.geom.Geometry-double-)
       */
      equalsExact(geometry: Geometry, other: Geometry, tolerance: number): boolean;
      /**
       * Tests whether two geometries are exactly equal
       * in their normalized forms.
       * This is a convenience method which creates normalized
       * versions of both geometries before computing
       * `equalsExact`.
       *
       * This method is relatively expensive to compute.
       * For maximum performance, the client
       * should instead perform normalization on the individual geometries
       * at an appropriate point during processing.
       *
       * @param g - a Geometry
       * @returns true if the input geometries are exactly equal in their normalized form
       * @see [org.locationtech.jts.geom.Geometry.equalsNorm](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsNorm-org.locationtech.jts.geom.Geometry-)
       */
      equalsNorm(geometry: Geometry, g: Geometry): boolean;
      /**
       * Tests whether this geometry is topologically equal to the argument geometry
       * as defined by the SFS `equals` predicate.
       *
       * The SFS `equals` predicate has the following equivalent definitions:
       *
       * - The two geometries have at least one point in common,
       * and no point of either geometry lies in the exterior of the other geometry.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * the pattern `T*F**FFF*`
       *
       * ```
       * T*F
       * **F
       * FF*
       * ```
       *
       * **Note** that this method computes **topologically equality**.
       * For structural equality, see `equalsExact`.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s are topologically equal
       * @see [org.locationtech.jts.geom.Geometry.equalsTopo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#equalsTopo-org.locationtech.jts.geom.Geometry-)
       */
      equalsTopo(geometry: Geometry, g: Geometry): boolean;
      fromFlat(type: 'Point' | 'MultiPoint' | 'LineString' | 'LinearRing' | 'MultiLineString' | 'Polygon' | 'MultiPolygon', coords: Float64Array | number[], dim?: number, ringOffsets?: Int32Array | number[] | null, partOffsets?: Int32Array | number[] | null): Geometry;
      /**
       * Notifies this geometry that its coordinates have been changed by an external
       * party (for example, via a `CoordinateFilter`).
       * When this method is called the geometry will flush
       * and/or update any derived information it has cached (such as its `Envelope` ).
       * The operation is applied to all component Geometries.
       *
       * @see [org.locationtech.jts.geom.Geometry.geometryChanged](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#geometryChanged--)
       */
      geometryChanged(geometry: Geometry): any /* void */;
      /**
       * Returns the area of this `Geometry`.
       * Areal Geometries have a non-zero area.
       * They override this function to compute the area.
       * Others return 0.0
       *
       * @returns the area of the Geometry
       * @see [org.locationtech.jts.geom.Geometry.getArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getArea--)
       */
      getArea(geometry: Geometry): number;
      /**
       * Returns the boundary, or an empty geometry of appropriate dimension
       * if this `Geometry`  is empty.
       * (In the case of zero-dimensional geometries, '
       * an empty GeometryCollection is returned.)
       * For a discussion of this function, see the OpenGIS Simple
       * Features Specification. As stated in SFS Section 2.1.13.1, "the boundary
       * of a Geometry is a set of Geometries of the next lower dimension."
       *
       * @returns the closure of the combinatorial boundary of this `Geometry`
       * @see [org.locationtech.jts.geom.Geometry.getBoundary](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getBoundary--)
       */
      getBoundary(geometry: Geometry): Geometry;
      /**
       * Returns the dimension of this `Geometry`s inherent boundary.
       *
       * @returns the dimension of the boundary of the class implementing this interface, whether or not this object is the empty geometry. Returns `Dimension.FALSE` if the boundary is the empty geometry.
       * @see [org.locationtech.jts.geom.Geometry.getBoundaryDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getBoundaryDimension--)
       */
      getBoundaryDimension(geometry: Geometry): number;
      /**
       * Computes the centroid of this `Geometry`.
       * The centroid
       * is equal to the centroid of the set of component Geometries of highest
       * dimension (since the lower-dimension geometries contribute zero
       * "weight" to the centroid).
       *
       * The centroid of an empty geometry is `POINT EMPTY`.
       *
       * @returns a `Point` which is the centroid of this Geometry
       * @see [org.locationtech.jts.geom.Geometry.getCentroid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getCentroid--)
       */
      getCentroid(geometry: Geometry): Geometry;
      /**
       * Returns a vertex of this geometry
       * (usually, but not necessarily, the first one),
       * or `null` if the geometry is empty.
       * The returned coordinate should not be assumed
       * to be an actual `Coordinate` object used in
       * the internal representation.
       *
       * @returns a coordinate which is a vertex of this `Geometry`.
       * @see [org.locationtech.jts.geom.Geometry.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getCoordinate--)
       */
      getCoordinate(geometry: Geometry): Coordinate;
      getCoordinateN(lineString: Geometry, n: number): Coordinate;
      getCoordinateSequence(lineString: Geometry): CoordinateSequence;
      getCoordinates(geometry: Geometry): { x: number; y: number; z?: number; m?: number }[];
      getCoordinatesFlat(geometry: Geometry, dim?: number, stride?: number): Float64Array;
      /**
       * Returns the dimension of this geometry.
       * The dimension of a geometry is is the topological
       * dimension of its embedding in the 2-D Euclidean plane.
       * In the JTS spatial model, dimension values are in the set {0,1,2}.
       *
       * Note that this is a different concept to the dimension of
       * the vertex `Coordinate`s.
       * The geometry dimension can never be greater than the coordinate dimension.
       * For example, a 0-dimensional geometry (e.g. a Point)
       * may have a coordinate dimension of 3 (X,Y,Z).
       *
       * @returns the topological dimension of this geometry.
       * @see [org.locationtech.jts.geom.Geometry.getDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getDimension--)
       */
      getDimension(geometry: Geometry): number;
      getEndPoint(lineString: Geometry): Geometry;
      /**
       * Gets a Geometry representing the envelope (bounding box) of
       * this `Geometry`.
       *
       * If this `Geometry` is:
       *
       * - empty, returns an empty `Point`.
       * - a point, returns a `Point`.
       * - a line parallel to an axis, a two-vertex `LineString`
       * - otherwise, returns a
       * `Polygon` whose vertices are (minx miny, minx maxy,
       * maxx maxy, maxx miny, minx miny).
       *
       * @returns a Geometry representing the envelope of this Geometry
       * @see [org.locationtech.jts.geom.Geometry.getEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getEnvelope--)
       */
      getEnvelope(geometry: Geometry): Geometry;
      /**
       * Gets an `Envelope` containing
       * the minimum and maximum x and y values in this `Geometry`.
       * If the geometry is empty, an empty `Envelope`
       * is returned.
       *
       * The returned object is a copy of the one maintained internally,
       * to avoid aliasing issues.
       * For best performance, clients which access this
       * envelope frequently should cache the return value.
       *
       * @returns the envelope of this `Geometry`.
       * @see [org.locationtech.jts.geom.Geometry.getEnvelopeInternal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getEnvelopeInternal--)
       */
      getEnvelopeInternal(geometry: Geometry): Envelope;
      getExteriorRing(polygon: Geometry): Geometry;
      /**
       * Gets the factory which contains the context in which this geometry was created.
       *
       * @returns the factory for this geometry
       * @see [org.locationtech.jts.geom.Geometry.getFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getFactory--)
       */
      getFactory(geometry: Geometry): any /* org.locationtech.jts.geom.GeometryFactory */;
      /**
       * Returns an element `Geometry` from a `GeometryCollection`
       * (or `this`, if the geometry is not a collection).
       *
       * @param n - the index of the geometry element
       * @returns the n'th geometry contained in this geometry
       * @see [org.locationtech.jts.geom.Geometry.getGeometryN](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getGeometryN-int-)
       */
      getGeometryN(geometry: Geometry, n: number): Geometry;
      /**
       * Returns the name of this Geometry's actual class.
       *
       * @returns the name of this `Geometry`s actual class
       * @see [org.locationtech.jts.geom.Geometry.getGeometryType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getGeometryType--)
       */
      getGeometryType(geometry: Geometry): string;
      /**
       * Computes an interior point of this `Geometry`.
       * An interior point is guaranteed to lie in the interior of the Geometry,
       * if it possible to calculate such a point exactly. Otherwise,
       * the point may lie on the boundary of the geometry.
       *
       * The interior point of an empty geometry is `POINT EMPTY`.
       *
       * @returns a `Point` which is in the interior of this Geometry
       * @see [org.locationtech.jts.geom.Geometry.getInteriorPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getInteriorPoint--)
       */
      getInteriorPoint(geometry: Geometry): Geometry;
      getInteriorRingN(polygon: Geometry, n: number): Geometry;
      /**
       * Returns the length of this `Geometry`.
       * Linear geometries return their length.
       * Areal geometries return their perimeter.
       * They override this function to compute the area.
       * Others return 0.0
       *
       * @returns the length of the Geometry
       * @see [org.locationtech.jts.geom.Geometry.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getLength--)
       */
      getLength(geometry: Geometry): number;
      /**
       * Returns the number of `Geometry`s in a `GeometryCollection`
       * (or 1, if the geometry is not a collection).
       *
       * @returns the number of geometries contained in this geometry
       * @see [org.locationtech.jts.geom.Geometry.getNumGeometries](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getNumGeometries--)
       */
      getNumGeometries(geometry: Geometry): number;
      getNumInteriorRing(polygon: Geometry): number;
      /**
       * Returns the count of this `Geometry`s vertices. The `Geometry`
       * s contained by composite `Geometry`s must be
       * Geometry's; that is, they must implement `getNumPoints`
       *
       * @returns the number of vertices in this `Geometry`
       * @see [org.locationtech.jts.geom.Geometry.getNumPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getNumPoints--)
       */
      getNumPoints(geometry: Geometry): number;
      getPointN(lineString: Geometry, n: number): Geometry;
      /**
       * Returns the `PrecisionModel` used by the `Geometry`.
       *
       * @returns the specification of the grid of allowable points, for this `Geometry` and all other `Geometry`s
       * @see [org.locationtech.jts.geom.Geometry.getPrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getPrecisionModel--)
       */
      getPrecisionModel(geometry: Geometry): PrecisionModel;
      /**
       * Returns the ID of the Spatial Reference System used by the `Geometry`.
       *
       * JTS supports Spatial Reference System information in the simple way
       * defined in the SFS. A Spatial Reference System ID (SRID) is present in
       * each `Geometry` object. `Geometry` provides basic
       * accessor operations for this field, but no others. The SRID is represented
       * as an integer.
       *
       * @returns the ID of the coordinate space in which the `Geometry` is defined.
       * @see [org.locationtech.jts.geom.Geometry.getSRID](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getSRID--)
       */
      getSRID(geometry: Geometry): number;
      getStartPoint(lineString: Geometry): Geometry;
      /**
       * Gets the user data object for this geometry, if any.
       *
       * @returns the user data object, or `null` if none set
       * @see [org.locationtech.jts.geom.Geometry.getUserData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#getUserData--)
       */
      getUserData(geometry: Geometry): any /* java.lang.Object */;
      getX(point: Geometry): number;
      getY(point: Geometry): number;
      /**
       * Tests whether an atomic geometry or any element of a collection
       * has the specified dimension.
       * In particular, this can be used with mixed-dimension `GeometryCollection`s
       * to test if they contain an element of the specified dimension.
       *
       * @param dim - the dimension to test
       * @returns true if the geometry has or contains an element with the dimension
       * @see [org.locationtech.jts.geom.Geometry.hasDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#hasDimension-int-)
       */
      hasDimension(geometry: Geometry, dim: number): boolean;
      impl: {
        CoordinateArraySequence: {
          /**
           * Creates a deep copy of the CoordinateArraySequence
           *
           * @returns The deep copy
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#copy--)
           */
          copy(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */): any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */;
          /**
           * Constructs a sequence based on the given array
           * of `Coordinate`s (the
           * array is not copied).
           * The coordinate dimension defaults to 3.
           *
           * @param coordinates - the coordinate array that will be referenced.
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.CoordinateArraySequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#CoordinateArraySequence-org.locationtech.jts.geom.Coordinate:A-)
           */
          create1(coordinates: Coordinate[]): any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */;
          /**
           * Constructs a sequence of a given size, populated
           * with new `Coordinate`s.
           *
           * @param size - the size of the sequence to create
           * @param dimension - the dimension of the coordinates
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.CoordinateArraySequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#CoordinateArraySequence-int-int-)
           */
          create2(size: number, dimension: number): any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */;
          /**
           * Constructs a sequence based on the given array
           * of `Coordinate`s (the array is not copied).
           *
           * It is your responsibility to ensure the array contains Coordinates of the
           * indicated dimension and measures (See
           * `CoordinateArrays.enforceConsistency` ).
           *
           * @param coordinates - the coordinate array that will be referenced.
           * @param dimension - the dimension of the coordinates
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.CoordinateArraySequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#CoordinateArraySequence-org.locationtech.jts.geom.Coordinate:A-int-int-)
           */
          create3(coordinates: Coordinate[], dimension: number, measures: number): any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */;
          /**
           * Expands the given `Envelope` to include the coordinates in the sequence.
           * Allows implementing classes to optimize access to coordinate values.
           *
           * @param env - the envelope to expand
           * @returns a ref to the expanded envelope
           * @see [org.locationtech.jts.geom.CoordinateSequence.expandEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#expandEnvelope-org.locationtech.jts.geom.Envelope-)
           */
          expandEnvelope(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, env: Envelope): Envelope;
          /**
           * Copies the i'th coordinate in the sequence to the supplied
           * `Coordinate`.  Only the first two dimensions are copied.
           *
           * @param index - the index of the coordinate to copy
           * @param coord - a `Coordinate` to receive the value
           * @see [org.locationtech.jts.geom.CoordinateSequence.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getCoordinate-int-org.locationtech.jts.geom.Coordinate-)
           */
          getCoordinate(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number, coord: Coordinate): any /* void */;
          /**
           * Get a copy of the Coordinate with index i.
           *
           * @param i - the index of the coordinate
           * @returns a copy of the requested Coordinate
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.getCoordinateCopy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#getCoordinateCopy-int-)
           */
          getCoordinateCopy(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, i: number): Coordinate;
          /**
           * Returns the dimension (number of ordinates in each coordinate) for this sequence.
           *
           * This total includes any measures, indicated by non-zero `getMeasures`.
           *
           * @returns the dimension of the sequence.
           * @see [org.locationtech.jts.geom.CoordinateSequence.getDimension](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getDimension--)
           */
          getDimension(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */): number;
          /**
           * Returns ordinate M of the specified coordinate if available.
           *
           * @param index - the coordinate index in the sequence
           * @returns the value of the M ordinate in the index'th coordinate, or Double.NaN if not defined.
           * @see [org.locationtech.jts.geom.CoordinateSequence.getM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getM-int-)
           */
          getM(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number): number;
          /**
           * Returns the number of measures included in `getDimension` for each coordinate for this
           * sequence.
           *
           * For a measured coordinate sequence a non-zero value is returned.
           *
           * - For XY sequence measures is zero
           * - For XYM sequence measure is one
           * -
           * - For XYZ sequence measure is zero
           * - For XYZM sequence measure is one
           * - Values greater than one are supported
           *
           * @returns the number of measures included in dimension
           * @see [org.locationtech.jts.geom.CoordinateSequence.getMeasures](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getMeasures--)
           */
          getMeasures(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */): number;
          /**
           * Returns the ordinate of a coordinate in this sequence.
           * Ordinate indices 0 and 1 are assumed to be X and Y.
           *
           * Ordinates indices greater than 1 have user-defined semantics
           * (for instance, they may contain other dimensions or measure
           * values as described by `getDimension` and `getMeasures`).
           *
           * @param index - the coordinate index in the sequence
           * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
           * @returns ordinate value
           * @see [org.locationtech.jts.geom.CoordinateSequence.getOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getOrdinate-int-int-)
           */
          getOrdinate(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number, ordinateIndex: number): number;
          /**
           * Returns ordinate X (0) of the specified coordinate.
           *
           * @param index - the coordinate index in the sequence
           * @returns the value of the X ordinate in the index'th coordinate
           * @see [org.locationtech.jts.geom.CoordinateSequence.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getX-int-)
           */
          getX(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number): number;
          /**
           * Returns ordinate Y (1) of the specified coordinate.
           *
           * @param index - the coordinate index in the sequence
           * @returns the value of the Y ordinate in the index'th coordinate
           * @see [org.locationtech.jts.geom.CoordinateSequence.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getY-int-)
           */
          getY(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number): number;
          /**
           * Returns ordinate Z of the specified coordinate if available.
           *
           * @param index - the coordinate index in the sequence
           * @returns the value of the Z ordinate in the index'th coordinate, or Double.NaN if not defined.
           * @see [org.locationtech.jts.geom.CoordinateSequence.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#getZ-int-)
           */
          getZ(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number): number;
          /**
           * Sets the value for a given ordinate of a coordinate in this sequence.
           *
           * @param index - the coordinate index in the sequence
           * @param ordinateIndex - the ordinate index in the coordinate (in range [0, dimension-1])
           * @param value - the new ordinate value
           * @see [org.locationtech.jts.geom.CoordinateSequence.setOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequence.html#setOrdinate-int-int-double-)
           */
          setOrdinate(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */, index: number, ordinateIndex: number, value: number): any /* void */;
          /**
           * Returns the size of the coordinate sequence
           *
           * @returns the number of coordinates
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#size--)
           */
          size(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */): number;
          /**
           * This method exposes the internal Array of Coordinate Objects
           *
           * @returns the Coordinate[] array.
           * @see [org.locationtech.jts.geom.impl.CoordinateArraySequence.toCoordinateArray](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/CoordinateArraySequence.html#toCoordinateArray--)
           */
          toCoordinateArray(coordinateArraySequence: any /* org.locationtech.jts.geom.impl.CoordinateArraySequence */): Coordinate[];
        };
        PackedCoordinateSequenceFactory: {
          /**
           * Type code for arrays of type `double`.
           *
           * @see [org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory.DOUBLE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/PackedCoordinateSequenceFactory.html#DOUBLE)
           */
          DOUBLE: number;
          /**
           * Type code for arrays of type `float`.
           *
           * @see [org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory.FLOAT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/PackedCoordinateSequenceFactory.html#FLOAT)
           */
          FLOAT: number;
          /**
           * Creates a `CoordinateSequence` of the specified size and dimension with measure support.
           * For this to be useful, the `CoordinateSequence` implementation must
           * be mutable.
           *
           * If the requested dimension or measures are larger than the CoordinateSequence implementation
           * can provide, then a sequence of maximum possible dimension should be created.
           * An error should not be thrown.
           *
           * @param size - the number of coordinates in the sequence
           * @param dimension - the dimension of the coordinates in the sequence (if user-specifiable, otherwise ignored)
           * @param measures - the number of measures of the coordinates in the sequence (if user-specifiable, otherwise ignored)
           * @see [org.locationtech.jts.geom.CoordinateSequenceFactory.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequenceFactory.html#create-int-int-int-)
           */
          create(packedCoordinateSequenceFactory: any /* org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory */, size: number, dimension: number, measures: number): CoordinateSequence;
          /**
           * Creates a new PackedCoordinateSequenceFactory
           * of type DOUBLE.
           *
           * @see [org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory.PackedCoordinateSequenceFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/PackedCoordinateSequenceFactory.html#PackedCoordinateSequenceFactory--)
           */
          create0(): any /* org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory */;
          /**
           * Creates a new PackedCoordinateSequenceFactory
           * of the given type.
           * Acceptable type values are
           * `PackedCoordinateSequenceFactory.FLOAT`or
           * `PackedCoordinateSequenceFactory.DOUBLE`
           *
           * @see [org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory.PackedCoordinateSequenceFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/PackedCoordinateSequenceFactory.html#PackedCoordinateSequenceFactory-int-)
           */
          create1(type: number): any /* org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory */;
          /**
           * Gets the type of packed coordinate sequence this factory builds, either
           * `PackedCoordinateSequenceFactory.FLOAT` or
           * `PackedCoordinateSequenceFactory.DOUBLE`
           *
           * @returns the type of packed array built
           * @see [org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory.getType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/impl/PackedCoordinateSequenceFactory.html#getType--)
           */
          getType(packedCoordinateSequenceFactory: any /* org.locationtech.jts.geom.impl.PackedCoordinateSequenceFactory */): number;
        };
      };
      /**
       * Computes a `Geometry` representing the point-set which is
       * common to both this `Geometry` and the `other` Geometry.
       *
       * The intersection of two geometries of different dimension produces a result
       * geometry of dimension less than or equal to the minimum dimension of the input
       * geometries.
       * The result geometry may be a heterogeneous `GeometryCollection`.
       * If the result is empty, it is an atomic geometry
       * with the dimension of the lowest input dimension.
       *
       * Intersection of `GeometryCollection`s is supported
       * only for homogeneous collection types.
       *
       * Non-empty heterogeneous `GeometryCollection` arguments are not supported.
       *
       * @param other - the `Geometry` with which to compute the intersection
       * @returns a Geometry representing the point-set common to the two `Geometry`s
       * @throws TopologyException if a robustness error occurs
       * @throws IllegalArgumentException if the argument is a non-empty heterogeneous `GeometryCollection`
       * @see [org.locationtech.jts.geom.Geometry.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#intersection-org.locationtech.jts.geom.Geometry-)
       */
      intersection(geometry: Geometry, other: Geometry): Geometry;
      /**
       * Tests whether this geometry intersects the argument geometry.
       *
       * The `intersects` predicate has the following equivalent definitions:
       *
       * - The two geometries have at least one point in common
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * at least one of the patterns
       *
       * - `[T********]`
       * - `[*T*******]`
       * - `[***T*****]`
       * - `[****T****]`
       *
       * - `! g.disjoint(this) = true`
       *
       * (`intersects` is the inverse of `disjoint`)
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s intersect
       * @see [org.locationtech.jts.geom.Geometry.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#intersects-org.locationtech.jts.geom.Geometry-)
       */
      intersects(geometry: Geometry, g: Geometry): boolean;
      isClosed(lineString: Geometry): boolean;
      /**
       * Returns true if the given point is a vertex of this `LineString`.
       *
       * @param pt - the `Coordinate` to check
       * @returns `true` if `pt` is one of this `LineString` 's vertices
       * @see [org.locationtech.jts.geom.LineString.isCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/LineString.html#isCoordinate-org.locationtech.jts.geom.Coordinate-)
       */
      isCoordinate(lineString: Geometry, pt: Coordinate): boolean;
      /**
       * Tests whether the set of points covered by this `Geometry` is
       * empty.
       *
       * Note this test is for topological emptiness,
       * not structural emptiness.
       * A collection containing only empty elements is reported as empty.
       * To check structural emptiness use `getNumGeometries`.
       *
       * @returns `true` if this `Geometry` does not cover any points
       * @see [org.locationtech.jts.geom.Geometry.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isEmpty--)
       */
      isEmpty(geometry: Geometry): boolean;
      /**
       * Tests whether this is a rectangular `Polygon`.
       *
       * @returns true if the geometry is a rectangle.
       * @see [org.locationtech.jts.geom.Geometry.isRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isRectangle--)
       */
      isRectangle(geometry: Geometry): boolean;
      isRing(lineString: Geometry): boolean;
      /**
       * Tests whether this `Geometry` is simple.
       * The SFS definition of simplicity
       * follows the general rule that a Geometry is simple if it has no points of
       * self-tangency, self-intersection or other anomalous points.
       *
       * Simplicity is defined for each `Geometry` subclass as follows:
       *
       * - Valid polygonal geometries are simple, since their rings
       * must not self-intersect.  `isSimple`
       * tests for this condition and reports `false` if it is not met.
       * (This is a looser test than checking for validity).
       * - Linear rings have the same semantics.
       * - Linear geometries are simple if they do not self-intersect at points
       * other than boundary points.
       * - Zero-dimensional geometries (points) are simple if they have no
       * repeated points.
       * - Empty `Geometry`s are always simple.
       *
       * @returns `true` if this `Geometry` is simple
       * @see [org.locationtech.jts.geom.Geometry.isSimple](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isSimple--)
       */
      isSimple(geometry: Geometry): boolean;
      /**
       * Tests whether this `Geometry`
       * is topologically valid, according to the OGC SFS specification.
       *
       * For validity rules see the Javadoc for the specific Geometry subclass.
       *
       * @returns `true` if this `Geometry` is valid
       * @see [org.locationtech.jts.geom.Geometry.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isValid--)
       */
      isValid(geometry: Geometry): boolean;
      /**
       * Tests whether the distance from this `Geometry`
       * to another is less than or equal to a specified value.
       *
       * @param geom - the Geometry to check the distance to
       * @param distance - the distance value to compare
       * @returns `true` if the geometries are less than `distance` apart.
       * @see [org.locationtech.jts.geom.Geometry.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#isWithinDistance-org.locationtech.jts.geom.Geometry-double-)
       */
      isWithinDistance(geometry: Geometry, geom: Geometry, distance: number): boolean;
      /**
       * Creates a new Geometry which is a normalized
       * copy of this Geometry.
       *
       * @returns a normalized copy of this geometry.
       * @see [org.locationtech.jts.geom.Geometry.norm](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#norm--)
       */
      norm(geometry: Geometry): Geometry;
      /**
       * Converts this `Geometry` to **normal form** (or **canonical form** ). Normal form is a unique representation for `Geometry`
       * s. It can be used to test whether two `Geometry`s are equal
       * in a way that is independent of the ordering of the coordinates within
       * them. Normal form equality is a stronger condition than topological
       * equality, but weaker than pointwise equality. The definitions for normal
       * form use the standard lexicographical ordering for coordinates. "Sorted in
       * order of coordinates" means the obvious extension of this ordering to
       * sequences of coordinates.
       *
       * NOTE that this method mutates the value of this geometry in-place.
       * If this is not safe and/or wanted, the geometry should be
       * cloned prior to normalization.
       *
       * @see [org.locationtech.jts.geom.Geometry.normalize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#normalize--)
       */
      normalize(geometry: Geometry): any /* void */;
      /**
       * Tests whether this geometry overlaps the
       * specified geometry.
       *
       * The `overlaps` predicate has the following equivalent definitions:
       *
       * - The geometries have at least one point each not shared by the other
       * (or equivalently neither covers the other),
       * they have the same dimension,
       * and the intersection of the interiors of the two geometries has
       * the same dimension as the geometries themselves.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * `[T*T***T**]` (for two points or two surfaces)
       * or `[1*T***T**]` (for two curves)
       *
       * If the geometries are of different dimension this predicate returns `false`.
       * This predicate is symmetric.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s overlap.
       * @see [org.locationtech.jts.geom.Geometry.overlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#overlaps-org.locationtech.jts.geom.Geometry-)
       */
      overlaps(geometry: Geometry, g: Geometry): boolean;
      prep: {
        PreparedGeometry: {
          /**
           * Tests whether the base `Geometry` contains a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry contains the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#contains-org.locationtech.jts.geom.Geometry-)
           */
          contains(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` properly contains a given geometry.
           *
           * The `containsProperly` predicate has the following equivalent definitions:
           *
           * - Every point of the other geometry is a point of this geometry's interior.
           * - The DE-9IM Intersection Matrix for the two geometries matches
           * `[T**FF*FF*]`
           *
           * In other words, if the test geometry has any interaction with the boundary of the target
           * geometry the result of `containsProperly` is `false`.
           * This is different semantics to the `Geometry.contains` predicate,
           * in which test geometries can intersect the target's boundary and still be contained.
           *
           * The advantage of using this predicate is that it can be computed
           * efficiently, since it avoids the need to compute the full topological relationship
           * of the input boundaries in cases where they intersect.
           *
           * An example use case is computing the intersections
           * of a set of geometries with a large polygonal geometry.
           * Since `intersection` is a fairly slow operation, it can be more efficient
           * to use `containsProperly` to filter out test geometries which lie
           * wholly inside the area.  In these cases the intersection is
           * known _a priori_ to be exactly the original test geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry properly contains the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.containsProperly](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#containsProperly-org.locationtech.jts.geom.Geometry-)
           */
          containsProperly(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` is covered by a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry is covered by the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.coveredBy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#coveredBy-org.locationtech.jts.geom.Geometry-)
           */
          coveredBy(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` covers a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry covers the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.covers](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#covers-org.locationtech.jts.geom.Geometry-)
           */
          covers(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` crosses a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry crosses the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.crosses](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#crosses-org.locationtech.jts.geom.Geometry-)
           */
          crosses(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` is disjoint from a given geometry.
           * This method supports `GeometryCollection`s as input
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry is disjoint from the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.disjoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#disjoint-org.locationtech.jts.geom.Geometry-)
           */
          disjoint(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Gets the original `Geometry` which has been prepared.
           *
           * @returns the base geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#getGeometry--)
           */
          getGeometry(preparedGeometry: PreparedGeometry): Geometry;
          /**
           * Tests whether the base `Geometry` intersects a given geometry.
           * This method supports `GeometryCollection`s as input
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry intersects the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#intersects-org.locationtech.jts.geom.Geometry-)
           */
          intersects(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` overlaps a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry overlaps the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.overlaps](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#overlaps-org.locationtech.jts.geom.Geometry-)
           */
          overlaps(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` touches a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry touches the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.touches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#touches-org.locationtech.jts.geom.Geometry-)
           */
          touches(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
          /**
           * Tests whether the base `Geometry` is within a given geometry.
           *
           * @param geom - the Geometry to test
           * @returns true if this Geometry is within the given Geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometry.within](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometry.html#within-org.locationtech.jts.geom.Geometry-)
           */
          within(preparedGeometry: PreparedGeometry, geom: Geometry): boolean;
        };
        PreparedGeometryFactory: {
          /**
           * Creates a new `PreparedGeometry` appropriate for the argument `Geometry`.
           *
           * @param geom - the geometry to prepare
           * @returns the prepared geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometryFactory.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometryFactory.html#create-org.locationtech.jts.geom.Geometry-)
           */
          create(preparedGeometryFactory: PreparedGeometryFactory, geom: Geometry): PreparedGeometry;
          create0(): PreparedGeometryFactory;
          /**
           * Creates a new `PreparedGeometry` appropriate for the argument `Geometry`.
           *
           * @param geom - the geometry to prepare
           * @returns the prepared geometry
           * @see [org.locationtech.jts.geom.prep.PreparedGeometryFactory.prepare](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/prep/PreparedGeometryFactory.html#prepare-org.locationtech.jts.geom.Geometry-)
           */
          prepare(geom: Geometry): PreparedGeometry;
        };
      };
      /**
       * Returns the DE-9IM `IntersectionMatrix` for the two `Geometry`s.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns an `IntersectionMatrix` describing the intersections of the interiors, boundaries and exteriors of the two `Geometry`s
       * @see [org.locationtech.jts.geom.Geometry.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#relate-org.locationtech.jts.geom.Geometry-)
       */
      relate(geometry: Geometry, g: Geometry): IntersectionMatrix;
      /**
       * Tests whether the elements in the DE-9IM
       * `IntersectionMatrix` for the two `Geometry`s match the elements in `intersectionPattern`.
       * The pattern is a 9-character string, with symbols drawn from the following set:
       *
       * - 0 (dimension 0)
       * - 1 (dimension 1)
       * - 2 (dimension 2)
       * - T ( matches 0, 1 or 2)
       * - F ( matches FALSE)
       * - * ( matches any value)
       *
       * For more information on the DE-9IM, see the _OpenGIS Simple Features
       * Specification_.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @param intersectionPattern - the pattern against which to check the intersection matrix for the two `Geometry`s
       * @returns `true` if the DE-9IM intersection matrix for the two `Geometry`s match `intersectionPattern`
       * @see [org.locationtech.jts.geom.Geometry.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#relate-org.locationtech.jts.geom.Geometry-java.lang.String-)
       */
      relatePattern(geometry: Geometry, g: Geometry, intersectionPattern: string): boolean;
      /**
       * Computes a new geometry which has all component coordinate sequences
       * in reverse order (opposite orientation) to this one.
       *
       * @returns a reversed geometry
       * @see [org.locationtech.jts.geom.Geometry.reverse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#reverse--)
       */
      reverse(geometry: Geometry): Geometry;
      /**
       * Sets the ID of the Spatial Reference System used by the `Geometry`.
       *
       * **NOTE:** This method should only be used for exceptional circumstances or
       * for backwards compatibility.  Normally the SRID should be set on the
       * `GeometryFactory` used to create the geometry.
       * SRIDs set using this method will _not_ be propagated to
       * geometries returned by constructive methods.
       *
       * @see [org.locationtech.jts.geom.Geometry.setSRID](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#setSRID-int-)
       */
      setSRID(geometry: Geometry, SRID: number): any /* void */;
      /**
       * A simple scheme for applications to add their own custom data to a Geometry.
       * An example use might be to add an object representing a Coordinate Reference System.
       *
       * Note that user data objects are not present in geometries created by
       * construction methods.
       *
       * @param userData - an object, the semantics for which are defined by the application using this Geometry
       * @see [org.locationtech.jts.geom.Geometry.setUserData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#setUserData-java.lang.Object-)
       */
      setUserData(geometry: Geometry, userData: any /* java.lang.Object */): any /* void */;
      /**
       * Computes a `Geometry` representing the closure of the point-set
       * which is the union of the points in this `Geometry` which are not
       * contained in the `other` Geometry,
       * with the points in the `other` Geometry not contained in this
       * `Geometry`.
       * If the result is empty, it is an atomic geometry
       * with the dimension of the highest input dimension.
       *
       * Non-empty `GeometryCollection` arguments are not supported.
       *
       * @param other - the `Geometry` with which to compute the symmetric difference
       * @returns a Geometry representing the point-set symmetric difference of this `Geometry` with `other`
       * @throws TopologyException if a robustness error occurs
       * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
       * @see [org.locationtech.jts.geom.Geometry.symDifference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#symDifference-org.locationtech.jts.geom.Geometry-)
       */
      symDifference(geometry: Geometry, other: Geometry): Geometry;
      toFlat(geometry: Geometry, dim?: number): { type: 'Point' | 'MultiPoint' | 'LineString' | 'LinearRing' | 'MultiLineString' | 'Polygon' | 'MultiPolygon'; coords: Float64Array; dim: number; ringOffsets: Int32Array | null; partOffsets: Int32Array | null };
      /**
       * Returns the Well-known Text representation of this `Geometry`.
       * For a definition of the Well-known Text format, see the OpenGIS Simple
       * Features Specification.
       *
       * @returns the Well-known Text representation of this `Geometry`
       * @see [org.locationtech.jts.geom.Geometry.toText](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#toText--)
       */
      toText(geometry: Geometry): string;
      /**
       * Tests whether this geometry touches the
       * argument geometry.
       *
       * The `touches` predicate has the following equivalent definitions:
       *
       * - The geometries have at least one point in common,
       * but their interiors do not intersect.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * at least one of the following patterns
       *
       * - `[FT*******]`
       * - `[F**T*****]`
       * - `[F***T****]`
       *
       * If both geometries have dimension 0, the predicate returns `false`,
       * since points have only interiors.
       * This predicate is symmetric.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if the two `Geometry`s touch; Returns `false` if both `Geometry`s are points
       * @see [org.locationtech.jts.geom.Geometry.touches](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#touches-org.locationtech.jts.geom.Geometry-)
       */
      touches(geometry: Geometry, g: Geometry): boolean;
      /**
       * Computes the union of all the elements of this geometry.
       *
       * This method supports
       * `GeometryCollection`s
       * (which the other overlay operations currently do not).
       *
       * The result obeys the following contract:
       *
       * - Unioning a set of `LineString`s has the effect of fully noding
       * and dissolving the linework.
       * - Unioning a set of `Polygon`s always
       * returns a `Polygonal` geometry (unlike `union`,
       * which may return geometries of lower dimension if a topology collapse occurred).
       *
       * @returns the union geometry
       * @throws TopologyException if a robustness error occurs
       * @see [org.locationtech.jts.geom.Geometry.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#union--)
       */
      unaryUnion(geometry: Geometry): Geometry;
      /**
       * Computes a `Geometry` representing the point-set
       * which is contained in both this
       * `Geometry` and the `other` Geometry.
       *
       * The union of two geometries of different dimension produces a result
       * geometry of dimension equal to the maximum dimension of the input
       * geometries.
       * The result geometry may be a heterogeneous
       * `GeometryCollection`.
       * If the result is empty, it is an atomic geometry
       * with the dimension of the highest input dimension.
       *
       * Unioning `LineString`s has the effect of
       * **noding** and **dissolving** the input linework. In this context
       * "noding" means that there will be a node or endpoint in the result for
       * every endpoint or line segment crossing in the input. "Dissolving" means
       * that any duplicate (i.e. coincident) line segments or portions of line
       * segments will be reduced to a single line segment in the result.
       * If **merged** linework is required, the `LineMerger`
       * class can be used.
       *
       * Non-empty `GeometryCollection` arguments are not supported.
       *
       * @param other - the `Geometry` with which to compute the union
       * @returns a point-set combining the points of this `Geometry` and the points of `other`
       * @throws TopologyException if a robustness error occurs
       * @throws IllegalArgumentException if either input is a non-empty GeometryCollection
       * @see [org.locationtech.jts.geom.Geometry.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#union-org.locationtech.jts.geom.Geometry-)
       */
      union(geometry: Geometry, other: Geometry): Geometry;
      util: {
        AffineTransformation: {
          /**
           * Updates this transformation to be
           * the composition of this transformation with the given `AffineTransformation`.
           * This produces a transformation whose effect
           * is equal to applying this transformation
           * followed by the argument transformation.
           * Mathematically,
           * `A.compose(B) = TB x TA`
           *
           * @param trans - an affine transformation
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.compose](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#compose-org.locationtech.jts.geom.util.AffineTransformation-)
           */
          compose(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, trans: any /* org.locationtech.jts.geom.util.AffineTransformation */): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Updates this transformation to be the composition
           * of a given `AffineTransformation` with this transformation.
           * This produces a transformation whose effect
           * is equal to applying the argument transformation
           * followed by this transformation.
           * Mathematically,
           * `A.composeBefore(B) = TA x TB`
           *
           * @param trans - an affine transformation
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.composeBefore](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#composeBefore-org.locationtech.jts.geom.util.AffineTransformation-)
           */
          composeBefore(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, trans: any /* org.locationtech.jts.geom.util.AffineTransformation */): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Constructs a new identity transformation
           *
           * @see [org.locationtech.jts.geom.util.AffineTransformation.AffineTransformation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#AffineTransformation--)
           */
          create0(): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Constructs a new transformation whose
           * matrix has the specified values.
           *
           * @param matrix - an array containing the 6 values { m00, m01, m02, m10, m11, m12 }
           * @throws NullPointerException if matrix is null
           * @throws ArrayIndexOutOfBoundsException if matrix is too small
           * @see [org.locationtech.jts.geom.util.AffineTransformation.AffineTransformation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#AffineTransformation-double:A-)
           */
          create1(matrix: number[]): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Constructs a transformation
           * which maps the given source
           * points into the given destination points.
           *
           * @param src0 - source point 0
           * @param src1 - source point 1
           * @param src2 - source point 2
           * @param dest0 - the mapped point for source point 0
           * @param dest1 - the mapped point for source point 1
           * @param dest2 - the mapped point for source point 2
           * @see [org.locationtech.jts.geom.util.AffineTransformation.AffineTransformation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#AffineTransformation-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          create6(src0: Coordinate, src1: Coordinate, src2: Coordinate, dest0: Coordinate, dest1: Coordinate, dest2: Coordinate): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Transforms the i'th coordinate in the input sequence
           *
           * @param seq - a `CoordinateSequence`
           * @param i - the index of the coordinate to transform
           * @see [org.locationtech.jts.geom.util.AffineTransformation.filter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#filter-org.locationtech.jts.geom.CoordinateSequence-int-)
           */
          filter(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, seq: CoordinateSequence, i: number): any /* void */;
          /**
           * Computes the determinant of the transformation matrix.
           * The determinant is computed as:
           *
           * ```
           * | m00 m01 m02 |
           * | m10 m11 m12 | = m00 * m11 - m01 * m10
           * |  0   0   1  |
           * ```
           *
           * If the determinant is zero,
           * the transform is singular (not invertible),
           * and operations which attempt to compute
           * an inverse will throw a `NoninvertibleTransformException`.
           *
           * @returns the determinant of the transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformation.getDeterminant](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#getDeterminant--)
           */
          getDeterminant(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): number;
          /**
           * Gets an array containing the entries
           * of the transformation matrix.
           * Only the 6 non-trivial entries are returned,
           * in the sequence:
           *
           * ```
           * m00, m01, m02, m10, m11, m12
           * ```
           *
           * @returns an array of length 6
           * @see [org.locationtech.jts.geom.util.AffineTransformation.getMatrixEntries](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#getMatrixEntries--)
           */
          getMatrixEntries(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): number[];
          /**
           * Reports that this filter should continue to be executed until
           * all coordinates have been transformed.
           *
           * @returns false
           * @see [org.locationtech.jts.geom.util.AffineTransformation.isDone](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#isDone--)
           */
          isDone(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): boolean;
          /**
           * Reports whether the execution of this filter
           * has modified the coordinates of the geometry.
           * If so, `Geometry.geometryChanged` will be executed
           * after this filter has finished being executed.
           *
           * Most filters can simply return a constant value reflecting
           * whether they are able to change the coordinates.
           *
           * @returns true if this filter has changed the coordinates of the geometry
           * @see [org.locationtech.jts.geom.CoordinateSequenceFilter.isGeometryChanged](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateSequenceFilter.html#isGeometryChanged--)
           */
          isGeometryChanged(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): boolean;
          /**
           * Tests if this transformation is the identity transformation.
           *
           * @returns true if this is the identity transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformation.isIdentity](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#isIdentity--)
           */
          isIdentity(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): boolean;
          /**
           * Updates the value of this transformation
           * to that of a reflection transformation composed
           * with the current value.
           *
           * @param x0 - the x-ordinate of a point on the line to reflect around
           * @param y0 - the y-ordinate of a point on the line to reflect around
           * @param x1 - the x-ordinate of a point on the line to reflect around
           * @param y1 - the y-ordinate of a point on the line to reflect around
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.reflect](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#reflect-double-double-double-double-)
           */
          reflect(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, x0: number, y0: number, x1: number, y1: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation for a reflection about the
           * line (x0,y0) - (x1,y1).
           *
           * @param x0 - the x-ordinate of a point on the reflection line
           * @param y0 - the y-ordinate of a point on the reflection line
           * @param x1 - the x-ordinate of a another point on the reflection line
           * @param y1 - the y-ordinate of a another point on the reflection line
           * @returns a transformation for the reflection
           * @see [org.locationtech.jts.geom.util.AffineTransformation.reflectionInstance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#reflectionInstance-double-double-double-double-)
           */
          reflectionInstance(x0: number, y0: number, x1: number, y1: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Updates the value of this transformation
           * to that of a rotation around a given point composed
           * with the current value,
           * with the sin and cos of the rotation angle specified directly.
           *
           * @param sinTheta - the sine of the angle to rotate by
           * @param cosTheta - the cosine of the angle to rotate by
           * @param x - the x-ordinate of the rotation point
           * @param y - the y-ordinate of the rotation point
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.rotate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#rotate-double-double-double-double-)
           */
          rotate(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, sinTheta: number, cosTheta: number, x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation for a rotation
           * about the point (x,y) by an angle _theta_,
           * specified by the sine and cosine of the angle.
           * This allows providing exact values for sin(theta) and cos(theta)
           * for the common case of rotations of multiples of quarter-circles.
           *
           * @param sinTheta - the sine of the rotation angle
           * @param cosTheta - the cosine of the rotation angle
           * @param x - the x-ordinate of the rotation point
           * @param y - the y-ordinate of the rotation point
           * @returns a transformation for the rotation
           * @see [org.locationtech.jts.geom.util.AffineTransformation.rotationInstance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#rotationInstance-double-double-double-double-)
           */
          rotationInstance(sinTheta: number, cosTheta: number, x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Updates the value of this transformation
           * to that of a scale transformation composed
           * with the current value.
           *
           * @param xScale - the value to scale by in the x direction
           * @param yScale - the value to scale by in the y direction
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.scale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#scale-double-double-)
           */
          scale(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, xScale: number, yScale: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation for a scaling relative to the point (x,y).
           *
           * @param xScale - the value to scale by in the x direction
           * @param yScale - the value to scale by in the y direction
           * @param x - the x-ordinate of the point to scale around
           * @param y - the y-ordinate of the point to scale around
           * @returns a transformation for the scaling
           * @see [org.locationtech.jts.geom.util.AffineTransformation.scaleInstance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#scaleInstance-double-double-double-double-)
           */
          scaleInstance(xScale: number, yScale: number, x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be the identity transformation.
           * The identity transformation has the matrix:
           *
           * ```
           * | 1 0 0 |
           * | 0 1 0 |
           * | 0 0 1 |
           * ```
           *
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToIdentity](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToIdentity--)
           */
          setToIdentity(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be a reflection
           * about the line defined by a line `(x0,y0) - (x1,y1)`.
           *
           * @param x0 - the X ordinate of one point on the reflection line
           * @param y0 - the Y ordinate of one point on the reflection line
           * @param x1 - the X ordinate of another point on the reflection line
           * @param y1 - the Y ordinate of another point on the reflection line
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToReflection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToReflection-double-double-double-double-)
           */
          setToReflection(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, x0: number, y0: number, x1: number, y1: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Explicitly computes the math for a reflection.  May not work.
           *
           * @param x0 - the X ordinate of one point on the reflection line
           * @param y0 - the Y ordinate of one point on the reflection line
           * @param x1 - the X ordinate of another point on the reflection line
           * @param y1 - the Y ordinate of another point on the reflection line
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToReflectionBasic](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToReflectionBasic-double-double-double-double-)
           */
          setToReflectionBasic(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, x0: number, y0: number, x1: number, y1: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be a rotation
           * around a given point (x,y)
           * by specifying the sin and cos of the rotation angle directly.
           * The transformation matrix for the rotation
           * has the value:
           *
           * ```
           * |  cosTheta  -sinTheta   x-x*cos+y*sin |
           * |  sinTheta   cosTheta   y-x*sin-y*cos |
           * |         0          0         1       |
           * ```
           *
           * @param sinTheta - the sine of the rotation angle
           * @param cosTheta - the cosine of the rotation angle
           * @param x - the x-ordinate of the rotation point
           * @param y - the y-ordinate of the rotation point
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToRotation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToRotation-double-double-double-double-)
           */
          setToRotation(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, sinTheta: number, cosTheta: number, x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be a scaling.
           * The transformation matrix for a scale
           * has the value:
           *
           * ```
           * |  xScale      0  dx |
           * |  0      yScale  dy |
           * |  0           0   1 |
           * ```
           *
           * @param xScale - the amount to scale x-ordinates by
           * @param yScale - the amount to scale y-ordinates by
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToScale-double-double-)
           */
          setToScale(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, xScale: number, yScale: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be a shear.
           * The transformation matrix for a shear
           * has the value:
           *
           * ```
           * |  1      xShear  0 |
           * |  yShear      1  0 |
           * |  0           0  1 |
           * ```
           *
           * Note that a shear of (1, 1) is _not_
           * equal to shear(1, 0) composed with shear(0, 1).
           * Instead, shear(1, 1) corresponds to a mapping onto the
           * line x = y.
           *
           * @param xShear - the x component to shear by
           * @param yShear - the y component to shear by
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToShear](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToShear-double-double-)
           */
          setToShear(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, xShear: number, yShear: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation to be a translation.
           * For a translation by the vector (x, y)
           * the transformation matrix has the value:
           *
           * ```
           * |  1  0  dx |
           * |  1  0  dy |
           * |  0  0   1 |
           * ```
           *
           * @param dx - the x component to translate by
           * @param dy - the y component to translate by
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setToTranslation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setToTranslation-double-double-)
           */
          setToTranslation(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, dx: number, dy: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Sets this transformation's matrix to have the given values.
           *
           * @param m00 - the entry for the [0, 0] element in the transformation matrix
           * @param m01 - the entry for the [0, 1] element in the transformation matrix
           * @param m02 - the entry for the [0, 2] element in the transformation matrix
           * @param m10 - the entry for the [1, 0] element in the transformation matrix
           * @param m11 - the entry for the [1, 1] element in the transformation matrix
           * @param m12 - the entry for the [1, 2] element in the transformation matrix
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.setTransformation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#setTransformation-double-double-double-double-double-double-)
           */
          setTransformation(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, m00: number, m01: number, m02: number, m10: number, m11: number, m12: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Updates the value of this transformation
           * to that of a shear transformation composed
           * with the current value.
           *
           * @param xShear - the value to shear by in the x direction
           * @param yShear - the value to shear by in the y direction
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.shear](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#shear-double-double-)
           */
          shear(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, xShear: number, yShear: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation for a shear.
           *
           * @param xShear - the value to shear by in the x direction
           * @param yShear - the value to shear by in the y direction
           * @returns a transformation for the shear
           * @see [org.locationtech.jts.geom.util.AffineTransformation.shearInstance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#shearInstance-double-double-)
           */
          shearInstance(xShear: number, yShear: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Applies this transformation to the i'th coordinate
           * in the given CoordinateSequence.
           *
           * @param seq - a `CoordinateSequence`
           * @param i - the index of the coordinate to transform
           * @see [org.locationtech.jts.geom.util.AffineTransformation.transform](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#transform-org.locationtech.jts.geom.CoordinateSequence-int-)
           */
          transform(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, seq: CoordinateSequence, i: number): any /* void */;
          /**
           * Updates the value of this transformation
           * to that of a translation transformation composed
           * with the current value.
           *
           * @param x - the value to translate by in the x direction
           * @param y - the value to translate by in the y direction
           * @returns this transformation, with an updated matrix
           * @see [org.locationtech.jts.geom.util.AffineTransformation.translate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#translate-double-double-)
           */
          translate(affineTransformation: any /* org.locationtech.jts.geom.util.AffineTransformation */, x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation for a translation.
           *
           * @param x - the value to translate by in the x direction
           * @param y - the value to translate by in the y direction
           * @returns a transformation for the translation
           * @see [org.locationtech.jts.geom.util.AffineTransformation.translationInstance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformation.html#translationInstance-double-double-)
           */
          translationInstance(x: number, y: number): any /* org.locationtech.jts.geom.util.AffineTransformation */;
        };
        AffineTransformationBuilder: {
          /**
           * Constructs a new builder for
           * the transformation defined by the given
           * set of control point mappings.
           *
           * @param src0 - a control point
           * @param src1 - a control point
           * @param src2 - a control point
           * @param dest0 - the image of control point 0 under the required transformation
           * @param dest1 - the image of control point 1 under the required transformation
           * @param dest2 - the image of control point 2 under the required transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformationBuilder.AffineTransformationBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformationBuilder.html#AffineTransformationBuilder-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          create6(src0: Coordinate, src1: Coordinate, src2: Coordinate, dest0: Coordinate, dest1: Coordinate, dest2: Coordinate): any /* org.locationtech.jts.geom.util.AffineTransformationBuilder */;
          /**
           * Computes the `AffineTransformation`
           * determined by the control point mappings,
           * or `null` if the control vectors do not determine a well-defined transformation.
           *
           * @returns an affine transformation, or null if the control vectors do not determine a well-defined transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformationBuilder.getTransformation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformationBuilder.html#getTransformation--)
           */
          getTransformation(affineTransformationBuilder: any /* org.locationtech.jts.geom.util.AffineTransformationBuilder */): any /* org.locationtech.jts.geom.util.AffineTransformation */;
        };
        AffineTransformationFactory: {
          /**
           * Creates an AffineTransformation defined by a mapping between two baselines.
           * The computed transformation consists of:
           *
           * - a translation
           * from the start point of the source baseline to the start point of the destination baseline,
           * - a rotation through the angle between the baselines about the destination start point,
           * - and a scaling equal to the ratio of the baseline lengths.
           *
           * If the source baseline has zero length, an identity transformation is returned.
           *
           * @param src0 - the start point of the source baseline
           * @param src1 - the end point of the source baseline
           * @param dest0 - the start point of the destination baseline
           * @param dest1 - the end point of the destination baseline
           * @returns the computed transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformationFactory.createFromBaseLines](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformationFactory.html#createFromBaseLines-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          createFromBaseLines(src0: Coordinate, src1: Coordinate, dest0: Coordinate, dest1: Coordinate): any /* org.locationtech.jts.geom.util.AffineTransformation */;
          /**
           * Creates a transformation from a set of three control vectors. A control
           * vector consists of a source point and a destination point, which is the
           * image of the source point under the desired transformation. Three control
           * vectors allows defining a fully general affine transformation.
           *
           * @param src0
           * @param src1
           * @param src2
           * @param dest0
           * @param dest1
           * @param dest2
           * @returns the computed transformation
           * @see [org.locationtech.jts.geom.util.AffineTransformationFactory.createFromControlVectors](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/AffineTransformationFactory.html#createFromControlVectors-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          createFromControlVectors(src0: Coordinate, src1: Coordinate, src2: Coordinate, dest0: Coordinate, dest1: Coordinate, dest2: Coordinate): any /* org.locationtech.jts.geom.util.AffineTransformation */;
        };
        GeometryCombiner: {
          /**
           * Combines three geometries.
           *
           * @param g0 - a geometry to combine
           * @param g1 - a geometry to combine
           * @param g2 - a geometry to combine
           * @returns the combined geometry
           * @see [org.locationtech.jts.geom.util.GeometryCombiner.combine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryCombiner.html#combine-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          combine(g0: Geometry, g1: Geometry, g2: Geometry): Geometry;
          /**
           * Creates a new combiner for a collection of geometries
           *
           * @param geoms - the geometries to combine
           * @see [org.locationtech.jts.geom.util.GeometryCombiner.GeometryCombiner](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryCombiner.html#GeometryCombiner-java.util.Collection-)
           */
          create1(geoms: any /* java.util.Collection */): any /* org.locationtech.jts.geom.util.GeometryCombiner */;
          /**
           * Extracts the GeometryFactory used by the geometries in a collection
           *
           * @param geoms
           * @returns a GeometryFactory
           * @see [org.locationtech.jts.geom.util.GeometryCombiner.extractFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryCombiner.html#extractFactory-java.util.Collection-)
           */
          extractFactory(geoms: any /* java.util.Collection */): any /* org.locationtech.jts.geom.GeometryFactory */;
        };
        GeometryEditor: {
          /**
           * Creates a new GeometryEditor object which will create
           * edited `Geometry`s with the same `GeometryFactory` as the input Geometry.
           *
           * @see [org.locationtech.jts.geom.util.GeometryEditor.GeometryEditor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryEditor.html#GeometryEditor--)
           */
          create0(): any /* org.locationtech.jts.geom.util.GeometryEditor */;
          /**
           * Creates a new GeometryEditor object which will create
           * edited `Geometry`s with the given `GeometryFactory`.
           *
           * @param factory - the GeometryFactory to create edited Geometrys with
           * @see [org.locationtech.jts.geom.util.GeometryEditor.GeometryEditor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryEditor.html#GeometryEditor-org.locationtech.jts.geom.GeometryFactory-)
           */
          create1(factory: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.geom.util.GeometryEditor */;
          /**
           * Sets whether the User Data is copied to the edit result.
           * Only the object reference is copied.
           *
           * @param isUserDataCopied - true if the input user data should be copied.
           * @see [org.locationtech.jts.geom.util.GeometryEditor.setCopyUserData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryEditor.html#setCopyUserData-boolean-)
           */
          setCopyUserData(geometryEditor: any /* org.locationtech.jts.geom.util.GeometryEditor */, isUserDataCopied: boolean): any /* void */;
        };
        GeometryFixer: {
          /**
           * Creates a new instance to fix a given geometry.
           *
           * @param geom - the geometry to be fixed
           * @see [org.locationtech.jts.geom.util.GeometryFixer.GeometryFixer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#GeometryFixer-org.locationtech.jts.geom.Geometry-)
           */
          create(geom: Geometry): GeometryFixer;
          /**
           * Fixes a geometry to be valid.
           *
           * @param geom - the geometry to be fixed
           * @returns the valid fixed geometry
           * @see [org.locationtech.jts.geom.util.GeometryFixer.fix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#fix-org.locationtech.jts.geom.Geometry-)
           */
          fix(geom: Geometry): Geometry;
          /**
           * Fixes a geometry to be valid, allowing to set a flag controlling how
           * single item results from fixed `MULTI` geometries should be
           * returned.
           *
           * @param geom - the geometry to be fixed
           * @param isKeepMulti - a flag indicating if `MULTI` geometries should not be converted to single instance types if they consist of only one item.
           * @returns the valid fixed geometry
           * @see [org.locationtech.jts.geom.util.GeometryFixer.fix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#fix-org.locationtech.jts.geom.Geometry-boolean-)
           */
          fixKeepMulti(geom: Geometry, isKeepMulti: boolean): Geometry;
          /**
           * Gets the fixed geometry.
           *
           * @returns the fixed geometry
           * @see [org.locationtech.jts.geom.util.GeometryFixer.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#getResult--)
           */
          getResult(geometryFixer: GeometryFixer): Geometry;
          /**
           * Sets whether collapsed geometries are converted to empty,
           * (which will be removed from collections),
           * or to a valid geometry of lower dimension.
           * The default is to convert collapses to empty geometries.
           *
           * @param isKeepCollapsed - whether collapses should be converted to a lower dimension geometry
           * @see [org.locationtech.jts.geom.util.GeometryFixer.setKeepCollapsed](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#setKeepCollapsed-boolean-)
           */
          setKeepCollapsed(geometryFixer: GeometryFixer, isKeepCollapsed: boolean): any /* void */;
          /**
           * Sets whether fixed `MULTI` geometries that consist of
           * only one item should still be returned as `MULTI` geometries.
           *
           * The default is to keep `MULTI` geometries.
           *
           * @param isKeepMulti - flag whether to keep `MULTI` geometries.
           * @see [org.locationtech.jts.geom.util.GeometryFixer.setKeepMulti](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryFixer.html#setKeepMulti-boolean-)
           */
          setKeepMulti(geometryFixer: GeometryFixer, isKeepMulti: boolean): any /* void */;
        };
        GeometryTransformer: {
          create0(): any /* org.locationtech.jts.geom.util.GeometryTransformer */;
          /**
           * Utility function to make input geometry available
           *
           * @returns the input geometry
           * @see [org.locationtech.jts.geom.util.GeometryTransformer.getInputGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/GeometryTransformer.html#getInputGeometry--)
           */
          getInputGeometry(geometryTransformer: any /* org.locationtech.jts.geom.util.GeometryTransformer */): Geometry;
          transform(geometryTransformer: any /* org.locationtech.jts.geom.util.GeometryTransformer */, inputGeom: Geometry): Geometry;
        };
        LineStringExtracter: {
          /**
           * Extracts the `LineString` elements from a single `Geometry`
           * and returns them as either a `LineString` or `MultiLineString`.
           *
           * @param geom - the geometry from which to extract
           * @returns a linear geometry
           * @see [org.locationtech.jts.geom.util.LineStringExtracter.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/LineStringExtracter.html#getGeometry-org.locationtech.jts.geom.Geometry-)
           */
          getGeometry(geom: Geometry): Geometry;
          /**
           * Extracts the `LineString` elements from a single `Geometry`
           * and adds them to the provided `List`.
           *
           * @param geom - the geometry from which to extract
           * @param lines - the list to add the extracted LineStrings to
           * @returns the list argument
           * @see [org.locationtech.jts.geom.util.LineStringExtracter.getLines](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/LineStringExtracter.html#getLines-org.locationtech.jts.geom.Geometry-java.util.List-)
           */
          getLines(geom: Geometry, lines: any /* java.util.List */): any /* java.util.List */;
        };
        LinearComponentExtracter: {
          /**
           * Extracts the linear components from a single `Geometry`
           * and returns them as either a `LineString` or `MultiLineString`.
           *
           * @param geom - the geometry from which to extract
           * @param forceToLineString - true if LinearRings should be converted to LineStrings
           * @returns a linear geometry
           * @see [org.locationtech.jts.geom.util.LinearComponentExtracter.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/LinearComponentExtracter.html#getGeometry-org.locationtech.jts.geom.Geometry-boolean-)
           */
          getGeometry(geom: Geometry, forceToLineString: boolean): Geometry;
          /**
           * Extracts the linear components from a single `Geometry`
           * and adds them to the provided `Collection`.
           *
           * @param geom - the geometry from which to extract linear components
           * @param lines - the Collection to add the extracted linear components to
           * @param forceToLineString - true if LinearRings should be converted to LineStrings
           * @returns the Collection of linear components (LineStrings or LinearRings)
           * @see [org.locationtech.jts.geom.util.LinearComponentExtracter.getLines](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/LinearComponentExtracter.html#getLines-org.locationtech.jts.geom.Geometry-java.util.Collection-boolean-)
           */
          getLines(geom: Geometry, lines: any /* java.util.Collection */, forceToLineString: boolean): any /* java.util.Collection */;
        };
        PolygonalExtracter: {
          /**
           * Extracts the `Polygon` and `MultiPolygon` elements from a `Geometry`
           * and adds them to the provided list.
           *
           * @param geom - the geometry from which to extract
           * @param list - the list to add the extracted elements to
           * @see [org.locationtech.jts.geom.util.PolygonalExtracter.getPolygonals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/PolygonalExtracter.html#getPolygonals-org.locationtech.jts.geom.Geometry-java.util.List-)
           */
          getPolygonals(geom: Geometry, list: any /* java.util.List */): any /* java.util.List */;
        };
        ShortCircuitedGeometryVisitor: {
          applyTo(shortCircuitedGeometryVisitor: any /* org.locationtech.jts.geom.util.ShortCircuitedGeometryVisitor */, geom: Geometry): any /* void */;
        };
        SineStarFactory: {
          /**
           * Creates a sine star with the given parameters.
           *
           * @param origin - the origin point
           * @param size - the size of the star
           * @param nPts - the number of points in the star
           * @param nArms - the number of arms to generate
           * @param armLengthRatio - the arm length ratio
           * @returns a sine star shape
           * @see [org.locationtech.jts.geom.util.SineStarFactory.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#create-org.locationtech.jts.geom.Coordinate-double-int-int-double-)
           */
          create(origin: Coordinate, size: number, nPts: number, nArms: number, armLengthRatio: number): Geometry;
          /**
           * Creates a factory which will create sine stars using the default
           * `GeometryFactory`.
           *
           * @see [org.locationtech.jts.geom.util.SineStarFactory.SineStarFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#SineStarFactory--)
           */
          create0(): any /* org.locationtech.jts.geom.util.SineStarFactory */;
          /**
           * Creates a factory which will create sine stars using the given
           * `GeometryFactory`.
           *
           * @param geomFact - the factory to use
           * @see [org.locationtech.jts.geom.util.SineStarFactory.SineStarFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#SineStarFactory-org.locationtech.jts.geom.GeometryFactory-)
           */
          create1(geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.geom.util.SineStarFactory */;
          /**
           * Generates the geometry for the sine star
           *
           * @returns the geometry representing the sine star
           * @see [org.locationtech.jts.geom.util.SineStarFactory.createSineStar](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#createSineStar--)
           */
          createSineStar(sineStarFactory: any /* org.locationtech.jts.geom.util.SineStarFactory */): Geometry;
          /**
           * Sets the ratio of the length of each arm to the radius of the star.
           * A smaller number makes the arms shorter.
           * Value should be between 0.0 and 1.0
           *
           * @param armLengthRatio - the ratio determining the length of them arms.
           * @see [org.locationtech.jts.geom.util.SineStarFactory.setArmLengthRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#setArmLengthRatio-double-)
           */
          setArmLengthRatio(sineStarFactory: any /* org.locationtech.jts.geom.util.SineStarFactory */, armLengthRatio: number): any /* void */;
          /**
           * Sets the number of arms in the star
           *
           * @param numArms - the number of arms to generate
           * @see [org.locationtech.jts.geom.util.SineStarFactory.setNumArms](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/util/SineStarFactory.html#setNumArms-int-)
           */
          setNumArms(sineStarFactory: any /* org.locationtech.jts.geom.util.SineStarFactory */, numArms: number): any /* void */;
        };
      };
      /**
       * Tests whether this geometry is within the
       * specified geometry.
       *
       * The `within` predicate has the following equivalent definitions:
       *
       * - Every point of this geometry is a point of the other geometry,
       * and the interiors of the two geometries have at least one point in common.
       * - The DE-9IM Intersection Matrix for the two geometries matches
       * `[T*F**F***]`
       * - `g.contains(this) = true`
       *
       * (`within` is the converse of `contains`)
       *
       * An implication of the definition is that
       * "The boundary of a Geometry is not within the Geometry".
       * In other words, if a geometry A is a subset of
       * the points in the boundary of a geometry B, `A.within(B) = false`
       * (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.)
       * For a predicate with similar behaviour but avoiding
       * this subtle limitation, see `coveredBy`.
       *
       * @param g - the `Geometry` with which to compare this `Geometry`
       * @returns `true` if this `Geometry` is within `g`
       * @see [org.locationtech.jts.geom.Geometry.within](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/Geometry.html#within-org.locationtech.jts.geom.Geometry-)
       */
      within(geometry: Geometry, g: Geometry): boolean;
    };
    index: {
      ArrayListVisitor: {
        /**
         * Creates a new instance.
         *
         * @see [org.locationtech.jts.index.ArrayListVisitor.ArrayListVisitor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/ArrayListVisitor.html#ArrayListVisitor--)
         */
        create0(): any /* org.locationtech.jts.index.ArrayListVisitor */;
      };
      VertexSequencePackedRtree: {
        /**
         * Creates a new tree over the given sequence of coordinates.
         * The sequence should be spatially coherent to provide query performance.
         *
         * @param pts - a sequence of points
         * @see [org.locationtech.jts.index.VertexSequencePackedRtree.VertexSequencePackedRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/VertexSequencePackedRtree.html#VertexSequencePackedRtree-org.locationtech.jts.geom.Coordinate:A-)
         */
        create1(pts: Coordinate[]): any /* org.locationtech.jts.index.VertexSequencePackedRtree */;
        /**
         * Removes the input item at the given index from the spatial index.
         * This does not change the underlying coordinate array.
         *
         * @param index - the index of the item in the input
         * @see [org.locationtech.jts.index.VertexSequencePackedRtree.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/VertexSequencePackedRtree.html#remove-int-)
         */
        remove(vertexSequencePackedRtree: any /* org.locationtech.jts.index.VertexSequencePackedRtree */, index: number): any /* void */;
      };
      bintree: {
        Bintree: {
          create0(): any /* org.locationtech.jts.index.bintree.Bintree */;
          depth(bintree: any /* org.locationtech.jts.index.bintree.Bintree */): number;
          /**
           * Compute the total number of nodes in the tree
           *
           * @returns the number of nodes in the tree
           * @see [org.locationtech.jts.index.bintree.Bintree.nodeSize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/bintree/Bintree.html#nodeSize--)
           */
          nodeSize(bintree: any /* org.locationtech.jts.index.bintree.Bintree */): number;
          size(bintree: any /* org.locationtech.jts.index.bintree.Bintree */): number;
        };
      };
      chain: {
        MonotoneChainOverlapAction: {
          create0(): any /* org.locationtech.jts.index.chain.MonotoneChainOverlapAction */;
          /**
           * This is a convenience function which can be overridden to obtain the actual
           * line segments which overlap
           *
           * @param seg1
           * @param seg2
           * @see [org.locationtech.jts.index.chain.MonotoneChainOverlapAction.overlap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/chain/MonotoneChainOverlapAction.html#overlap-org.locationtech.jts.geom.LineSegment-org.locationtech.jts.geom.LineSegment-)
           */
          overlap(monotoneChainOverlapAction: any /* org.locationtech.jts.index.chain.MonotoneChainOverlapAction */, seg1: LineSegment, seg2: LineSegment): any /* void */;
        };
        MonotoneChainSelectAction: {
          create0(): any /* org.locationtech.jts.index.chain.MonotoneChainSelectAction */;
          /**
           * This is a convenience method which can be overridden to obtain the actual
           * line segment which is selected.
           *
           * @param seg
           * @see [org.locationtech.jts.index.chain.MonotoneChainSelectAction.select](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/chain/MonotoneChainSelectAction.html#select-org.locationtech.jts.geom.LineSegment-)
           */
          select(monotoneChainSelectAction: any /* org.locationtech.jts.index.chain.MonotoneChainSelectAction */, seg: LineSegment): any /* void */;
        };
      };
      hprtree: {
        HPRtree: {
          /**
           * Builds the index, if not already built.
           *
           * @see [org.locationtech.jts.index.hprtree.HPRtree.build](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/hprtree/HPRtree.html#build--)
           */
          build(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */): any /* void */;
          /**
           * Creates a new index with the default node capacity.
           *
           * @see [org.locationtech.jts.index.hprtree.HPRtree.HPRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/hprtree/HPRtree.html#HPRtree--)
           */
          create0(): any /* org.locationtech.jts.index.hprtree.HPRtree */;
          /**
           * Creates a new index with the given node capacity.
           *
           * @param nodeCapacity - the node capacity to use
           * @see [org.locationtech.jts.index.hprtree.HPRtree.HPRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/hprtree/HPRtree.html#HPRtree-int-)
           */
          create1(nodeCapacity: number): any /* org.locationtech.jts.index.hprtree.HPRtree */;
          /**
           * Adds a spatial item with an extent specified by the given `Envelope` to the index
           *
           * @see [org.locationtech.jts.index.SpatialIndex.insert](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/SpatialIndex.html#insert-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          insert(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */, itemEnv: Envelope, item: any /* java.lang.Object */): any /* void */;
          /**
           * Queries the index for all items whose extents intersect the given search `Envelope`
           * Note that some kinds of indexes may also return objects which do not in fact
           * intersect the query envelope.
           *
           * @param searchEnv - the envelope to query for
           * @returns a list of the items found by the query
           * @see [org.locationtech.jts.index.SpatialIndex.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/SpatialIndex.html#query-org.locationtech.jts.geom.Envelope-)
           */
          query(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */, searchEnv: Envelope): any /* java.util.List */;
          /**
           * Queries the index for all items whose extents intersect the given search `Envelope`,
           * and applies an `ItemVisitor` to them.
           * Note that some kinds of indexes may also return objects which do not in fact
           * intersect the query envelope.
           *
           * @param searchEnv - the envelope to query for
           * @param visitor - a visitor object to apply to the items found
           * @see [org.locationtech.jts.index.SpatialIndex.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/SpatialIndex.html#query-org.locationtech.jts.geom.Envelope-org.locationtech.jts.index.ItemVisitor-)
           */
          queryVisit(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */, searchEnv: Envelope, visitor: any /* org.locationtech.jts.index.ItemVisitor */): any /* void */;
          /**
           * Removes a single item from the tree.
           *
           * @param itemEnv - the Envelope of the item to remove
           * @param item - the item to remove
           * @returns `true` if the item was found
           * @see [org.locationtech.jts.index.SpatialIndex.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/SpatialIndex.html#remove-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          remove(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */, itemEnv: Envelope, item: any /* java.lang.Object */): boolean;
          /**
           * Gets the number of items in the index.
           *
           * @returns the number of items
           * @see [org.locationtech.jts.index.hprtree.HPRtree.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/hprtree/HPRtree.html#size--)
           */
          size(hPRtree: any /* org.locationtech.jts.index.hprtree.HPRtree */): number;
        };
        HilbertEncoder: {
          create2(level: number, extent: Envelope): any /* org.locationtech.jts.index.hprtree.HilbertEncoder */;
          encode(hilbertEncoder: any /* org.locationtech.jts.index.hprtree.HilbertEncoder */, env: Envelope): number;
        };
      };
      intervalrtree: {
        IntervalRTreeNode: {
          getMax(intervalRTreeNode: any /* org.locationtech.jts.index.intervalrtree.IntervalRTreeNode */): number;
          getMin(intervalRTreeNode: any /* org.locationtech.jts.index.intervalrtree.IntervalRTreeNode */): number;
        };
        SortedPackedIntervalRTree: {
          create0(): any /* org.locationtech.jts.index.intervalrtree.SortedPackedIntervalRTree */;
          /**
           * Search for intervals in the index which intersect the given closed interval
           * and apply the visitor to them.
           *
           * @param min - the lower bound of the query interval
           * @param max - the upper bound of the query interval
           * @param visitor - the visitor to pass any matched items to
           * @see [org.locationtech.jts.index.intervalrtree.SortedPackedIntervalRTree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/intervalrtree/SortedPackedIntervalRTree.html#query-double-double-org.locationtech.jts.index.ItemVisitor-)
           */
          query(sortedPackedIntervalRTree: any /* org.locationtech.jts.index.intervalrtree.SortedPackedIntervalRTree */, min: number, max: number, visitor: any /* org.locationtech.jts.index.ItemVisitor */): any /* void */;
        };
      };
      kdtree: {
        KdTree: {
          /**
           * Creates a new instance of a KdTree with a snapping tolerance of 0.0. (I.e.
           * distinct points will _not_ be snapped)
           *
           * @see [org.locationtech.jts.index.kdtree.KdTree.KdTree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/kdtree/KdTree.html#KdTree--)
           */
          create0(): any /* org.locationtech.jts.index.kdtree.KdTree */;
          /**
           * Creates a new instance of a KdTree, specifying a snapping distance
           * tolerance. Points which lie closer than the tolerance to a point already in
           * the tree will be treated as identical to the existing point.
           *
           * @param tolerance - the tolerance distance for considering two points equal
           * @see [org.locationtech.jts.index.kdtree.KdTree.KdTree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/kdtree/KdTree.html#KdTree-double-)
           */
          create1(tolerance: number): any /* org.locationtech.jts.index.kdtree.KdTree */;
          /**
           * Computes the depth of the tree.
           *
           * @returns the depth of the tree
           * @see [org.locationtech.jts.index.kdtree.KdTree.depth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/kdtree/KdTree.html#depth--)
           */
          depth(kdTree: any /* org.locationtech.jts.index.kdtree.KdTree */): number;
          /**
           * Tests whether the index contains any items.
           *
           * @returns true if the index does not contain any items
           * @see [org.locationtech.jts.index.kdtree.KdTree.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/kdtree/KdTree.html#isEmpty--)
           */
          isEmpty(kdTree: any /* org.locationtech.jts.index.kdtree.KdTree */): boolean;
          /**
           * Computes the size (number of items) in the tree.
           *
           * @returns the size of the tree
           * @see [org.locationtech.jts.index.kdtree.KdTree.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/kdtree/KdTree.html#size--)
           */
          size(kdTree: any /* org.locationtech.jts.index.kdtree.KdTree */): number;
        };
      };
      quadtree: {
        DoubleBits: {
          EXPONENT_BIAS: number;
          /**
           * Determines the exponent for the number
           *
           * @see [org.locationtech.jts.index.quadtree.DoubleBits.biasedExponent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/DoubleBits.html#biasedExponent--)
           */
          biasedExponent(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */): number;
          create1(x: number): any /* org.locationtech.jts.index.quadtree.DoubleBits */;
          exponent(d: number): number;
          getBit(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */, i: number): number;
          getDouble(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */): number;
          /**
           * Determines the exponent for the number
           *
           * @see [org.locationtech.jts.index.quadtree.DoubleBits.getExponent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/DoubleBits.html#getExponent--)
           */
          getExponent(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */): number;
          maximumCommonMantissa(d1: number, d2: number): number;
          /**
           * This computes the number of common most-significant bits in the mantissa.
           * It does not count the hidden bit, which is always 1.
           * It does not determine whether the numbers have the same exponent - if they do
           * not, the value computed by this function is meaningless.
           *
           * @param db
           * @returns the number of common most-significant mantissa bits
           * @see [org.locationtech.jts.index.quadtree.DoubleBits.numCommonMantissaBits](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/DoubleBits.html#numCommonMantissaBits-org.locationtech.jts.index.quadtree.DoubleBits-)
           */
          numCommonMantissaBits(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */, db: any /* org.locationtech.jts.index.quadtree.DoubleBits */): number;
          powerOf2(exp: number): number;
          toBinaryString(d: number): string;
          truncateToPowerOfTwo(d: number): number;
          zeroLowerBits(doubleBits: any /* org.locationtech.jts.index.quadtree.DoubleBits */, nBits: number): any /* void */;
        };
        IntervalSize: {
          /**
           * This value is chosen to be a few powers of 2 less than the
           * number of bits available in the double representation (i.e. 53).
           * This should allow enough extra precision for simple computations to be correct,
           * at least for comparison purposes.
           *
           * @see [org.locationtech.jts.index.quadtree.IntervalSize.MIN_BINARY_EXPONENT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/IntervalSize.html#MIN_BINARY_EXPONENT)
           */
          MIN_BINARY_EXPONENT: number;
          /**
           * Computes whether the interval [min, max] is effectively zero width.
           * I.e. the width of the interval is so much less than the
           * location of the interval that the midpoint of the interval cannot be
           * represented precisely.
           *
           * @see [org.locationtech.jts.index.quadtree.IntervalSize.isZeroWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/IntervalSize.html#isZeroWidth-double-double-)
           */
          isZeroWidth(min: number, max: number): boolean;
        };
        Key: {
          /**
           * return a square envelope containing the argument envelope,
           * whose extent is a power of two and which is based at a power of 2
           *
           * @see [org.locationtech.jts.index.quadtree.Key.computeKey](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Key.html#computeKey-org.locationtech.jts.geom.Envelope-)
           */
          computeKey(key: any /* org.locationtech.jts.index.quadtree.Key */, itemEnv: Envelope): any /* void */;
          computeQuadLevel(env: Envelope): number;
          create1(itemEnv: Envelope): any /* org.locationtech.jts.index.quadtree.Key */;
          getCentre(key: any /* org.locationtech.jts.index.quadtree.Key */): Coordinate;
          getEnvelope(key: any /* org.locationtech.jts.index.quadtree.Key */): Envelope;
          getLevel(key: any /* org.locationtech.jts.index.quadtree.Key */): number;
          getPoint(key: any /* org.locationtech.jts.index.quadtree.Key */): Coordinate;
        };
        Node: {
          create2(env: Envelope, level: number): any /* org.locationtech.jts.index.quadtree.Node */;
          createExpanded(node: any /* org.locationtech.jts.index.quadtree.Node */, addEnv: Envelope): any /* org.locationtech.jts.index.quadtree.Node */;
          createNode(env: Envelope): any /* org.locationtech.jts.index.quadtree.Node */;
          getEnvelope(node: any /* org.locationtech.jts.index.quadtree.Node */): Envelope;
          /**
           * Returns the subquad containing the envelope `searchEnv`.
           * Creates the subquad if
           * it does not already exist.
           *
           * @returns the subquad containing the search envelope
           * @see [org.locationtech.jts.index.quadtree.Node.getNode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Node.html#getNode-org.locationtech.jts.geom.Envelope-)
           */
          getNode(node: any /* org.locationtech.jts.index.quadtree.Node */, searchEnv: Envelope): any /* org.locationtech.jts.index.quadtree.Node */;
        };
        NodeBase: {
          /**
           * Gets the index of the subquad that wholly contains the given envelope.
           * If none does, returns -1.
           *
           * @returns the index of the subquad that wholly contains the given envelope or -1 if no subquad wholly contains the envelope
           * @see [org.locationtech.jts.index.quadtree.NodeBase.getSubnodeIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/NodeBase.html#getSubnodeIndex-org.locationtech.jts.geom.Envelope-double-double-)
           */
          getSubnodeIndex(env: Envelope, centrex: number, centrey: number): number;
        };
        Quadtree: {
          /**
           * Constructs a Quadtree with zero items.
           *
           * @see [org.locationtech.jts.index.quadtree.Quadtree.Quadtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#Quadtree--)
           */
          create0(): any /* org.locationtech.jts.index.quadtree.Quadtree */;
          /**
           * Returns the number of levels in the tree.
           *
           * @see [org.locationtech.jts.index.quadtree.Quadtree.depth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#depth--)
           */
          depth(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */): number;
          /**
           * Ensure that the envelope for the inserted item has non-zero extents.
           * Use the current minExtent to pad the envelope, if necessary
           *
           * @see [org.locationtech.jts.index.quadtree.Quadtree.ensureExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#ensureExtent-org.locationtech.jts.geom.Envelope-double-)
           */
          ensureExtent(itemEnv: Envelope, minExtent: number): Envelope;
          /**
           * Adds a spatial item with an extent specified by the given `Envelope` to the index
           *
           * @see [org.locationtech.jts.index.SpatialIndex.insert](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/SpatialIndex.html#insert-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          insert(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */, itemEnv: Envelope, item: any /* java.lang.Object */): any /* void */;
          /**
           * Tests whether the index contains any items.
           *
           * @returns true if the index does not contain any items
           * @see [org.locationtech.jts.index.quadtree.Quadtree.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#isEmpty--)
           */
          isEmpty(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */): boolean;
          /**
           * Queries the tree and returns items which may lie in the given search envelope.
           * Precisely, the items that are returned are all items in the tree
           * whose envelope **may** intersect the search Envelope.
           * Note that some items with non-intersecting envelopes may be returned as well;
           * the client is responsible for filtering these out.
           * In most situations there will be many items in the tree which do not
           * intersect the search envelope and which are not returned - thus
           * providing improved performance over a simple linear scan.
           *
           * @param searchEnv - the envelope of the desired query area.
           * @returns a List of items which may intersect the search envelope
           * @see [org.locationtech.jts.index.quadtree.Quadtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#query-org.locationtech.jts.geom.Envelope-)
           */
          query(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */, searchEnv: Envelope): any /* java.util.List */;
          /**
           * Return a list of all items in the Quadtree
           *
           * @see [org.locationtech.jts.index.quadtree.Quadtree.queryAll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#queryAll--)
           */
          queryAll(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */): any /* java.util.List */;
          /**
           * Queries the tree and visits items which may lie in the given search envelope.
           * Precisely, the items that are visited are all items in the tree
           * whose envelope **may** intersect the search Envelope.
           * Note that some items with non-intersecting envelopes may be visited as well;
           * the client is responsible for filtering these out.
           * In most situations there will be many items in the tree which do not
           * intersect the search envelope and which are not visited - thus
           * providing improved performance over a simple linear scan.
           *
           * @param searchEnv - the envelope of the desired query area.
           * @param visitor - a visitor object which is passed the visited items
           * @see [org.locationtech.jts.index.quadtree.Quadtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#query-org.locationtech.jts.geom.Envelope-org.locationtech.jts.index.ItemVisitor-)
           */
          queryVisit(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */, searchEnv: Envelope, visitor: any /* org.locationtech.jts.index.ItemVisitor */): any /* void */;
          /**
           * Removes a single item from the tree.
           *
           * @param itemEnv - the Envelope of the item to be removed
           * @param item - the item to remove
           * @returns `true` if the item was found (and thus removed)
           * @see [org.locationtech.jts.index.quadtree.Quadtree.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#remove-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          remove(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */, itemEnv: Envelope, item: any /* java.lang.Object */): boolean;
          /**
           * Returns the number of items in the tree.
           *
           * @returns the number of items in the tree
           * @see [org.locationtech.jts.index.quadtree.Quadtree.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/quadtree/Quadtree.html#size--)
           */
          size(quadtree: any /* org.locationtech.jts.index.quadtree.Quadtree */): number;
        };
      };
      strtree: {
        AbstractNode: {
          /**
           * Returns 0 if this node is a leaf, 1 if a parent of a leaf, and so on; the
           * root node will have the highest level
           *
           * @returns the node level
           * @see [org.locationtech.jts.index.strtree.AbstractNode.getLevel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractNode.html#getLevel--)
           */
          getLevel(abstractNode: any /* org.locationtech.jts.index.strtree.AbstractNode */): number;
          /**
           * Tests whether there are any `Boundable`s at this node.
           *
           * @returns true if there are boundables at this node
           * @see [org.locationtech.jts.index.strtree.AbstractNode.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractNode.html#isEmpty--)
           */
          isEmpty(abstractNode: any /* org.locationtech.jts.index.strtree.AbstractNode */): boolean;
          /**
           * Gets the count of the `Boundable`s at this node.
           *
           * @returns the count of boundables at this node
           * @see [org.locationtech.jts.index.strtree.AbstractNode.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractNode.html#size--)
           */
          size(abstractNode: any /* org.locationtech.jts.index.strtree.AbstractNode */): number;
        };
        AbstractSTRtree: {
          /**
           * Creates parent nodes, grandparent nodes, and so forth up to the root
           * node, for the data that has been inserted into the tree. Can only be
           * called once, and thus can be called only after all of the data has been
           * inserted into the tree.
           *
           * @see [org.locationtech.jts.index.strtree.AbstractSTRtree.build](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractSTRtree.html#build--)
           */
          build(abstractSTRtree: any /* org.locationtech.jts.index.strtree.AbstractSTRtree */): any /* void */;
          /**
           * Returns the maximum number of child nodes that a node may have.
           *
           * @returns the node capacity
           * @see [org.locationtech.jts.index.strtree.AbstractSTRtree.getNodeCapacity](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractSTRtree.html#getNodeCapacity--)
           */
          getNodeCapacity(abstractSTRtree: any /* org.locationtech.jts.index.strtree.AbstractSTRtree */): number;
          /**
           * Gets the root node of the tree.
           *
           * @returns the root node
           * @see [org.locationtech.jts.index.strtree.AbstractSTRtree.getRoot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractSTRtree.html#getRoot--)
           */
          getRoot(abstractSTRtree: any /* org.locationtech.jts.index.strtree.AbstractSTRtree */): any /* org.locationtech.jts.index.strtree.AbstractNode */;
          /**
           * Tests whether the index contains any items.
           * This method does not build the index,
           * so items can still be inserted after it has been called.
           *
           * @returns true if the index does not contain any items
           * @see [org.locationtech.jts.index.strtree.AbstractSTRtree.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/AbstractSTRtree.html#isEmpty--)
           */
          isEmpty(abstractSTRtree: any /* org.locationtech.jts.index.strtree.AbstractSTRtree */): boolean;
        };
        BoundablePairDistanceComparator: {
          /**
           * Instantiates a new boundable pair distance comparator.
           *
           * @param normalOrder - true puts the lowest record at the head of this queue. This is the natural order. PriorityQueue peek() will get the least element.
           * @see [org.locationtech.jts.index.strtree.BoundablePairDistanceComparator.BoundablePairDistanceComparator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/BoundablePairDistanceComparator.html#BoundablePairDistanceComparator-boolean-)
           */
          create1(normalOrder: boolean): any /* org.locationtech.jts.index.strtree.BoundablePairDistanceComparator */;
        };
        EnvelopeDistance: {
          /**
           * Computes the maximum distance between the points defining two envelopes.
           * It is equal to the length of the diagonal of
           * the envelope containing both input envelopes.
           * This is a coarse upper bound on the distance between
           * geometries bounded by the envelopes.
           *
           * @param env1 - an envelope
           * @param env2 - an envelope
           * @returns the maximum distance between the points defining the envelopes
           * @see [org.locationtech.jts.index.strtree.EnvelopeDistance.maximumDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/EnvelopeDistance.html#maximumDistance-org.locationtech.jts.geom.Envelope-org.locationtech.jts.geom.Envelope-)
           */
          maximumDistance(env1: Envelope, env2: Envelope): number;
          /**
           * Computes the Min-Max Distance between two `Envelope`s.
           * It is equal to the minimum of the maximum distances between all pairs of
           * edge segments from the two envelopes.
           * This is the tight upper bound on the distance between
           * geometric items bounded by the envelopes.
           *
           * Theoretically this bound can be used in the R-tree nearest-neighbour branch-and-bound search
           * instead of `Envelope)`.
           * However, little performance improvement is observed in practice.
           *
           * @param a - an envelope
           * @param b - an envelope
           * @returns the min-max-distance between the envelopes
           * @see [org.locationtech.jts.index.strtree.EnvelopeDistance.minMaxDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/EnvelopeDistance.html#minMaxDistance-org.locationtech.jts.geom.Envelope-org.locationtech.jts.geom.Envelope-)
           */
          minMaxDistance(a: Envelope, b: Envelope): number;
        };
        GeometryItemDistance: {
          create0(): any /* org.locationtech.jts.index.strtree.GeometryItemDistance */;
        };
        SIRtree: {
          /**
           * Constructs an SIRtree with the default node capacity.
           *
           * @see [org.locationtech.jts.index.strtree.SIRtree.SIRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/SIRtree.html#SIRtree--)
           */
          create0(): any /* org.locationtech.jts.index.strtree.SIRtree */;
          /**
           * Constructs an SIRtree with the given maximum number of child nodes that
           * a node may have
           *
           * @see [org.locationtech.jts.index.strtree.SIRtree.SIRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/SIRtree.html#SIRtree-int-)
           */
          create1(nodeCapacity: number): any /* org.locationtech.jts.index.strtree.SIRtree */;
          /**
           * Inserts an item having the given bounds into the tree.
           *
           * @see [org.locationtech.jts.index.strtree.SIRtree.insert](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/SIRtree.html#insert-double-double-java.lang.Object-)
           */
          insert(sIRtree: any /* org.locationtech.jts.index.strtree.SIRtree */, x1: number, x2: number, item: any /* java.lang.Object */): any /* void */;
          /**
           * Returns items whose bounds intersect the given bounds.
           *
           * @param x1 - possibly equal to x2
           * @see [org.locationtech.jts.index.strtree.SIRtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/SIRtree.html#query-double-double-)
           */
          query(sIRtree: any /* org.locationtech.jts.index.strtree.SIRtree */, x1: number, x2: number): any /* java.util.List */;
          /**
           * Returns items whose bounds intersect the given value.
           *
           * @see [org.locationtech.jts.index.strtree.SIRtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/SIRtree.html#query-double-)
           */
          queryPoint(sIRtree: any /* org.locationtech.jts.index.strtree.SIRtree */, x: number): any /* java.util.List */;
        };
        STRtree: {
          /**
           * Constructs an STRtree with the default node capacity.
           *
           * @see [org.locationtech.jts.index.strtree.STRtree.STRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#STRtree--)
           */
          create(): any /* org.locationtech.jts.index.strtree.STRtree */;
          /**
           * Constructs an STRtree with the given maximum number of child nodes that
           * a node may have.
           *
           * The minimum recommended capacity setting is 4.
           *
           * @see [org.locationtech.jts.index.strtree.STRtree.STRtree](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#STRtree-int-)
           */
          create1(nodeCapacity: number): any /* org.locationtech.jts.index.strtree.STRtree */;
          /**
           * Returns the number of levels in the tree.
           *
           * @returns the number of levels in the tree
           * @see [org.locationtech.jts.index.strtree.STRtree.depth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#depth--)
           */
          depth(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */): number;
          /**
           * Inserts an item having the given bounds into the tree.
           *
           * @see [org.locationtech.jts.index.strtree.STRtree.insert](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#insert-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          insert(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, itemEnv: Envelope, item: any /* java.lang.Object */): any /* void */;
          /**
           * Tests whether some two items from this tree and another tree
           * lie within a given distance.
           * `ItemDistance` is used as the distance metric.
           * A Branch-and-Bound tree traversal algorithm is used
           * to provide an efficient search.
           *
           * @param tree - another tree
           * @param itemDist - a distance metric applicable to the items in the trees
           * @param maxDistance - the distance limit for the search
           * @returns true if there are items within the distance
           * @see [org.locationtech.jts.index.strtree.STRtree.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#isWithinDistance-org.locationtech.jts.index.strtree.STRtree-org.locationtech.jts.index.strtree.ItemDistance-double-)
           */
          isWithinDistance(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, tree: any /* org.locationtech.jts.index.strtree.STRtree */, itemDist: any /* org.locationtech.jts.index.strtree.ItemDistance */, maxDistance: number): boolean;
          /**
           * Finds the two nearest items in the tree,
           * using `ItemDistance` as the distance metric.
           * A Branch-and-Bound tree traversal algorithm is used
           * to provide an efficient search.
           *
           * If the tree is empty, the return value is `null`.
           * If the tree contains only one item,
           * the return value is a pair containing that item.
           *
           * If it is required to find only pairs of distinct items,
           * the `ItemDistance` function must be **anti-reflexive**.
           *
           * @param itemDist - a distance metric applicable to the items in this tree
           * @returns the pair of the nearest items or `null` if the tree is empty
           * @see [org.locationtech.jts.index.strtree.STRtree.nearestNeighbour](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#nearestNeighbour-org.locationtech.jts.index.strtree.ItemDistance-)
           */
          nearestNeighbour(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, itemDist: any /* org.locationtech.jts.index.strtree.ItemDistance */): any /* java.lang.Object */[];
          /**
           * Finds the item in this tree which is nearest to the given `Object`,
           * using `ItemDistance` as the distance metric.
           * A Branch-and-Bound tree traversal algorithm is used
           * to provide an efficient search.
           *
           * The query `object` does **not** have to be
           * contained in the tree, but it does
           * have to be compatible with the `itemDist`
           * distance metric.
           *
           * @param env - the envelope of the query item
           * @param item - the item to find the nearest neighbour of
           * @param itemDist - a distance metric applicable to the items in this tree and the query item
           * @returns the nearest item in this tree or `null` if the tree is empty
           * @see [org.locationtech.jts.index.strtree.STRtree.nearestNeighbour](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#nearestNeighbour-org.locationtech.jts.geom.Envelope-java.lang.Object-org.locationtech.jts.index.strtree.ItemDistance-)
           */
          nearestNeighbourItem(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, env: Envelope, item: any /* java.lang.Object */, itemDist: any /* org.locationtech.jts.index.strtree.ItemDistance */): any /* java.lang.Object */;
          /**
           * Finds the two nearest items from this tree
           * and another tree,
           * using `ItemDistance` as the distance metric.
           * A Branch-and-Bound tree traversal algorithm is used
           * to provide an efficient search.
           * The result value is a pair of items,
           * the first from this tree and the second
           * from the argument tree.
           *
           * @param tree - another tree
           * @param itemDist - a distance metric applicable to the items in the trees
           * @returns the pair of the nearest items, one from each tree or `null` if no pair of distinct items can be found
           * @see [org.locationtech.jts.index.strtree.STRtree.nearestNeighbour](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#nearestNeighbour-org.locationtech.jts.index.strtree.STRtree-org.locationtech.jts.index.strtree.ItemDistance-)
           */
          nearestNeighbourJoin(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, tree: any /* org.locationtech.jts.index.strtree.STRtree */, itemDist: any /* org.locationtech.jts.index.strtree.ItemDistance */): any /* java.lang.Object */[];
          /**
           * Finds up to k items in this tree which are the nearest neighbors to the given `item`,
           * using `itemDist` as the distance metric.
           * A Branch-and-Bound tree traversal algorithm is used
           * to provide an efficient search.
           * This method implements the KNN algorithm described in the following paper:
           *
           * Roussopoulos, Nick, Stephen Kelley, and Frédéric Vincent. "Nearest neighbor queries."
           * ACM sigmod record. Vol. 24. No. 2. ACM, 1995.
           *
           * The query `item` does **not** have to be
           * contained in the tree, but it does
           * have to be compatible with the `itemDist`
           * distance metric.
           *
           * If the tree size is smaller than k fewer items will be returned.
           * If the tree is empty an array of size 0 is returned.
           *
           * @param env - the envelope of the query item
           * @param item - the item to find the nearest neighbours of
           * @param itemDist - a distance metric applicable to the items in this tree and the query item
           * @param k - the maximum number of nearest items to search for
           * @returns an array of the nearest items found (with length between 0 and K)
           * @see [org.locationtech.jts.index.strtree.STRtree.nearestNeighbour](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#nearestNeighbour-org.locationtech.jts.geom.Envelope-java.lang.Object-org.locationtech.jts.index.strtree.ItemDistance-int-)
           */
          nearestNeighbourK(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, env: Envelope, item: any /* java.lang.Object */, itemDist: any /* org.locationtech.jts.index.strtree.ItemDistance */, k: number): any /* java.lang.Object */[];
          /**
           * Returns items whose bounds intersect the given envelope.
           *
           * @see [org.locationtech.jts.index.strtree.STRtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#query-org.locationtech.jts.geom.Envelope-)
           */
          query(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, searchEnv: Envelope): any /* java.util.List */;
          /**
           * Returns items whose bounds intersect the given envelope.
           *
           * @see [org.locationtech.jts.index.strtree.STRtree.query](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#query-org.locationtech.jts.geom.Envelope-org.locationtech.jts.index.ItemVisitor-)
           */
          queryVisit(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, searchEnv: Envelope, visitor: any /* org.locationtech.jts.index.ItemVisitor */): any /* void */;
          /**
           * Removes a single item from the tree.
           *
           * @param itemEnv - the Envelope of the item to remove
           * @param item - the item to remove
           * @returns `true` if the item was found
           * @see [org.locationtech.jts.index.strtree.STRtree.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#remove-org.locationtech.jts.geom.Envelope-java.lang.Object-)
           */
          remove(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */, itemEnv: Envelope, item: any /* java.lang.Object */): boolean;
          /**
           * Returns the number of items in the tree.
           *
           * @returns the number of items in the tree
           * @see [org.locationtech.jts.index.strtree.STRtree.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/index/strtree/STRtree.html#size--)
           */
          size(sTRtree: any /* org.locationtech.jts.index.strtree.STRtree */): number;
        };
      };
      sweepline: {
        SweepLineEvent: {
          DELETE: number;
          INSERT: number;
        };
        SweepLineIndex: {
          create0(): any /* org.locationtech.jts.index.sweepline.SweepLineIndex */;
        };
        SweepLineInterval: {
          create2(min: number, max: number): any /* org.locationtech.jts.index.sweepline.SweepLineInterval */;
          getMax(sweepLineInterval: any /* org.locationtech.jts.index.sweepline.SweepLineInterval */): number;
          getMin(sweepLineInterval: any /* org.locationtech.jts.index.sweepline.SweepLineInterval */): number;
        };
      };
    };
    io: {
      ByteArrayInStream: {
        /**
         * Creates a new stream based on the given buffer.
         *
         * @param buffer - the bytes to read
         * @see [org.locationtech.jts.io.ByteArrayInStream.ByteArrayInStream](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/ByteArrayInStream.html#ByteArrayInStream-byte:A-)
         */
        create1(buffer: number[]): any /* org.locationtech.jts.io.ByteArrayInStream */;
        /**
         * Reads up to `buf.length` bytes from the stream
         * into the given byte buffer.
         *
         * @param buf - the buffer to place the read bytes into
         * @returns the number of bytes read
         * @see [org.locationtech.jts.io.ByteArrayInStream.read](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/ByteArrayInStream.html#read-byte:A-)
         */
        read(byteArrayInStream: any /* org.locationtech.jts.io.ByteArrayInStream */, buf: number[]): number;
        /**
         * Sets this stream to read from the given buffer
         *
         * @param buffer - the bytes to read
         * @see [org.locationtech.jts.io.ByteArrayInStream.setBytes](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/ByteArrayInStream.html#setBytes-byte:A-)
         */
        setBytes(byteArrayInStream: any /* org.locationtech.jts.io.ByteArrayInStream */, buffer: number[]): any /* void */;
      };
      ByteOrderDataInStream: {
        create0(): any /* org.locationtech.jts.io.ByteOrderDataInStream */;
        /**
         * Gets the data item that was last read from the stream.
         *
         * @returns the data last read
         * @see [org.locationtech.jts.io.ByteOrderDataInStream.getData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/ByteOrderDataInStream.html#getData--)
         */
        getData(byteOrderDataInStream: any /* org.locationtech.jts.io.ByteOrderDataInStream */): number[];
        /**
         * Sets the ordering on the stream using the codes in `ByteOrderValues`.
         *
         * @param byteOrder - the byte order code
         * @see [org.locationtech.jts.io.ByteOrderDataInStream.setOrder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/ByteOrderDataInStream.html#setOrder-int-)
         */
        setOrder(byteOrderDataInStream: any /* org.locationtech.jts.io.ByteOrderDataInStream */, byteOrder: number): any /* void */;
      };
      ByteOrderValues: {
        BIG_ENDIAN: number;
        LITTLE_ENDIAN: number;
        getDouble(buf: number[], byteOrder: number): number;
        getInt(buf: number[], byteOrder: number): number;
        putDouble(doubleValue: number, buf: number[], byteOrder: number): any /* void */;
        putInt(intValue: number, buf: number[], byteOrder: number): any /* void */;
      };
      OrdinateFormat: {
        /**
         * The maximum number of fraction digits to support output of reasonable ordinate values.
         *
         * The default is chosen to allow representing the smallest possible IEEE-754 double-precision value,
         * although this is not expected to occur (and is not supported by other areas of the JTS code).
         *
         * @see [org.locationtech.jts.io.OrdinateFormat.MAX_FRACTION_DIGITS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/OrdinateFormat.html#MAX_FRACTION_DIGITS)
         */
        MAX_FRACTION_DIGITS: number;
        /**
         * Creates a new formatter with the given maximum number of digits in the fraction portion of a number.
         *
         * @param maximumFractionDigits - the maximum number of fraction digits to output
         * @returns a formatter
         * @see [org.locationtech.jts.io.OrdinateFormat.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/OrdinateFormat.html#create-int-)
         */
        create(maximumFractionDigits: number): any /* org.locationtech.jts.io.OrdinateFormat */;
        /**
         * Creates an OrdinateFormat using the default maximum number of fraction digits.
         *
         * @see [org.locationtech.jts.io.OrdinateFormat.OrdinateFormat](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/OrdinateFormat.html#OrdinateFormat--)
         */
        create0(): any /* org.locationtech.jts.io.OrdinateFormat */;
        /**
         * Creates an OrdinateFormat using the given maximum number of fraction digits.
         *
         * @param maximumFractionDigits - the maximum number of fraction digits to output
         * @see [org.locationtech.jts.io.OrdinateFormat.OrdinateFormat](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/OrdinateFormat.html#OrdinateFormat-int-)
         */
        create1(maximumFractionDigits: number): any /* org.locationtech.jts.io.OrdinateFormat */;
        /**
         * Returns a string representation of the given ordinate numeric value.
         *
         * @param ord - the ordinate value
         * @returns the formatted number string
         * @see [org.locationtech.jts.io.OrdinateFormat.format](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/OrdinateFormat.html#format-double-)
         */
        format(ordinateFormat: any /* org.locationtech.jts.io.OrdinateFormat */, ord: number): string;
      };
      WKBReader: {
        create0(): any /* org.locationtech.jts.io.WKBReader */;
        /**
         * Reads a single `Geometry` in WKB format from a byte array.
         *
         * @param bytes - the byte array to read from
         * @returns the geometry read
         * @throws ParseException if the WKB is ill-formed
         * @see [org.locationtech.jts.io.WKBReader.read](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKBReader.html#read-byte:A-)
         */
        read(wKBReader: any /* org.locationtech.jts.io.WKBReader */, bytes: number[]): Geometry;
      };
      WKBWriter: {
        /**
         * Creates a writer that writes `Geometry`s with
         * output dimension = 2 and BIG_ENDIAN byte order
         *
         * @see [org.locationtech.jts.io.WKBWriter.WKBWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKBWriter.html#WKBWriter--)
         */
        create0(): any /* org.locationtech.jts.io.WKBWriter */;
        /**
         * Creates a writer that writes `Geometry`s with
         * the given dimension (2 or 3) for output coordinates
         * and `ByteOrderValues.BIG_ENDIAN` byte order.
         * If the input geometry has a small coordinate dimension,
         * coordinates will be padded with `Coordinate.NULL_ORDINATE`.
         *
         * @param outputDimension - the coordinate dimension to output (2 or 3)
         * @see [org.locationtech.jts.io.WKBWriter.WKBWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKBWriter.html#WKBWriter-int-)
         */
        create1(outputDimension: number): any /* org.locationtech.jts.io.WKBWriter */;
        /**
         * Writes a `Geometry` into a byte array.
         *
         * @param geom - the geometry to write
         * @returns the byte array containing the WKB
         * @see [org.locationtech.jts.io.WKBWriter.write](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKBWriter.html#write-org.locationtech.jts.geom.Geometry-)
         */
        write(wKBWriter: any /* org.locationtech.jts.io.WKBWriter */, geom: Geometry): number[];
      };
      WKTReader: {
        /**
         * Creates a reader that creates objects using the default `GeometryFactory`.
         *
         * @see [org.locationtech.jts.io.WKTReader.WKTReader](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKTReader.html#WKTReader--)
         */
        create0(): any /* org.locationtech.jts.io.WKTReader */;
        /**
         * Reads a Well-Known Text representation of a `Geometry`
         * from a `String`.
         *
         * @param wellKnownText - one or more <Geometry Tagged Text> strings (see the OpenGIS Simple Features Specification) separated by whitespace
         * @returns a `Geometry` specified by `wellKnownText`
         * @throws ParseException if a parsing problem occurs
         * @see [org.locationtech.jts.io.WKTReader.read](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKTReader.html#read-java.lang.String-)
         */
        read(wKTReader: any /* org.locationtech.jts.io.WKTReader */, wellKnownText: string): Geometry;
      };
      WKTWriter: {
        /**
         * Creates a new WKTWriter with default settings
         *
         * @see [org.locationtech.jts.io.WKTWriter.WKTWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKTWriter.html#WKTWriter--)
         */
        create0(): any /* org.locationtech.jts.io.WKTWriter */;
        /**
         * Creates a writer that writes `Geometry`s with
         * the given output dimension (2 to 4).
         * The output follows the following rules:
         *
         * - If the specified **output dimension is 3** and the **z is measure flag
         * is set to true**, the Z value of coordinates will be written if it is present
         * (i.e. if it is not `Double.NaN`)
         * - If the specified **output dimension is 3** and the **z is measure flag
         * is set to false**, the Measure value of coordinates will be written if it is present
         * (i.e. if it is not `Double.NaN`)
         * - If the specified **output dimension is 4**, the Z value of coordinates will
         * be written even if it is not present when the Measure value is present. The Measure
         * value of coordinates will be written if it is present
         * (i.e. if it is not `Double.NaN`)
         *
         * See also `setOutputOrdinates`
         *
         * @param outputDimension - the coordinate dimension to output (2 to 4)
         * @see [org.locationtech.jts.io.WKTWriter.WKTWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKTWriter.html#WKTWriter-int-)
         */
        create1(outputDimension: number): any /* org.locationtech.jts.io.WKTWriter */;
        /**
         * Converts a `Geometry` to its Well-known Text representation.
         *
         * @param geometry - a `Geometry` to process
         * @returns a <Geometry Tagged Text> string (see the OpenGIS Simple Features Specification)
         * @see [org.locationtech.jts.io.WKTWriter.write](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/WKTWriter.html#write-org.locationtech.jts.geom.Geometry-)
         */
        write(wKTWriter: any /* org.locationtech.jts.io.WKTWriter */, geometry: Geometry): string;
      };
      geojson: {
        GeoJsonReader: {
          create0(): any /* org.locationtech.jts.io.geojson.GeoJsonReader */;
          read(geoJsonReader: any /* org.locationtech.jts.io.geojson.GeoJsonReader */, json: string): Geometry;
        };
        GeoJsonWriter: {
          create0(): any /* org.locationtech.jts.io.geojson.GeoJsonWriter */;
          create1(decimals: number): any /* org.locationtech.jts.io.geojson.GeoJsonWriter */;
          setEncodeCRS(geoJsonWriter: any /* org.locationtech.jts.io.geojson.GeoJsonWriter */, isEncodeCRS: boolean): any /* void */;
          setForceCCW(geoJsonWriter: any /* org.locationtech.jts.io.geojson.GeoJsonWriter */, isForceCCW: boolean): any /* void */;
          write(geoJsonWriter: any /* org.locationtech.jts.io.geojson.GeoJsonWriter */, geometry: Geometry): string;
        };
        OrientationTransformer: {
          transformCCW(geometry: Geometry): Geometry;
        };
      };
      gml2: {
        GMLWriter: {
          /**
           * Creates a writer which outputs GML with default settings.
           * The defaults are:
           *
           * - the namespace prefix is `gml:`
           * - no namespace prefix declaration is written
           * - no `srsName` attribute is written
           *
           * @see [org.locationtech.jts.io.gml2.GMLWriter.GMLWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#GMLWriter--)
           */
          create0(): any /* org.locationtech.jts.io.gml2.GMLWriter */;
          /**
           * Creates a writer which may emit the GML namespace prefix
           * declaration in the geometry root element.
           *
           * @param emitNamespace - true if the GML namespace prefix declaration should be written in the geometry root element
           * @see [org.locationtech.jts.io.gml2.GMLWriter.GMLWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#GMLWriter-boolean-)
           */
          create1(emitNamespace: boolean): any /* org.locationtech.jts.io.gml2.GMLWriter */;
          /**
           * Sets the number of coordinates printed per line.
           *
           * @param num
           * @see [org.locationtech.jts.io.gml2.GMLWriter.setMaxCoordinatesPerLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#setMaxCoordinatesPerLine-int-)
           */
          setMaxCoordinatesPerLine(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, num: number): any /* void */;
          /**
           * Determines whether a GML namespace declaration will be written in the
           * opening tag of geometries.  Useful in XML-aware environments which
           * parse the geometries before use, such as XSLT.
           *
           * @param emitNamespace - true if the GML namespace prefix declaration should be written in the root geometry element
           * @see [org.locationtech.jts.io.gml2.GMLWriter.setNamespace](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#setNamespace-boolean-)
           */
          setNamespace(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, emitNamespace: boolean): any /* void */;
          /**
           * Specifies the namespace prefix to write on each GML tag.
           * A null or blank prefix may be used to indicate no prefix.
           *
           * The default is to write `gml:` as the namespace prefix.
           *
           * @param prefix - the namespace prefix to use (`null` or blank if none)
           * @see [org.locationtech.jts.io.gml2.GMLWriter.setPrefix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#setPrefix-java.lang.String-)
           */
          setPrefix(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, prefix: string): any /* void */;
          /**
           * Sets the value of the `srsName` attribute
           * to be written into the root geometry tag.
           * If the value is `null` or blank no srsName attribute will be written.
           * The provided value must be a valid XML attribute value
           * - it will not be XML-escaped.
           *
           * The default is not to write the `srsName` attribute.
           *
           * @param srsName - the srsName attribute value
           * @see [org.locationtech.jts.io.gml2.GMLWriter.setSrsName](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#setSrsName-java.lang.String-)
           */
          setSrsName(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, srsName: string): any /* void */;
          /**
           * Sets the starting column index for pretty printing
           *
           * @param indent
           * @see [org.locationtech.jts.io.gml2.GMLWriter.setStartingIndentIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#setStartingIndentIndex-int-)
           */
          setStartingIndentIndex(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, indent: number): any /* void */;
          /**
           * Writes a `Geometry` in GML2 format to a String.
           *
           * @param geom
           * @returns String GML2 Encoded Geometry
           * @see [org.locationtech.jts.io.gml2.GMLWriter.write](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/gml2/GMLWriter.html#write-org.locationtech.jts.geom.Geometry-)
           */
          write(gMLWriter: any /* org.locationtech.jts.io.gml2.GMLWriter */, geom: Geometry): string;
        };
      };
      kml: {
        KMLReader: {
          /**
           * Creates a reader that creates objects using the default `GeometryFactory`.
           *
           * @see [org.locationtech.jts.io.kml.KMLReader.KMLReader](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLReader.html#KMLReader--)
           */
          create0(): any /* org.locationtech.jts.io.kml.KMLReader */;
          /**
           * Reads a KML representation of a `Geometry` from a `String`.
           * If any attribute names were specified during `KMLReader` construction,
           * they will be stored as `Map` in `Geometry.setUserData`
           *
           * @param kmlGeometryString - string that specifies kml representation of geometry
           * @returns a `Geometry` specified by `kmlGeometryString`
           * @throws ParseException if a parsing problem occurs
           * @see [org.locationtech.jts.io.kml.KMLReader.read](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLReader.html#read-java.lang.String-)
           */
          read(kMLReader: any /* org.locationtech.jts.io.kml.KMLReader */, kmlGeometryString: string): Geometry;
        };
        KMLWriter: {
          /**
           * Creates a new writer.
           *
           * @see [org.locationtech.jts.io.kml.KMLWriter.KMLWriter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#KMLWriter--)
           */
          create0(): any /* org.locationtech.jts.io.kml.KMLWriter */;
          /**
           * Sets the value output in the `altitudeMode` element.
           *
           * @param altitudeMode - string representing the altitude mode
           * @see [org.locationtech.jts.io.kml.KMLWriter.setAltitudeMode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setAltitudeMode-java.lang.String-)
           */
          setAltitudeMode(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, altitudeMode: string): any /* void */;
          /**
           * Sets the flag to be output in the `extrude` element.
           *
           * @param extrude - the extrude flag to output
           * @see [org.locationtech.jts.io.kml.KMLWriter.setExtrude](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setExtrude-boolean-)
           */
          setExtrude(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, extrude: boolean): any /* void */;
          /**
           * Sets a tag string which is prefixed to every emitted text line.
           * This can be used to indent the geometry text in a containing document.
           *
           * @param linePrefix - the tag string
           * @see [org.locationtech.jts.io.kml.KMLWriter.setLinePrefix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setLinePrefix-java.lang.String-)
           */
          setLinePrefix(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, linePrefix: string): any /* void */;
          /**
           * Sets the maximum number of coordinates to output per line.
           *
           * @param maxCoordinatesPerLine - the maximum number of coordinates to output
           * @see [org.locationtech.jts.io.kml.KMLWriter.setMaximumCoordinatesPerLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setMaximumCoordinatesPerLine-int-)
           */
          setMaximumCoordinatesPerLine(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, maxCoordinatesPerLine: number): any /* void */;
          /**
           * Sets the maximum number of decimal places to output in ordinate values.
           * Useful for limiting output size.
           *
           * @param precision - the number of decimal places to output
           * @see [org.locationtech.jts.io.kml.KMLWriter.setPrecision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setPrecision-int-)
           */
          setPrecision(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, precision: number): any /* void */;
          /**
           * Sets the flag to be output in the `tesselate` element.
           *
           * @param tesselate - the tesselate flag to output
           * @see [org.locationtech.jts.io.kml.KMLWriter.setTesselate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setTesselate-boolean-)
           */
          setTesselate(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, tesselate: boolean): any /* void */;
          /**
           * Sets the Z value to be output for all coordinates.
           * This overrides any Z value present in the Geometry coordinates.
           *
           * @param zVal - the Z value to output
           * @see [org.locationtech.jts.io.kml.KMLWriter.setZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#setZ-double-)
           */
          setZ(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, zVal: number): any /* void */;
          /**
           * Writes a `Geometry` in KML format as a string.
           *
           * @param geom - the geometry to write
           * @returns a string containing the KML geometry representation
           * @see [org.locationtech.jts.io.kml.KMLWriter.write](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/io/kml/KMLWriter.html#write-org.locationtech.jts.geom.Geometry-)
           */
          write(kMLWriter: any /* org.locationtech.jts.io.kml.KMLWriter */, geom: Geometry): string;
        };
      };
      twkb: {
        TWKBReader: {
          create0(): any /* org.locationtech.jts.io.twkb.TWKBReader */;
          read(tWKBReader: any /* org.locationtech.jts.io.twkb.TWKBReader */, bytes: number[]): Geometry;
        };
        TWKBWriter: {
          create0(): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setEncodeM(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, includeMDimension: boolean): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setEncodeZ(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, includeZDimension: boolean): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setIncludeBbox(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, includeBbox: boolean): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setIncludeSize(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, includeSize: boolean): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setMPrecision(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, mprecision: number): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setXYPrecision(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, xyprecision: number): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          setZPrecision(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, zprecision: number): any /* org.locationtech.jts.io.twkb.TWKBWriter */;
          write(tWKBWriter: any /* org.locationtech.jts.io.twkb.TWKBWriter */, geom: Geometry): number[];
        };
      };
    };
    linearref: {
      LengthIndexedLine: {
        /**
         * Computes a valid index for this line
         * by clamping the given index to the valid range of index values
         *
         * @returns a valid index value
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.clampIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#clampIndex-double-)
         */
        clampIndex(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, index: number): number;
        /**
         * Constructs an object which allows a linear `Geometry`
         * to be linearly referenced using length as an index.
         *
         * @param linearGeom - the linear geometry to reference along
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.LengthIndexedLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#LengthIndexedLine-org.locationtech.jts.geom.Geometry-)
         */
        create1(linearGeom: Geometry): any /* org.locationtech.jts.linearref.LengthIndexedLine */;
        /**
         * Computes the `LineString` for the interval
         * on the line between the given indices.
         * If the endIndex lies before the startIndex,
         * the computed geometry is reversed.
         *
         * @param startIndex - the index of the start of the interval
         * @param endIndex - the index of the end of the interval
         * @returns the linear interval between the indices
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.extractLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#extractLine-double-double-)
         */
        extractLine(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, startIndex: number, endIndex: number): Geometry;
        /**
         * Computes the `Coordinate` for the point
         * on the line at the given index, offset by the given distance.
         * If the index is out of range the first or last point on the
         * line will be returned.
         * The computed point is offset to the left of the line if the offset distance is
         * positive, to the right if negative.
         *
         * The Z-ordinate of the computed point will be interpolated from
         * the Z-ordinates of the line segment containing it, if they exist.
         *
         * @param index - the index of the desired point
         * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
         * @returns the Coordinate at the given index
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.extractPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#extractPoint-double-double-)
         */
        extractPoint(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, index: number, offsetDistance: number): Coordinate;
        /**
         * Returns the index of the end of the line
         *
         * @returns the end index
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.getEndIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#getEndIndex--)
         */
        getEndIndex(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */): number;
        /**
         * Returns the index of the start of the line
         *
         * @returns the start index
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.getStartIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#getStartIndex--)
         */
        getStartIndex(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */): number;
        /**
         * Computes the minimum index for a point on the line.
         * If the line is not simple (i.e. loops back on itself)
         * a single point may have more than one possible index.
         * In this case, the smallest index is returned.
         *
         * The supplied point does not _necessarily_ have to lie precisely
         * on the line, but if it is far from the line the accuracy and
         * performance of this function is not guaranteed.
         * Use `project` to compute a guaranteed result for points
         * which may be far from the line.
         *
         * @param pt - a point on the line
         * @returns the minimum index of the point
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.indexOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#indexOf-org.locationtech.jts.geom.Coordinate-)
         */
        indexOf(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, pt: Coordinate): number;
        /**
         * Finds the index for a point on the line
         * which is greater than the given index.
         * If no such index exists, returns `minIndex`.
         * This method can be used to determine all indexes for
         * a point which occurs more than once on a non-simple line.
         * It can also be used to disambiguate cases where the given point lies
         * slightly off the line and is equidistant from two different
         * points on the line.
         *
         * The supplied point does not _necessarily_ have to lie precisely
         * on the line, but if it is far from the line the accuracy and
         * performance of this function is not guaranteed.
         * Use `project` to compute a guaranteed result for points
         * which may be far from the line.
         *
         * @param pt - a point on the line
         * @param minIndex - the value the returned index must be greater than
         * @returns the index of the point greater than the given minimum index
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.indexOfAfter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#indexOfAfter-org.locationtech.jts.geom.Coordinate-double-)
         */
        indexOfAfter(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, pt: Coordinate, minIndex: number): number;
        /**
         * Computes the indices for a subline of the line.
         * (The subline must **conform** to the line; that is,
         * all vertices in the subline (except possibly the first and last)
         * must be vertices of the line and occur in the same order).
         *
         * @param subLine - a subLine of the line
         * @returns a pair of indices for the start and end of the subline.
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.indicesOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#indicesOf-org.locationtech.jts.geom.Geometry-)
         */
        indicesOf(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, subLine: Geometry): number[];
        /**
         * Tests whether an index is in the valid index range for the line.
         *
         * @param index - the index to test
         * @returns `true` if the index is in the valid range
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.isValidIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#isValidIndex-double-)
         */
        isValidIndex(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, index: number): boolean;
        /**
         * Computes the index for the closest point on the line to the given point.
         * If more than one point has the closest distance the first one along the line
         * is returned.
         * (The point does not necessarily have to lie precisely on the line.)
         *
         * @param pt - a point on the line
         * @returns the index of the point
         * @see [org.locationtech.jts.linearref.LengthIndexedLine.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthIndexedLine.html#project-org.locationtech.jts.geom.Coordinate-)
         */
        project(lengthIndexedLine: any /* org.locationtech.jts.linearref.LengthIndexedLine */, pt: Coordinate): number;
      };
      LengthLocationMap: {
        create1(linearGeom: Geometry): any /* org.locationtech.jts.linearref.LengthLocationMap */;
        /**
         * Computes the length for a given `LinearLocation`
         * on a linear `Geometry`.
         *
         * @param linearGeom - the linear geometry to use
         * @param loc - the `LinearLocation` index of the location
         * @returns the length for the `LinearLocation`
         * @see [org.locationtech.jts.linearref.LengthLocationMap.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthLocationMap.html#getLength-org.locationtech.jts.geom.Geometry-org.locationtech.jts.linearref.LinearLocation-)
         */
        getLength(linearGeom: Geometry, loc: any /* org.locationtech.jts.linearref.LinearLocation */): number;
        /**
         * Computes the `LinearLocation` for a
         * given length along a linear `Geometry`,
         * with control over how the location
         * is resolved at component endpoints.
         *
         * @param linearGeom - the linear geometry to use
         * @param length - the length index of the location
         * @param resolveLower - if true lengths are resolved to the lowest possible index
         * @returns the `LinearLocation` for the length
         * @see [org.locationtech.jts.linearref.LengthLocationMap.getLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LengthLocationMap.html#getLocation-org.locationtech.jts.geom.Geometry-double-boolean-)
         */
        getLocation(linearGeom: Geometry, length: number, resolveLower: boolean): any /* org.locationtech.jts.linearref.LinearLocation */;
      };
      LinearIterator: {
        /**
         * Creates an iterator initialized to the start of a linear `Geometry`
         *
         * @param linear - the linear geometry to iterate over
         * @throws IllegalArgumentException if linearGeom is not lineal
         * @see [org.locationtech.jts.linearref.LinearIterator.LinearIterator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#LinearIterator-org.locationtech.jts.geom.Geometry-)
         */
        create1(linear: Geometry): any /* org.locationtech.jts.linearref.LinearIterator */;
        /**
         * Creates an iterator starting at
         * a `LinearLocation` on a linear `Geometry`
         *
         * @param linear - the linear geometry to iterate over
         * @param start - the location to start at
         * @throws IllegalArgumentException if linearGeom is not lineal
         * @see [org.locationtech.jts.linearref.LinearIterator.LinearIterator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#LinearIterator-org.locationtech.jts.geom.Geometry-org.locationtech.jts.linearref.LinearLocation-)
         */
        create2(linear: Geometry, start: any /* org.locationtech.jts.linearref.LinearLocation */): any /* org.locationtech.jts.linearref.LinearIterator */;
        /**
         * Creates an iterator starting at
         * a specified component and vertex in a linear `Geometry`
         *
         * @param linearGeom - the linear geometry to iterate over
         * @param componentIndex - the component to start at
         * @param vertexIndex - the vertex to start at
         * @throws IllegalArgumentException if linearGeom is not lineal
         * @see [org.locationtech.jts.linearref.LinearIterator.LinearIterator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#LinearIterator-org.locationtech.jts.geom.Geometry-int-int-)
         */
        create3(linearGeom: Geometry, componentIndex: number, vertexIndex: number): any /* org.locationtech.jts.linearref.LinearIterator */;
        /**
         * The component index of the vertex the iterator is currently at.
         *
         * @returns the current component index
         * @see [org.locationtech.jts.linearref.LinearIterator.getComponentIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#getComponentIndex--)
         */
        getComponentIndex(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): number;
        /**
         * Gets the `LineString` component the iterator is current at.
         *
         * @returns a linestring
         * @see [org.locationtech.jts.linearref.LinearIterator.getLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#getLine--)
         */
        getLine(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): Geometry;
        /**
         * Gets the second `Coordinate` of the current segment.
         * (the coordinate of the next vertex).
         * If the iterator is at the end of a line, `null` is returned.
         *
         * @returns a `Coordinate` or `null`
         * @see [org.locationtech.jts.linearref.LinearIterator.getSegmentEnd](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#getSegmentEnd--)
         */
        getSegmentEnd(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): Coordinate;
        /**
         * Gets the first `Coordinate` of the current segment.
         * (the coordinate of the current vertex).
         *
         * @returns a `Coordinate`
         * @see [org.locationtech.jts.linearref.LinearIterator.getSegmentStart](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#getSegmentStart--)
         */
        getSegmentStart(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): Coordinate;
        /**
         * The vertex index of the vertex the iterator is currently at.
         *
         * @returns the current vertex index
         * @see [org.locationtech.jts.linearref.LinearIterator.getVertexIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#getVertexIndex--)
         */
        getVertexIndex(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): number;
        /**
         * Tests whether there are any vertices left to iterator over.
         * Specifically, hasNext() return `true` if the
         * current state of the iterator represents a valid location
         * on the linear geometry.
         *
         * @returns `true` if there are more vertices to scan
         * @see [org.locationtech.jts.linearref.LinearIterator.hasNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#hasNext--)
         */
        hasNext(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): boolean;
        /**
         * Checks whether the iterator cursor is pointing to the
         * endpoint of a component `LineString`.
         *
         * @returns `true` if the iterator is at an endpoint
         * @see [org.locationtech.jts.linearref.LinearIterator.isEndOfLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#isEndOfLine--)
         */
        isEndOfLine(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): boolean;
        /**
         * Moves the iterator ahead to the next vertex and (possibly) linear component.
         *
         * @see [org.locationtech.jts.linearref.LinearIterator.next](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearIterator.html#next--)
         */
        next(linearIterator: any /* org.locationtech.jts.linearref.LinearIterator */): any /* void */;
      };
      LinearLocation: {
        /**
         * Ensures the indexes are valid for a given linear `Geometry`.
         *
         * @param linear - a linear geometry
         * @see [org.locationtech.jts.linearref.LinearLocation.clamp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#clamp-org.locationtech.jts.geom.Geometry-)
         */
        clamp(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linear: Geometry): any /* void */;
        /**
         * Compares two sets of location values for order.
         *
         * @param componentIndex0 - a component index
         * @param segmentIndex0 - a segment index
         * @param segmentFraction0 - a segment fraction
         * @param componentIndex1 - another component index
         * @param segmentIndex1 - another segment index
         * @param segmentFraction1 - another segment fraction
         * @returns a negative integer, zero, or a positive integer as the first set of location values is less than, equal to, or greater than the second set of locationValues
         * @see [org.locationtech.jts.linearref.LinearLocation.compareLocationValues](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#compareLocationValues-int-int-double-int-int-double-)
         */
        compareLocationValues(componentIndex0: number, segmentIndex0: number, segmentFraction0: number, componentIndex1: number, segmentIndex1: number, segmentFraction1: number): number;
        /**
         * Copies this location
         *
         * @returns a copy of this location
         * @see [org.locationtech.jts.linearref.LinearLocation.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#copy--)
         */
        copy(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Creates a location referring to the start of a linear geometry
         *
         * @see [org.locationtech.jts.linearref.LinearLocation.LinearLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#LinearLocation--)
         */
        create0(): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Creates a new location equal to a given one.
         *
         * @param loc - a LinearLocation
         * @see [org.locationtech.jts.linearref.LinearLocation.LinearLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#LinearLocation-org.locationtech.jts.linearref.LinearLocation-)
         */
        create1(loc: any /* org.locationtech.jts.linearref.LinearLocation */): any /* org.locationtech.jts.linearref.LinearLocation */;
        create2(segmentIndex: number, segmentFraction: number): any /* org.locationtech.jts.linearref.LinearLocation */;
        create3(componentIndex: number, segmentIndex: number, segmentFraction: number): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Gets the component index for this location.
         *
         * @returns the component index
         * @see [org.locationtech.jts.linearref.LinearLocation.getComponentIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getComponentIndex--)
         */
        getComponentIndex(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */): number;
        /**
         * Gets the `Coordinate` along the
         * given linear `Geometry` which is
         * referenced by this location.
         *
         * @param linearGeom - the linear geometry referenced by this location
         * @returns the `Coordinate` at the location
         * @see [org.locationtech.jts.linearref.LinearLocation.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getCoordinate-org.locationtech.jts.geom.Geometry-)
         */
        getCoordinate(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): Coordinate;
        /**
         * Gets a location which refers to the end of a linear `Geometry`.
         *
         * @param linear - the linear geometry
         * @returns a new `LinearLocation`
         * @see [org.locationtech.jts.linearref.LinearLocation.getEndLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getEndLocation-org.locationtech.jts.geom.Geometry-)
         */
        getEndLocation(linear: Geometry): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Gets a `LineSegment` representing the segment of the
         * given linear `Geometry` which contains this location.
         *
         * @param linearGeom - a linear geometry
         * @returns the `LineSegment` containing the location
         * @see [org.locationtech.jts.linearref.LinearLocation.getSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getSegment-org.locationtech.jts.geom.Geometry-)
         */
        getSegment(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): LineSegment;
        /**
         * Gets the segment fraction for this location
         *
         * @returns the segment fraction
         * @see [org.locationtech.jts.linearref.LinearLocation.getSegmentFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getSegmentFraction--)
         */
        getSegmentFraction(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */): number;
        /**
         * Gets the segment index for this location
         *
         * @returns the segment index
         * @see [org.locationtech.jts.linearref.LinearLocation.getSegmentIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getSegmentIndex--)
         */
        getSegmentIndex(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */): number;
        /**
         * Gets the length of the segment in the given
         * Geometry containing this location.
         *
         * @param linearGeom - a linear geometry
         * @returns the length of the segment
         * @see [org.locationtech.jts.linearref.LinearLocation.getSegmentLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#getSegmentLength-org.locationtech.jts.geom.Geometry-)
         */
        getSegmentLength(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): number;
        /**
         * Tests whether this location is an endpoint of
         * the linear component it refers to.
         *
         * @param linearGeom - the linear geometry referenced by this location
         * @returns true if the location is a component endpoint
         * @see [org.locationtech.jts.linearref.LinearLocation.isEndpoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#isEndpoint-org.locationtech.jts.geom.Geometry-)
         */
        isEndpoint(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): boolean;
        /**
         * Tests whether two locations
         * are on the same segment in the parent `Geometry`.
         *
         * @param loc - a location on the same geometry
         * @returns true if the locations are on the same segment of the parent geometry
         * @see [org.locationtech.jts.linearref.LinearLocation.isOnSameSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#isOnSameSegment-org.locationtech.jts.linearref.LinearLocation-)
         */
        isOnSameSegment(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, loc: any /* org.locationtech.jts.linearref.LinearLocation */): boolean;
        /**
         * Tests whether this location refers to a valid
         * location on the given linear `Geometry`.
         *
         * @param linearGeom - a linear geometry
         * @returns true if this location is valid
         * @see [org.locationtech.jts.linearref.LinearLocation.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#isValid-org.locationtech.jts.geom.Geometry-)
         */
        isValid(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): boolean;
        /**
         * Tests whether this location refers to a vertex
         *
         * @returns true if the location is a vertex
         * @see [org.locationtech.jts.linearref.LinearLocation.isVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#isVertex--)
         */
        isVertex(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */): boolean;
        /**
         * Computes the `Coordinate` of a point a given fraction
         * along the line segment `(p0, p1)`.
         * If the fraction is greater than 1.0 the last
         * point of the segment is returned.
         * If the fraction is less than or equal to 0.0 the first point
         * of the segment is returned.
         * The Z ordinate is interpolated from the Z-ordinates of the given points,
         * if they are specified.
         *
         * @param p0 - the first point of the line segment
         * @param p1 - the last point of the line segment
         * @param frac - the length to the desired point
         * @returns the `Coordinate` of the desired point
         * @see [org.locationtech.jts.linearref.LinearLocation.pointAlongSegmentByFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#pointAlongSegmentByFraction-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-double-)
         */
        pointAlongSegmentByFraction(p0: Coordinate, p1: Coordinate, frac: number): Coordinate;
        /**
         * Sets the value of this location to
         * refer to the end of a linear geometry.
         *
         * @param linear - the linear geometry to use to set the end
         * @see [org.locationtech.jts.linearref.LinearLocation.setToEnd](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#setToEnd-org.locationtech.jts.geom.Geometry-)
         */
        setToEnd(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linear: Geometry): any /* void */;
        /**
         * Snaps the value of this location to
         * the nearest vertex on the given linear `Geometry`,
         * if the vertex is closer than `minDistance`.
         *
         * @param linearGeom - a linear geometry
         * @param minDistance - the minimum allowable distance to a vertex
         * @see [org.locationtech.jts.linearref.LinearLocation.snapToVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#snapToVertex-org.locationtech.jts.geom.Geometry-double-)
         */
        snapToVertex(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry, minDistance: number): any /* void */;
        /**
         * Converts a linear location to the lowest equivalent location index.
         * The lowest index has the lowest possible component and segment indices.
         *
         * Specifically:
         *
         * - if the location point is an endpoint, a location value is returned as (nseg-1, 1.0)
         * - if the location point is ambiguous (i.e. an endpoint and a startpoint), the lowest endpoint location is returned
         *
         * If the location index is already the lowest possible value, the original location is returned.
         *
         * @param linearGeom - the linear geometry referenced by this location
         * @returns the lowest equivalent location
         * @see [org.locationtech.jts.linearref.LinearLocation.toLowest](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LinearLocation.html#toLowest-org.locationtech.jts.geom.Geometry-)
         */
        toLowest(linearLocation: any /* org.locationtech.jts.linearref.LinearLocation */, linearGeom: Geometry): any /* org.locationtech.jts.linearref.LinearLocation */;
      };
      LocationIndexedLine: {
        /**
         * Computes a valid index for this line
         * by clamping the given index to the valid range of index values
         *
         * @returns a valid index value
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.clampIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#clampIndex-org.locationtech.jts.linearref.LinearLocation-)
         */
        clampIndex(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, index: any /* org.locationtech.jts.linearref.LinearLocation */): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Constructs an object which allows linear referencing along
         * a given linear `Geometry`.
         *
         * @param linearGeom - the linear geometry to reference along
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.LocationIndexedLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#LocationIndexedLine-org.locationtech.jts.geom.Geometry-)
         */
        create1(linearGeom: Geometry): any /* org.locationtech.jts.linearref.LocationIndexedLine */;
        /**
         * Computes the `LineString` for the interval
         * on the line between the given indices.
         * If the start location is after the end location,
         * the computed linear geometry has reverse orientation to the input line.
         *
         * @param startIndex - the index of the start of the interval
         * @param endIndex - the index of the end of the interval
         * @returns the linear geometry between the indices
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.extractLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#extractLine-org.locationtech.jts.linearref.LinearLocation-org.locationtech.jts.linearref.LinearLocation-)
         */
        extractLine(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, startIndex: any /* org.locationtech.jts.linearref.LinearLocation */, endIndex: any /* org.locationtech.jts.linearref.LinearLocation */): Geometry;
        /**
         * Computes the `Coordinate` for the point
         * on the line at the given index, offset by the given distance.
         * If the index is out of range the first or last point on the
         * line will be returned.
         * The computed point is offset to the left of the line if the offset distance is
         * positive, to the right if negative.
         *
         * The Z-ordinate of the computed point will be interpolated from
         * the Z-ordinates of the line segment containing it, if they exist.
         *
         * @param index - the index of the desired point
         * @param offsetDistance - the distance the point is offset from the segment (positive is to the left, negative is to the right)
         * @returns the Coordinate at the given index
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.extractPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#extractPoint-org.locationtech.jts.linearref.LinearLocation-double-)
         */
        extractPoint(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, index: any /* org.locationtech.jts.linearref.LinearLocation */, offsetDistance: number): Coordinate;
        /**
         * Returns the index of the end of the line
         *
         * @returns the location index
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.getEndIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#getEndIndex--)
         */
        getEndIndex(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Returns the index of the start of the line
         *
         * @returns the location index
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.getStartIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#getStartIndex--)
         */
        getStartIndex(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Computes the index for a given point on the line.
         *
         * The supplied point does not _necessarily_ have to lie precisely
         * on the line, but if it is far from the line the accuracy and
         * performance of this function is not guaranteed.
         * Use `project` to compute a guaranteed result for points
         * which may be far from the line.
         *
         * @param pt - a point on the line
         * @returns the index of the point
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.indexOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#indexOf-org.locationtech.jts.geom.Coordinate-)
         */
        indexOf(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, pt: Coordinate): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Finds the index for a point on the line
         * which is greater than the given index.
         * If no such index exists, returns `minIndex`.
         * This method can be used to determine all indexes for
         * a point which occurs more than once on a non-simple line.
         * It can also be used to disambiguate cases where the given point lies
         * slightly off the line and is equidistant from two different
         * points on the line.
         *
         * The supplied point does not _necessarily_ have to lie precisely
         * on the line, but if it is far from the line the accuracy and
         * performance of this function is not guaranteed.
         * Use `project` to compute a guaranteed result for points
         * which may be far from the line.
         *
         * @param pt - a point on the line
         * @param minIndex - the value the returned index must be greater than
         * @returns the index of the point greater than the given minimum index
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.indexOfAfter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#indexOfAfter-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.linearref.LinearLocation-)
         */
        indexOfAfter(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, pt: Coordinate, minIndex: any /* org.locationtech.jts.linearref.LinearLocation */): any /* org.locationtech.jts.linearref.LinearLocation */;
        /**
         * Computes the indices for a subline of the line.
         * (The subline must _conform_ to the line; that is,
         * all vertices in the subline (except possibly the first and last)
         * must be vertices of the line and occur in the same order).
         *
         * @param subLine - a subLine of the line
         * @returns a pair of indices for the start and end of the subline.
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.indicesOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#indicesOf-org.locationtech.jts.geom.Geometry-)
         */
        indicesOf(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, subLine: Geometry): any /* org.locationtech.jts.linearref.LinearLocation */[];
        /**
         * Tests whether an index is in the valid index range for the line.
         *
         * @param index - the index to test
         * @returns `true` if the index is in the valid range
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.isValidIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#isValidIndex-org.locationtech.jts.linearref.LinearLocation-)
         */
        isValidIndex(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, index: any /* org.locationtech.jts.linearref.LinearLocation */): boolean;
        /**
         * Computes the index for the closest point on the line to the given point.
         * If more than one point has the closest distance the first one along the line
         * is returned.
         * (The point does not necessarily have to lie precisely on the line.)
         *
         * @param pt - a point on the line
         * @returns the index of the point
         * @see [org.locationtech.jts.linearref.LocationIndexedLine.project](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/linearref/LocationIndexedLine.html#project-org.locationtech.jts.geom.Coordinate-)
         */
        project(locationIndexedLine: any /* org.locationtech.jts.linearref.LocationIndexedLine */, pt: Coordinate): any /* org.locationtech.jts.linearref.LinearLocation */;
      };
    };
    math: {
      DD: {
        /**
         * The smallest representable relative difference between two {link @ DoubleDouble} values
         *
         * @see [org.locationtech.jts.math.DD.EPS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#EPS)
         */
        EPS: number;
        /**
         * Returns the absolute value of this value.
         * Special cases:
         *
         * - If this value is NaN, it is returned.
         *
         * @returns the absolute value of this value
         * @see [org.locationtech.jts.math.DD.abs](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#abs--)
         */
        abs(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns a new DoubleDouble whose value is `(this + y)`.
         *
         * @param y - the addend
         * @returns `(this + y)`
         * @see [org.locationtech.jts.math.DD.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#add-double-)
         */
        add(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns the smallest (closest to negative infinity) value
         * that is not less than the argument and is equal to a mathematical integer.
         * Special cases:
         *
         * - If this value is NaN, returns NaN.
         *
         * @returns the smallest (closest to negative infinity) value that is not less than the argument and is equal to a mathematical integer.
         * @see [org.locationtech.jts.math.DD.ceil](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#ceil--)
         */
        ceil(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Creates a new DoubleDouble with the value of the argument.
         *
         * @param dd - the DoubleDouble value to copy
         * @returns a copy of the input value
         * @see [org.locationtech.jts.math.DD.copy](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#copy-org.locationtech.jts.math.DD-)
         */
        copy(dd: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Creates a new DoubleDouble with value 0.0.
         *
         * @see [org.locationtech.jts.math.DD.DD](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#DD--)
         */
        create0(): any /* org.locationtech.jts.math.DD */;
        /**
         * Creates a new DoubleDouble with value x.
         *
         * @param x - the value to initialize
         * @see [org.locationtech.jts.math.DD.DD](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#DD-double-)
         */
        create1(x: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Creates a new DoubleDouble with value (hi, lo).
         *
         * @param hi - the high-order component
         * @param lo - the high-order component
         * @see [org.locationtech.jts.math.DD.DD](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#DD-double-double-)
         */
        create2(hi: number, lo: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Computes the determinant of the 2x2 matrix with the given entries.
         *
         * @param x1 - a double value
         * @param y1 - a double value
         * @param x2 - a double value
         * @param y2 - a double value
         * @returns the determinant of the values
         * @see [org.locationtech.jts.math.DD.determinant](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#determinant-double-double-double-double-)
         */
        determinant(x1: number, y1: number, x2: number, y2: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Computes a new DoubleDouble whose value is `(this / y)`.
         *
         * @param y - the divisor
         * @returns a new object with the value `(this / y)`
         * @see [org.locationtech.jts.math.DD.divide](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#divide-double-)
         */
        divide(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Converts this value to the nearest double-precision number.
         *
         * @returns the nearest double-precision number to this value
         * @see [org.locationtech.jts.math.DD.doubleValue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#doubleValue--)
         */
        doubleValue(dD: any /* org.locationtech.jts.math.DD */): number;
        /**
         * Dumps the components of this number to a string.
         *
         * @returns a string showing the components of the number
         * @see [org.locationtech.jts.math.DD.dump](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#dump--)
         */
        dump(dD: any /* org.locationtech.jts.math.DD */): string;
        /**
         * Tests whether this value is equal to another `DoubleDouble` value.
         *
         * @param y - a DoubleDouble value
         * @returns true if this value = y
         * @see [org.locationtech.jts.math.DD.equals](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#equals-org.locationtech.jts.math.DD-)
         */
        equals(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Returns the largest (closest to positive infinity)
         * value that is not greater than the argument
         * and is equal to a mathematical integer.
         * Special cases:
         *
         * - If this value is NaN, returns NaN.
         *
         * @returns the largest (closest to positive infinity) value that is not greater than the argument and is equal to a mathematical integer.
         * @see [org.locationtech.jts.math.DD.floor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#floor--)
         */
        floor(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Tests whether this value is greater than or equals to another `DoubleDouble` value.
         *
         * @param y - a DoubleDouble value
         * @returns true if this value >= y
         * @see [org.locationtech.jts.math.DD.ge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#ge-org.locationtech.jts.math.DD-)
         */
        ge(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is greater than another `DoubleDouble` value.
         *
         * @param y - a DoubleDouble value
         * @returns true if this value > y
         * @see [org.locationtech.jts.math.DD.gt](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#gt-org.locationtech.jts.math.DD-)
         */
        gt(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Converts this value to the nearest integer.
         *
         * @returns the nearest integer to this value
         * @see [org.locationtech.jts.math.DD.intValue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#intValue--)
         */
        intValue(dD: any /* org.locationtech.jts.math.DD */): number;
        /**
         * Tests whether this value is NaN.
         *
         * @returns true if this value is NaN
         * @see [org.locationtech.jts.math.DD.isNaN](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#isNaN--)
         */
        isNaN(dD: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is less than 0.
         *
         * @returns true if this value is less than 0
         * @see [org.locationtech.jts.math.DD.isNegative](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#isNegative--)
         */
        isNegative(dD: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is greater than 0.
         *
         * @returns true if this value is greater than 0
         * @see [org.locationtech.jts.math.DD.isPositive](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#isPositive--)
         */
        isPositive(dD: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is equal to 0.
         *
         * @returns true if this value is equal to 0
         * @see [org.locationtech.jts.math.DD.isZero](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#isZero--)
         */
        isZero(dD: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is less than or equal to another `DoubleDouble` value.
         *
         * @param y - a DoubleDouble value
         * @returns true if this value <= y
         * @see [org.locationtech.jts.math.DD.le](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#le-org.locationtech.jts.math.DD-)
         */
        le(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Tests whether this value is less than another `DoubleDouble` value.
         *
         * @param y - a DoubleDouble value
         * @returns true if this value < y
         * @see [org.locationtech.jts.math.DD.lt](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#lt-org.locationtech.jts.math.DD-)
         */
        lt(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): boolean;
        /**
         * Computes the maximum of this and another DD number.
         *
         * @param x - a DD number
         * @returns the maximum of the two numbers
         * @see [org.locationtech.jts.math.DD.max](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#max-org.locationtech.jts.math.DD-)
         */
        max(dD: any /* org.locationtech.jts.math.DD */, x: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Computes the minimum of this and another DD number.
         *
         * @param x - a DD number
         * @returns the minimum of the two numbers
         * @see [org.locationtech.jts.math.DD.min](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#min-org.locationtech.jts.math.DD-)
         */
        min(dD: any /* org.locationtech.jts.math.DD */, x: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns a new DoubleDouble whose value is `(this * y)`.
         *
         * @param y - the multiplicand
         * @returns `(this * y)`
         * @see [org.locationtech.jts.math.DD.multiply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#multiply-double-)
         */
        multiply(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns a new DoubleDouble whose value is `-this`.
         *
         * @returns `-this`
         * @see [org.locationtech.jts.math.DD.negate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#negate--)
         */
        negate(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Converts a string representation of a real number into a DoubleDouble value.
         * The format accepted is similar to the standard Java real number syntax.
         * It is defined by the following regular expression:
         *
         * ```
         * [+|-] {digit} [ . {digit} ] [ ( e | E ) [+|-] {digit}+
         * ```
         *
         * @param str - the string to parse
         * @returns the value of the parsed number
         * @throws NumberFormatException if `str` is not a valid representation of a number
         * @see [org.locationtech.jts.math.DD.parse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#parse-java.lang.String-)
         */
        parse(str: string): any /* org.locationtech.jts.math.DD */;
        /**
         * Computes the value of this number raised to an integral power.
         * Follows semantics of Java Math.pow as closely as possible.
         *
         * @param exp - the integer exponent
         * @returns x raised to the integral power exp
         * @see [org.locationtech.jts.math.DD.pow](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#pow-int-)
         */
        pow(dD: any /* org.locationtech.jts.math.DD */, exp: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns a DoubleDouble whose value is  `1 / this`.
         *
         * @returns the reciprocal of this value
         * @see [org.locationtech.jts.math.DD.reciprocal](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#reciprocal--)
         */
        reciprocal(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Rounds this value to the nearest integer.
         * The value is rounded to an integer by adding 1/2 and taking the floor of the result.
         * Special cases:
         *
         * - If this value is NaN, returns NaN.
         *
         * @returns this value rounded to the nearest integer
         * @see [org.locationtech.jts.math.DD.rint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#rint--)
         */
        rint(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Adds the argument to the value of `this`.
         * To prevent altering constants,
         * this method **must only** be used on values known to
         * be newly created.
         *
         * @param y - the addend
         * @returns this object, increased by y
         * @see [org.locationtech.jts.math.DD.selfAdd](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#selfAdd-org.locationtech.jts.math.DD-)
         */
        selfAdd(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Divides this object by the argument, returning `this`.
         * To prevent altering constants,
         * this method **must only** be used on values known to
         * be newly created.
         *
         * @param y - the value to divide by
         * @returns this object, divided by y
         * @see [org.locationtech.jts.math.DD.selfDivide](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#selfDivide-double-)
         */
        selfDivide(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Multiplies this object by the argument, returning `this`.
         * To prevent altering constants,
         * this method **must only** be used on values known to
         * be newly created.
         *
         * @param y - the value to multiply by
         * @returns this object, multiplied by y
         * @see [org.locationtech.jts.math.DD.selfMultiply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#selfMultiply-double-)
         */
        selfMultiply(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Squares this object.
         * To prevent altering constants,
         * this method **must only** be used on values known to
         * be newly created.
         *
         * @returns the square of this value.
         * @see [org.locationtech.jts.math.DD.selfSqr](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#selfSqr--)
         */
        selfSqr(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Subtracts the argument from the value of `this`.
         * To prevent altering constants,
         * this method **must only** be used on values known to
         * be newly created.
         *
         * @param y - the addend
         * @returns this object, decreased by y
         * @see [org.locationtech.jts.math.DD.selfSubtract](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#selfSubtract-double-)
         */
        selfSubtract(dD: any /* org.locationtech.jts.math.DD */, y: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Set the value for the DD object. This method supports the mutating
         * operations concept described in the class documentation (see above).
         *
         * @param value - a floating point value to be stored in the instance.
         * @returns a self-reference to the DD instance.
         * @see [org.locationtech.jts.math.DD.setValue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#setValue-double-)
         */
        setValue(dD: any /* org.locationtech.jts.math.DD */, value: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns an integer indicating the sign of this value.
         *
         * - if this value is > 0, returns 1
         * - if this value is < 0, returns -1
         * - if this value is = 0, returns 0
         * - if this value is NaN, returns 0
         *
         * @returns an integer indicating the sign of this value
         * @see [org.locationtech.jts.math.DD.signum](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#signum--)
         */
        signum(dD: any /* org.locationtech.jts.math.DD */): number;
        /**
         * Computes the square of this value.
         *
         * @returns the square of this value.
         * @see [org.locationtech.jts.math.DD.sqr](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#sqr-double-)
         */
        sqr(x: number): any /* org.locationtech.jts.math.DD */;
        sqrt(x: number): any /* org.locationtech.jts.math.DD */;
        /**
         * Computes a new DoubleDouble object whose value is `(this - y)`.
         *
         * @param y - the subtrahend
         * @returns `(this - y)`
         * @see [org.locationtech.jts.math.DD.subtract](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#subtract-org.locationtech.jts.math.DD-)
         */
        subtract(dD: any /* org.locationtech.jts.math.DD */, y: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Returns the string representation of this value in scientific notation.
         *
         * @returns the string representation in scientific notation
         * @see [org.locationtech.jts.math.DD.toSciNotation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#toSciNotation--)
         */
        toSciNotation(dD: any /* org.locationtech.jts.math.DD */): string;
        /**
         * Returns the string representation of this value in standard notation.
         *
         * @returns the string representation in standard notation
         * @see [org.locationtech.jts.math.DD.toStandardNotation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#toStandardNotation--)
         */
        toStandardNotation(dD: any /* org.locationtech.jts.math.DD */): string;
        /**
         * Returns the integer which is largest in absolute value and not further
         * from zero than this value.
         * Special cases:
         *
         * - If this value is NaN, returns NaN.
         *
         * @returns the integer which is largest in absolute value and not further from zero than this value
         * @see [org.locationtech.jts.math.DD.trunc](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#trunc--)
         */
        trunc(dD: any /* org.locationtech.jts.math.DD */): any /* org.locationtech.jts.math.DD */;
        /**
         * Converts the string argument to a DoubleDouble number.
         *
         * @param str - a string containing a representation of a numeric value
         * @returns the extended precision version of the value
         * @throws NumberFormatException if `s` is not a valid representation of a number
         * @see [org.locationtech.jts.math.DD.valueOf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/DD.html#valueOf-java.lang.String-)
         */
        valueOf(str: string): any /* org.locationtech.jts.math.DD */;
      };
      MathUtil: {
        /**
         * The inverse of the Golden Ratio phi.
         *
         * @see [org.locationtech.jts.math.MathUtil.PHI_INV](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#PHI_INV)
         */
        PHI_INV: number;
        /**
         * Computes the average of two numbers.
         *
         * @param x1 - a number
         * @param x2 - a number
         * @returns the average of the inputs
         * @see [org.locationtech.jts.math.MathUtil.average](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#average-double-double-)
         */
        average(x1: number, x2: number): number;
        /**
         * Computes the ceiling function of the dividend of two integers.
         *
         * @param num - the numerator
         * @param denom - the denominator
         * @returns the ceiling of num / denom
         * @see [org.locationtech.jts.math.MathUtil.ceil](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#ceil-int-int-)
         */
        ceil(num: number, denom: number): number;
        /**
         * Clamps an `int` value to a given range.
         *
         * @param x - the value to clamp
         * @param min - the minimum value of the range
         * @param max - the maximum value of the range
         * @returns the clamped value
         * @see [org.locationtech.jts.math.MathUtil.clamp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#clamp-int-int-int-)
         */
        clamp(x: number, min: number, max: number): number;
        /**
         * Clamps an integer to a given maximum limit.
         *
         * @param x - the value to clamp
         * @param max - the maximum value
         * @returns the clamped value
         * @see [org.locationtech.jts.math.MathUtil.clampMax](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#clampMax-int-int-)
         */
        clampMax(x: number, max: number): number;
        /**
         * Computes the base-10 logarithm of a `double` value.
         *
         * - If the argument is NaN or less than zero, then the result is NaN.
         * - If the argument is positive infinity, then the result is positive infinity.
         * - If the argument is positive zero or negative zero, then the result is negative infinity.
         *
         * @param x - a positive number
         * @returns the value log a, the base-10 logarithm of the input value
         * @see [org.locationtech.jts.math.MathUtil.log10](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#log10-double-)
         */
        log10(x: number): number;
        max(v1: number, v2: number, v3: number, v4: number): number;
        min(v1: number, v2: number, v3: number, v4: number): number;
        /**
         * Generates a quasi-random sequence of numbers in the range [0,1].
         * They are produced by an additive recurrence with constant α.
         *
         * ```
         * R(α) :  tn = { t0 + nα },  n = 1,2,3,...
         * ```
         *
         * When α is irrational this produces a
         * [Low discrepancy sequence](https://en.wikipedia.org/wiki/Low-discrepancy_sequence#Additive_recurrence)
         * which is more evenly
         * distributed than random numbers.
         *
         * The sequence is initialized by calling it
         * with any positive fractional number. 0 works well for most uses.
         *
         * @param curr - the current number in the sequence
         * @param alpha - the sequence additive constant
         * @returns the next value in the sequence
         * @see [org.locationtech.jts.math.MathUtil.quasirandom](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#quasirandom-double-double-)
         */
        quasirandom(curr: number, alpha: number): number;
        /**
         * Computes an index which wraps around a given maximum value.
         * For values >= 0, this is equals to `val % max`.
         * For values < 0, this is equal to `max - (-val) % max`
         *
         * @param index - the value to wrap
         * @param max - the maximum value (or modulus)
         * @returns the wrapped index
         * @see [org.locationtech.jts.math.MathUtil.wrap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/MathUtil.html#wrap-int-int-)
         */
        wrap(index: number, max: number): number;
      };
      Plane3D: {
        /**
         * Enums for the 3 coordinate planes
         *
         * @see [org.locationtech.jts.math.Plane3D.XY_PLANE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Plane3D.html#XY_PLANE)
         */
        XY_PLANE: number;
        XZ_PLANE: number;
        YZ_PLANE: number;
        /**
         * Computes the axis plane that this plane lies closest to.
         *
         * Geometries lying in this plane undergo least distortion
         * (and have maximum area)
         * when projected to the closest axis plane.
         * This provides optimal conditioning for
         * computing a Point-in-Polygon test.
         *
         * @returns the index of the closest axis plane.
         * @see [org.locationtech.jts.math.Plane3D.closestAxisPlane](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Plane3D.html#closestAxisPlane--)
         */
        closestAxisPlane(plane3D: any /* org.locationtech.jts.math.Plane3D */): number;
        create2(normal: any /* org.locationtech.jts.math.Vector3D */, basePt: Coordinate): any /* org.locationtech.jts.math.Plane3D */;
        /**
         * Computes the oriented distance from a point to the plane.
         * The distance is:
         *
         * - **positive** if the point lies above the plane (relative to the plane normal)
         * - **zero** if the point is on the plane
         * - **negative** if the point lies below the plane (relative to the plane normal)
         *
         * @param p - the point to compute the distance for
         * @returns the oriented distance to the plane
         * @see [org.locationtech.jts.math.Plane3D.orientedDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Plane3D.html#orientedDistance-org.locationtech.jts.geom.Coordinate-)
         */
        orientedDistance(plane3D: any /* org.locationtech.jts.math.Plane3D */, p: Coordinate): number;
      };
      Vector2D: {
        add(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): any /* org.locationtech.jts.math.Vector2D */;
        angle(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): number;
        angleTo(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): number;
        average(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): any /* org.locationtech.jts.math.Vector2D */;
        /**
         * Creates a new vector with given X and Y components.
         *
         * @param x - the x component
         * @param y - the y component
         * @returns a new vector
         * @see [org.locationtech.jts.math.Vector2D.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#create-double-double-)
         */
        create(x: number, y: number): any /* org.locationtech.jts.math.Vector2D */;
        create0(): any /* org.locationtech.jts.math.Vector2D */;
        create1(v: Coordinate): any /* org.locationtech.jts.math.Vector2D */;
        create2(from: Coordinate, to: Coordinate): any /* org.locationtech.jts.math.Vector2D */;
        /**
         * Computes the distance between this vector and another one.
         *
         * @param v - a vector
         * @returns the distance between the vectors
         * @see [org.locationtech.jts.math.Vector2D.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#distance-org.locationtech.jts.math.Vector2D-)
         */
        distance(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): number;
        /**
         * Divides the vector by a scalar value.
         *
         * @param d - the value to divide by
         * @returns a new vector with the value v / d
         * @see [org.locationtech.jts.math.Vector2D.divide](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#divide-double-)
         */
        divide(vector2D: any /* org.locationtech.jts.math.Vector2D */, d: number): any /* org.locationtech.jts.math.Vector2D */;
        /**
         * Computes the dot-product of two vectors
         *
         * @param v - a vector
         * @returns the dot product of the vectors
         * @see [org.locationtech.jts.math.Vector2D.dot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#dot-org.locationtech.jts.math.Vector2D-)
         */
        dot(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): number;
        getComponent(vector2D: any /* org.locationtech.jts.math.Vector2D */, index: number): number;
        getX(vector2D: any /* org.locationtech.jts.math.Vector2D */): number;
        getY(vector2D: any /* org.locationtech.jts.math.Vector2D */): number;
        isParallel(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): boolean;
        length(vector2D: any /* org.locationtech.jts.math.Vector2D */): number;
        lengthSquared(vector2D: any /* org.locationtech.jts.math.Vector2D */): number;
        /**
         * Multiplies the vector by a scalar value.
         *
         * @param d - the value to multiply by
         * @returns a new vector with the value v * d
         * @see [org.locationtech.jts.math.Vector2D.multiply](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#multiply-double-)
         */
        multiply(vector2D: any /* org.locationtech.jts.math.Vector2D */, d: number): any /* org.locationtech.jts.math.Vector2D */;
        negate(vector2D: any /* org.locationtech.jts.math.Vector2D */): any /* org.locationtech.jts.math.Vector2D */;
        normalize(vector2D: any /* org.locationtech.jts.math.Vector2D */): any /* org.locationtech.jts.math.Vector2D */;
        rotate(vector2D: any /* org.locationtech.jts.math.Vector2D */, angle: number): any /* org.locationtech.jts.math.Vector2D */;
        /**
         * Rotates a vector by a given number of quarter-circles (i.e. multiples of 90
         * degrees or Pi/2 radians). A positive number rotates counter-clockwise, a
         * negative number rotates clockwise. Under this operation the magnitude of
         * the vector and the absolute values of the ordinates do not change, only
         * their sign and ordinate index.
         *
         * @param numQuarters - the number of quarter-circles to rotate by
         * @returns the rotated vector.
         * @see [org.locationtech.jts.math.Vector2D.rotateByQuarterCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#rotateByQuarterCircle-int-)
         */
        rotateByQuarterCircle(vector2D: any /* org.locationtech.jts.math.Vector2D */, numQuarters: number): any /* org.locationtech.jts.math.Vector2D */;
        subtract(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */): any /* org.locationtech.jts.math.Vector2D */;
        toCoordinate(vector2D: any /* org.locationtech.jts.math.Vector2D */): Coordinate;
        translate(vector2D: any /* org.locationtech.jts.math.Vector2D */, coord: Coordinate): Coordinate;
        /**
         * Computes the weighted sum of this vector
         * with another vector,
         * with this vector contributing a fraction
         * of `frac` to the total.
         *
         * In other words,
         *
         * ```
         * sum = frac * this + (1 - frac) * v
         * ```
         *
         * @param v - the vector to sum
         * @param frac - the fraction of the total contributed by this vector
         * @returns the weighted sum of the two vectors
         * @see [org.locationtech.jts.math.Vector2D.weightedSum](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector2D.html#weightedSum-org.locationtech.jts.math.Vector2D-double-)
         */
        weightedSum(vector2D: any /* org.locationtech.jts.math.Vector2D */, v: any /* org.locationtech.jts.math.Vector2D */, frac: number): any /* org.locationtech.jts.math.Vector2D */;
      };
      Vector3D: {
        /**
         * Computes a vector which is the sum
         * of this vector and the given vector.
         *
         * @param v - the vector to add
         * @returns the sum of this and `v`
         * @see [org.locationtech.jts.math.Vector3D.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#add-org.locationtech.jts.math.Vector3D-)
         */
        add(vector3D: any /* org.locationtech.jts.math.Vector3D */, v: any /* org.locationtech.jts.math.Vector3D */): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a new 3D vector from a `Coordinate`. The coordinate should have
         * the X,Y and Z ordinates specified.
         *
         * @param v - the Coordinate to copy
         * @see [org.locationtech.jts.math.Vector3D.Vector3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#Vector3D-org.locationtech.jts.geom.Coordinate-)
         */
        create1(v: Coordinate): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a new vector with the direction and magnitude
         * of the difference between the
         * `to` and `from` `Coordinate`s.
         *
         * @param from - the origin Coordinate
         * @param to - the destination Coordinate
         * @see [org.locationtech.jts.math.Vector3D.Vector3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#Vector3D-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create2(from: Coordinate, to: Coordinate): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a vector with the givne components.
         *
         * @param x - the X component
         * @param y - the Y component
         * @param z - the Z component
         * @see [org.locationtech.jts.math.Vector3D.Vector3D](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#Vector3D-double-double-double-)
         */
        create3(x: number, y: number, z: number): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a vector from a 3D `Coordinate`.
         * The coordinate should have the
         * X,Y and Z ordinates specified.
         *
         * @param coord - the Coordinate to copy
         * @returns a new vector
         * @see [org.locationtech.jts.math.Vector3D.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#create-org.locationtech.jts.geom.Coordinate-)
         */
        createFromCoordinate(coord: Coordinate): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a new vector with given X, Y and Z components.
         *
         * @param x - the X component
         * @param y - the Y component
         * @param z - the Z component
         * @returns a new vector
         * @see [org.locationtech.jts.math.Vector3D.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#create-double-double-double-)
         */
        createFromDoubles(x: number, y: number, z: number): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Creates a new vector which has the same direction
         * and with length equals to the length of this vector
         * divided by the scalar value `d`.
         *
         * @param d - the scalar divisor
         * @returns a new vector with divided length
         * @see [org.locationtech.jts.math.Vector3D.divide](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#divide-double-)
         */
        divide(vector3D: any /* org.locationtech.jts.math.Vector3D */, d: number): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Computes the dot-product of two vectors
         *
         * @param v - a vector
         * @returns the dot product of the vectors
         * @see [org.locationtech.jts.math.Vector3D.dot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#dot-org.locationtech.jts.math.Vector3D-)
         */
        dot(vector3D: any /* org.locationtech.jts.math.Vector3D */, v: any /* org.locationtech.jts.math.Vector3D */): number;
        /**
         * Computes the 3D dot-product of two `Coordinate`s.
         *
         * @param v1 - the first vector
         * @param v2 - the second vector
         * @returns the dot product of the vectors
         * @see [org.locationtech.jts.math.Vector3D.dot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#dot-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        dot2(v1: Coordinate, v2: Coordinate): number;
        /**
         * Computes the dot product of the 3D vectors AB and CD.
         *
         * @param A - the start point of the first vector
         * @param B - the end point of the first vector
         * @param C - the start point of the second vector
         * @param D - the end point of the second vector
         * @returns the dot product
         * @see [org.locationtech.jts.math.Vector3D.dot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#dot-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        dot4(A: Coordinate, B: Coordinate, C: Coordinate, D: Coordinate): number;
        /**
         * Gets the X component of this vector.
         *
         * @returns the value of the X component
         * @see [org.locationtech.jts.math.Vector3D.getX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#getX--)
         */
        getX(vector3D: any /* org.locationtech.jts.math.Vector3D */): number;
        /**
         * Gets the Y component of this vector.
         *
         * @returns the value of the Y component
         * @see [org.locationtech.jts.math.Vector3D.getY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#getY--)
         */
        getY(vector3D: any /* org.locationtech.jts.math.Vector3D */): number;
        /**
         * Gets the Z component of this vector.
         *
         * @returns the value of the Z component
         * @see [org.locationtech.jts.math.Vector3D.getZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#getZ--)
         */
        getZ(vector3D: any /* org.locationtech.jts.math.Vector3D */): number;
        /**
         * Computes the length of this vector.
         *
         * @returns the length of the vector
         * @see [org.locationtech.jts.math.Vector3D.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#length--)
         */
        length(vector3D: any /* org.locationtech.jts.math.Vector3D */): number;
        /**
         * Computes the length of a vector.
         *
         * @param v - a coordinate representing a 3D vector
         * @returns the length of the vector
         * @see [org.locationtech.jts.math.Vector3D.length](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#length-org.locationtech.jts.geom.Coordinate-)
         */
        lengthStatic(v: Coordinate): number;
        /**
         * Computes a vector having identical direction
         * but normalized to have length 1.
         *
         * @returns a new normalized vector
         * @see [org.locationtech.jts.math.Vector3D.normalize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#normalize--)
         */
        normalize(vector3D: any /* org.locationtech.jts.math.Vector3D */): any /* org.locationtech.jts.math.Vector3D */;
        /**
         * Computes a vector having identical direction
         * but normalized to have length 1.
         *
         * @param v - a coordinate representing a 3D vector
         * @returns a coordinate representing the normalized vector
         * @see [org.locationtech.jts.math.Vector3D.normalize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#normalize-org.locationtech.jts.geom.Coordinate-)
         */
        normalizeStatic(v: Coordinate): Coordinate;
        /**
         * Computes a vector which is the difference
         * of this vector and the given vector.
         *
         * @param v - the vector to subtract
         * @returns the difference of this and `v`
         * @see [org.locationtech.jts.math.Vector3D.subtract](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/math/Vector3D.html#subtract-org.locationtech.jts.math.Vector3D-)
         */
        subtract(vector3D: any /* org.locationtech.jts.math.Vector3D */, v: any /* org.locationtech.jts.math.Vector3D */): any /* org.locationtech.jts.math.Vector3D */;
      };
    };
    noding: {
      IteratedNoder: {
        MAX_ITER: number;
      };
      Octant: {
        /**
         * Returns the octant of a directed line segment from p0 to p1.
         *
         * @see [org.locationtech.jts.noding.Octant.octant](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/noding/Octant.html#octant-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        octant(p0: Coordinate, p1: Coordinate): number;
      };
      SegmentPointComparator: {
        /**
         * Compares two `Coordinate`s for their relative position along a segment
         * lying in the specified `Octant`.
         *
         * @returns -1 node0 occurs first; 0 the two nodes are equal; 1 node1 occurs first
         * @see [org.locationtech.jts.noding.SegmentPointComparator.compare](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/noding/SegmentPointComparator.html#compare-int-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        compare(octant: number, p0: Coordinate, p1: Coordinate): number;
        relativeSign(x0: number, x1: number): number;
      };
    };
    operation: {
      BoundaryOp: {
        /**
         * Creates a new instance for the given geometry.
         *
         * @param geom - the input geometry
         * @see [org.locationtech.jts.operation.BoundaryOp.BoundaryOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/BoundaryOp.html#BoundaryOp-org.locationtech.jts.geom.Geometry-)
         */
        create1(geom: Geometry): any /* org.locationtech.jts.operation.BoundaryOp */;
        /**
         * Computes a geometry representing the boundary of a geometry.
         *
         * @param g - the input geometry
         * @returns the computed boundary
         * @see [org.locationtech.jts.operation.BoundaryOp.getBoundary](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/BoundaryOp.html#getBoundary-org.locationtech.jts.geom.Geometry-)
         */
        getBoundary(g: Geometry): Geometry;
      };
      IsSimpleOp: {
        /**
         * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
         *
         * @see [org.locationtech.jts.operation.IsSimpleOp.IsSimpleOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/IsSimpleOp.html#IsSimpleOp--)
         */
        create0(): any /* org.locationtech.jts.operation.IsSimpleOp */;
        /**
         * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
         *
         * @param geom - the geometry to test
         * @see [org.locationtech.jts.operation.IsSimpleOp.IsSimpleOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/IsSimpleOp.html#IsSimpleOp-org.locationtech.jts.geom.Geometry-)
         */
        create1(geom: Geometry): any /* org.locationtech.jts.operation.IsSimpleOp */;
        /**
         * Gets a coordinate for the location where the geometry
         * fails to be simple.
         * (i.e. where it has a non-boundary self-intersection).
         * `isSimple` must be called before this method is called.
         *
         * @returns a coordinate for the location of the non-boundary self-intersection or null if the geometry is simple
         * @see [org.locationtech.jts.operation.IsSimpleOp.getNonSimpleLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/IsSimpleOp.html#getNonSimpleLocation--)
         */
        getNonSimpleLocation(isSimpleOp: any /* org.locationtech.jts.operation.IsSimpleOp */): Coordinate;
        /**
         * Reports whether a `LineString` is simple.
         *
         * @param geom - the lineal geometry to test
         * @returns true if the geometry is simple
         * @see [org.locationtech.jts.operation.IsSimpleOp.isSimple](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/IsSimpleOp.html#isSimple-org.locationtech.jts.geom.LineString-)
         */
        isSimple(isSimpleOp: any /* org.locationtech.jts.operation.IsSimpleOp */, geom: Geometry): boolean;
      };
      buffer: {
        BufferCurveSetBuilder: {
          create4(inputGeom: Geometry, distance: number, precisionModel: PrecisionModel, bufParams: any /* org.locationtech.jts.operation.buffer.BufferParameters */): any /* org.locationtech.jts.operation.buffer.BufferCurveSetBuilder */;
        };
        BufferInputLineSimplifier: {
          create1(inputLine: Coordinate[]): any /* org.locationtech.jts.operation.buffer.BufferInputLineSimplifier */;
          /**
           * Simplify the input coordinate list.
           * If the distance tolerance is positive,
           * concavities on the LEFT side of the line are simplified.
           * If the supplied distance tolerance is negative,
           * concavities on the RIGHT side of the line are simplified.
           *
           * @param inputLine - the coordinate list to simplify
           * @param distanceTol - simplification distance tolerance to use
           * @returns the simplified coordinate list
           * @see [org.locationtech.jts.operation.buffer.BufferInputLineSimplifier.simplify](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferInputLineSimplifier.html#simplify-org.locationtech.jts.geom.Coordinate:A-double-)
           */
          simplify(inputLine: Coordinate[], distanceTol: number): Coordinate[];
        };
        BufferOp: {
          /**
           * Specifies a butt (or flat) line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_BUTT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_BUTT)
           */
          CAP_BUTT: number;
          /**
           * Specifies a butt (or flat) line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_FLAT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_FLAT)
           */
          CAP_FLAT: number;
          /**
           * Specifies a round line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_ROUND](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_ROUND)
           */
          CAP_ROUND: number;
          /**
           * Specifies a square line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferOp.CAP_SQUARE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#CAP_SQUARE)
           */
          CAP_SQUARE: number;
          /**
           * Computes the buffer for a geometry for a given buffer distance
           * and accuracy of approximation.
           *
           * @param g - the geometry to buffer
           * @param distance - the buffer distance
           * @param params - the buffer parameters to use
           * @returns the buffer of the input geometry
           * @see [org.locationtech.jts.operation.buffer.BufferOp.bufferOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#bufferOp-org.locationtech.jts.geom.Geometry-double-org.locationtech.jts.operation.buffer.BufferParameters-)
           */
          bufferOp(g: Geometry, distance: number, params: any /* org.locationtech.jts.operation.buffer.BufferParameters */): Geometry;
          /**
           * Initializes a buffer computation for the given geometry
           *
           * @param g - the geometry to buffer
           * @see [org.locationtech.jts.operation.buffer.BufferOp.BufferOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#BufferOp-org.locationtech.jts.geom.Geometry-)
           */
          create1(g: Geometry): BufferOp;
          /**
           * Initializes a buffer computation for the given geometry
           * with the given set of parameters
           *
           * @param g - the geometry to buffer
           * @param bufParams - the buffer parameters to use
           * @see [org.locationtech.jts.operation.buffer.BufferOp.BufferOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#BufferOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.operation.buffer.BufferParameters-)
           */
          create2(g: Geometry, bufParams: any /* org.locationtech.jts.operation.buffer.BufferParameters */): BufferOp;
          /**
           * Returns the buffer computed for a geometry for a given buffer distance.
           *
           * @param distance - the buffer distance
           * @returns the buffer of the input geometry
           * @see [org.locationtech.jts.operation.buffer.BufferOp.getResultGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#getResultGeometry-double-)
           */
          getResultGeometry(bufferOp: BufferOp, distance: number): Geometry;
          /**
           * Specifies the end cap style of the generated buffer.
           * The styles supported are `BufferParameters.CAP_ROUND`, `BufferParameters.CAP_FLAT`, and `BufferParameters.CAP_SQUARE`.
           * The default is CAP_ROUND.
           *
           * @param endCapStyle - the end cap style to specify
           * @see [org.locationtech.jts.operation.buffer.BufferOp.setEndCapStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#setEndCapStyle-int-)
           */
          setEndCapStyle(bufferOp: BufferOp, endCapStyle: number): any /* void */;
          /**
           * Sets the number of line segments in a quarter-circle
           * used to approximate angle fillets for round end caps and joins.
           *
           * @param quadrantSegments - the number of segments in a fillet for a quadrant
           * @see [org.locationtech.jts.operation.buffer.BufferOp.setQuadrantSegments](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferOp.html#setQuadrantSegments-int-)
           */
          setQuadrantSegments(bufferOp: BufferOp, quadrantSegments: number): any /* void */;
        };
        BufferParameters: {
          /**
           * Specifies a flat line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.CAP_FLAT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#CAP_FLAT)
           */
          CAP_FLAT: number;
          /**
           * Specifies a round line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.CAP_ROUND](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#CAP_ROUND)
           */
          CAP_ROUND: number;
          /**
           * Specifies a square line buffer end cap style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.CAP_SQUARE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#CAP_SQUARE)
           */
          CAP_SQUARE: number;
          /**
           * The default mitre limit
           * Allows fairly pointy mitres.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.DEFAULT_MITRE_LIMIT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#DEFAULT_MITRE_LIMIT)
           */
          DEFAULT_MITRE_LIMIT: number;
          /**
           * The default number of facets into which to divide a fillet of 90 degrees.
           * A value of 8 gives less than 2% max error in the buffer distance.
           * For a max error of < 1%, use QS = 12.
           * For a max error of < 0.1%, use QS = 18.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.DEFAULT_QUADRANT_SEGMENTS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#DEFAULT_QUADRANT_SEGMENTS)
           */
          DEFAULT_QUADRANT_SEGMENTS: number;
          /**
           * The default simplify factor
           * Provides an accuracy of about 1%, which matches the accuracy of the default Quadrant Segments parameter.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.DEFAULT_SIMPLIFY_FACTOR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#DEFAULT_SIMPLIFY_FACTOR)
           */
          DEFAULT_SIMPLIFY_FACTOR: number;
          /**
           * Specifies a bevel join style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.JOIN_BEVEL](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#JOIN_BEVEL)
           */
          JOIN_BEVEL: number;
          /**
           * Specifies a mitre join style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.JOIN_MITRE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#JOIN_MITRE)
           */
          JOIN_MITRE: number;
          /**
           * Specifies a round join style.
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.JOIN_ROUND](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#JOIN_ROUND)
           */
          JOIN_ROUND: number;
          /**
           * Computes the maximum distance error due to a given level
           * of approximation to a true arc.
           *
           * @param quadSegs - the number of segments used to approximate a quarter-circle
           * @returns the error of approximation
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.bufferDistanceError](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#bufferDistanceError-int-)
           */
          bufferDistanceError(quadSegs: number): number;
          copy(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * Creates a default set of parameters
           *
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.BufferParameters](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#BufferParameters--)
           */
          create0(): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * Creates a set of parameters with the
           * given quadrantSegments value.
           *
           * @param quadrantSegments - the number of quadrant segments to use
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.BufferParameters](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#BufferParameters-int-)
           */
          create1(quadrantSegments: number): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * Creates a set of parameters with the
           * given quadrantSegments and endCapStyle values.
           *
           * @param quadrantSegments - the number of quadrant segments to use
           * @param endCapStyle - the end cap style to use
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.BufferParameters](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#BufferParameters-int-int-)
           */
          create2(quadrantSegments: number, endCapStyle: number): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * Creates a set of parameters with the
           * given parameter values.
           *
           * @param quadrantSegments - the number of quadrant segments to use
           * @param endCapStyle - the end cap style to use
           * @param joinStyle - the join style to use
           * @param mitreLimit - the mitre limit to use
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.BufferParameters](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#BufferParameters-int-int-int-double-)
           */
          create4(quadrantSegments: number, endCapStyle: number, joinStyle: number, mitreLimit: number): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * Gets the end cap style.
           *
           * @returns the end cap style code
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.getEndCapStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#getEndCapStyle--)
           */
          getEndCapStyle(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): number;
          /**
           * Gets the join style.
           *
           * @returns the join style code
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.getJoinStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#getJoinStyle--)
           */
          getJoinStyle(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): number;
          /**
           * Gets the mitre ratio limit.
           *
           * @returns the limit value
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.getMitreLimit](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#getMitreLimit--)
           */
          getMitreLimit(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): number;
          /**
           * Gets the number of quadrant segments which will be used
           * to approximate angle fillets in round endcaps and joins.
           *
           * @returns the number of quadrant segments
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.getQuadrantSegments](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#getQuadrantSegments--)
           */
          getQuadrantSegments(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): number;
          /**
           * Gets the simplify factor.
           *
           * @returns the simplify factor
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.getSimplifyFactor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#getSimplifyFactor--)
           */
          getSimplifyFactor(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): number;
          /**
           * Tests whether the buffer is to be generated on a single side only.
           *
           * @returns true if the generated buffer is to be single-sided
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.isSingleSided](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#isSingleSided--)
           */
          isSingleSided(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */): boolean;
          /**
           * Specifies the end cap style of the generated buffer.
           * The styles supported are `CAP_ROUND`, `CAP_FLAT`, and `CAP_SQUARE`.
           * The default is `CAP_ROUND`.
           *
           * @param endCapStyle - the code for the end cap style
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setEndCapStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setEndCapStyle-int-)
           */
          setEndCapStyle(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, endCapStyle: number): any /* void */;
          /**
           * Sets the join style for outside (reflex) corners between line segments.
           * The styles supported are `JOIN_ROUND`,
           * `JOIN_MITRE` and {link JOIN_BEVEL}.
           * The default is `JOIN_ROUND`.
           *
           * @param joinStyle - the code for the join style
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setJoinStyle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setJoinStyle-int-)
           */
          setJoinStyle(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, joinStyle: number): any /* void */;
          /**
           * Sets the limit on the mitre ratio used for very sharp corners.
           * The mitre ratio is the ratio of the distance from the corner
           * to the end of the mitred offset corner.
           * When two line segments meet at a sharp angle,
           * a miter join will extend far beyond the original geometry.
           * (and in the extreme case will be infinitely far.)
           * To prevent unreasonable geometry, the mitre limit
           * allows controlling the maximum length of the join corner.
           * Corners with a ratio which exceed the limit will be beveled.
           *
           * @param mitreLimit - the mitre ratio limit
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setMitreLimit](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setMitreLimit-double-)
           */
          setMitreLimit(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, mitreLimit: number): any /* void */;
          /**
           * Sets the number of line segments in a quarter-circle
           * used to approximate angle fillets in round endcaps and joins.
           * The value should be at least 1.
           *
           * This determines the
           * error in the approximation to the true buffer curve.
           * The default value of 8 gives less than 2% error in the buffer distance.
           * For a error of < 1%, use QS = 12.
           * For a error of < 0.1%, use QS = 18.
           * The error is always less than the buffer distance
           * (in other words, the computed buffer curve is always inside the true
           * curve).
           *
           * @param quadSegs - the number of segments in a fillet for a circle quadrant
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setQuadrantSegments](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setQuadrantSegments-int-)
           */
          setQuadrantSegments(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, quadSegs: number): any /* void */;
          /**
           * Sets the factor used to determine the simplify distance tolerance
           * for input simplification.
           * Simplifying can increase the performance of computing buffers.
           * Generally the simplify factor should be greater than 0.
           * Values between 0.01 and .1 produce relatively good accuracy for the generate buffer.
           * Larger values sacrifice accuracy in return for performance.
           *
           * @param simplifyFactor - a value greater than or equal to zero.
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setSimplifyFactor](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setSimplifyFactor-double-)
           */
          setSimplifyFactor(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, simplifyFactor: number): any /* void */;
          /**
           * Sets whether the computed buffer should be single-sided.
           * A single-sided buffer is constructed on only one side of each input line.
           *
           * The side used is determined by the sign of the buffer distance:
           *
           * - a positive distance indicates the left-hand side
           * - a negative distance indicates the right-hand side
           *
           * The single-sided buffer of point geometries is
           * the same as the regular buffer.
           *
           * The End Cap Style for single-sided buffers is
           * always ignored,
           * and forced to the equivalent of `CAP_FLAT`.
           *
           * @param isSingleSided - true if a single-sided buffer should be constructed
           * @see [org.locationtech.jts.operation.buffer.BufferParameters.setSingleSided](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/BufferParameters.html#setSingleSided-boolean-)
           */
          setSingleSided(bufferParameters: any /* org.locationtech.jts.operation.buffer.BufferParameters */, isSingleSided: boolean): any /* void */;
        };
        OffsetCurve: {
          /**
           * Creates a new instance for computing an offset curve for a geometry at a given distance.
           * with default quadrant segments (`BufferParameters.DEFAULT_QUADRANT_SEGMENTS`)
           * and join style (`BufferParameters.JOIN_STYLE`).
           *
           * @param geom - the geometry to offset
           * @param distance - the offset distance (positive for left, negative for right)
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.OffsetCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#OffsetCurve-org.locationtech.jts.geom.Geometry-double-)
           */
          create2(geom: Geometry, distance: number): OffsetCurve;
          /**
           * Creates a new instance for computing an offset curve for a geometry at a given distance.
           * setting the quadrant segments and join style and mitre limit
           * via `BufferParameters`.
           *
           * @param geom - the geometry to offset
           * @param distance - the offset distance (positive for left, negative for right)
           * @param bufParams - the buffer parameters to use
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.OffsetCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#OffsetCurve-org.locationtech.jts.geom.Geometry-double-org.locationtech.jts.operation.buffer.BufferParameters-)
           */
          create3(geom: Geometry, distance: number, bufParams: any /* org.locationtech.jts.operation.buffer.BufferParameters */): OffsetCurve;
          /**
           * Computes the offset curve of a geometry at a given distance.
           *
           * @param geom - a geometry
           * @param distance - the offset distance (positive for left, negative for right)
           * @returns the offset curve
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve-org.locationtech.jts.geom.Geometry-double-)
           */
          getCurve(geom: Geometry, distance: number): Geometry;
          /**
           * Gets the computed offset curve lines.
           *
           * @returns the offset curve geometry
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve--)
           */
          getCurveInstance(offsetCurve: OffsetCurve): Geometry;
          /**
           * Computes the offset curve of a geometry at a given distance,
           * with specified quadrant segments, join style and mitre limit.
           *
           * @param geom - a geometry
           * @param distance - the offset distance (positive for left, negative for right)
           * @param quadSegs - the quadrant segments (-1 for default)
           * @param joinStyle - the join style (-1 for default)
           * @param mitreLimit - the mitre limit (-1 for default)
           * @returns the offset curve
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.getCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#getCurve-org.locationtech.jts.geom.Geometry-double-int-int-double-)
           */
          getCurveParametric(geom: Geometry, distance: number, quadSegs: number, joinStyle: number, mitreLimit: number): Geometry;
          /**
           * Computes a single curve line for each input linear component,
           * by joining curve sections in order along the raw offset curve.
           * The default mode is to compute separate curve sections.
           *
           * @param isJoined - true if joined mode should be used.
           * @see [org.locationtech.jts.operation.buffer.OffsetCurve.setJoined](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurve.html#setJoined-boolean-)
           */
          setJoined(offsetCurve: OffsetCurve, isJoined: boolean): any /* void */;
        };
        OffsetCurveBuilder: {
          create2(precisionModel: PrecisionModel, bufParams: any /* org.locationtech.jts.operation.buffer.BufferParameters */): any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */;
          /**
           * Gets the buffer parameters being used to generate the curve.
           *
           * @returns the buffer parameters being used
           * @see [org.locationtech.jts.operation.buffer.OffsetCurveBuilder.getBufferParameters](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.html#getBufferParameters--)
           */
          getBufferParameters(offsetCurveBuilder: any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */): any /* org.locationtech.jts.operation.buffer.BufferParameters */;
          /**
           * This method handles single points as well as LineStrings.
           * LineStrings are assumed **not** to be closed (the function will not
           * fail for closed lines, but will generate superfluous line caps).
           *
           * @param inputPts - the vertices of the line to offset
           * @param distance - the offset distance
           * @returns a Coordinate array representing the curve or null if the curve is empty
           * @see [org.locationtech.jts.operation.buffer.OffsetCurveBuilder.getLineCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.html#getLineCurve-org.locationtech.jts.geom.Coordinate:A-double-)
           */
          getLineCurve(offsetCurveBuilder: any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */, inputPts: Coordinate[], distance: number): Coordinate[];
          getOffsetCurve(offsetCurveBuilder: any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */, inputPts: Coordinate[], distance: number): Coordinate[];
          /**
           * This method handles the degenerate cases of single points and lines,
           * as well as valid rings.
           *
           * @param inputPts - the coordinates of the ring (must not contain repeated points)
           * @param side - side the side `Position` of the ring on which to construct the buffer line
           * @param distance - the positive distance at which to create the offset
           * @returns a Coordinate array representing the curve, or null if the curve is empty
           * @see [org.locationtech.jts.operation.buffer.OffsetCurveBuilder.getRingCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.html#getRingCurve-org.locationtech.jts.geom.Coordinate:A-int-double-)
           */
          getRingCurve(offsetCurveBuilder: any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */, inputPts: Coordinate[], side: number, distance: number): Coordinate[];
          /**
           * Tests whether the offset curve for line or point geometries
           * at the given offset distance is empty (does not exist).
           * This is the case if:
           *
           * - the distance is zero,
           * - the distance is negative, except for the case of singled-sided buffers
           *
           * @param distance - the offset curve distance
           * @returns true if the offset curve is empty
           * @see [org.locationtech.jts.operation.buffer.OffsetCurveBuilder.isLineOffsetEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/OffsetCurveBuilder.html#isLineOffsetEmpty-double-)
           */
          isLineOffsetEmpty(offsetCurveBuilder: any /* org.locationtech.jts.operation.buffer.OffsetCurveBuilder */, distance: number): boolean;
        };
        VariableBuffer: {
          /**
           * Creates a buffer polygon along a line with the buffer distance interpolated
           * between a start distance, a middle distance and an end distance.
           * The middle distance is attained at
           * the vertex at or just past the half-length of the line.
           * For smooth buffering of a `LinearRing` (or the rings of a `Polygon`)
           * the start distance and end distance should be equal.
           *
           * @param line - the line to buffer
           * @param startDistance - the buffer width at the start of the line
           * @param midDistance - the buffer width at the middle vertex of the line
           * @param endDistance - the buffer width at the end of the line
           * @returns the variable-distance buffer polygon
           * @see [org.locationtech.jts.operation.buffer.VariableBuffer.buffer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/VariableBuffer.html#buffer-org.locationtech.jts.geom.Geometry-double-double-double-)
           */
          buffer(line: Geometry, startDistance: number, midDistance: number, endDistance: number): Geometry;
        };
        validate: {
          BufferCurveMaximumDistanceFinder: {
            create1(inputGeom: Geometry): any /* org.locationtech.jts.operation.buffer.validate.BufferCurveMaximumDistanceFinder */;
            findDistance(bufferCurveMaximumDistanceFinder: any /* org.locationtech.jts.operation.buffer.validate.BufferCurveMaximumDistanceFinder */, bufferCurve: Geometry): number;
          };
          BufferDistanceValidator: {
            create3(input: Geometry, bufDistance: number, result: Geometry): any /* org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator */;
            /**
             * Gets a geometry which indicates the location and nature of a validation failure.
             *
             * The indicator is a line segment showing the location and size
             * of the distance discrepancy.
             *
             * @returns a geometric error indicator or null if no error was found
             * @see [org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator.getErrorIndicator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/validate/BufferDistanceValidator.html#getErrorIndicator--)
             */
            getErrorIndicator(bufferDistanceValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator */): Geometry;
            getErrorLocation(bufferDistanceValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator */): Coordinate;
            getErrorMessage(bufferDistanceValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator */): string;
            isValid(bufferDistanceValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferDistanceValidator */): boolean;
          };
          BufferResultValidator: {
            create3(input: Geometry, distance: number, result: Geometry): any /* org.locationtech.jts.operation.buffer.validate.BufferResultValidator */;
            /**
             * Gets a geometry which indicates the location and nature of a validation failure.
             *
             * If the failure is due to the buffer curve being too far or too close
             * to the input, the indicator is a line segment showing the location and size
             * of the discrepancy.
             *
             * @returns a geometric error indicator or null if no error was found
             * @see [org.locationtech.jts.operation.buffer.validate.BufferResultValidator.getErrorIndicator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/validate/BufferResultValidator.html#getErrorIndicator--)
             */
            getErrorIndicator(bufferResultValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferResultValidator */): Geometry;
            getErrorLocation(bufferResultValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferResultValidator */): Coordinate;
            getErrorMessage(bufferResultValidator: any /* org.locationtech.jts.operation.buffer.validate.BufferResultValidator */): string;
            isValid(g: Geometry, distance: number, result: Geometry): boolean;
            /**
             * Checks whether the geometry buffer is valid,
             * and returns an error message if not.
             *
             * @param g
             * @param distance
             * @param result
             * @returns an appropriate error message or null if the buffer is valid
             * @see [org.locationtech.jts.operation.buffer.validate.BufferResultValidator.isValidMsg](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/buffer/validate/BufferResultValidator.html#isValidMsg-org.locationtech.jts.geom.Geometry-double-org.locationtech.jts.geom.Geometry-)
             */
            isValidMsg(g: Geometry, distance: number, result: Geometry): string;
          };
        };
      };
      distance: {
        DistanceOp: {
          /**
           * Compute the the closest points of two geometries.
           * The points are presented in the same order as the input Geometries.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @returns the closest points in the geometries
           * @see [org.locationtech.jts.operation.distance.DistanceOp.closestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#closestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          closestPoints(g0: Geometry, g1: Geometry): Coordinate[];
          /**
           * Constructs a DistanceOp that computes the distance and nearest points between
           * the two specified geometries.
           *
           * @param g0 - a Geometry
           * @param g1 - a Geometry
           * @see [org.locationtech.jts.operation.distance.DistanceOp.DistanceOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#DistanceOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): DistanceOp;
          /**
           * Constructs a DistanceOp that computes the distance and nearest points between
           * the two specified geometries.
           *
           * @param g0 - a Geometry
           * @param g1 - a Geometry
           * @param terminateDistance - the distance on which to terminate the search
           * @see [org.locationtech.jts.operation.distance.DistanceOp.DistanceOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#DistanceOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          create3(g0: Geometry, g1: Geometry, terminateDistance: number): DistanceOp;
          /**
           * Compute the distance between the nearest points of two geometries.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @returns the distance between the geometries
           * @see [org.locationtech.jts.operation.distance.DistanceOp.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#distance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          distance(g0: Geometry, g1: Geometry): number;
          /**
           * Report the distance between the nearest points on the input geometries.
           *
           * @returns the distance between the geometries or 0 if either input geometry is empty
           * @throws IllegalArgumentException if either input geometry is null
           * @see [org.locationtech.jts.operation.distance.DistanceOp.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#distance--)
           */
          distanceInstance(distanceOp: DistanceOp): number;
          /**
           * Test whether two geometries lie within a given distance of each other.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @param distance - the distance to test
           * @returns true if g0.distance(g1) <= distance
           * @see [org.locationtech.jts.operation.distance.DistanceOp.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#isWithinDistance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          isWithinDistance(g0: Geometry, g1: Geometry, distance: number): boolean;
          /**
           * Compute the the nearest points of two geometries.
           * The points are presented in the same order as the input Geometries.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @returns the nearest points in the geometries
           * @see [org.locationtech.jts.operation.distance.DistanceOp.nearestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/DistanceOp.html#nearestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          nearestPoints(g0: Geometry, g1: Geometry): Coordinate[];
        };
        FacetSequence: {
          /**
           * Creates a new sequence for a single point from a `CoordinateSequence`.
           *
           * @param pts - the sequence containing the facet point
           * @param start - the index of the point
           * @see [org.locationtech.jts.operation.distance.FacetSequence.FacetSequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/FacetSequence.html#FacetSequence-org.locationtech.jts.geom.CoordinateSequence-int-)
           */
          create2(pts: CoordinateSequence, start: number): any /* org.locationtech.jts.operation.distance.FacetSequence */;
          /**
           * Creates a new sequence of facets based on a `CoordinateSequence`.
           *
           * @param pts - the sequence containing the facet points
           * @param start - the index of the start point
           * @param end - the index of the end point + 1
           * @see [org.locationtech.jts.operation.distance.FacetSequence.FacetSequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/FacetSequence.html#FacetSequence-org.locationtech.jts.geom.CoordinateSequence-int-int-)
           */
          create3(pts: CoordinateSequence, start: number, end: number): any /* org.locationtech.jts.operation.distance.FacetSequence */;
          /**
           * Creates a new sequence of facets based on a `CoordinateSequence`
           * contained in the given `Geometry`.
           *
           * @param geom - the geometry containing the facets
           * @param pts - the sequence containing the facet points
           * @param start - the index of the start point
           * @param end - the index of the end point + 1
           * @see [org.locationtech.jts.operation.distance.FacetSequence.FacetSequence](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/FacetSequence.html#FacetSequence-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.CoordinateSequence-int-int-)
           */
          create4(geom: Geometry, pts: CoordinateSequence, start: number, end: number): any /* org.locationtech.jts.operation.distance.FacetSequence */;
          getCoordinate(facetSequence: any /* org.locationtech.jts.operation.distance.FacetSequence */, index: number): Coordinate;
          getEnvelope(facetSequence: any /* org.locationtech.jts.operation.distance.FacetSequence */): Envelope;
          isPoint(facetSequence: any /* org.locationtech.jts.operation.distance.FacetSequence */): boolean;
          size(facetSequence: any /* org.locationtech.jts.operation.distance.FacetSequence */): number;
        };
        FacetSequenceTreeBuilder: {
          build(g: Geometry): any /* org.locationtech.jts.index.strtree.STRtree */;
        };
        GeometryLocation: {
          /**
           * A special value of segmentIndex used for locations inside area geometries.
           * These locations are not located on a segment,
           * and thus do not have an associated segment index.
           *
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.INSIDE_AREA](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#INSIDE_AREA)
           */
          INSIDE_AREA: number;
          /**
           * Constructs a GeometryLocation specifying a point inside an area geometry.
           *
           * @param component - the component of the geometry containing the point
           * @param pt - the coordinate of the location
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.GeometryLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#GeometryLocation-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Coordinate-)
           */
          create2(component: Geometry, pt: Coordinate): any /* org.locationtech.jts.operation.distance.GeometryLocation */;
          /**
           * Constructs a GeometryLocation specifying a point on a geometry, as well as the
           * segment that the point is on
           * (or `INSIDE_AREA` if the point is not on a segment).
           *
           * @param component - the component of the geometry containing the point
           * @param segIndex - the segment index of the location, or INSIDE_AREA
           * @param pt - the coordinate of the location
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.GeometryLocation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#GeometryLocation-org.locationtech.jts.geom.Geometry-int-org.locationtech.jts.geom.Coordinate-)
           */
          create3(component: Geometry, segIndex: number, pt: Coordinate): any /* org.locationtech.jts.operation.distance.GeometryLocation */;
          /**
           * Returns the `Coordinate` of this location.
           *
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#getCoordinate--)
           */
          getCoordinate(geometryLocation: any /* org.locationtech.jts.operation.distance.GeometryLocation */): Coordinate;
          /**
           * Returns the geometry component on (or in) which this location occurs.
           *
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.getGeometryComponent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#getGeometryComponent--)
           */
          getGeometryComponent(geometryLocation: any /* org.locationtech.jts.operation.distance.GeometryLocation */): Geometry;
          /**
           * Returns the segment index for this location. If the location is inside an
           * area, the index will have the value `INSIDE_AREA`;
           *
           * @returns the segment index for the location, or INSIDE_AREA
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.getSegmentIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#getSegmentIndex--)
           */
          getSegmentIndex(geometryLocation: any /* org.locationtech.jts.operation.distance.GeometryLocation */): number;
          /**
           * Tests whether this location represents a point inside an area geometry.
           *
           * @see [org.locationtech.jts.operation.distance.GeometryLocation.isInsideArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/GeometryLocation.html#isInsideArea--)
           */
          isInsideArea(geometryLocation: any /* org.locationtech.jts.operation.distance.GeometryLocation */): boolean;
        };
        IndexedFacetDistance: {
          /**
           * Creates a new distance-finding instance for a given target `Geometry`.
           *
           * Distances will be computed to all facets of the input geometry.
           * The facets of the geometry are the discrete segments and points
           * contained in its components.
           * In the case of `Lineal` and `Puntal` inputs,
           * this is equivalent to computing the conventional distance.
           * In the case of `Polygonal` inputs, this is equivalent
           * to computing the distance to the polygon boundaries.
           *
           * @param geom - a Geometry, which may be of any type.
           * @see [org.locationtech.jts.operation.distance.IndexedFacetDistance.IndexedFacetDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/IndexedFacetDistance.html#IndexedFacetDistance-org.locationtech.jts.geom.Geometry-)
           */
          create1(geom: Geometry): any /* org.locationtech.jts.operation.distance.IndexedFacetDistance */;
          /**
           * Computes the distance between facets of two geometries.
           *
           * For geometries with many segments or points,
           * this can be faster than using a simple distance
           * algorithm.
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @returns the distance between facets of the geometries
           * @see [org.locationtech.jts.operation.distance.IndexedFacetDistance.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/IndexedFacetDistance.html#distance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          distance(g1: Geometry, g2: Geometry): number;
          /**
           * Tests whether the facets of two geometries lie within a given distance.
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @param distance - the distance limit
           * @returns true if two facets lie with the given distance
           * @see [org.locationtech.jts.operation.distance.IndexedFacetDistance.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/IndexedFacetDistance.html#isWithinDistance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          isWithinDistance(g1: Geometry, g2: Geometry, distance: number): boolean;
          /**
           * Computes the nearest points of the facets of two geometries.
           *
           * @param g1 - a geometry
           * @param g2 - a geometry
           * @returns the nearest points on the facets of the geometries
           * @see [org.locationtech.jts.operation.distance.IndexedFacetDistance.nearestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance/IndexedFacetDistance.html#nearestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          nearestPoints(g1: Geometry, g2: Geometry): Coordinate[];
        };
      };
      distance3d: {
        AxisPlaneCoordinateSequence: {
          /**
           * Creates a wrapper projecting to the XY plane.
           *
           * @param seq - the sequence to be projected
           * @returns a sequence which projects coordinates
           * @see [org.locationtech.jts.operation.distance3d.AxisPlaneCoordinateSequence.projectToXY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/AxisPlaneCoordinateSequence.html#projectToXY-org.locationtech.jts.geom.CoordinateSequence-)
           */
          projectToXY(seq: CoordinateSequence): CoordinateSequence;
          /**
           * Creates a wrapper projecting to the XZ plane.
           *
           * @param seq - the sequence to be projected
           * @returns a sequence which projects coordinates
           * @see [org.locationtech.jts.operation.distance3d.AxisPlaneCoordinateSequence.projectToXZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/AxisPlaneCoordinateSequence.html#projectToXZ-org.locationtech.jts.geom.CoordinateSequence-)
           */
          projectToXZ(seq: CoordinateSequence): CoordinateSequence;
          /**
           * Creates a wrapper projecting to the YZ plane.
           *
           * @param seq - the sequence to be projected
           * @returns a sequence which projects coordinates
           * @see [org.locationtech.jts.operation.distance3d.AxisPlaneCoordinateSequence.projectToYZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/AxisPlaneCoordinateSequence.html#projectToYZ-org.locationtech.jts.geom.CoordinateSequence-)
           */
          projectToYZ(seq: CoordinateSequence): CoordinateSequence;
        };
        Distance3DOp: {
          /**
           * Constructs a DistanceOp that computes the distance and nearest points
           * between the two specified geometries.
           *
           * @param g0 - a Geometry
           * @param g1 - a Geometry
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.Distance3DOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#Distance3DOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.operation.distance3d.Distance3DOp */;
          /**
           * Constructs a DistanceOp that computes the distance and nearest points
           * between the two specified geometries.
           *
           * @param g0 - a Geometry
           * @param g1 - a Geometry
           * @param terminateDistance - the distance on which to terminate the search
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.Distance3DOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#Distance3DOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          create3(g0: Geometry, g1: Geometry, terminateDistance: number): any /* org.locationtech.jts.operation.distance3d.Distance3DOp */;
          /**
           * Compute the distance between the nearest points of two geometries.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @returns the distance between the geometries
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.distance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#distance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          distance(g0: Geometry, g1: Geometry): number;
          /**
           * Test whether two geometries lie within a given distance of each other.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @param distance - the distance to test
           * @returns true if g0.distance(g1) <= distance
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.isWithinDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#isWithinDistance-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
           */
          isWithinDistance(g0: Geometry, g1: Geometry, distance: number): boolean;
          /**
           * Report the locations of the nearest points in the input geometries. The
           * locations are presented in the same order as the input Geometries.
           *
           * @returns a pair of `GeometryLocation`s for the nearest points
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.nearestLocations](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#nearestLocations--)
           */
          nearestLocations(distance3DOp: any /* org.locationtech.jts.operation.distance3d.Distance3DOp */): any /* org.locationtech.jts.operation.distance.GeometryLocation */[];
          /**
           * Compute the the nearest points of two geometries. The points are
           * presented in the same order as the input Geometries.
           *
           * @param g0 - a `Geometry`
           * @param g1 - another `Geometry`
           * @returns the nearest points in the geometries
           * @see [org.locationtech.jts.operation.distance3d.Distance3DOp.nearestPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/distance3d/Distance3DOp.html#nearestPoints-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          nearestPoints(g0: Geometry, g1: Geometry): Coordinate[];
        };
      };
      linemerge: {
        LineMerger: {
          /**
           * Adds a Geometry to be processed. May be called multiple times.
           * Any dimension of Geometry may be added; the constituent linework will be
           * extracted.
           *
           * @param geometry - geometry to be line-merged
           * @see [org.locationtech.jts.operation.linemerge.LineMerger.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineMerger.html#add-org.locationtech.jts.geom.Geometry-)
           */
          add(lineMerger: any /* org.locationtech.jts.operation.linemerge.LineMerger */, geometry: Geometry): any /* void */;
          /**
           * Creates a new line merger.
           *
           * @see [org.locationtech.jts.operation.linemerge.LineMerger.LineMerger](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineMerger.html#LineMerger--)
           */
          create(): any /* org.locationtech.jts.operation.linemerge.LineMerger */;
          /**
           * Gets the `LineString`s created by the merging process.
           *
           * @returns the collection of merged LineStrings
           * @see [org.locationtech.jts.operation.linemerge.LineMerger.getMergedLineStrings](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineMerger.html#getMergedLineStrings--)
           */
          getMergedLineStrings(lineMerger: any /* org.locationtech.jts.operation.linemerge.LineMerger */): any /* java.util.Collection */;
        };
        LineSequencer: {
          /**
           * Adds a `Geometry` to be sequenced.
           * May be called multiple times.
           * Any dimension of Geometry may be added; the constituent linework will be
           * extracted.
           *
           * @param geometry - the geometry to add
           * @see [org.locationtech.jts.operation.linemerge.LineSequencer.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineSequencer.html#add-org.locationtech.jts.geom.Geometry-)
           */
          add(lineSequencer: any /* org.locationtech.jts.operation.linemerge.LineSequencer */, geometry: Geometry): any /* void */;
          create0(): any /* org.locationtech.jts.operation.linemerge.LineSequencer */;
          /**
           * Returns the `LineString` or `MultiLineString`
           * built by the sequencing process, if one exists.
           *
           * @returns the sequenced linestrings, or `null` if a valid sequence does not exist
           * @see [org.locationtech.jts.operation.linemerge.LineSequencer.getSequencedLineStrings](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineSequencer.html#getSequencedLineStrings--)
           */
          getSequencedLineStrings(lineSequencer: any /* org.locationtech.jts.operation.linemerge.LineSequencer */): Geometry;
          /**
           * Tests whether the arrangement of linestrings has a valid
           * sequence.
           *
           * @returns `true` if a valid sequence exists.
           * @see [org.locationtech.jts.operation.linemerge.LineSequencer.isSequenceable](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineSequencer.html#isSequenceable--)
           */
          isSequenceable(lineSequencer: any /* org.locationtech.jts.operation.linemerge.LineSequencer */): boolean;
          /**
           * Tests whether a `Geometry` is sequenced correctly.
           * `LineString`s are trivially sequenced.
           * `MultiLineString`s are checked for correct sequencing.
           * Otherwise, `isSequenced` is defined
           * to be `true` for geometries that are not lineal.
           *
           * @param geom - the geometry to test
           * @returns `true` if the geometry is sequenced or is not lineal
           * @see [org.locationtech.jts.operation.linemerge.LineSequencer.isSequenced](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/linemerge/LineSequencer.html#isSequenced-org.locationtech.jts.geom.Geometry-)
           */
          isSequenced(geom: Geometry): boolean;
          sequence(geom: Geometry): Geometry;
        };
      };
      overlay: {
        OverlayNodeFactory: {
          create0(): any /* org.locationtech.jts.operation.overlay.OverlayNodeFactory */;
        };
        OverlayOp: {
          /**
           * The code for the Difference overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.DIFFERENCE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#DIFFERENCE)
           */
          DIFFERENCE: number;
          /**
           * The code for the Intersection overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#INTERSECTION)
           */
          INTERSECTION: number;
          /**
           * The code for the Symmetric Difference overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.SYMDIFFERENCE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#SYMDIFFERENCE)
           */
          SYMDIFFERENCE: number;
          /**
           * The code for the Union overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.UNION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#UNION)
           */
          UNION: number;
          /**
           * Constructs an instance to compute a single overlay operation
           * for the given geometries.
           *
           * @param g0 - the first geometry argument
           * @param g1 - the second geometry argument
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.OverlayOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#OverlayOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.operation.overlay.OverlayOp */;
          /**
           * Creates an empty result geometry of the appropriate dimension,
           * based on the given overlay operation and the dimensions of the inputs.
           * The created geometry is always an atomic geometry,
           * not a collection.
           *
           * The empty result is constructed using the following rules:
           *
           * - `INTERSECTION` - result has the dimension of the lowest input dimension
           * - `UNION` - result has the dimension of the highest input dimension
           * - `DIFFERENCE` - result has the dimension of the left-hand input
           * - `SYMDIFFERENCE` - result has the dimension of the highest input dimension
           * (since the symmetric Difference is the union of the differences).
           *
           * @param overlayOpCode - the code for the overlay operation being performed
           * @param a - an input geometry
           * @param b - an input geometry
           * @param geomFact - the geometry factory being used for the operation
           * @returns an empty atomic geometry of the appropriate dimension
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.createEmptyResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#createEmptyResult-int-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.GeometryFactory-)
           */
          createEmptyResult(overlayOpCode: number, a: Geometry, b: Geometry, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Gets the result of the overlay for a given overlay operation.
           *
           * Note: this method can be called once only.
           *
           * @param overlayOpCode - the overlay operation to perform
           * @returns the compute result geometry
           * @throws TopologyException if a robustness problem is encountered
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.getResultGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#getResultGeometry-int-)
           */
          getResultGeometry(overlayOp: any /* org.locationtech.jts.operation.overlay.OverlayOp */, overlayOpCode: number): Geometry;
          /**
           * Tests if an L edge should be included in the result or not.
           *
           * @param coord - the point coordinate
           * @returns true if the coordinate point is covered by a result Area geometry
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.isCoveredByA](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#isCoveredByA-org.locationtech.jts.geom.Coordinate-)
           */
          isCoveredByA(overlayOp: any /* org.locationtech.jts.operation.overlay.OverlayOp */, coord: Coordinate): boolean;
          /**
           * Tests if a point node should be included in the result or not.
           *
           * @param coord - the point coordinate
           * @returns true if the coordinate point is covered by a result Line or Area geometry
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.isCoveredByLA](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#isCoveredByLA-org.locationtech.jts.geom.Coordinate-)
           */
          isCoveredByLA(overlayOp: any /* org.locationtech.jts.operation.overlay.OverlayOp */, coord: Coordinate): boolean;
          /**
           * Tests whether a point with given `Location`s
           * relative to two geometries is contained in
           * the result of overlaying the geometries using
           * a given overlay operation.
           *
           * The method handles arguments of `Location.NONE` correctly
           *
           * @param loc0 - the code for the location in the first geometry
           * @param loc1 - the code for the location in the second geometry
           * @param overlayOpCode - the code for the overlay operation to test
           * @returns true if the locations correspond to the overlayOpCode
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.isResultOfOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#isResultOfOp-int-int-int-)
           */
          isResultOfOp(loc0: number, loc1: number, overlayOpCode: number): boolean;
          /**
           * Computes an overlay operation for
           * the given geometry arguments.
           *
           * @param geom0 - the first geometry argument
           * @param geom1 - the second geometry argument
           * @param opCode - the code for the desired overlay operation
           * @returns the result of the overlay operation
           * @throws TopologyException if a robustness problem is encountered
           * @see [org.locationtech.jts.operation.overlay.OverlayOp.overlayOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/OverlayOp.html#overlayOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-int-)
           */
          overlayOp(geom0: Geometry, geom1: Geometry, opCode: number): Geometry;
        };
        snap: {
          GeometrySnapper: {
            computeOverlaySnapTolerance(g0: Geometry, g1: Geometry): number;
            computeSizeBasedSnapTolerance(g: Geometry): number;
            /**
             * Creates a new snapper acting on the given geometry
             *
             * @param srcGeom - the geometry to snap
             * @see [org.locationtech.jts.operation.overlay.snap.GeometrySnapper.GeometrySnapper](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/GeometrySnapper.html#GeometrySnapper-org.locationtech.jts.geom.Geometry-)
             */
            create1(srcGeom: Geometry): any /* org.locationtech.jts.operation.overlay.snap.GeometrySnapper */;
            /**
             * Snaps two geometries together with a given tolerance.
             *
             * @param g0 - a geometry to snap
             * @param g1 - a geometry to snap
             * @param snapTolerance - the tolerance to use
             * @returns the snapped geometries
             * @see [org.locationtech.jts.operation.overlay.snap.GeometrySnapper.snap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/GeometrySnapper.html#snap-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-double-)
             */
            snap(g0: Geometry, g1: Geometry, snapTolerance: number): Geometry[];
            /**
             * Snaps the vertices in the component `LineString`s
             * of the source geometry
             * to the vertices of the given snap geometry.
             *
             * @param snapGeom - a geometry to snap the source to
             * @returns a new snapped Geometry
             * @see [org.locationtech.jts.operation.overlay.snap.GeometrySnapper.snapTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/GeometrySnapper.html#snapTo-org.locationtech.jts.geom.Geometry-double-)
             */
            snapTo(geometrySnapper: any /* org.locationtech.jts.operation.overlay.snap.GeometrySnapper */, snapGeom: Geometry, snapTolerance: number): Geometry;
            /**
             * Snaps a geometry to itself.
             * Allows optionally cleaning the result to ensure it is
             * topologically valid
             * (which fixes issues such as topology collapses in polygonal inputs).
             *
             * Snapping a geometry to itself can remove artifacts such as very narrow slivers, gores and spikes.
             *
             * @param geom - the geometry to snap
             * @param snapTolerance - the snapping tolerance
             * @param cleanResult - whether the result should be made valid
             * @returns a new snapped Geometry
             * @see [org.locationtech.jts.operation.overlay.snap.GeometrySnapper.snapToSelf](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/GeometrySnapper.html#snapToSelf-org.locationtech.jts.geom.Geometry-double-boolean-)
             */
            snapToSelf(geom: Geometry, snapTolerance: number, cleanResult: boolean): Geometry;
          };
          LineStringSnapper: {
            /**
             * Creates a new snapper using the points in the given `LineString`
             * as source snap points.
             *
             * @param srcLine - a LineString to snap (may be empty)
             * @param snapTolerance - the snap tolerance to use
             * @see [org.locationtech.jts.operation.overlay.snap.LineStringSnapper.LineStringSnapper](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/LineStringSnapper.html#LineStringSnapper-org.locationtech.jts.geom.LineString-double-)
             */
            create2(srcLine: Geometry, snapTolerance: number): any /* org.locationtech.jts.operation.overlay.snap.LineStringSnapper */;
            setAllowSnappingToSourceVertices(lineStringSnapper: any /* org.locationtech.jts.operation.overlay.snap.LineStringSnapper */, allowSnappingToSourceVertices: boolean): any /* void */;
            /**
             * Snaps the vertices and segments of the source LineString
             * to the given set of snap vertices.
             *
             * @param snapPts - the vertices to snap to
             * @returns a list of the snapped points
             * @see [org.locationtech.jts.operation.overlay.snap.LineStringSnapper.snapTo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/snap/LineStringSnapper.html#snapTo-org.locationtech.jts.geom.Coordinate:A-)
             */
            snapTo(lineStringSnapper: any /* org.locationtech.jts.operation.overlay.snap.LineStringSnapper */, snapPts: Coordinate[]): Coordinate[];
          };
          SnapIfNeededOverlayOp: {
            create2(g1: Geometry, g2: Geometry): any /* org.locationtech.jts.operation.overlay.snap.SnapIfNeededOverlayOp */;
            difference(g0: Geometry, g1: Geometry): Geometry;
            getResultGeometry(snapIfNeededOverlayOp: any /* org.locationtech.jts.operation.overlay.snap.SnapIfNeededOverlayOp */, opCode: number): Geometry;
            intersection(g0: Geometry, g1: Geometry): Geometry;
            overlayOp(g0: Geometry, g1: Geometry, opCode: number): Geometry;
            symDifference(g0: Geometry, g1: Geometry): Geometry;
            union(g0: Geometry, g1: Geometry): Geometry;
          };
          SnapOverlayOp: {
            create2(g1: Geometry, g2: Geometry): any /* org.locationtech.jts.operation.overlay.snap.SnapOverlayOp */;
            difference(g0: Geometry, g1: Geometry): Geometry;
            getResultGeometry(snapOverlayOp: any /* org.locationtech.jts.operation.overlay.snap.SnapOverlayOp */, opCode: number): Geometry;
            intersection(g0: Geometry, g1: Geometry): Geometry;
            overlayOp(g0: Geometry, g1: Geometry, opCode: number): Geometry;
            symDifference(g0: Geometry, g1: Geometry): Geometry;
            union(g0: Geometry, g1: Geometry): Geometry;
          };
        };
        validate: {
          FuzzyPointLocator: {
            create2(g: Geometry, boundaryDistanceTolerance: number): any /* org.locationtech.jts.operation.overlay.validate.FuzzyPointLocator */;
            getLocation(fuzzyPointLocator: any /* org.locationtech.jts.operation.overlay.validate.FuzzyPointLocator */, pt: Coordinate): number;
          };
          OffsetPointGenerator: {
            create1(g: Geometry): any /* org.locationtech.jts.operation.overlay.validate.OffsetPointGenerator */;
            /**
             * Set the sides on which to generate offset points.
             *
             * @param doLeft
             * @param doRight
             * @see [org.locationtech.jts.operation.overlay.validate.OffsetPointGenerator.setSidesToGenerate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlay/validate/OffsetPointGenerator.html#setSidesToGenerate-boolean-boolean-)
             */
            setSidesToGenerate(offsetPointGenerator: any /* org.locationtech.jts.operation.overlay.validate.OffsetPointGenerator */, doLeft: boolean, doRight: boolean): any /* void */;
          };
          OverlayResultValidator: {
            create3(a: Geometry, b: Geometry, result: Geometry): any /* org.locationtech.jts.operation.overlay.validate.OverlayResultValidator */;
            getInvalidLocation(overlayResultValidator: any /* org.locationtech.jts.operation.overlay.validate.OverlayResultValidator */): Coordinate;
            isValid(a: Geometry, b: Geometry, overlayOp: number, result: Geometry): boolean;
          };
        };
      };
      overlayng: {
        CoverageUnion: {
          /**
           * Unions a valid polygonal coverage or linear network.
           *
           * @param coverage - a coverage of polygons or lines
           * @returns the union of the coverage
           * @throws TopologyException in some cases if the coverage is invalid
           * @see [org.locationtech.jts.operation.overlayng.CoverageUnion.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/CoverageUnion.html#union-org.locationtech.jts.geom.Geometry-)
           */
          union(coverage: Geometry): Geometry;
        };
        FastOverlayFilter: {
          create1(geom: Geometry): any /* org.locationtech.jts.operation.overlayng.FastOverlayFilter */;
          /**
           * Computes the overlay operation on the input geometries,
           * if it can be determined that the result is either
           * empty or equal to one of the input values.
           * Otherwise `null` is returned, indicating
           * that a full overlay operation must be performed.
           *
           * @param geom
           * @param overlayOpCode
           * @returns overlay of the input geometries
           * @see [org.locationtech.jts.operation.overlayng.FastOverlayFilter.overlay](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/FastOverlayFilter.html#overlay-org.locationtech.jts.geom.Geometry-int-)
           */
          overlay(fastOverlayFilter: any /* org.locationtech.jts.operation.overlayng.FastOverlayFilter */, geom: Geometry, overlayOpCode: number): Geometry;
        };
        LineLimiter: {
          /**
           * Creates a new limiter for a given envelope.
           *
           * @param env - the envelope to limit to
           * @see [org.locationtech.jts.operation.overlayng.LineLimiter.LineLimiter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/LineLimiter.html#LineLimiter-org.locationtech.jts.geom.Envelope-)
           */
          create1(env: Envelope): any /* org.locationtech.jts.operation.overlayng.LineLimiter */;
        };
        OverlayNG: {
          /**
           * The code for the Difference overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.DIFFERENCE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#DIFFERENCE)
           */
          DIFFERENCE: number;
          /**
           * The code for the Intersection overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#INTERSECTION)
           */
          INTERSECTION: number;
          /**
           * The code for the Symmetric Difference overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.SYMDIFFERENCE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#SYMDIFFERENCE)
           */
          SYMDIFFERENCE: number;
          /**
           * The code for the Union overlay operation.
           *
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.UNION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#UNION)
           */
          UNION: number;
          /**
           * Creates an overlay operation on the given geometries
           * using the precision model of the geometries.
           *
           * The noder is chosen according to the precision model specified.
           *
           * - For `PrecisionModel.FIXED`
           * a snap-rounding noder is used, and the computation is robust.
           * - For `PrecisionModel.FLOATING`
           * a non-snapping noder is used,
           * and this computation may not be robust.
           * If errors occur a `TopologyException` is thrown.
           *
           * @param geom0 - the A operand geometry
           * @param geom1 - the B operand geometry (may be null)
           * @param opCode - the overlay opcode
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.OverlayNG](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#OverlayNG-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-int-)
           */
          create3(geom0: Geometry, geom1: Geometry, opCode: number): any /* org.locationtech.jts.operation.overlayng.OverlayNG */;
          /**
           * Creates an overlay operation on the given geometries,
           * with a defined precision model.
           * The noding strategy is determined by the precision model.
           *
           * @param geom0 - the A operand geometry
           * @param geom1 - the B operand geometry (may be null)
           * @param pm - the precision model to use
           * @param opCode - the overlay opcode
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.OverlayNG](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#OverlayNG-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-int-)
           */
          create4(geom0: Geometry, geom1: Geometry, pm: PrecisionModel, opCode: number): any /* org.locationtech.jts.operation.overlayng.OverlayNG */;
          /**
           * Gets the result of the overlay operation.
           *
           * @returns the result of the overlay operation.
           * @throws IllegalArgumentException if the input is not supported (e.g. a mixed-dimension geometry)
           * @throws TopologyException if a robustness error occurs
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#getResult--)
           */
          getResult(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */): Geometry;
          /**
           * Computes an overlay operation for
           * the given geometry operands, with the
           * noding strategy determined by the precision model.
           *
           * @param geom0 - the first geometry argument
           * @param geom1 - the second geometry argument
           * @param opCode - the code for the desired overlay operation
           * @param pm - the precision model to use
           * @returns the result of the overlay operation
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.overlay](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#overlay-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-int-org.locationtech.jts.geom.PrecisionModel-)
           */
          overlay(geom0: Geometry, geom1: Geometry, opCode: number, pm: PrecisionModel): Geometry;
          /**
           * Sets whether overlay processing optimizations are enabled.
           * It may be useful to disable optimizations
           * for testing purposes.
           * Default is TRUE (optimization enabled).
           *
           * @param isOptimized - whether to optimize processing
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.setOptimized](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#setOptimized-boolean-)
           */
          setOptimized(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */, isOptimized: boolean): any /* void */;
          /**
           * @param isOutputEdges
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.setOutputEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#setOutputEdges-boolean-)
           */
          setOutputEdges(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */, isOutputEdges: boolean): any /* void */;
          setOutputNodedEdges(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */, isOutputNodedEdges: boolean): any /* void */;
          setOutputResultEdges(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */, isOutputResultEdges: boolean): any /* void */;
          /**
           * Sets whether the overlay results are computed according to strict mode
           * semantics.
           *
           * - Lines resulting from topology collapse are not included
           * - Result geometry is homogeneous
           * for the `INTERSECTION` and `DIFFERENCE` operations.
           * - Result geometry is homogeneous
           * for the `UNION` and `SYMDIFFERENCE` operations
           * if the inputs have the same dimension
           *
           * @param isStrictMode - true if strict mode is to be used
           * @see [org.locationtech.jts.operation.overlayng.OverlayNG.setStrictMode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNG.html#setStrictMode-boolean-)
           */
          setStrictMode(overlayNG: any /* org.locationtech.jts.operation.overlayng.OverlayNG */, isStrictMode: boolean): any /* void */;
        };
        OverlayNGRobust: {
          /**
           * Overlay two geometries, using heuristics to ensure
           * computation completes correctly.
           * In practice the heuristics are observed to be fully correct.
           *
           * @param geom0 - a geometry
           * @param geom1 - a geometry
           * @param opCode - the overlay operation code (from `OverlayNG`
           * @returns the overlay result geometry
           * @see [org.locationtech.jts.operation.overlayng.OverlayNGRobust.overlay](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNGRobust.html#overlay-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-int-)
           */
          overlay(geom0: Geometry, geom1: Geometry, opCode: number): Geometry;
          /**
           * Computes the unary union of a geometry using robust computation.
           *
           * @param geom - the geometry to union
           * @returns the union result
           * @see [org.locationtech.jts.operation.overlayng.OverlayNGRobust.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/OverlayNGRobust.html#union-org.locationtech.jts.geom.Geometry-)
           */
          union(geom: Geometry): Geometry;
        };
        PrecisionReducer: {
          /**
           * Reduces the precision of a geometry by rounding and snapping it to the
           * supplied `PrecisionModel`.
           * The input geometry must be polygonal or linear.
           *
           * The output is always a valid geometry.  This implies that input components
           * may be merged if they are closer than the grid precision.
           * if merging is not desired, then the individual geometry components
           * should be processed separately.
           *
           * The output is fully noded
           * (i.e. coincident lines are merged and noded).
           * This provides an effective way to node / snap-round a collection of `LineString`s.
           *
           * @param geom - the geometry to reduce
           * @param pm - the precision model to use
           * @returns the precision-reduced geometry
           * @throws IllegalArgumentException if the reduction fails due to invalid input geometry is invalid
           * @see [org.locationtech.jts.operation.overlayng.PrecisionReducer.reducePrecision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/PrecisionReducer.html#reducePrecision-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
           */
          reducePrecision(geom: Geometry, pm: PrecisionModel): Geometry;
        };
        PrecisionUtil: {
          /**
           * Computes the inherent scale of two geometries.
           * The inherent scale is the scale factor for rounding
           * which preserves **all** digits of precision
           * (significant digits)
           * present in the geometry ordinates.
           *
           * This is the maximum inherent scale
           * of all ordinate values in the geometries.
           *
           * WARNING: this is very slow.
           *
           * @param a - a geometry
           * @param b - a geometry
           * @returns the inherent scale factor of the two geometries
           * @see [org.locationtech.jts.operation.overlayng.PrecisionUtil.inherentScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/PrecisionUtil.html#inherentScale-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          inherentScale(a: Geometry, b: Geometry): number;
          /**
           * Determines a precision model to
           * use for robust overlay operations.
           * The precision scale factor is chosen to maximize
           * output precision while avoiding round-off issues.
           *
           * NOTE: this is a heuristic determination, so is not guaranteed to
           * eliminate precision issues.
           *
           * WARNING: this is very slow.
           *
           * @param a - a geometry
           * @param b - a geometry
           * @returns a suitable precision model for overlay
           * @see [org.locationtech.jts.operation.overlayng.PrecisionUtil.robustPM](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/PrecisionUtil.html#robustPM-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          robustPM(a: Geometry, b: Geometry): PrecisionModel;
          /**
           * Determines a scale factor which maximizes
           * the digits of precision and is
           * safe to use for overlay operations.
           * The robust scale is the minimum of the
           * inherent scale and the safe scale factors.
           *
           * WARNING: this is very slow.
           *
           * @param a - a geometry
           * @param b - a geometry
           * @returns a scale factor for use in overlay operations
           * @see [org.locationtech.jts.operation.overlayng.PrecisionUtil.robustScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/PrecisionUtil.html#robustScale-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          robustScale(a: Geometry, b: Geometry): number;
          /**
           * Computes a safe scale factor for two geometries.
           * A safe scale factor ensures that the rounded
           * ordinates have no more than `MAX_ROBUST_DP_DIGITS`
           * digits of precision.
           *
           * @param a - a geometry
           * @param b - a geometry (which may be null)
           * @returns a safe scale factor for the geometry ordinates
           * @see [org.locationtech.jts.operation.overlayng.PrecisionUtil.safeScale](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/PrecisionUtil.html#safeScale-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          safeScale(a: Geometry, b: Geometry): number;
        };
        RingClipper: {
          /**
           * Clips a list of points to the clipping rectangle box.
           *
           * @param pts
           * @returns clipped pts array
           * @see [org.locationtech.jts.operation.overlayng.RingClipper.clip](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/RingClipper.html#clip-org.locationtech.jts.geom.Coordinate:A-)
           */
          clip(ringClipper: any /* org.locationtech.jts.operation.overlayng.RingClipper */, pts: Coordinate[]): Coordinate[];
          /**
           * Creates a new clipper for the given envelope.
           *
           * @param clipEnv - the clipping envelope
           * @see [org.locationtech.jts.operation.overlayng.RingClipper.RingClipper](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/RingClipper.html#RingClipper-org.locationtech.jts.geom.Envelope-)
           */
          create1(clipEnv: Envelope): any /* org.locationtech.jts.operation.overlayng.RingClipper */;
        };
        UnaryUnionNG: {
          /**
           * Unions a geometry (which is often a collection)
           * using a given precision model.
           *
           * @param geom - the geometry to union
           * @param pm - the precision model to use
           * @returns the union of the geometry
           * @see [org.locationtech.jts.operation.overlayng.UnaryUnionNG.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/overlayng/UnaryUnionNG.html#union-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
           */
          union(geom: Geometry, pm: PrecisionModel): Geometry;
        };
      };
      polygonize: {
        Polygonizer: {
          /**
           * Add a `Geometry` to the edges to be polygonized.
           * May be called multiple times.
           * Any dimension of Geometry may be added;
           * the constituent linework will be extracted and used
           *
           * @param g - a `Geometry` with linework to be polygonized
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#add-org.locationtech.jts.geom.Geometry-)
           */
          add(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */, g: Geometry): any /* void */;
          /**
           * Creates a polygonizer that extracts all polygons.
           *
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.Polygonizer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#Polygonizer--)
           */
          create0(): any /* org.locationtech.jts.operation.polygonize.Polygonizer */;
          /**
           * Creates a polygonizer, specifying whether a valid polygonal geometry must be created.
           * If the argument is `true`
           * then areas may be discarded in order to
           * ensure that the extracted geometry is a valid polygonal geometry.
           *
           * @param extractOnlyPolygonal - true if a valid polygonal geometry should be extracted
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.Polygonizer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#Polygonizer-boolean-)
           */
          create1(extractOnlyPolygonal: boolean): any /* org.locationtech.jts.operation.polygonize.Polygonizer */;
          /**
           * Gets the list of cut edges found during polygonization.
           *
           * @returns a collection of the input `LineString`s which are cut edges
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.getCutEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#getCutEdges--)
           */
          getCutEdges(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */): any /* java.util.Collection */;
          /**
           * Gets the list of dangling lines found during polygonization.
           *
           * @returns a collection of the input `LineString`s which are dangles
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.getDangles](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#getDangles--)
           */
          getDangles(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */): any /* java.util.Collection */;
          /**
           * Gets a geometry representing the polygons formed by the polygonization.
           * If a valid polygonal geometry was extracted the result is a `org.locationtech.jts.geom.Polygonal` geometry.
           *
           * @returns a geometry containing the polygons
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#getGeometry--)
           */
          getGeometry(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */): Geometry;
          /**
           * Gets the list of lines forming invalid rings found during polygonization.
           *
           * @returns a collection of the input `LineString`s which form invalid rings
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.getInvalidRingLines](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#getInvalidRingLines--)
           */
          getInvalidRingLines(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */): any /* java.util.Collection */;
          /**
           * Gets the list of polygons formed by the polygonization.
           *
           * @returns a collection of `Polygon`s
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.getPolygons](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#getPolygons--)
           */
          getPolygons(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */): any /* java.util.Collection */;
          /**
           * Allows disabling the valid ring checking,
           * to optimize situations where invalid rings are not expected.
           *
           * The default is `true`.
           *
           * @param isCheckingRingsValid - true if generated rings should be checked for validity
           * @see [org.locationtech.jts.operation.polygonize.Polygonizer.setCheckRingsValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/polygonize/Polygonizer.html#setCheckRingsValid-boolean-)
           */
          setCheckRingsValid(polygonizer: any /* org.locationtech.jts.operation.polygonize.Polygonizer */, isCheckingRingsValid: boolean): any /* void */;
        };
      };
      predicate: {
        RectangleContains: {
          /**
           * Tests whether a rectangle contains a given geometry.
           *
           * @param rectangle - a rectangular Polygon
           * @param b - a Geometry of any type
           * @returns true if the geometries intersect
           * @see [org.locationtech.jts.operation.predicate.RectangleContains.contains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/predicate/RectangleContains.html#contains-org.locationtech.jts.geom.Polygon-org.locationtech.jts.geom.Geometry-)
           */
          contains(rectangle: Geometry, b: Geometry): boolean;
          /**
           * Create a new contains computer for two geometries.
           *
           * @param rectangle - a rectangular geometry
           * @see [org.locationtech.jts.operation.predicate.RectangleContains.RectangleContains](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/predicate/RectangleContains.html#RectangleContains-org.locationtech.jts.geom.Polygon-)
           */
          create1(rectangle: Geometry): any /* org.locationtech.jts.operation.predicate.RectangleContains */;
        };
        RectangleIntersects: {
          /**
           * Create a new intersects computer for a rectangle.
           *
           * @param rectangle - a rectangular Polygon
           * @see [org.locationtech.jts.operation.predicate.RectangleIntersects.RectangleIntersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/predicate/RectangleIntersects.html#RectangleIntersects-org.locationtech.jts.geom.Polygon-)
           */
          create1(rectangle: Geometry): any /* org.locationtech.jts.operation.predicate.RectangleIntersects */;
          /**
           * Tests whether a rectangle intersects a given geometry.
           *
           * @param rectangle - a rectangular Polygon
           * @param b - a Geometry of any type
           * @returns true if the geometries intersect
           * @see [org.locationtech.jts.operation.predicate.RectangleIntersects.intersects](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/predicate/RectangleIntersects.html#intersects-org.locationtech.jts.geom.Polygon-org.locationtech.jts.geom.Geometry-)
           */
          intersects(rectangle: Geometry, b: Geometry): boolean;
        };
      };
      relate: {
        EdgeEndBuilder: {
          create0(): any /* org.locationtech.jts.operation.relate.EdgeEndBuilder */;
        };
        RelateNodeGraph: {
          create0(): any /* org.locationtech.jts.operation.relate.RelateNodeGraph */;
        };
        RelateOp: {
          /**
           * Creates a new Relate operation, using the default (OGC SFS) Boundary Node Rule.
           *
           * @param g0 - a Geometry to relate
           * @param g1 - another Geometry to relate
           * @see [org.locationtech.jts.operation.relate.RelateOp.RelateOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relate/RelateOp.html#RelateOp-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.operation.relate.RelateOp */;
          /**
           * Gets the IntersectionMatrix for the spatial relationship
           * between the input geometries.
           *
           * @returns the IntersectionMatrix for the spatial relationship between the input geometries
           * @see [org.locationtech.jts.operation.relate.RelateOp.getIntersectionMatrix](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relate/RelateOp.html#getIntersectionMatrix--)
           */
          getIntersectionMatrix(relateOp: any /* org.locationtech.jts.operation.relate.RelateOp */): IntersectionMatrix;
          /**
           * Computes the `IntersectionMatrix` for the spatial relationship
           * between two `Geometry`s, using the default (OGC SFS) Boundary Node Rule
           *
           * @param a - a Geometry to test
           * @param b - a Geometry to test
           * @returns the IntersectionMatrix for the spatial relationship between the geometries
           * @see [org.locationtech.jts.operation.relate.RelateOp.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relate/RelateOp.html#relate-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          relate(a: Geometry, b: Geometry): IntersectionMatrix;
        };
      };
      relateng: {
        RelateNG: {
          /**
           * Tests whether the topological relationship to a geometry
           * matches a DE-9IM matrix pattern.
           *
           * @param b - the B geometry to test against
           * @param imPattern - the DE-9IM pattern to match
           * @returns true if the geometries' topological relationship matches the DE-9IM pattern
           * @see [org.locationtech.jts.operation.relateng.RelateNG.evaluate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relateng/RelateNG.html#evaluate-org.locationtech.jts.geom.Geometry-java.lang.String-)
           */
          evaluate(relateNG: any /* org.locationtech.jts.operation.relateng.RelateNG */, b: Geometry, imPattern: string): boolean;
          /**
           * Creates a prepared RelateNG instance to optimize the
           * evaluation of relationships against a single geometry.
           *
           * @param a - the A input geometry
           * @returns a prepared instance
           * @see [org.locationtech.jts.operation.relateng.RelateNG.prepare](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relateng/RelateNG.html#prepare-org.locationtech.jts.geom.Geometry-)
           */
          prepare(a: Geometry): any /* org.locationtech.jts.operation.relateng.RelateNG */;
          /**
           * Tests whether the topological relationship to a geometry
           * matches a DE-9IM matrix pattern.
           *
           * @param a - the A input geometry
           * @param b - the A input geometry
           * @param imPattern - the DE-9IM pattern to match
           * @returns true if the geometries relationship matches the DE-9IM pattern
           * @see [org.locationtech.jts.operation.relateng.RelateNG.relate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/relateng/RelateNG.html#relate-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-java.lang.String-)
           */
          relate(a: Geometry, b: Geometry, imPattern: string): boolean;
        };
      };
      union: {
        CascadedPolygonUnion: {
          /**
           * Computes the union of
           * a collection of `Polygonal` `Geometry`s.
           *
           * @param polys - a collection of `Polygonal` `Geometry`s
           * @see [org.locationtech.jts.operation.union.CascadedPolygonUnion.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/union/CascadedPolygonUnion.html#union-java.util.Collection-)
           */
          union(polys: any /* java.util.Collection */): Geometry;
        };
        OverlapUnion: {
          /**
           * Creates a new instance for unioning the given geometries.
           *
           * @param g0 - a geometry to union
           * @param g1 - a geometry to union
           * @see [org.locationtech.jts.operation.union.OverlapUnion.OverlapUnion](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/union/OverlapUnion.html#OverlapUnion-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
           */
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.operation.union.OverlapUnion */;
          /**
           * Unions the input geometries,
           * using the more performant overlap union algorithm if possible.
           *
           * @returns the union of the inputs
           * @see [org.locationtech.jts.operation.union.OverlapUnion.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/union/OverlapUnion.html#union--)
           */
          union(overlapUnion: any /* org.locationtech.jts.operation.union.OverlapUnion */): Geometry;
        };
        UnaryUnionOp: {
          /**
           * Constructs a unary union operation for a `Geometry`
           * (which may be a `GeometryCollection`).
           *
           * @param geom
           * @see [org.locationtech.jts.operation.union.UnaryUnionOp.UnaryUnionOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/union/UnaryUnionOp.html#UnaryUnionOp-org.locationtech.jts.geom.Geometry-)
           */
          create1(geom: Geometry): any /* org.locationtech.jts.operation.union.UnaryUnionOp */;
          /**
           * Constructs a unary union operation for a `Geometry`
           * (which may be a `GeometryCollection`).
           *
           * @param geom - a geometry to union
           * @returns the union of the elements of the geometry or an empty GEOMETRYCOLLECTION
           * @see [org.locationtech.jts.operation.union.UnaryUnionOp.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/union/UnaryUnionOp.html#union-org.locationtech.jts.geom.Geometry-)
           */
          union(geom: Geometry): Geometry;
        };
        UnionInteracting: {
          create2(g0: Geometry, g1: Geometry): any /* org.locationtech.jts.operation.union.UnionInteracting */;
          union(g0: Geometry, g1: Geometry): Geometry;
        };
      };
      valid: {
        IsSimpleOp: {
          /**
           * Tests whether a geometry is simple.
           *
           * @param geom - the geometry to test
           * @returns true if the geometry is simple
           * @see [org.locationtech.jts.operation.valid.IsSimpleOp.isSimple](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/IsSimpleOp.html#isSimple-org.locationtech.jts.geom.Geometry-)
           */
          isSimple(geom: Geometry): boolean;
        };
        IsValidOp: {
          /**
           * Creates a new validator for a geometry.
           *
           * @param inputGeometry - the geometry to validate
           * @see [org.locationtech.jts.operation.valid.IsValidOp.IsValidOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/IsValidOp.html#IsValidOp-org.locationtech.jts.geom.Geometry-)
           */
          create1(inputGeometry: Geometry): any /* org.locationtech.jts.operation.valid.IsValidOp */;
          /**
           * Computes the validity of the geometry,
           * and if not valid returns the validation error for the geometry,
           * or null if the geometry is valid.
           *
           * @returns the validation error, if the geometry is invalid or null if the geometry is valid
           * @see [org.locationtech.jts.operation.valid.IsValidOp.getValidationError](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/IsValidOp.html#getValidationError--)
           */
          getValidationError(isValidOp: any /* org.locationtech.jts.operation.valid.IsValidOp */): any /* org.locationtech.jts.operation.valid.TopologyValidationError */;
          /**
           * Checks whether a coordinate is valid for processing.
           * Coordinates are valid if their x and y ordinates are in the
           * range of the floating point representation.
           *
           * @param coord - the coordinate to validate
           * @returns `true` if the coordinate is valid
           * @see [org.locationtech.jts.operation.valid.IsValidOp.isValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/IsValidOp.html#isValid-org.locationtech.jts.geom.Coordinate-)
           */
          isValid(coord: Coordinate): boolean;
          /**
           * Sets whether polygons using **Self-Touching Rings** to form
           * holes are reported as valid.
           * If this flag is set, the following Self-Touching conditions
           * are treated as being valid:
           *
           * - **inverted shell** - the shell ring self-touches to create a hole touching the shell
           * - **exverted hole** - a hole ring self-touches to create two holes touching at a point
           *
           * The default (following the OGC SFS standard)
           * is that this condition is **not** valid (`false`).
           *
           * Self-Touching Rings which disconnect the
           * the polygon interior are still considered to be invalid
           * (these are **invalid** under the SFS, and many other
           * spatial models as well).
           * This includes:
           *
           * - exverted ("bow-tie") shells which self-touch at a single point
           * - inverted shells with the inversion touching the shell at another point
           * - exverted holes with exversion touching the hole at another point
           * - inverted ("C-shaped") holes which self-touch at a single point causing an island to be formed
           * - inverted shells or exverted holes which form part of a chain of touching rings
           * (which disconnect the interior)
           *
           * @param isValid - states whether geometry with this condition is valid
           * @see [org.locationtech.jts.operation.valid.IsValidOp.setSelfTouchingRingFormingHoleValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/IsValidOp.html#setSelfTouchingRingFormingHoleValid-boolean-)
           */
          setSelfTouchingRingFormingHoleValid(isValidOp: any /* org.locationtech.jts.operation.valid.IsValidOp */, isValid: boolean): any /* void */;
        };
        RepeatedPointTester: {
          create0(): any /* org.locationtech.jts.operation.valid.RepeatedPointTester */;
          getCoordinate(repeatedPointTester: any /* org.locationtech.jts.operation.valid.RepeatedPointTester */): Coordinate;
          hasRepeatedPoint(repeatedPointTester: any /* org.locationtech.jts.operation.valid.RepeatedPointTester */, g: Geometry): boolean;
        };
        TopologyValidationError: {
          /**
           * Indicates that the interior of a polygon is disjoint
           * (often caused by set of contiguous holes splitting the polygon into two parts)
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.DISCONNECTED_INTERIOR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#DISCONNECTED_INTERIOR)
           */
          DISCONNECTED_INTERIOR: number;
          /**
           * Indicates that a polygonal geometry contains two rings which are identical
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.DUPLICATE_RINGS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#DUPLICATE_RINGS)
           */
          DUPLICATE_RINGS: number;
          /**
           * Not used
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.ERROR](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#ERROR)
           */
          ERROR: number;
          /**
           * Indicates that a hole of a polygon lies partially or completely in the exterior of the shell
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.HOLE_OUTSIDE_SHELL](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#HOLE_OUTSIDE_SHELL)
           */
          HOLE_OUTSIDE_SHELL: number;
          /**
           * Indicates that the `X` or `Y` ordinate of
           * a Coordinate is not a valid numeric value (e.g. `Double.NaN` )
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.INVALID_COORDINATE](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#INVALID_COORDINATE)
           */
          INVALID_COORDINATE: number;
          /**
           * Indicates that a hole lies in the interior of another hole in the same polygon
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.NESTED_HOLES](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#NESTED_HOLES)
           */
          NESTED_HOLES: number;
          /**
           * Indicates that a polygon component of a MultiPolygon lies inside another polygonal component
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.NESTED_SHELLS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#NESTED_SHELLS)
           */
          NESTED_SHELLS: number;
          /**
           * No longer used - repeated points are considered valid as per the SFS
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.REPEATED_POINT](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#REPEATED_POINT)
           */
          REPEATED_POINT: number;
          /**
           * Indicates that a ring is not correctly closed
           * (the first and the last coordinate are different)
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.RING_NOT_CLOSED](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#RING_NOT_CLOSED)
           */
          RING_NOT_CLOSED: number;
          /**
           * Indicates that a ring self-intersects
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.RING_SELF_INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#RING_SELF_INTERSECTION)
           */
          RING_SELF_INTERSECTION: number;
          /**
           * Indicates that two rings of a polygonal geometry intersect
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.SELF_INTERSECTION](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#SELF_INTERSECTION)
           */
          SELF_INTERSECTION: number;
          /**
           * Indicates that either
           *
           * - a LineString contains a single point
           * - a LinearRing contains 2 or 3 points
           *
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.TOO_FEW_POINTS](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#TOO_FEW_POINTS)
           */
          TOO_FEW_POINTS: number;
          /**
           * Creates a validation error of the given type with a null location
           *
           * @param errorType - the type of the error
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.TopologyValidationError](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#TopologyValidationError-int-)
           */
          create1(errorType: number): any /* org.locationtech.jts.operation.valid.TopologyValidationError */;
          /**
           * Creates a validation error with the given type and location
           *
           * @param errorType - the type of the error
           * @param pt - the location of the error
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.TopologyValidationError](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#TopologyValidationError-int-org.locationtech.jts.geom.Coordinate-)
           */
          create2(errorType: number, pt: Coordinate): any /* org.locationtech.jts.operation.valid.TopologyValidationError */;
          /**
           * Returns the location of this error (on the `Geometry` containing the error).
           *
           * @returns a `Coordinate` on the input geometry
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#getCoordinate--)
           */
          getCoordinate(topologyValidationError: any /* org.locationtech.jts.operation.valid.TopologyValidationError */): Coordinate;
          /**
           * Gets the type of this error.
           *
           * @returns the error type
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.getErrorType](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#getErrorType--)
           */
          getErrorType(topologyValidationError: any /* org.locationtech.jts.operation.valid.TopologyValidationError */): number;
          /**
           * Gets an error message describing this error.
           * The error message does not describe the location of the error.
           *
           * @returns the error message
           * @see [org.locationtech.jts.operation.valid.TopologyValidationError.getMessage](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/operation/valid/TopologyValidationError.html#getMessage--)
           */
          getMessage(topologyValidationError: any /* org.locationtech.jts.operation.valid.TopologyValidationError */): string;
        };
      };
    };
    precision: {
      CommonBits: {
        add(commonBits: any /* org.locationtech.jts.precision.CommonBits */, num: number): any /* void */;
        create0(): any /* org.locationtech.jts.precision.CommonBits */;
        getCommon(commonBits: any /* org.locationtech.jts.precision.CommonBits */): number;
      };
      CommonBitsOp: {
        /**
         * Computes the buffer a geometry,
         * using enhanced precision.
         *
         * @param geom0 - the Geometry to buffer
         * @param distance - the buffer distance
         * @returns the Geometry representing the buffer of the input Geometry.
         * @see [org.locationtech.jts.precision.CommonBitsOp.buffer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#buffer-org.locationtech.jts.geom.Geometry-double-)
         */
        buffer(commonBitsOp: any /* org.locationtech.jts.precision.CommonBitsOp */, geom0: Geometry, distance: number): Geometry;
        /**
         * Creates a new instance of class, which reshifts result `Geometry`s.
         *
         * @see [org.locationtech.jts.precision.CommonBitsOp.CommonBitsOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#CommonBitsOp--)
         */
        create0(): any /* org.locationtech.jts.precision.CommonBitsOp */;
        /**
         * Creates a new instance of class, specifying whether
         * the result `Geometry`s should be reshifted.
         *
         * @param returnToOriginalPrecision
         * @see [org.locationtech.jts.precision.CommonBitsOp.CommonBitsOp](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#CommonBitsOp-boolean-)
         */
        create1(returnToOriginalPrecision: boolean): any /* org.locationtech.jts.precision.CommonBitsOp */;
        /**
         * Computes the set-theoretic difference of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry, to be subtracted from the first
         * @returns the Geometry representing the set-theoretic difference of the input Geometries.
         * @see [org.locationtech.jts.precision.CommonBitsOp.difference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#difference-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        difference(commonBitsOp: any /* org.locationtech.jts.precision.CommonBitsOp */, geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic intersection of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic intersection of the input Geometries.
         * @see [org.locationtech.jts.precision.CommonBitsOp.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#intersection-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        intersection(commonBitsOp: any /* org.locationtech.jts.precision.CommonBitsOp */, geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic symmetric difference of two geometries,
         * using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic symmetric difference of the input Geometries.
         * @see [org.locationtech.jts.precision.CommonBitsOp.symDifference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#symDifference-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        symDifference(commonBitsOp: any /* org.locationtech.jts.precision.CommonBitsOp */, geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic union of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic union of the input Geometries.
         * @see [org.locationtech.jts.precision.CommonBitsOp.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsOp.html#union-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        union(commonBitsOp: any /* org.locationtech.jts.precision.CommonBitsOp */, geom0: Geometry, geom1: Geometry): Geometry;
      };
      CommonBitsRemover: {
        /**
         * Add a geometry to the set of geometries whose common bits are
         * being computed.  After this method has executed the
         * common coordinate reflects the common bits of all added
         * geometries.
         *
         * @param geom - a Geometry to test for common bits
         * @see [org.locationtech.jts.precision.CommonBitsRemover.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsRemover.html#add-org.locationtech.jts.geom.Geometry-)
         */
        add(commonBitsRemover: any /* org.locationtech.jts.precision.CommonBitsRemover */, geom: Geometry): any /* void */;
        /**
         * Adds the common coordinate bits back into a Geometry.
         * The coordinates of the Geometry are changed.
         *
         * @param geom - the Geometry to which to add the common coordinate bits
         * @see [org.locationtech.jts.precision.CommonBitsRemover.addCommonBits](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsRemover.html#addCommonBits-org.locationtech.jts.geom.Geometry-)
         */
        addCommonBits(commonBitsRemover: any /* org.locationtech.jts.precision.CommonBitsRemover */, geom: Geometry): any /* void */;
        create0(): any /* org.locationtech.jts.precision.CommonBitsRemover */;
        /**
         * The common bits of the Coordinates in the supplied Geometries.
         *
         * @see [org.locationtech.jts.precision.CommonBitsRemover.getCommonCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsRemover.html#getCommonCoordinate--)
         */
        getCommonCoordinate(commonBitsRemover: any /* org.locationtech.jts.precision.CommonBitsRemover */): Coordinate;
        /**
         * Removes the common coordinate bits from a Geometry.
         * The coordinates of the Geometry are changed.
         *
         * @param geom - the Geometry from which to remove the common coordinate bits
         * @returns the shifted Geometry
         * @see [org.locationtech.jts.precision.CommonBitsRemover.removeCommonBits](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CommonBitsRemover.html#removeCommonBits-org.locationtech.jts.geom.Geometry-)
         */
        removeCommonBits(commonBitsRemover: any /* org.locationtech.jts.precision.CommonBitsRemover */, geom: Geometry): Geometry;
      };
      CoordinatePrecisionReducerFilter: {
        /**
         * Creates a new precision reducer filter.
         *
         * @param precModel - the PrecisionModel to use
         * @see [org.locationtech.jts.precision.CoordinatePrecisionReducerFilter.CoordinatePrecisionReducerFilter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CoordinatePrecisionReducerFilter.html#CoordinatePrecisionReducerFilter-org.locationtech.jts.geom.PrecisionModel-)
         */
        create1(precModel: PrecisionModel): any /* org.locationtech.jts.precision.CoordinatePrecisionReducerFilter */;
        /**
         * Rounds the Coordinates in the sequence to match the PrecisionModel
         *
         * @see [org.locationtech.jts.precision.CoordinatePrecisionReducerFilter.filter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CoordinatePrecisionReducerFilter.html#filter-org.locationtech.jts.geom.CoordinateSequence-int-)
         */
        filter(coordinatePrecisionReducerFilter: any /* org.locationtech.jts.precision.CoordinatePrecisionReducerFilter */, seq: CoordinateSequence, i: number): any /* void */;
        /**
         * Always runs over all geometry components.
         *
         * @returns false
         * @see [org.locationtech.jts.precision.CoordinatePrecisionReducerFilter.isDone](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CoordinatePrecisionReducerFilter.html#isDone--)
         */
        isDone(coordinatePrecisionReducerFilter: any /* org.locationtech.jts.precision.CoordinatePrecisionReducerFilter */): boolean;
        /**
         * Always reports that the geometry has changed
         *
         * @returns true
         * @see [org.locationtech.jts.precision.CoordinatePrecisionReducerFilter.isGeometryChanged](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/CoordinatePrecisionReducerFilter.html#isGeometryChanged--)
         */
        isGeometryChanged(coordinatePrecisionReducerFilter: any /* org.locationtech.jts.precision.CoordinatePrecisionReducerFilter */): boolean;
      };
      EnhancedPrecisionOp: {
        /**
         * Computes the buffer of a `Geometry`, using enhanced precision.
         * This method should no longer be necessary, since the buffer algorithm
         * now is highly robust.
         *
         * @param geom - the first Geometry
         * @param distance - the buffer distance
         * @returns the Geometry representing the buffer of the input Geometry.
         * @see [org.locationtech.jts.precision.EnhancedPrecisionOp.buffer](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/EnhancedPrecisionOp.html#buffer-org.locationtech.jts.geom.Geometry-double-)
         */
        buffer(geom: Geometry, distance: number): Geometry;
        /**
         * Computes the set-theoretic difference of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic difference of the input Geometries.
         * @see [org.locationtech.jts.precision.EnhancedPrecisionOp.difference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/EnhancedPrecisionOp.html#difference-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        difference(geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic intersection of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic intersection of the input Geometries.
         * @see [org.locationtech.jts.precision.EnhancedPrecisionOp.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/EnhancedPrecisionOp.html#intersection-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        intersection(geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic symmetric difference of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic symmetric difference of the input Geometries.
         * @see [org.locationtech.jts.precision.EnhancedPrecisionOp.symDifference](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/EnhancedPrecisionOp.html#symDifference-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        symDifference(geom0: Geometry, geom1: Geometry): Geometry;
        /**
         * Computes the set-theoretic union of two `Geometry`s, using enhanced precision.
         *
         * @param geom0 - the first Geometry
         * @param geom1 - the second Geometry
         * @returns the Geometry representing the set-theoretic union of the input Geometries.
         * @see [org.locationtech.jts.precision.EnhancedPrecisionOp.union](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/EnhancedPrecisionOp.html#union-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.Geometry-)
         */
        union(geom0: Geometry, geom1: Geometry): Geometry;
      };
      GeometryPrecisionReducer: {
        create(pm: PrecisionModel): GeometryPrecisionReducer;
        /**
         * Reduces precision of a geometry, ensuring output geometry is valid.
         * Collapsed linear and polygonal components are removed.
         * Duplicate vertices are removed.
         * The geometry precision model is not changed.
         *
         * Invalid input geometry may cause an error,
         * unless the invalidity is below the scale of the precision reduction.
         *
         * @param g - the geometry to reduce
         * @param precModel - the precision model to use
         * @returns the reduced geometry
         * @throws IllegalArgumentException if the reduction fails due to invalid input geometry
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.reduce](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#reduce-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
         */
        reduce(g: Geometry, precModel: PrecisionModel): Geometry;
        /**
         * Reduces the precision of a geometry,
         * according to the specified strategy of this reducer.
         *
         * @param geom - the geometry to reduce
         * @returns the precision-reduced geometry
         * @throws IllegalArgumentException if the reduction fails due to invalid input geometry is invalid
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.reduce](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#reduce-org.locationtech.jts.geom.Geometry-)
         */
        reduceInstance(geometryPrecisionReducer: GeometryPrecisionReducer, geom: Geometry): Geometry;
        /**
         * Reduces precision of a geometry, ensuring output polygonal geometry is valid,
         * and preserving collapsed linear elements.
         * Duplicate vertices are removed.
         * The geometry precision model is not changed.
         *
         * Invalid input geometry may cause an error,
         * unless the invalidity is below the scale of the precision reduction.
         *
         * @param geom - the geometry to reduce
         * @param pm - the precision model to use
         * @returns the reduced geometry
         * @throws IllegalArgumentException if the reduction fails due to invalid input geometry
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.reduceKeepCollapsed](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#reduceKeepCollapsed-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
         */
        reduceKeepCollapsed(geom: Geometry, pm: PrecisionModel): Geometry;
        /**
         * Reduce precision of a geometry in a pointwise way.
         * All input geometry elements are preserved in the output,
         * including invalid polygons and collapsed polygons and linestrings.
         * The output may not be valid, due to collapse or self-intersection.
         * Duplicate vertices are not removed.
         * The geometry precision model is not changed.
         *
         * Invalid input geometry is allowed.
         *
         * @param g - the geometry to reduce
         * @param precModel - the precision model to use
         * @returns the reduced geometry
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.reducePointwise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#reducePointwise-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
         */
        reducePointwise(g: Geometry, precModel: PrecisionModel): Geometry;
        /**
         * Sets whether the `PrecisionModel` of the new reduced Geometry
         * will be changed to be the `PrecisionModel` supplied to
         * specify the precision reduction.
         *
         * The default is to **not** change the precision model
         *
         * @param changePrecisionModel - if `true` the precision model of the created Geometry will be the the precisionModel supplied in the constructor.
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.setChangePrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#setChangePrecisionModel-boolean-)
         */
        setChangePrecisionModel(geometryPrecisionReducer: GeometryPrecisionReducer, changePrecisionModel: boolean): any /* void */;
        /**
         * Sets whether the precision reduction will be done
         * in pointwise fashion only.
         * Pointwise precision reduction reduces the precision
         * of the individual coordinates only, but does
         * not attempt to recreate valid topology.
         * This is only relevant for geometries containing polygonal components.
         *
         * @param isPointwise - if reduction should be done pointwise only
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.setPointwise](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#setPointwise-boolean-)
         */
        setPointwise(geometryPrecisionReducer: GeometryPrecisionReducer, isPointwise: boolean): any /* void */;
        /**
         * Sets whether the reduction will result in collapsed components
         * being removed completely, or simply being collapsed to an (invalid)
         * Geometry of the same type.
         * The default is to remove collapsed components.
         *
         * @param removeCollapsed - if `true` collapsed components will be removed
         * @see [org.locationtech.jts.precision.GeometryPrecisionReducer.setRemoveCollapsedComponents](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/GeometryPrecisionReducer.html#setRemoveCollapsedComponents-boolean-)
         */
        setRemoveCollapsedComponents(geometryPrecisionReducer: GeometryPrecisionReducer, removeCollapsed: boolean): any /* void */;
      };
      MinimumClearance: {
        /**
         * Creates an object to compute the Minimum Clearance
         * for the given Geometry
         *
         * @param geom - the input geometry
         * @see [org.locationtech.jts.precision.MinimumClearance.MinimumClearance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/MinimumClearance.html#MinimumClearance-org.locationtech.jts.geom.Geometry-)
         */
        create1(geom: Geometry): any /* org.locationtech.jts.precision.MinimumClearance */;
        /**
         * Computes the Minimum Clearance distance for
         * the given Geometry.
         *
         * @param g - the input geometry
         * @returns the Minimum Clearance distance
         * @see [org.locationtech.jts.precision.MinimumClearance.getDistance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/MinimumClearance.html#getDistance-org.locationtech.jts.geom.Geometry-)
         */
        getDistance(g: Geometry): number;
        /**
         * Gets a LineString containing two points
         * which are at the Minimum Clearance distance
         * for the given Geometry.
         *
         * @param g - the input geometry
         * @returns the value of the minimum clearance distance or `LINESTRING EMPTY` if no Minimum Clearance distance exists
         * @see [org.locationtech.jts.precision.MinimumClearance.getLine](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/MinimumClearance.html#getLine-org.locationtech.jts.geom.Geometry-)
         */
        getLine(g: Geometry): Geometry;
      };
      PrecisionReducerCoordinateOperation: {
        create2(targetPM: PrecisionModel, removeCollapsed: boolean): any /* org.locationtech.jts.precision.PrecisionReducerCoordinateOperation */;
        edit(precisionReducerCoordinateOperation: any /* org.locationtech.jts.precision.PrecisionReducerCoordinateOperation */, coordinates: Coordinate[], geom: Geometry): Coordinate[];
      };
      SimpleGeometryPrecisionReducer: {
        create1(pm: PrecisionModel): any /* org.locationtech.jts.precision.SimpleGeometryPrecisionReducer */;
        /**
         * Convenience method for doing precision reduction on a single geometry,
         * with collapses removed and keeping the geometry precision model the same.
         *
         * @param g
         * @param precModel
         * @returns the reduced geometry
         * @see [org.locationtech.jts.precision.SimpleGeometryPrecisionReducer.reduce](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/SimpleGeometryPrecisionReducer.html#reduce-org.locationtech.jts.geom.Geometry-org.locationtech.jts.geom.PrecisionModel-)
         */
        reduce(g: Geometry, precModel: PrecisionModel): Geometry;
        /**
         * Sets whether the `PrecisionModel` of the new reduced Geometry
         * will be changed to be the `PrecisionModel` supplied to
         * specify the precision reduction.
         *
         * The default is to **not** change the precision model
         *
         * @param changePrecisionModel - if `true` the precision model of the created Geometry will be the the precisionModel supplied in the constructor.
         * @see [org.locationtech.jts.precision.SimpleGeometryPrecisionReducer.setChangePrecisionModel](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/SimpleGeometryPrecisionReducer.html#setChangePrecisionModel-boolean-)
         */
        setChangePrecisionModel(simpleGeometryPrecisionReducer: any /* org.locationtech.jts.precision.SimpleGeometryPrecisionReducer */, changePrecisionModel: boolean): any /* void */;
        /**
         * Sets whether the reduction will result in collapsed components
         * being removed completely, or simply being collapsed to an (invalid)
         * Geometry of the same type.
         * The default is to remove collapsed components.
         *
         * @param removeCollapsed - if `true` collapsed components will be removed
         * @see [org.locationtech.jts.precision.SimpleGeometryPrecisionReducer.setRemoveCollapsedComponents](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/precision/SimpleGeometryPrecisionReducer.html#setRemoveCollapsedComponents-boolean-)
         */
        setRemoveCollapsedComponents(simpleGeometryPrecisionReducer: any /* org.locationtech.jts.precision.SimpleGeometryPrecisionReducer */, removeCollapsed: boolean): any /* void */;
      };
      SimpleMinimumClearance: {
        create1(geom: Geometry): any /* org.locationtech.jts.precision.SimpleMinimumClearance */;
        getDistance(g: Geometry): number;
        getLine(g: Geometry): Geometry;
      };
    };
    shape: {
      CubicBezierCurve: {
        /**
         * Creates a geometry of linearized Cubic Bezier Curves
         * defined by the segments of the input and a parameter
         * controlling how curved the result should be, with a skew factor
         * affecting the curve shape at each vertex.
         *
         * @param geom - the geometry defining the curve
         * @param alpha - curvedness parameter (0 is linear, 1 is round, >1 is increasingly curved)
         * @param skew - the skew parameter (0 is none, positive skews towards longer side, negative towards shorter
         * @returns the linearized curved geometry
         * @see [org.locationtech.jts.shape.CubicBezierCurve.bezierCurve](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/CubicBezierCurve.html#bezierCurve-org.locationtech.jts.geom.Geometry-double-double-)
         */
        bezierCurve(geom: Geometry, alpha: number, skew: number): Geometry;
      };
      fractal: {
        HilbertCode: {
          /**
           * The maximum curve level that can be represented.
           *
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.MAX_LEVEL](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#MAX_LEVEL)
           */
          MAX_LEVEL: number;
          /**
           * Computes the point on a Hilbert curve
           * of given level for a given code index.
           * The point ordinates will lie in the range [0, 2^level - 1].
           *
           * @param level - the Hilbert curve level
           * @param index - the index of the point on the curve
           * @returns the point on the Hilbert curve
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.decode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#decode-int-int-)
           */
          decode(level: number, index: number): Coordinate;
          /**
           * Encodes a point (x,y)
           * in the range of the the Hilbert curve at a given level
           * as the index of the point along the curve.
           * The index will lie in the range [0, 2^level + 1].
           *
           * @param level - the level of the Hilbert curve
           * @param x - the x ordinate of the point
           * @param y - the y ordinate of the point
           * @returns the index of the point along the Hilbert curve
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.encode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#encode-int-int-int-)
           */
          encode(level: number, x: number, y: number): number;
          /**
           * The level of the finite Hilbert curve which contains at least
           * the given number of points.
           *
           * @param numPoints - the number of points required
           * @returns the level of the curve
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.level](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#level-int-)
           */
          level(numPoints: number): number;
          /**
           * The maximum ordinate value for points
           * in the curve for the given level.
           * The maximum ordinate is 2^level - 1.
           *
           * @param level - the level of the curve
           * @returns the maximum ordinate value
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.maxOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#maxOrdinate-int-)
           */
          maxOrdinate(level: number): number;
          /**
           * The number of points in the curve for the given level.
           * The number of points is 2^2 * level.
           *
           * @param level - the level of the curve
           * @returns the number of points
           * @see [org.locationtech.jts.shape.fractal.HilbertCode.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/HilbertCode.html#size-int-)
           */
          size(level: number): number;
        };
        KochSnowflakeBuilder: {
          addSide(kochSnowflakeBuilder: any /* org.locationtech.jts.shape.fractal.KochSnowflakeBuilder */, level: number, p0: Coordinate, p1: Coordinate): any /* void */;
          create1(geomFactory: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.shape.fractal.KochSnowflakeBuilder */;
          getGeometry(kochSnowflakeBuilder: any /* org.locationtech.jts.shape.fractal.KochSnowflakeBuilder */): Geometry;
          recursionLevelForSize(numPts: number): number;
        };
        MortonCode: {
          /**
           * The maximum curve level that can be represented.
           *
           * @see [org.locationtech.jts.shape.fractal.MortonCode.MAX_LEVEL](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#MAX_LEVEL)
           */
          MAX_LEVEL: number;
          /**
           * Computes the point on the Morton curve
           * for a given index.
           *
           * @param index - the index of the point on the curve
           * @returns the point on the curve
           * @see [org.locationtech.jts.shape.fractal.MortonCode.decode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#decode-int-)
           */
          decode(index: number): Coordinate;
          /**
           * Computes the index of the point (x,y)
           * in the Morton curve ordering.
           *
           * @param x - the x ordinate of the point
           * @param y - the y ordinate of the point
           * @returns the index of the point along the Morton curve
           * @see [org.locationtech.jts.shape.fractal.MortonCode.encode](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#encode-int-int-)
           */
          encode(x: number, y: number): number;
          /**
           * The level of the finite Morton curve which contains at least
           * the given number of points.
           *
           * @param numPoints - the number of points required
           * @returns the level of the curve
           * @see [org.locationtech.jts.shape.fractal.MortonCode.level](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#level-int-)
           */
          level(numPoints: number): number;
          /**
           * The maximum ordinate value for points
           * in the curve for the given level.
           * The maximum ordinate is 2^level - 1.
           *
           * @param level - the level of the curve
           * @returns the maximum ordinate value
           * @see [org.locationtech.jts.shape.fractal.MortonCode.maxOrdinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#maxOrdinate-int-)
           */
          maxOrdinate(level: number): number;
          /**
           * The number of points in the curve for the given level.
           * The number of points is 2^2 * level.
           *
           * @param level - the level of the curve
           * @returns the number of points
           * @see [org.locationtech.jts.shape.fractal.MortonCode.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/fractal/MortonCode.html#size-int-)
           */
          size(level: number): number;
        };
        SierpinskiCarpetBuilder: {
          create1(geomFactory: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.shape.fractal.SierpinskiCarpetBuilder */;
          getGeometry(sierpinskiCarpetBuilder: any /* org.locationtech.jts.shape.fractal.SierpinskiCarpetBuilder */): Geometry;
          recursionLevelForSize(numPts: number): number;
        };
      };
      random: {
        RandomPointsBuilder: {
          /**
           * Create a shape factory which will create shapes using the default
           * `GeometryFactory`.
           *
           * @see [org.locationtech.jts.shape.random.RandomPointsBuilder.RandomPointsBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsBuilder.html#RandomPointsBuilder--)
           */
          create0(): any /* org.locationtech.jts.shape.random.RandomPointsBuilder */;
          /**
           * Create a shape factory which will create shapes using the given
           * `GeometryFactory`.
           *
           * @param geomFact - the factory to use
           * @see [org.locationtech.jts.shape.random.RandomPointsBuilder.RandomPointsBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsBuilder.html#RandomPointsBuilder-org.locationtech.jts.geom.GeometryFactory-)
           */
          create1(geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.shape.random.RandomPointsBuilder */;
          getGeometry(randomPointsBuilder: any /* org.locationtech.jts.shape.random.RandomPointsBuilder */): Geometry;
          /**
           * Sets a polygonal mask.
           *
           * @param mask
           * @throws IllegalArgumentException if the mask is not polygonal
           * @see [org.locationtech.jts.shape.random.RandomPointsBuilder.setExtent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsBuilder.html#setExtent-org.locationtech.jts.geom.Geometry-)
           */
          setExtent(randomPointsBuilder: any /* org.locationtech.jts.shape.random.RandomPointsBuilder */, mask: Geometry): any /* void */;
        };
        RandomPointsInGridBuilder: {
          /**
           * Create a builder which will create shapes using the default
           * `GeometryFactory`.
           *
           * @see [org.locationtech.jts.shape.random.RandomPointsInGridBuilder.RandomPointsInGridBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.html#RandomPointsInGridBuilder--)
           */
          create0(): any /* org.locationtech.jts.shape.random.RandomPointsInGridBuilder */;
          /**
           * Create a builder which will create shapes using the given
           * `GeometryFactory`.
           *
           * @param geomFact - the factory to use
           * @see [org.locationtech.jts.shape.random.RandomPointsInGridBuilder.RandomPointsInGridBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.html#RandomPointsInGridBuilder-org.locationtech.jts.geom.GeometryFactory-)
           */
          create1(geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.shape.random.RandomPointsInGridBuilder */;
          /**
           * Gets the `MultiPoint` containing the generated point
           *
           * @returns a MultiPoint
           * @see [org.locationtech.jts.shape.random.RandomPointsInGridBuilder.getGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.html#getGeometry--)
           */
          getGeometry(randomPointsInGridBuilder: any /* org.locationtech.jts.shape.random.RandomPointsInGridBuilder */): Geometry;
          /**
           * Sets whether generated points are constrained to lie
           * within a circle contained within each grid cell.
           * This provides greater separation between points
           * in adjacent cells.
           *
           * The default is to not be constrained to a circle.
           *
           * @param isConstrainedToCircle
           * @see [org.locationtech.jts.shape.random.RandomPointsInGridBuilder.setConstrainedToCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.html#setConstrainedToCircle-boolean-)
           */
          setConstrainedToCircle(randomPointsInGridBuilder: any /* org.locationtech.jts.shape.random.RandomPointsInGridBuilder */, isConstrainedToCircle: boolean): any /* void */;
          /**
           * Sets the fraction of the grid cell side which will be treated as
           * a gutter, in which no points will be created.
           * The provided value is clamped to the range [0.0, 1.0].
           *
           * @param gutterFraction
           * @see [org.locationtech.jts.shape.random.RandomPointsInGridBuilder.setGutterFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.html#setGutterFraction-double-)
           */
          setGutterFraction(randomPointsInGridBuilder: any /* org.locationtech.jts.shape.random.RandomPointsInGridBuilder */, gutterFraction: number): any /* void */;
        };
      };
    };
    simplify: {
      DouglasPeuckerSimplifier: {
        /**
         * Simplifies a geometry using a given tolerance.
         *
         * @param geom - geometry to simplify
         * @param distanceTolerance - the tolerance to use
         * @returns a simplified version of the geometry
         * @see [org.locationtech.jts.simplify.DouglasPeuckerSimplifier.simplify](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/DouglasPeuckerSimplifier.html#simplify-org.locationtech.jts.geom.Geometry-double-)
         */
        simplify(geom: Geometry, distanceTolerance: number): Geometry;
      };
      LinkedLine: {
        create1(pts: Coordinate[]): any /* org.locationtech.jts.simplify.LinkedLine */;
        getCoordinate(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, index: number): Coordinate;
        getCoordinates(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */): Coordinate[];
        hasCoordinate(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, index: number): boolean;
        isCorner(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, i: number): boolean;
        isRing(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */): boolean;
        next(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, i: number): number;
        nextCoordinate(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, index: number): Coordinate;
        prev(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, i: number): number;
        prevCoordinate(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, index: number): Coordinate;
        remove(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */, index: number): any /* void */;
        size(linkedLine: any /* org.locationtech.jts.simplify.LinkedLine */): number;
      };
      PolygonHullSimplifier: {
        /**
         * Creates a new instance
         * to compute a simplified hull of a polygonal geometry.
         * An outer or inner hull is computed
         * depending on the value of `isOuter`.
         *
         * @param inputGeom - the polygonal geometry to process
         * @param isOuter - indicates whether to compute an outer or inner hull
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.PolygonHullSimplifier](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#PolygonHullSimplifier-org.locationtech.jts.geom.Geometry-boolean-)
         */
        create2(inputGeom: Geometry, isOuter: boolean): any /* org.locationtech.jts.simplify.PolygonHullSimplifier */;
        /**
         * Gets the result polygonal hull geometry.
         *
         * @returns the polygonal geometry for the hull
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#getResult--)
         */
        getResult(polygonHullSimplifier: any /* org.locationtech.jts.simplify.PolygonHullSimplifier */): Geometry;
        /**
         * Computes a topology-preserving simplified hull of a polygonal geometry,
         * with hull shape determined by a target parameter
         * specifying the fraction of the input vertices retained in the result.
         * Larger values compute less concave results.
         * A value of 1 produces the convex hull; a value of 0 produces the original geometry.
         * Either outer or inner hulls can be computed.
         *
         * @param geom - the polygonal geometry to process
         * @param isOuter - indicates whether to compute an outer or inner hull
         * @param vertexNumFraction - the target fraction of number of input vertices in result
         * @returns the hull geometry
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.hull](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#hull-org.locationtech.jts.geom.Geometry-boolean-double-)
         */
        hull(geom: Geometry, isOuter: boolean, vertexNumFraction: number): Geometry;
        /**
         * Computes a topology-preserving simplified hull of a polygonal geometry,
         * with hull shape determined by a target parameter
         * specifying the ratio of maximum difference in area to original area.
         * Larger values compute less concave results.
         * A value of 0 produces the original geometry.
         * Either outer or inner hulls can be computed.
         *
         * @param geom - the polygonal geometry to process
         * @param isOuter - indicates whether to compute an outer or inner hull
         * @param areaDeltaRatio - the target ratio of area difference to original area
         * @returns the hull geometry
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.hullByAreaDelta](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#hullByAreaDelta-org.locationtech.jts.geom.Geometry-boolean-double-)
         */
        hullByAreaDelta(geom: Geometry, isOuter: boolean, areaDeltaRatio: number): Geometry;
        /**
         * Sets the target maximum ratio of the change in area of the result to the input area.
         * The value must be 0 or greater.
         *
         * @param areaDeltaRatio - a ratio of the change in area of the result
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.setAreaDeltaRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#setAreaDeltaRatio-double-)
         */
        setAreaDeltaRatio(polygonHullSimplifier: any /* org.locationtech.jts.simplify.PolygonHullSimplifier */, areaDeltaRatio: number): any /* void */;
        /**
         * Sets the target fraction of input vertices
         * which are retained in the result.
         * The value should be in the range [0,1].
         *
         * @param vertexNumFraction - a fraction of the number of input vertices
         * @see [org.locationtech.jts.simplify.PolygonHullSimplifier.setVertexNumFraction](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/PolygonHullSimplifier.html#setVertexNumFraction-double-)
         */
        setVertexNumFraction(polygonHullSimplifier: any /* org.locationtech.jts.simplify.PolygonHullSimplifier */, vertexNumFraction: number): any /* void */;
      };
      TopologyPreservingSimplifier: {
        create1(inputGeom: Geometry): any /* org.locationtech.jts.simplify.TopologyPreservingSimplifier */;
        getResultGeometry(topologyPreservingSimplifier: any /* org.locationtech.jts.simplify.TopologyPreservingSimplifier */): Geometry;
        /**
         * Sets the distance tolerance for the simplification.
         * All vertices in the simplified geometry will be within this
         * distance of the original geometry.
         * The tolerance value must be non-negative.  A tolerance value
         * of zero is effectively a no-op.
         *
         * @param distanceTolerance - the approximation tolerance to use
         * @see [org.locationtech.jts.simplify.TopologyPreservingSimplifier.setDistanceTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/TopologyPreservingSimplifier.html#setDistanceTolerance-double-)
         */
        setDistanceTolerance(topologyPreservingSimplifier: any /* org.locationtech.jts.simplify.TopologyPreservingSimplifier */, distanceTolerance: number): any /* void */;
        simplify(geom: Geometry, distanceTolerance: number): Geometry;
      };
      VWSimplifier: {
        /**
         * Creates a simplifier for a given geometry.
         *
         * @param inputGeom - the geometry to simplify
         * @see [org.locationtech.jts.simplify.VWSimplifier.VWSimplifier](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/VWSimplifier.html#VWSimplifier-org.locationtech.jts.geom.Geometry-)
         */
        create1(inputGeom: Geometry): any /* org.locationtech.jts.simplify.VWSimplifier */;
        /**
         * Gets the simplified geometry.
         *
         * @returns the simplified geometry
         * @see [org.locationtech.jts.simplify.VWSimplifier.getResultGeometry](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/VWSimplifier.html#getResultGeometry--)
         */
        getResultGeometry(vWSimplifier: any /* org.locationtech.jts.simplify.VWSimplifier */): Geometry;
        /**
         * Sets the distance tolerance for the simplification. All vertices in the
         * simplified geometry will be within this distance of the original geometry.
         * The tolerance value must be non-negative.
         *
         * @param distanceTolerance - the approximation tolerance to use
         * @see [org.locationtech.jts.simplify.VWSimplifier.setDistanceTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/VWSimplifier.html#setDistanceTolerance-double-)
         */
        setDistanceTolerance(vWSimplifier: any /* org.locationtech.jts.simplify.VWSimplifier */, distanceTolerance: number): any /* void */;
        /**
         * Controls whether simplified polygons will be "fixed" to have valid
         * topology. The caller may choose to disable this because:
         *
         * - valid topology is not required
         * - fixing topology is a relative expensive operation
         * - in some pathological cases the topology fixing operation may either
         * fail or run for too long
         *
         * The default is to fix polygon topology.
         *
         * @param isEnsureValidTopology
         * @see [org.locationtech.jts.simplify.VWSimplifier.setEnsureValid](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/VWSimplifier.html#setEnsureValid-boolean-)
         */
        setEnsureValid(vWSimplifier: any /* org.locationtech.jts.simplify.VWSimplifier */, isEnsureValidTopology: boolean): any /* void */;
        /**
         * Simplifies a geometry using a given tolerance.
         *
         * @param geom - geometry to simplify
         * @param distanceTolerance - the tolerance to use
         * @returns a simplified version of the geometry
         * @see [org.locationtech.jts.simplify.VWSimplifier.simplify](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/simplify/VWSimplifier.html#simplify-org.locationtech.jts.geom.Geometry-double-)
         */
        simplify(geom: Geometry, distanceTolerance: number): Geometry;
      };
    };
    triangulate: {
      ConformingDelaunayTriangulationBuilder: {
        create0(): any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */;
        /**
         * Gets the edges of the computed triangulation as a `MultiLineString`.
         *
         * @param geomFact - the geometry factory to use to create the output
         * @returns the edges of the triangulation
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.getEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#getEdges-org.locationtech.jts.geom.GeometryFactory-)
         */
        getEdges(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Gets the QuadEdgeSubdivision which models the computed triangulation.
         *
         * @returns the subdivision containing the triangulation
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.getSubdivision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#getSubdivision--)
         */
        getSubdivision(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */;
        /**
         * Gets the faces of the computed triangulation as a `GeometryCollection`
         * of `Polygon`.
         *
         * @param geomFact - the geometry factory to use to create the output
         * @returns the faces of the triangulation
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.getTriangles](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#getTriangles-org.locationtech.jts.geom.GeometryFactory-)
         */
        getTriangles(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Sets the linear constraints to be conformed to.
         * All linear components in the input will be used as constraints.
         * The constraint vertices do not have to be disjoint from
         * the site vertices.
         * The constraints must not contain duplicate segments (up to orientation).
         *
         * @param constraintLines - the lines to constraint to
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.setConstraints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#setConstraints-org.locationtech.jts.geom.Geometry-)
         */
        setConstraints(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */, constraintLines: Geometry): any /* void */;
        /**
         * Sets the sites (point or vertices) which will be triangulated.
         * All vertices of the given geometry will be used as sites.
         * The site vertices do not have to contain the constraint
         * vertices as well; any site vertices which are
         * identical to a constraint vertex will be removed
         * from the site vertex set.
         *
         * @param geom - the geometry from which the sites will be extracted.
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.setSites](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#setSites-org.locationtech.jts.geom.Geometry-)
         */
        setSites(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */, geom: Geometry): any /* void */;
        /**
         * Sets the snapping tolerance which will be used
         * to improved the robustness of the triangulation computation.
         * A tolerance of 0.0 specifies that no snapping will take place.
         *
         * @param tolerance - the tolerance distance to use
         * @see [org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder.setTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConformingDelaunayTriangulationBuilder.html#setTolerance-double-)
         */
        setTolerance(conformingDelaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.ConformingDelaunayTriangulationBuilder */, tolerance: number): any /* void */;
      };
      ConstraintEnforcementException: {
        /**
         * Creates a new instance with a given message.
         *
         * @param msg - a string
         * @see [org.locationtech.jts.triangulate.ConstraintEnforcementException.ConstraintEnforcementException](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintEnforcementException.html#ConstraintEnforcementException-java.lang.String-)
         */
        create1(msg: string): any /* org.locationtech.jts.triangulate.ConstraintEnforcementException */;
        /**
         * Creates a new instance with a given message and approximate location.
         *
         * @param msg - a string
         * @param pt - the location of the error
         * @see [org.locationtech.jts.triangulate.ConstraintEnforcementException.ConstraintEnforcementException](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintEnforcementException.html#ConstraintEnforcementException-java.lang.String-org.locationtech.jts.geom.Coordinate-)
         */
        create2(msg: string, pt: Coordinate): any /* org.locationtech.jts.triangulate.ConstraintEnforcementException */;
        /**
         * Gets the approximate location of this error.
         *
         * @returns a location
         * @see [org.locationtech.jts.triangulate.ConstraintEnforcementException.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintEnforcementException.html#getCoordinate--)
         */
        getCoordinate(constraintEnforcementException: any /* org.locationtech.jts.triangulate.ConstraintEnforcementException */): Coordinate;
      };
      ConstraintVertex: {
        /**
         * Creates a new constraint vertex
         *
         * @param p - the location of the vertex
         * @see [org.locationtech.jts.triangulate.ConstraintVertex.ConstraintVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintVertex.html#ConstraintVertex-org.locationtech.jts.geom.Coordinate-)
         */
        create1(p: Coordinate): any /* org.locationtech.jts.triangulate.ConstraintVertex */;
        /**
         * Tests whether this vertex lies on a constraint.
         *
         * @returns true if the vertex lies on a constraint
         * @see [org.locationtech.jts.triangulate.ConstraintVertex.isOnConstraint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintVertex.html#isOnConstraint--)
         */
        isOnConstraint(constraintVertex: any /* org.locationtech.jts.triangulate.ConstraintVertex */): boolean;
        /**
         * Sets whether this vertex lies on a constraint.
         *
         * @param isOnConstraint - true if this vertex lies on a constraint
         * @see [org.locationtech.jts.triangulate.ConstraintVertex.setOnConstraint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/ConstraintVertex.html#setOnConstraint-boolean-)
         */
        setOnConstraint(constraintVertex: any /* org.locationtech.jts.triangulate.ConstraintVertex */, isOnConstraint: boolean): any /* void */;
      };
      DelaunayTriangulationBuilder: {
        /**
         * Creates a new triangulation builder.
         *
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.DelaunayTriangulationBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#DelaunayTriangulationBuilder--)
         */
        create0(): any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */;
        /**
         * Computes the `Envelope` of a collection of `Coordinate`s.
         *
         * @param coords - a List of Coordinates
         * @returns the envelope of the set of coordinates
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.envelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#envelope-java.util.Collection-)
         */
        envelope(coords: any /* java.util.Collection */): Envelope;
        /**
         * Extracts the unique `Coordinate`s from the given `Geometry`.
         *
         * @param geom - the geometry to extract from
         * @returns a List of the unique Coordinates
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.extractUniqueCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#extractUniqueCoordinates-org.locationtech.jts.geom.Geometry-)
         */
        extractUniqueCoordinates(geom: Geometry): any /* org.locationtech.jts.geom.CoordinateList */;
        /**
         * Gets the edges of the computed triangulation as a `MultiLineString`.
         *
         * @param geomFact - the geometry factory to use to create the output
         * @returns the edges of the triangulation
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.getEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#getEdges-org.locationtech.jts.geom.GeometryFactory-)
         */
        getEdges(delaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Gets the `QuadEdgeSubdivision` which models the computed triangulation.
         *
         * @returns the subdivision containing the triangulation
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.getSubdivision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#getSubdivision--)
         */
        getSubdivision(delaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */;
        /**
         * Gets the faces of the computed triangulation as a `GeometryCollection`
         * of `Polygon`.
         *
         * @param geomFact - the geometry factory to use to create the output
         * @returns the faces of the triangulation
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.getTriangles](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#getTriangles-org.locationtech.jts.geom.GeometryFactory-)
         */
        getTriangles(delaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Sets the sites (vertices) which will be triangulated.
         * All vertices of the given geometry will be used as sites.
         *
         * @param geom - the geometry from which the sites will be extracted.
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.setSites](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#setSites-org.locationtech.jts.geom.Geometry-)
         */
        setSites(delaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */, geom: Geometry): any /* void */;
        /**
         * Sets the snapping tolerance which will be used
         * to improved the robustness of the triangulation computation.
         * A tolerance of 0.0 specifies that no snapping will take place.
         *
         * @param tolerance - the tolerance distance to use
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.setTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#setTolerance-double-)
         */
        setTolerance(delaunayTriangulationBuilder: any /* org.locationtech.jts.triangulate.DelaunayTriangulationBuilder */, tolerance: number): any /* void */;
        /**
         * Converts all `Coordinate`s in a collection to `Vertex`es.
         *
         * @param coords - the coordinates to convert
         * @returns a List of Vertex objects
         * @see [org.locationtech.jts.triangulate.DelaunayTriangulationBuilder.toVertices](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/DelaunayTriangulationBuilder.html#toVertices-java.util.Collection-)
         */
        toVertices(coords: any /* java.util.Collection */): any /* java.util.List */;
        unique(coords: Coordinate[]): any /* org.locationtech.jts.geom.CoordinateList */;
      };
      MidpointSplitPointFinder: {
        create0(): any /* org.locationtech.jts.triangulate.MidpointSplitPointFinder */;
        /**
         * Gets the midpoint of the split segment
         *
         * @see [org.locationtech.jts.triangulate.MidpointSplitPointFinder.findSplitPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/MidpointSplitPointFinder.html#findSplitPoint-org.locationtech.jts.triangulate.Segment-org.locationtech.jts.geom.Coordinate-)
         */
        findSplitPoint(midpointSplitPointFinder: any /* org.locationtech.jts.triangulate.MidpointSplitPointFinder */, seg: any /* org.locationtech.jts.triangulate.Segment */, encroachPt: Coordinate): Coordinate;
      };
      NonEncroachingSplitPointFinder: {
        create0(): any /* org.locationtech.jts.triangulate.NonEncroachingSplitPointFinder */;
        /**
         * A basic strategy for finding split points when nothing extra is known about the geometry of
         * the situation.
         *
         * @param seg - the encroached segment
         * @param encroachPt - the encroaching point
         * @returns the point at which to split the encroached segment
         * @see [org.locationtech.jts.triangulate.NonEncroachingSplitPointFinder.findSplitPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/NonEncroachingSplitPointFinder.html#findSplitPoint-org.locationtech.jts.triangulate.Segment-org.locationtech.jts.geom.Coordinate-)
         */
        findSplitPoint(nonEncroachingSplitPointFinder: any /* org.locationtech.jts.triangulate.NonEncroachingSplitPointFinder */, seg: any /* org.locationtech.jts.triangulate.Segment */, encroachPt: Coordinate): Coordinate;
        /**
         * Computes a split point which is the projection of the encroaching point on the segment
         *
         * @param seg
         * @param encroachPt
         * @returns a split point on the segment
         * @see [org.locationtech.jts.triangulate.NonEncroachingSplitPointFinder.projectedSplitPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/NonEncroachingSplitPointFinder.html#projectedSplitPoint-org.locationtech.jts.triangulate.Segment-org.locationtech.jts.geom.Coordinate-)
         */
        projectedSplitPoint(seg: any /* org.locationtech.jts.triangulate.Segment */, encroachPt: Coordinate): Coordinate;
      };
      Segment: {
        /**
         * Creates a new instance for the given points.
         *
         * @param p0 - the start point
         * @param p1 - the end point
         * @see [org.locationtech.jts.triangulate.Segment.Segment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#Segment-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
         */
        create2(p0: Coordinate, p1: Coordinate): any /* org.locationtech.jts.triangulate.Segment */;
        /**
         * Creates a new instance for the given ordinates.
         *
         * @see [org.locationtech.jts.triangulate.Segment.Segment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#Segment-double-double-double-double-double-double-)
         */
        create6(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): any /* org.locationtech.jts.triangulate.Segment */;
        /**
         * Determines whether two segments are topologically equal.
         * I.e. equal up to orientation.
         *
         * @param s - a segment
         * @returns true if the segments are topologically equal
         * @see [org.locationtech.jts.triangulate.Segment.equalsTopo](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#equalsTopo-org.locationtech.jts.triangulate.Segment-)
         */
        equalsTopo(segment: any /* org.locationtech.jts.triangulate.Segment */, s: any /* org.locationtech.jts.triangulate.Segment */): boolean;
        /**
         * Gets the end coordinate of the segment
         *
         * @returns a Coordinate
         * @see [org.locationtech.jts.triangulate.Segment.getEnd](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getEnd--)
         */
        getEnd(segment: any /* org.locationtech.jts.triangulate.Segment */): Coordinate;
        /**
         * Gets the end X ordinate of the segment
         *
         * @returns the X ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getEndX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getEndX--)
         */
        getEndX(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Gets the end Y ordinate of the segment
         *
         * @returns the Y ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getEndY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getEndY--)
         */
        getEndY(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Gets the end Z ordinate of the segment
         *
         * @returns the Z ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getEndZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getEndZ--)
         */
        getEndZ(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Gets a `LineSegment` modelling this segment.
         *
         * @returns a LineSegment
         * @see [org.locationtech.jts.triangulate.Segment.getLineSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getLineSegment--)
         */
        getLineSegment(segment: any /* org.locationtech.jts.triangulate.Segment */): LineSegment;
        /**
         * Gets the start coordinate of the segment
         *
         * @returns a Coordinate
         * @see [org.locationtech.jts.triangulate.Segment.getStart](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getStart--)
         */
        getStart(segment: any /* org.locationtech.jts.triangulate.Segment */): Coordinate;
        /**
         * Gets the start X ordinate of the segment
         *
         * @returns the X ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getStartX](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getStartX--)
         */
        getStartX(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Gets the start Y ordinate of the segment
         *
         * @returns the Y ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getStartY](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getStartY--)
         */
        getStartY(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Gets the start Z ordinate of the segment
         *
         * @returns the Z ordinate value
         * @see [org.locationtech.jts.triangulate.Segment.getStartZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#getStartZ--)
         */
        getStartZ(segment: any /* org.locationtech.jts.triangulate.Segment */): number;
        /**
         * Computes the intersection point between this segment and another one.
         *
         * @param s - a segment
         * @returns the intersection point, or `null` if there is none
         * @see [org.locationtech.jts.triangulate.Segment.intersection](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/Segment.html#intersection-org.locationtech.jts.triangulate.Segment-)
         */
        intersection(segment: any /* org.locationtech.jts.triangulate.Segment */, s: any /* org.locationtech.jts.triangulate.Segment */): Coordinate;
      };
      SplitSegment: {
        create1(seg: LineSegment): any /* org.locationtech.jts.triangulate.SplitSegment */;
        getSplitPoint(splitSegment: any /* org.locationtech.jts.triangulate.SplitSegment */): Coordinate;
        setMinimumLength(splitSegment: any /* org.locationtech.jts.triangulate.SplitSegment */, minLen: number): any /* void */;
        splitAt(splitSegment: any /* org.locationtech.jts.triangulate.SplitSegment */, length: number, endPt: Coordinate): any /* void */;
      };
      VertexTaggedGeometryDataMapper: {
        create0(): any /* org.locationtech.jts.triangulate.VertexTaggedGeometryDataMapper */;
        getCoordinates(vertexTaggedGeometryDataMapper: any /* org.locationtech.jts.triangulate.VertexTaggedGeometryDataMapper */): any /* java.util.List */;
        loadSourceGeometries(vertexTaggedGeometryDataMapper: any /* org.locationtech.jts.triangulate.VertexTaggedGeometryDataMapper */, geomColl: Geometry): any /* void */;
        /**
         * Input is assumed to be a multiGeometry
         * in which every component has its userData
         * set to be a Coordinate which is the key to the output data.
         * The Coordinate is used to determine
         * the output data object to be written back into the component.
         *
         * @param targetGeom
         * @see [org.locationtech.jts.triangulate.VertexTaggedGeometryDataMapper.transferData](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VertexTaggedGeometryDataMapper.html#transferData-org.locationtech.jts.geom.Geometry-)
         */
        transferData(vertexTaggedGeometryDataMapper: any /* org.locationtech.jts.triangulate.VertexTaggedGeometryDataMapper */, targetGeom: Geometry): any /* void */;
      };
      VoronoiDiagramBuilder: {
        /**
         * Creates a new Voronoi diagram builder.
         *
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.VoronoiDiagramBuilder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#VoronoiDiagramBuilder--)
         */
        create0(): any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */;
        /**
         * Gets the faces of the computed diagram as a `GeometryCollection`
         * of `Polygon`s, clipped as specified.
         *
         * The `userData` attribute of each face `Polygon` is set to
         * the `Coordinate`  of the corresponding input site.
         * This allows using a `Map` to link faces to data associated with sites.
         *
         * @param geomFact - the geometry factory to use to create the output
         * @returns a `GeometryCollection` containing the face `Polygon`s of the diagram
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.getDiagram](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#getDiagram-org.locationtech.jts.geom.GeometryFactory-)
         */
        getDiagram(voronoiDiagramBuilder: any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
        /**
         * Gets the `QuadEdgeSubdivision` which models the computed diagram.
         *
         * @returns the subdivision containing the triangulation
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.getSubdivision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#getSubdivision--)
         */
        getSubdivision(voronoiDiagramBuilder: any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */;
        /**
         * Sets the envelope to clip the diagram to.
         * The diagram will be clipped to the larger
         * of this envelope or an envelope surrounding the sites.
         *
         * @param clipEnv - the clip envelope.
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.setClipEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#setClipEnvelope-org.locationtech.jts.geom.Envelope-)
         */
        setClipEnvelope(voronoiDiagramBuilder: any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */, clipEnv: Envelope): any /* void */;
        /**
         * Sets the sites (point or vertices) which will be diagrammed
         * from a collection of `Coordinate`s.
         *
         * @param coords - a collection of Coordinates.
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.setSites](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#setSites-java.util.Collection-)
         */
        setSites(voronoiDiagramBuilder: any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */, coords: any /* java.util.Collection */): any /* void */;
        /**
         * Sets the snapping tolerance which will be used
         * to improved the robustness of the triangulation computation.
         * A tolerance of 0.0 specifies that no snapping will take place.
         *
         * @param tolerance - the tolerance distance to use
         * @see [org.locationtech.jts.triangulate.VoronoiDiagramBuilder.setTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/VoronoiDiagramBuilder.html#setTolerance-double-)
         */
        setTolerance(voronoiDiagramBuilder: any /* org.locationtech.jts.triangulate.VoronoiDiagramBuilder */, tolerance: number): any /* void */;
      };
      polygon: {
        ConstrainedDelaunayTriangulator: {
          /**
           * Constructs a new Constrained Delaunay triangulator.
           *
           * @param inputGeom - the input geometry
           * @see [org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator.ConstrainedDelaunayTriangulator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/ConstrainedDelaunayTriangulator.html#ConstrainedDelaunayTriangulator-org.locationtech.jts.geom.Geometry-)
           */
          create1(inputGeom: Geometry): any /* org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator */;
          /**
           * Gets the triangulation as a `GeometryCollection` of triangular `Polygon`s.
           *
           * @returns a collection of the result triangle polygons
           * @see [org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/ConstrainedDelaunayTriangulator.html#getResult--)
           */
          getResult(constrainedDelaunayTriangulator: any /* org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator */): Geometry;
          /**
           * Computes the Constrained Delaunay Triangulation of each polygon element in a geometry.
           *
           * @param geom - the input geometry
           * @returns a GeometryCollection of the computed triangle polygons
           * @see [org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator.triangulate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/ConstrainedDelaunayTriangulator.html#triangulate-org.locationtech.jts.geom.Geometry-)
           */
          triangulate(geom: Geometry): Geometry;
        };
        PolygonHoleJoiner: {
          /**
           * Computes the joined ring.
           *
           * @returns the points in the joined ring
           * @see [org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner.compute](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonHoleJoiner.html#compute--)
           */
          compute(polygonHoleJoiner: any /* org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner */): Coordinate[];
          /**
           * Creates a new hole joiner.
           *
           * @param polygon - the polygon to join
           * @see [org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner.PolygonHoleJoiner](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonHoleJoiner.html#PolygonHoleJoiner-org.locationtech.jts.geom.Polygon-)
           */
          create1(polygon: Geometry): any /* org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner */;
          /**
           * Joins the shell and holes of a polygon
           * and returns the result as sequence of Coordinates.
           *
           * @param polygon - the polygon to join
           * @returns the result coordinates
           * @see [org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner.join](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonHoleJoiner.html#join-org.locationtech.jts.geom.Polygon-)
           */
          join(polygon: Geometry): Coordinate[];
          /**
           * Joins the shell and holes of a polygon
           * and returns the result as an (invalid) Polygon.
           *
           * @param polygon - the polygon to join
           * @returns the result polygon
           * @see [org.locationtech.jts.triangulate.polygon.PolygonHoleJoiner.joinAsPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonHoleJoiner.html#joinAsPolygon-org.locationtech.jts.geom.Polygon-)
           */
          joinAsPolygon(polygon: Geometry): Geometry;
        };
        PolygonTriangulator: {
          /**
           * Constructs a new triangulator.
           *
           * @param inputGeom - the input geometry
           * @see [org.locationtech.jts.triangulate.polygon.PolygonTriangulator.PolygonTriangulator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonTriangulator.html#PolygonTriangulator-org.locationtech.jts.geom.Geometry-)
           */
          create1(inputGeom: Geometry): any /* org.locationtech.jts.triangulate.polygon.PolygonTriangulator */;
          /**
           * Gets the triangulation as a `GeometryCollection` of triangular `Polygon`s.
           *
           * @returns a collection of the result triangle polygons
           * @see [org.locationtech.jts.triangulate.polygon.PolygonTriangulator.getResult](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonTriangulator.html#getResult--)
           */
          getResult(polygonTriangulator: any /* org.locationtech.jts.triangulate.polygon.PolygonTriangulator */): Geometry;
          /**
           * Computes a triangulation of each polygon in a geometry.
           *
           * @param geom - a geometry containing polygons
           * @returns a GeometryCollection containing the triangle polygons
           * @see [org.locationtech.jts.triangulate.polygon.PolygonTriangulator.triangulate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/polygon/PolygonTriangulator.html#triangulate-org.locationtech.jts.geom.Geometry-)
           */
          triangulate(geom: Geometry): Geometry;
        };
      };
      quadedge: {
        EdgeConnectedTriangleTraversal: {
          create0(): any /* org.locationtech.jts.triangulate.quadedge.EdgeConnectedTriangleTraversal */;
        };
        LocateFailureException: {
          create1(msg: string): any /* org.locationtech.jts.triangulate.quadedge.LocateFailureException */;
          create2(msg: string, seg: LineSegment): any /* org.locationtech.jts.triangulate.quadedge.LocateFailureException */;
          getSegment(locateFailureException: any /* org.locationtech.jts.triangulate.quadedge.LocateFailureException */): LineSegment;
        };
        QuadEdge: {
          /**
           * Creates a new QuadEdge connecting the destination of a to the origin of
           * b, in such a way that all three have the same left face after the
           * connection is complete. Additionally, the data pointers of the new edge
           * are set.
           *
           * @returns the connected edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.connect](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#connect-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          connect(a: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, b: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the next CCW edge around (into) the destination of this edge.
           *
           * @returns the next destination edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.dNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#dNext--)
           */
          dNext(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the next CW edge around (into) the destination of this edge.
           *
           * @returns the previous destination edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.dPrev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#dPrev--)
           */
          dPrev(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Marks this quadedge as being deleted.
           * This does not free the memory used by
           * this quadedge quartet, but indicates
           * that this edge no longer participates
           * in a subdivision.
           *
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.delete](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#delete--)
           */
          delete(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* void */;
          /**
           * Gets the vertex for the edge's destination
           *
           * @returns the destination vertex
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.dest](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#dest--)
           */
          dest(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          /**
           * Tests if this quadedge and another have the same line segment geometry,
           * regardless of orientation.
           *
           * @param qe - a quadedge
           * @returns true if the quadedges are based on the same line segment regardless of orientation
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.equalsNonOriented](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#equalsNonOriented-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          equalsNonOriented(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, qe: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * Tests if this quadedge and another have the same line segment geometry
           * with the same orientation.
           *
           * @param qe - a quadedge
           * @returns true if the quadedges are based on the same line segment
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.equalsOriented](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#equalsOriented-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          equalsOriented(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, qe: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * Gets the length of the geometry of this quadedge.
           *
           * @returns the length of the quadedge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#getLength--)
           */
          getLength(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): number;
          /**
           * Gets the primary edge of this quadedge and its `sym`.
           * The primary edge is the one for which the origin
           * and destination coordinates are ordered
           * according to the standard `Coordinate` ordering
           *
           * @returns the primary quadedge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.getPrimary](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#getPrimary--)
           */
          getPrimary(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the dual of this edge, directed from its left to its right.
           *
           * @returns the inverse rotated edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.invRot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#invRot--)
           */
          invRot(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Tests whether this edge has been deleted.
           *
           * @returns true if this edge has not been deleted.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.isLive](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#isLive--)
           */
          isLive(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * Gets the CCW edge around the left face following this edge.
           *
           * @returns the next left face edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.lNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#lNext--)
           */
          lNext(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the CCW edge around the left face before this edge.
           *
           * @returns the previous left face edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.lPrev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#lPrev--)
           */
          lPrev(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Creates a new QuadEdge quartet from `Vertex` o to `Vertex` d.
           *
           * @param o - the origin Vertex
           * @param d - the destination Vertex
           * @returns the new QuadEdge quartet
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.makeEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#makeEdge-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          makeEdge(o: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, d: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the next CCW edge around the origin of this edge.
           *
           * @returns the next linked edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.oNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#oNext--)
           */
          oNext(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the next CW edge around (from) the origin of this edge.
           *
           * @returns the previous edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.oPrev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#oPrev--)
           */
          oPrev(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the vertex for the edge's origin
           *
           * @returns the origin vertex
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.orig](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#orig--)
           */
          orig(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          /**
           * Gets the edge around the right face ccw following this edge.
           *
           * @returns the next right face edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.rNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#rNext--)
           */
          rNext(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the edge around the right face ccw before this edge.
           *
           * @returns the previous right face edge.
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.rPrev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#rPrev--)
           */
          rPrev(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Gets the dual of this edge, directed from its right to its left.
           *
           * @returns the rotated edge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.rot](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#rot--)
           */
          rot(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Sets the connected edge
           *
           * @param next - edge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.setNext](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#setNext-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          setNext(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, next: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* void */;
          /**
           * Splices two edges together or apart.
           * Splice affects the two edge rings around the origins of a and b, and, independently, the two
           * edge rings around the left faces of `a` and `b`.
           * In each case, (i) if the two rings are distinct,
           * Splice will combine them into one, or (ii) if the two are the same ring, Splice will break it
           * into two separate pieces. Thus, Splice can be used both to attach the two edges together, and
           * to break them apart.
           *
           * @param a - an edge to splice
           * @param b - an edge to splice
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.splice](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#splice-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          splice(a: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, b: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* void */;
          /**
           * Turns an edge counterclockwise inside its enclosing quadrilateral.
           *
           * @param e - the quadedge to turn
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.swap](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#swap-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          swap(e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* void */;
          /**
           * Gets the edge from the destination to the origin of this edge.
           *
           * @returns the sym of the edge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.sym](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#sym--)
           */
          sym(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Creates a `LineSegment` representing the
           * geometry of this edge.
           *
           * @returns a LineSegment
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdge.toLineSegment](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdge.html#toLineSegment--)
           */
          toLineSegment(quadEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): LineSegment;
        };
        QuadEdgeSubdivision: {
          /**
           * Creates a new QuadEdge connecting the destination of a to the origin of b,
           * in such a way that all three have the same left face after the connection
           * is complete. The quadedge is recorded in the edges list.
           *
           * @param a
           * @param b
           * @returns a quadedge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.connect](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#connect-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          connect(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, a: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, b: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Creates a new instance of a quad-edge subdivision based on a frame triangle
           * that encloses a supplied bounding box. A new super-bounding box that
           * contains the triangle is computed and stored.
           *
           * @param env - the bounding box to surround
           * @param tolerance - the tolerance value for determining if two sites are equal
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.QuadEdgeSubdivision](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#QuadEdgeSubdivision-org.locationtech.jts.geom.Envelope-double-)
           */
          create2(env: Envelope, tolerance: number): any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */;
          /**
           * Deletes a quadedge from the subdivision. Linked quadedges are updated to
           * reflect the deletion.
           *
           * @param e - the quadedge to delete
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.delete](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#delete-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          delete(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* void */;
          /**
           * Gets the geometry for the edges in the subdivision as a `MultiLineString`
           * containing 2-point lines.
           *
           * @param geomFact - the GeometryFactory to use
           * @returns a MultiLineString
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getEdges-org.locationtech.jts.geom.GeometryFactory-)
           */
          getEdges(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Gets the envelope of the Subdivision (including the frame).
           *
           * @returns the envelope
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getEnvelope](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getEnvelope--)
           */
          getEnvelope(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */): Envelope;
          /**
           * Gets the edges which touch frame vertices. The returned edges are oriented so
           * that their origin is a frame vertex.
           *
           * @returns the edges which touch the frame
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getFrameEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getFrameEdges--)
           */
          getFrameEdges(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */): any /* java.util.List */;
          /**
           * Gets all primary quadedges in the subdivision.
           * A primary edge is a `QuadEdge`
           * which occupies the 0'th position in its array of associated quadedges.
           * These provide the unique geometric edges of the triangulation.
           *
           * @param includeFrame - true if the frame edges are to be included
           * @returns a List of QuadEdges
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getPrimaryEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getPrimaryEdges-boolean-)
           */
          getPrimaryEdges(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.List */;
          /**
           * Gets the vertex-equality tolerance value
           * used in this subdivision
           *
           * @returns the tolerance value
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getTolerance](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getTolerance--)
           */
          getTolerance(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */): number;
          /**
           * Gets the coordinates for each triangle in the subdivision as an array.
           *
           * @param includeFrame - true if the frame triangles should be included
           * @returns a list of Coordinate[4] representing each triangle
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getTriangleCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getTriangleCoordinates-boolean-)
           */
          getTriangleCoordinates(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.List */;
          /**
           * Gets a list of the triangles
           * in the subdivision, specified as
           * an array of the primary quadedges around the triangle.
           *
           * @param includeFrame - true if the frame triangles should be included
           * @returns a List of QuadEdge[3] arrays
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getTriangleEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getTriangleEdges-boolean-)
           */
          getTriangleEdges(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.List */;
          /**
           * Gets a list of the triangles in the subdivision,
           * specified as an array of the triangle `Vertex`es.
           *
           * @param includeFrame - true if the frame triangles should be included
           * @returns a List of Vertex[3] arrays
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getTriangleVertices](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getTriangleVertices-boolean-)
           */
          getTriangleVertices(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.List */;
          /**
           * Gets the geometry for the triangles in a triangulated subdivision as a `GeometryCollection`
           * of triangular `Polygon`s, optionally including the frame triangles.
           *
           * @param includeFrame - true if the frame triangles should be included
           * @param geomFact - the GeometryFactory to use
           * @returns a GeometryCollection of triangular Polygons
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getTriangles](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getTriangles-boolean-org.locationtech.jts.geom.GeometryFactory-)
           */
          getTriangles(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Gets a collection of `QuadEdge`s whose origin
           * vertices are a unique set which includes
           * all vertices in the subdivision.
           * The frame vertices can be included if required.
           *
           * This is useful for algorithms which require traversing the
           * subdivision starting at all vertices.
           * Returning a quadedge for each vertex
           * is more efficient than
           * the alternative of finding the actual vertices
           * using `getVertices` and then locating
           * quadedges attached to them.
           *
           * @param includeFrame - true if the frame vertices should be included
           * @returns a collection of QuadEdge with the vertices of the subdivision as their origins
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getVertexUniqueEdges](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getVertexUniqueEdges-boolean-)
           */
          getVertexUniqueEdges(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.List */;
          /**
           * Gets the unique `Vertex`es in the subdivision,
           * including the frame vertices if desired.
           *
           * @param includeFrame - true if the frame vertices should be included
           * @returns a collection of the subdivision vertices
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getVertices](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getVertices-boolean-)
           */
          getVertices(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, includeFrame: boolean): any /* java.util.Collection */;
          /**
           * Gets the Voronoi cell around a site specified
           * by the origin of a QuadEdge.
           *
           * The userData of the polygon is set to be the `Coordinate`
           * of the site.  This allows attaching external
           * data associated with the site to this cell polygon.
           *
           * @param qe - a quadedge originating at the cell site
           * @param geomFact - a factory for building the polygon
           * @returns a polygon indicating the cell extent
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getVoronoiCellPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getVoronoiCellPolygon-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.geom.GeometryFactory-)
           */
          getVoronoiCellPolygon(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, qe: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Gets a List of `Polygon`s for the Voronoi cells
           * of this triangulation.
           *
           * The userData of each polygon is set to be the `Coordinate`
           * of the cell site.  This allows easily associating external
           * data associated with the sites to the cells.
           *
           * @param geomFact - a geometry factory
           * @returns a List of Polygons
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getVoronoiCellPolygons](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getVoronoiCellPolygons-org.locationtech.jts.geom.GeometryFactory-)
           */
          getVoronoiCellPolygons(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): any /* java.util.List */;
          /**
           * Gets the cells in the Voronoi diagram for this triangulation.
           * The cells are returned as a `GeometryCollection` of `Polygon`s
           *
           * The userData of each polygon is set to be the `Coordinate`
           * of the cell site.  This allows easily associating external
           * data associated with the sites to the cells.
           *
           * @param geomFact - a geometry factory
           * @returns a GeometryCollection of Polygons
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.getVoronoiDiagram](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#getVoronoiDiagram-org.locationtech.jts.geom.GeometryFactory-)
           */
          getVoronoiDiagram(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Inserts a new site into the Subdivision, connecting it to the vertices of
           * the containing triangle (or quadrilateral, if the split point falls on an
           * existing edge).
           *
           * This method does NOT maintain the Delaunay condition. If desired, this must
           * be checked and enforced by the caller.
           *
           * This method does NOT check if the inserted vertex falls on an edge. This
           * must be checked by the caller, since this situation may cause erroneous
           * triangulation
           *
           * @param v - the vertex to insert
           * @returns a new quad edge terminating in v
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.insertSite](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#insertSite-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          insertSite(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, v: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Tests whether a subdivision is a valid Delaunay Triangulation.
           * This is the case iff every edge is locally Delaunay, meaning that
           * the apex of one adjacent triangle is not inside the circumcircle
           * of the other adjacent triangle.
           *
           * @returns true if the subdivision is Delaunay
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isDelaunay](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isDelaunay--)
           */
          isDelaunay(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */): boolean;
          /**
           * Tests whether a QuadEdge is an edge on the border of the frame facets and
           * the internal facets. E.g. an edge which does not itself touch a frame
           * vertex, but which touches an edge which does.
           *
           * @param e - the edge to test
           * @returns true if the edge is on the border of the frame
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isFrameBorderEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isFrameBorderEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          isFrameBorderEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * Tests whether a QuadEdge is an edge incident on a frame triangle vertex.
           *
           * @param e - the edge to test
           * @returns true if the edge is connected to the frame triangle
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isFrameEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isFrameEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          isFrameEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * Tests whether a vertex is a vertex of the outer triangle.
           *
           * @param v - the vertex to test
           * @returns true if the vertex is an outer triangle vertex
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isFrameVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isFrameVertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          isFrameVertex(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, v: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): boolean;
          /**
           * Tests whether a `Coordinate` lies on a `QuadEdge`, up to a
           * tolerance determined by the subdivision tolerance.
           *
           * @param e - a QuadEdge
           * @param p - a point
           * @returns true if the vertex lies on the edge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isOnEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isOnEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.geom.Coordinate-)
           */
          isOnEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, p: Coordinate): boolean;
          /**
           * Tests whether a `Vertex` is the start or end vertex of a
           * `QuadEdge`, up to the subdivision tolerance distance.
           *
           * @param e
           * @param v
           * @returns true if the vertex is a endpoint of the edge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.isVertexOfEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#isVertexOfEdge-org.locationtech.jts.triangulate.quadedge.QuadEdge-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          isVertexOfEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */, v: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): boolean;
          /**
           * Locates the edge between the given vertices, if it exists in the
           * subdivision.
           *
           * @param p0 - a coordinate
           * @param p1 - another coordinate
           * @returns the edge joining the coordinates, if present or null if no such edge exists
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.locate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#locate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          locate(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, p0: Coordinate, p1: Coordinate): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Locates an edge of a triangle which contains a location
           * specified by a Vertex v.
           * The edge returned has the
           * property that either v is on e, or e is an edge of a triangle containing v.
           * The search starts from startEdge amd proceeds on the general direction of v.
           *
           * This locate algorithm relies on the subdivision being Delaunay. For
           * non-Delaunay subdivisions, this may loop for ever.
           *
           * @param v - the location to search for
           * @param startEdge - an edge of the subdivision to start searching at
           * @returns a QuadEdge which contains v, or is on the edge of a triangle containing v
           * @throws LocateFailureException if the location algorithm fails to converge in a reasonable number of iterations
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.locateFromEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#locateFromEdge-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.QuadEdge-)
           */
          locateFromEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, v: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, startEdge: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
          /**
           * Creates a new quadedge, recording it in the edges list.
           *
           * @param o
           * @param d
           * @returns a new quadedge
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision.makeEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeSubdivision.html#makeEdge-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          makeEdge(quadEdgeSubdivision: any /* org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision */, o: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, d: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */;
        };
        QuadEdgeTriangle: {
          /**
           * Finds the next index around the triangle. Index may be an edge or vertex
           * index.
           *
           * @param index
           * @returns the next index
           * @see [org.locationtech.jts.triangulate.quadedge.QuadEdgeTriangle.nextIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/QuadEdgeTriangle.html#nextIndex-int-)
           */
          nextIndex(index: number): number;
        };
        TrianglePredicate: {
          /**
           * Computes the inCircle test using distance from the circumcentre.
           * Uses standard double-precision arithmetic.
           *
           * In general this doesn't
           * appear to be any more robust than the standard calculation. However, there
           * is at least one case where the test point is far enough from the
           * circumcircle that this test gives the correct answer.
           *
           * ```
           * LINESTRING
           * (1507029.9878 518325.7547, 1507022.1120341457 518332.8225183258,
           * 1507029.9833 518325.7458, 1507029.9896965567 518325.744909031)
           * ```
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @param p - the point to test
           * @returns true if this point is inside the circle defined by the points a, b, c
           * @see [org.locationtech.jts.triangulate.quadedge.TrianglePredicate.isInCircleCC](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/TrianglePredicate.html#isInCircleCC-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          isInCircleCC(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          isInCircleDDFast(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          isInCircleDDNormalized(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          /**
           * Tests if a point is inside the circle defined by
           * the triangle with vertices a, b, c (oriented counter-clockwise).
           * The computation uses `DD` arithmetic for robustness.
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @param p - the point to test
           * @returns true if this point is inside the circle defined by the points a, b, c
           * @see [org.locationtech.jts.triangulate.quadedge.TrianglePredicate.isInCircleDDSlow](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/TrianglePredicate.html#isInCircleDDSlow-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          isInCircleDDSlow(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          /**
           * Tests if a point is inside the circle defined by
           * the triangle with vertices a, b, c (oriented counter-clockwise).
           * This test uses simple
           * double-precision arithmetic, and thus may not be robust.
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @param p - the point to test
           * @returns true if this point is inside the circle defined by the points a, b, c
           * @see [org.locationtech.jts.triangulate.quadedge.TrianglePredicate.isInCircleNonRobust](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/TrianglePredicate.html#isInCircleNonRobust-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          isInCircleNonRobust(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          /**
           * Tests if a point is inside the circle defined by
           * the triangle with vertices a, b, c (oriented counter-clockwise).
           * This test uses simple
           * double-precision arithmetic, and thus is not 100% robust.
           * However, by using normalization to the origin
           * it provides improved robustness and increased performance.
           *
           * Based on code by J.R.Shewchuk.
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @param p - the point to test
           * @returns true if this point is inside the circle defined by the points a, b, c
           * @see [org.locationtech.jts.triangulate.quadedge.TrianglePredicate.isInCircleNormalized](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/TrianglePredicate.html#isInCircleNormalized-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          isInCircleNormalized(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
          /**
           * Tests if a point is inside the circle defined by
           * the triangle with vertices a, b, c (oriented counter-clockwise).
           * This method uses more robust computation.
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @param p - the point to test
           * @returns true if this point is inside the circle defined by the points a, b, c
           * @see [org.locationtech.jts.triangulate.quadedge.TrianglePredicate.isInCircleRobust](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/TrianglePredicate.html#isInCircleRobust-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          isInCircleRobust(a: Coordinate, b: Coordinate, c: Coordinate, p: Coordinate): boolean;
        };
        Vertex: {
          BEHIND: number;
          BETWEEN: number;
          BEYOND: number;
          DESTINATION: number;
          LEFT: number;
          ORIGIN: number;
          RIGHT: number;
          /**
           * Computes the centre of the circumcircle of this vertex and two others.
           *
           * @param b
           * @param c
           * @returns the Coordinate which is the circumcircle of the 3 points.
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.circleCenter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#circleCenter-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          circleCenter(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, b: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, c: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          /**
           * Computes the value of the ratio of the circumradius to shortest edge. If smaller than some
           * given tolerance B, the associated triangle is considered skinny. For an equal lateral
           * triangle this value is 0.57735. The ratio is related to the minimum triangle angle theta by:
           * circumRadius/shortestEdge = 1/(2sin(theta)).
           *
           * @param b - second vertex of the triangle
           * @param c - third vertex of the triangle
           * @returns ratio of circumradius to shortest edge.
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.circumRadiusRatio](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#circumRadiusRatio-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          circumRadiusRatio(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, b: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, c: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          classify(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, p0: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, p1: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          create1(_p: Coordinate): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          create2(_x: number, _y: number): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          create3(_x: number, _y: number, _z: number): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          equals(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, _x: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, tolerance: number): boolean;
          getCoordinate(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): Coordinate;
          getX(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          getY(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          getZ(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          /**
           * Interpolates the Z-value (height) of a point enclosed in a triangle
           * whose vertices all have Z values.
           * The containing triangle must not be degenerate
           * (in other words, the three vertices must enclose a
           * non-zero area).
           *
           * @param p - the point to interpolate the Z value of
           * @param v0 - a vertex of a triangle containing the p
           * @param v1 - a vertex of a triangle containing the p
           * @param v2 - a vertex of a triangle containing the p
           * @returns the interpolated Z-value (height) of the point
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.interpolateZ](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#interpolateZ-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          interpolateZ(p: Coordinate, v0: Coordinate, v1: Coordinate, v2: Coordinate): number;
          /**
           * For this vertex enclosed in a triangle defined by three vertices v0, v1 and v2, interpolate
           * a z value from the surrounding vertices.
           *
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.interpolateZValue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#interpolateZValue-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          interpolateZValue(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, v0: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, v1: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, v2: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): number;
          /**
           * Tests whether the triangle formed by this vertex and two
           * other vertices is in CCW orientation.
           *
           * @param b - a vertex
           * @param c - a vertex
           * @returns true if the triangle is oriented CCW
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.isCCW](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#isCCW-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          isCCW(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, b: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, c: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): boolean;
          /**
           * Tests if the vertex is inside the circle defined by
           * the triangle with vertices a, b, c (oriented counter-clockwise).
           *
           * @param a - a vertex of the triangle
           * @param b - a vertex of the triangle
           * @param c - a vertex of the triangle
           * @returns true if this vertex is in the circumcircle of (a,b,c)
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.isInCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#isInCircle-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          isInCircle(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, a: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, b: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, c: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): boolean;
          leftOf(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          /**
           * returns a new vertex that is mid-way between this vertex and another end point.
           *
           * @param a - the other end point.
           * @returns the point mid-way between this and that.
           * @see [org.locationtech.jts.triangulate.quadedge.Vertex.midPoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/quadedge/Vertex.html#midPoint-org.locationtech.jts.triangulate.quadedge.Vertex-)
           */
          midPoint(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, a: any /* org.locationtech.jts.triangulate.quadedge.Vertex */): any /* org.locationtech.jts.triangulate.quadedge.Vertex */;
          rightOf(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, e: any /* org.locationtech.jts.triangulate.quadedge.QuadEdge */): boolean;
          setZ(vertex: any /* org.locationtech.jts.triangulate.quadedge.Vertex */, _z: number): any /* void */;
        };
      };
      tri: {
        Tri: {
          /**
           * Creates a triangle with the given vertices.
           * The vertices should be oriented clockwise.
           *
           * @param p0 - the first triangle vertex
           * @param p1 - the second triangle vertex
           * @param p2 - the third triangle vertex
           * @returns the created triangle
           * @see [org.locationtech.jts.triangulate.tri.Tri.create](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#create-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          create(p0: Coordinate, p1: Coordinate, p2: Coordinate): any /* org.locationtech.jts.triangulate.tri.Tri */;
          /**
           * Creates a triangle with the given vertices.
           * The vertices should be oriented clockwise.
           *
           * @param p0 - the first triangle vertex
           * @param p1 - the second triangle vertex
           * @param p2 - the third triangle vertex
           * @see [org.locationtech.jts.triangulate.tri.Tri.Tri](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#Tri-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-org.locationtech.jts.geom.Coordinate-)
           */
          create3(p0: Coordinate, p1: Coordinate, p2: Coordinate): any /* org.locationtech.jts.triangulate.tri.Tri */;
          /**
           * Interchanges the vertices of this triangle and a neighbor
           * so that their common edge
           * becomes the the other diagonal of the quadrilateral they form.
           * Neighbour triangle links are modified accordingly.
           *
           * @param index - the index of the adjacent tri to flip with
           * @see [org.locationtech.jts.triangulate.tri.Tri.flip](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#flip-int-)
           */
          flip(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): any /* void */;
          /**
           * Gets the triangle adjacent to an edge.
           *
           * @param index - the edge index
           * @returns the adjacent triangle (may be null)
           * @see [org.locationtech.jts.triangulate.tri.Tri.getAdjacent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#getAdjacent-int-)
           */
          getAdjacent(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): any /* org.locationtech.jts.triangulate.tri.Tri */;
          /**
           * Gets the area of the triangle.
           *
           * @returns the area of the triangle
           * @see [org.locationtech.jts.triangulate.tri.Tri.getArea](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#getArea--)
           */
          getArea(tri: any /* org.locationtech.jts.triangulate.tri.Tri */): number;
          /**
           * Gets the coordinate for a vertex.
           * This is the start vertex of the edge.
           *
           * @param index - the vertex (edge) index
           * @returns the vertex coordinate
           * @see [org.locationtech.jts.triangulate.tri.Tri.getCoordinate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#getCoordinate-int-)
           */
          getCoordinate(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): Coordinate;
          /**
           * Gets the index of the triangle vertex which has a given coordinate (if any).
           * This is also the index of the edge which originates at the vertex.
           *
           * @param p - the coordinate to find
           * @returns the vertex index, or -1 if it is not in the triangle
           * @see [org.locationtech.jts.triangulate.tri.Tri.getIndex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#getIndex-org.locationtech.jts.geom.Coordinate-)
           */
          getIndex(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, p: Coordinate): number;
          /**
           * Gets the length of an edge of the triangle.
           *
           * @param edgeIndex - the edge index
           * @returns the edge length
           * @see [org.locationtech.jts.triangulate.tri.Tri.getLength](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#getLength-int-)
           */
          getLength(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, edgeIndex: number): number;
          /**
           * Tests if there is an adjacent triangle to an edge.
           *
           * @param index - the edge index
           * @returns true if there is a triangle adjacent to edge
           * @see [org.locationtech.jts.triangulate.tri.Tri.hasAdjacent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#hasAdjacent-int-)
           */
          hasAdjacent(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): boolean;
          /**
           * Tests if a tri contains a boundary edge,
           * and thus on the border of the triangulation containing it.
           *
           * @returns true if the tri is on the border of the triangulation
           * @see [org.locationtech.jts.triangulate.tri.Tri.isBorder](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#isBorder--)
           */
          isBorder(tri: any /* org.locationtech.jts.triangulate.tri.Tri */): boolean;
          /**
           * Tests if an edge is on the boundary of a triangulation.
           *
           * @param index - index of an edge
           * @returns true if the edge is on the boundary
           * @see [org.locationtech.jts.triangulate.tri.Tri.isBoundary](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#isBoundary-int-)
           */
          isBoundary(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): boolean;
          /**
           * Tests if a tri vertex is interior.
           * A vertex of a triangle is interior if it
           * is fully surrounded by other triangles.
           *
           * @param index - the vertex index
           * @returns true if the vertex is interior
           * @see [org.locationtech.jts.triangulate.tri.Tri.isInteriorVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#isInteriorVertex-int-)
           */
          isInteriorVertex(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): boolean;
          /**
           * Computes a coordinate for the midpoint of a triangle edge.
           *
           * @param edgeIndex - the edge index
           * @returns the midpoint of the triangle edge
           * @see [org.locationtech.jts.triangulate.tri.Tri.midpoint](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#midpoint-int-)
           */
          midpoint(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, edgeIndex: number): Coordinate;
          /**
           * Computes the vertex or edge index which is the next one
           * (clockwise) around the triangle.
           *
           * @param index - the index
           * @returns the next index value
           * @see [org.locationtech.jts.triangulate.tri.Tri.next](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#next-int-)
           */
          next(index: number): number;
          /**
           * Computes the number of triangle adjacent to this triangle.
           * This is a number in the range [0,2].
           *
           * @returns the number of adjacent triangles
           * @see [org.locationtech.jts.triangulate.tri.Tri.numAdjacent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#numAdjacent--)
           */
          numAdjacent(tri: any /* org.locationtech.jts.triangulate.tri.Tri */): number;
          /**
           * Gets the index of the edge opposite a vertex.
           *
           * @param vertexIndex - the index of the vertex
           * @returns the index of the opposite edge
           * @see [org.locationtech.jts.triangulate.tri.Tri.oppEdge](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#oppEdge-int-)
           */
          oppEdge(vertexIndex: number): number;
          /**
           * Gets the index of the vertex opposite an edge.
           *
           * @param edgeIndex - the edge index
           * @returns the index of the opposite vertex
           * @see [org.locationtech.jts.triangulate.tri.Tri.oppVertex](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#oppVertex-int-)
           */
          oppVertex(edgeIndex: number): number;
          /**
           * Computes the vertex or edge index which is the previous one
           * (counter-clockwise) around the triangle.
           *
           * @param index - the index
           * @returns the previous index value
           * @see [org.locationtech.jts.triangulate.tri.Tri.prev](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#prev-int-)
           */
          prev(index: number): number;
          /**
           * Removes this triangle from a triangulation.
           * All adjacent references and the references to this
           * Tri in the adjacent Tris are set to `null`.
           *
           * @see [org.locationtech.jts.triangulate.tri.Tri.remove](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#remove--)
           */
          remove(tri: any /* org.locationtech.jts.triangulate.tri.Tri */): any /* void */;
          /**
           * Spits a triangle by a point located inside the triangle.
           * Creates the three new resulting triangles with adjacent links
           * set correctly.
           * Returns the new triangle whose 0'th vertex is the splitting point.
           *
           * @param p - the point to insert
           * @returns the new triangle whose 0'th vertex is p
           * @see [org.locationtech.jts.triangulate.tri.Tri.split](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#split-org.locationtech.jts.geom.Coordinate-)
           */
          split(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, p: Coordinate): any /* org.locationtech.jts.triangulate.tri.Tri */;
          /**
           * Creates a `Polygon` representing this triangle.
           *
           * @param geomFact - the geometry factory
           * @returns a polygon
           * @see [org.locationtech.jts.triangulate.tri.Tri.toPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#toPolygon-org.locationtech.jts.geom.GeometryFactory-)
           */
          toPolygon(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): Geometry;
          /**
           * Validates that a tri is correct.
           * Currently just checks that orientation is CW.
           *
           * @see [org.locationtech.jts.triangulate.tri.Tri.validate](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#validate--)
           */
          validate(tri: any /* org.locationtech.jts.triangulate.tri.Tri */): any /* void */;
          /**
           * Validates that the vertices of an adjacent linked triangle are correct.
           *
           * @param index - the index of the adjacent triangle
           * @see [org.locationtech.jts.triangulate.tri.Tri.validateAdjacent](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/triangulate/tri/Tri.html#validateAdjacent-int-)
           */
          validateAdjacent(tri: any /* org.locationtech.jts.triangulate.tri.Tri */, index: number): any /* void */;
        };
      };
    };
    util: {
      Assert: {
        /**
         * Throws an `AssertionFailedException` with the given message if
         * the given assertion is not true.
         *
         * @param assertion - a condition that is supposed to be true
         * @param message - a description of the assertion
         * @throws AssertionFailedException if the condition is false
         * @see [org.locationtech.jts.util.Assert.isTrue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/Assert.html#isTrue-boolean-java.lang.String-)
         */
        isTrue(assertion: boolean, message: string): any /* void */;
        /**
         * Always throws an `AssertionFailedException` with the given
         * message.
         *
         * @param message - a description of the assertion
         * @throws AssertionFailedException thrown always
         * @see [org.locationtech.jts.util.Assert.shouldNeverReachHere](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/Assert.html#shouldNeverReachHere-java.lang.String-)
         */
        shouldNeverReachHere(message: string): any /* void */;
      };
      CoordinateArrayFilter: {
        /**
         * Constructs a `CoordinateArrayFilter`.
         *
         * @param size - the number of points that the `CoordinateArrayFilter` will collect
         * @see [org.locationtech.jts.util.CoordinateArrayFilter.CoordinateArrayFilter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/CoordinateArrayFilter.html#CoordinateArrayFilter-int-)
         */
        create1(size: number): any /* org.locationtech.jts.util.CoordinateArrayFilter */;
        /**
         * Performs an operation with the provided `coord`.
         * Note that there is no guarantee that the input coordinate
         * is the actual object stored in the source geometry,
         * so changes to the coordinate object may not be persistent.
         *
         * @param coord - a `Coordinate` to which the filter is applied.
         * @see [org.locationtech.jts.geom.CoordinateFilter.filter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateFilter.html#filter-org.locationtech.jts.geom.Coordinate-)
         */
        filter(coordinateArrayFilter: any /* org.locationtech.jts.util.CoordinateArrayFilter */, coord: Coordinate): any /* void */;
        /**
         * Returns the gathered `Coordinate`s.
         *
         * @returns the `Coordinate`s collected by this `CoordinateArrayFilter`
         * @see [org.locationtech.jts.util.CoordinateArrayFilter.getCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/CoordinateArrayFilter.html#getCoordinates--)
         */
        getCoordinates(coordinateArrayFilter: any /* org.locationtech.jts.util.CoordinateArrayFilter */): Coordinate[];
      };
      CoordinateCountFilter: {
        create0(): any /* org.locationtech.jts.util.CoordinateCountFilter */;
        /**
         * Performs an operation with the provided `coord`.
         * Note that there is no guarantee that the input coordinate
         * is the actual object stored in the source geometry,
         * so changes to the coordinate object may not be persistent.
         *
         * @param coord - a `Coordinate` to which the filter is applied.
         * @see [org.locationtech.jts.geom.CoordinateFilter.filter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateFilter.html#filter-org.locationtech.jts.geom.Coordinate-)
         */
        filter(coordinateCountFilter: any /* org.locationtech.jts.util.CoordinateCountFilter */, coord: Coordinate): any /* void */;
        /**
         * Returns the result of the filtering.
         *
         * @returns the number of points found by this `CoordinateCountFilter`
         * @see [org.locationtech.jts.util.CoordinateCountFilter.getCount](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/CoordinateCountFilter.html#getCount--)
         */
        getCount(coordinateCountFilter: any /* org.locationtech.jts.util.CoordinateCountFilter */): number;
      };
      Debug: {
        breakIf(cond: boolean): any /* void */;
        breakIfEqual(p0: Coordinate, p1: Coordinate, tolerance: number): any /* void */;
        equals(c1: Coordinate, c2: Coordinate, tolerance: number): boolean;
        hasSegment(geom: Geometry, p0: Coordinate, p1: Coordinate): boolean;
        isDebugging(): boolean;
        print(str: string): any /* void */;
        printTime(tag: string): any /* void */;
        printWatch(): any /* void */;
        resetTime(): any /* void */;
        toLine(p0: Coordinate, p1: Coordinate, p2: Coordinate, p3: Coordinate): Geometry;
      };
      GeometricShapeFactory: {
        /**
         * Create a shape factory which will create shapes using the default
         * `GeometryFactory`.
         *
         * @see [org.locationtech.jts.util.GeometricShapeFactory.GeometricShapeFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#GeometricShapeFactory--)
         */
        create0(): any /* org.locationtech.jts.util.GeometricShapeFactory */;
        /**
         * Create a shape factory which will create shapes using the given
         * `GeometryFactory`.
         *
         * @param geomFact - the factory to use
         * @see [org.locationtech.jts.util.GeometricShapeFactory.GeometricShapeFactory](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#GeometricShapeFactory-org.locationtech.jts.geom.GeometryFactory-)
         */
        create1(geomFact: any /* org.locationtech.jts.geom.GeometryFactory */): any /* org.locationtech.jts.util.GeometricShapeFactory */;
        /**
         * Creates an elliptical arc, as a `LineString`.
         * The arc is always created in a counter-clockwise direction.
         * This can easily be reversed if required by using
         * {#link LineString.reverse()}
         *
         * @param startAng - start angle in radians
         * @param angExtent - size of angle in radians
         * @returns an elliptical arc
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createArc](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createArc-double-double-)
         */
        createArc(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, startAng: number, angExtent: number): Geometry;
        /**
         * Creates an elliptical arc polygon.
         * The polygon is formed from the specified arc of an ellipse
         * and the two radii connecting the endpoints to the centre of the ellipse.
         *
         * @param startAng - start angle in radians
         * @param angExtent - size of angle in radians
         * @returns an elliptical arc polygon
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createArcPolygon](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createArcPolygon-double-double-)
         */
        createArcPolygon(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, startAng: number, angExtent: number): Geometry;
        /**
         * Creates a circular or elliptical `Polygon`.
         *
         * @returns a circle or ellipse
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createCircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createCircle--)
         */
        createCircle(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */): Geometry;
        /**
         * Creates an elliptical `Polygon`.
         * If the supplied envelope is square the
         * result will be a circle.
         *
         * @returns an ellipse or circle
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createEllipse](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createEllipse--)
         */
        createEllipse(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */): Geometry;
        /**
         * Creates a rectangular `Polygon`.
         *
         * @returns a rectangular Polygon
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createRectangle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createRectangle--)
         */
        createRectangle(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */): Geometry;
        /**
         * Creates a squircular `Polygon`.
         *
         * @returns a squircle
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createSquircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createSquircle--)
         */
        createSquircle(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */): Geometry;
        /**
         * Creates a supercircular `Polygon`
         * of a given positive power.
         *
         * @returns a supercircle
         * @see [org.locationtech.jts.util.GeometricShapeFactory.createSupercircle](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#createSupercircle-double-)
         */
        createSupercircle(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, power: number): Geometry;
        /**
         * Sets the location of the shape by specifying the base coordinate
         * (which in most cases is the
         * lower left point of the envelope containing the shape).
         *
         * @param base - the base coordinate of the shape
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setBase](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setBase-org.locationtech.jts.geom.Coordinate-)
         */
        setBase(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, base: Coordinate): any /* void */;
        /**
         * Sets the location of the shape by specifying the centre of
         * the shape's bounding box
         *
         * @param centre - the centre coordinate of the shape
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setCentre](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setCentre-org.locationtech.jts.geom.Coordinate-)
         */
        setCentre(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, centre: Coordinate): any /* void */;
        setEnvelope(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, env: Envelope): any /* void */;
        /**
         * Sets the height of the shape.
         *
         * @param height - the height of the shape
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setHeight](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setHeight-double-)
         */
        setHeight(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, height: number): any /* void */;
        /**
         * Sets the total number of points in the created `Geometry`.
         * The created geometry will have no more than this number of points,
         * unless more are needed to create a valid geometry.
         *
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setNumPoints](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setNumPoints-int-)
         */
        setNumPoints(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, nPts: number): any /* void */;
        /**
         * Sets the rotation angle to use for the shape.
         * The rotation is applied relative to the centre of the shape.
         *
         * @param radians - the rotation angle in radians.
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setRotation](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setRotation-double-)
         */
        setRotation(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, radians: number): any /* void */;
        /**
         * Sets the size of the extent of the shape in both x and y directions.
         *
         * @param size - the size of the shape's extent
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setSize](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setSize-double-)
         */
        setSize(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, size: number): any /* void */;
        /**
         * Sets the width of the shape.
         *
         * @param width - the width of the shape
         * @see [org.locationtech.jts.util.GeometricShapeFactory.setWidth](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/GeometricShapeFactory.html#setWidth-double-)
         */
        setWidth(geometricShapeFactory: any /* org.locationtech.jts.util.GeometricShapeFactory */, width: number): any /* void */;
      };
      IntArrayList: {
        /**
         * Adds a value to the end of this list.
         *
         * @param value - the value to add
         * @see [org.locationtech.jts.util.IntArrayList.add](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#add-int-)
         */
        add(intArrayList: any /* org.locationtech.jts.util.IntArrayList */, value: number): any /* void */;
        /**
         * Adds all values in an array to the end of this list.
         *
         * @param values - an array of values
         * @see [org.locationtech.jts.util.IntArrayList.addAll](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#addAll-int:A-)
         */
        addAll(intArrayList: any /* org.locationtech.jts.util.IntArrayList */, values: number[]): any /* void */;
        /**
         * Constructs an empty list.
         *
         * @see [org.locationtech.jts.util.IntArrayList.IntArrayList](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#IntArrayList--)
         */
        create0(): any /* org.locationtech.jts.util.IntArrayList */;
        /**
         * Constructs an empty list with the specified initial capacity
         *
         * @param initialCapacity - the initial capacity of the list
         * @see [org.locationtech.jts.util.IntArrayList.IntArrayList](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#IntArrayList-int-)
         */
        create1(initialCapacity: number): any /* org.locationtech.jts.util.IntArrayList */;
        /**
         * Increases the capacity of this list instance, if necessary,
         * to ensure that it can hold at least the number of elements
         * specified by the capacity argument.
         *
         * @param capacity - the desired capacity
         * @see [org.locationtech.jts.util.IntArrayList.ensureCapacity](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#ensureCapacity-int-)
         */
        ensureCapacity(intArrayList: any /* org.locationtech.jts.util.IntArrayList */, capacity: number): any /* void */;
        /**
         * Returns the number of values in this list.
         *
         * @returns the number of values in the list
         * @see [org.locationtech.jts.util.IntArrayList.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#size--)
         */
        size(intArrayList: any /* org.locationtech.jts.util.IntArrayList */): number;
        /**
         * Returns a int array containing a copy of
         * the values in this list.
         *
         * @returns an array containing the values in this list
         * @see [org.locationtech.jts.util.IntArrayList.toArray](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/IntArrayList.html#toArray--)
         */
        toArray(intArrayList: any /* org.locationtech.jts.util.IntArrayList */): number[];
      };
      Memory: {
        GB: number;
        KB: number;
        MB: number;
        allString(): string;
        format(mem: number): string;
        free(): number;
        freeString(): string;
        round(d: number): number;
        total(): number;
        totalString(): string;
        used(): number;
        usedString(): string;
        usedTotalString(): string;
      };
      NumberUtil: {
        equalsWithTolerance(x1: number, x2: number, tolerance: number): boolean;
      };
      ObjectCounter: {
        create0(): any /* org.locationtech.jts.util.ObjectCounter */;
      };
      PriorityQueue: {
        /**
         * Make the priority queue logically empty.
         *
         * @see [org.locationtech.jts.util.PriorityQueue.clear](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/PriorityQueue.html#clear--)
         */
        clear(priorityQueue: any /* org.locationtech.jts.util.PriorityQueue */): any /* void */;
        /**
         * Creates a new empty priority queue
         *
         * @see [org.locationtech.jts.util.PriorityQueue.PriorityQueue](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/PriorityQueue.html#PriorityQueue--)
         */
        create0(): any /* org.locationtech.jts.util.PriorityQueue */;
        /**
         * Test if the priority queue is logically empty.
         *
         * @returns true if empty, false otherwise.
         * @see [org.locationtech.jts.util.PriorityQueue.isEmpty](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/PriorityQueue.html#isEmpty--)
         */
        isEmpty(priorityQueue: any /* org.locationtech.jts.util.PriorityQueue */): boolean;
        /**
         * Returns size.
         *
         * @returns current size.
         * @see [org.locationtech.jts.util.PriorityQueue.size](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/PriorityQueue.html#size--)
         */
        size(priorityQueue: any /* org.locationtech.jts.util.PriorityQueue */): number;
      };
      Stopwatch: {
        create0(): any /* org.locationtech.jts.util.Stopwatch */;
        getTime(stopwatch: any /* org.locationtech.jts.util.Stopwatch */): number;
        getTimeString(timeMillis: number): string;
        reset(stopwatch: any /* org.locationtech.jts.util.Stopwatch */): any /* void */;
        split(stopwatch: any /* org.locationtech.jts.util.Stopwatch */): number;
        start(stopwatch: any /* org.locationtech.jts.util.Stopwatch */): any /* void */;
        stop(stopwatch: any /* org.locationtech.jts.util.Stopwatch */): number;
      };
      StringUtil: {
        chars(c: any /* char */, n: number): string;
        spaces(n: number): string;
        /**
         * Mimics the the Java SE `String.split` method.
         *
         * @param s - the string to split.
         * @param separator - the separator to use.
         * @returns the array of split strings.
         * @see [org.locationtech.jts.util.StringUtil.split](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/StringUtil.html#split-java.lang.String-java.lang.String-)
         */
        split(s: string, separator: string): string[];
        /**
         * Returns a string representation of the given number,
         * using a format compatible with WKT.
         *
         * @param d - a number
         * @returns a string
         * @see [org.locationtech.jts.util.StringUtil.toString](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/StringUtil.html#toString-double-)
         */
        toString(d: number): string;
      };
      TestBuilderProxy: {
        /**
         * Tests whether the proxy is active (i.e. the TestBuilder is available).
         * This allows avoiding expensive geometry creation if not needed.
         *
         * @returns true if the proxy is active
         * @see [org.locationtech.jts.util.TestBuilderProxy.isActive](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/TestBuilderProxy.html#isActive--)
         */
        isActive(): boolean;
        /**
         * Shows a geometry as an indicator in the TestBuilder Edit panel.
         * The geometry is only displayed until the next screen refresh.
         * The TestBuilder also provides a menu option to capture
         * indicators on a layer.
         *
         * @param geom - the geometry to display
         * @see [org.locationtech.jts.util.TestBuilderProxy.showIndicator](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/TestBuilderProxy.html#showIndicator-org.locationtech.jts.geom.Geometry-)
         */
        showIndicator(geom: Geometry): any /* void */;
      };
      UniqueCoordinateArrayFilter: {
        create0(): any /* org.locationtech.jts.util.UniqueCoordinateArrayFilter */;
        /**
         * Performs an operation with the provided `coord`.
         * Note that there is no guarantee that the input coordinate
         * is the actual object stored in the source geometry,
         * so changes to the coordinate object may not be persistent.
         *
         * @param coord - a `Coordinate` to which the filter is applied.
         * @see [org.locationtech.jts.geom.CoordinateFilter.filter](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/geom/CoordinateFilter.html#filter-org.locationtech.jts.geom.Coordinate-)
         */
        filter(uniqueCoordinateArrayFilter: any /* org.locationtech.jts.util.UniqueCoordinateArrayFilter */, coord: Coordinate): any /* void */;
        /**
         * Convenience method which allows running the filter over an array of `Coordinate`s.
         *
         * @param coords - an array of coordinates
         * @returns an array of the unique coordinates
         * @see [org.locationtech.jts.util.UniqueCoordinateArrayFilter.filterCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/UniqueCoordinateArrayFilter.html#filterCoordinates-org.locationtech.jts.geom.Coordinate:A-)
         */
        filterCoordinates(coords: Coordinate[]): Coordinate[];
        /**
         * Returns the gathered `Coordinate`s.
         *
         * @returns the `Coordinate`s collected by this `CoordinateArrayFilter`
         * @see [org.locationtech.jts.util.UniqueCoordinateArrayFilter.getCoordinates](https://locationtech.github.io/jts/javadoc/org/locationtech/jts/util/UniqueCoordinateArrayFilter.html#getCoordinates--)
         */
        getCoordinates(uniqueCoordinateArrayFilter: any /* org.locationtech.jts.util.UniqueCoordinateArrayFilter */): Coordinate[];
      };
    };
  };
}

export {};