@crossbind/port-geos-ios 2.0.0-beta.56 → 2.0.0-beta.60

package/dist/prebuilt/ios-iphoneos-mt-release/include/geos_c.h

@@ -61,22 +61,22 @@ extern "C" {
 #define GEOS_VERSION_MAJOR 3
 #endif
 #ifndef GEOS_VERSION_MINOR
-#define GEOS_VERSION_MINOR 14
+#define GEOS_VERSION_MINOR 15
 #endif
 #ifndef GEOS_VERSION_PATCH
-#define GEOS_VERSION_PATCH 1
+#define GEOS_VERSION_PATCH 0
 #endif
 #ifndef GEOS_VERSION
-#define GEOS_VERSION "3.14.1"
+#define GEOS_VERSION "3.15.0"
 #endif
 #ifndef GEOS_JTS_PORT
-#define GEOS_JTS_PORT "1.18.0"
+#define GEOS_JTS_PORT "1.20.0"
 #endif
 
 #define GEOS_CAPI_VERSION_MAJOR 1
-#define GEOS_CAPI_VERSION_MINOR 20
-#define GEOS_CAPI_VERSION_PATCH 5
-#define GEOS_CAPI_VERSION "3.14.1-CAPI-1.20.5"
+#define GEOS_CAPI_VERSION_MINOR 21
+#define GEOS_CAPI_VERSION_PATCH 0
+#define GEOS_CAPI_VERSION "3.15.0-CAPI-1.21.0"
 
 #define GEOS_CAPI_FIRST_INTERFACE GEOS_CAPI_VERSION_MAJOR
 #define GEOS_CAPI_LAST_INTERFACE (GEOS_CAPI_VERSION_MAJOR+GEOS_CAPI_VERSION_MINOR)
@@ -117,6 +117,21 @@ typedef void (*GEOSMessageHandler)(GEOS_PRINTF_FORMAT const char *fmt, ...)
 */
 typedef void (*GEOSMessageHandler_r)(const char *message, void *userdata);
 
+
+/**
+ * A GEOS progress callback function.
+ *
+ * Such function takes a progress ratio (0 to 1), and an optional message.
+ *
+ * \param progressRatio Progression ratio (between 0 and 1)
+ * \param message Information message (can be NULL)
+ * \param userdata the user data pointer that was passed to GEOS together with
+ * this callback.
+ */
+typedef void (GEOSProgressCallback)(double progressRatio,
+                                    const char* message, void* userdata);
+
+
 /*
 * When we're included by geos_c.cpp, these types are #defined to the
 * C++ definitions via preprocessor. We don't touch them to allow the
@@ -188,6 +203,20 @@ typedef struct GEOSMakeValidParams_t GEOSMakeValidParams;
 */
 typedef struct GEOSClusterInfo_t GEOSClusterInfo;
 
+/**
+* Parameter object for curve-to-line conversion
+* \see GEOSCurveToLineParams_create()
+* \see GEOSCurveToLineParams_destroy()
+*/
+typedef struct GEOSCurveToLineParams_t GEOSCurveToLineParams;
+
+/**
+* Parameter object for line-to-curve conversion
+* \see GEOSLineToCurveParams_create()
+* \see GEOSLineToCurveParams_destroy()
+*/
+typedef struct GEOSLineToCurveParams_t GEOSLineToCurveParams;
+
 #endif
 
 /** \cond */
@@ -406,18 +435,29 @@ extern GEOSContextInterruptCallback GEOS_DLL *GEOSContext_setInterruptCallback_r
 */
 extern void GEOS_DLL GEOS_interruptRequest(void);
 
-/**
-* Interrupt the current thread.
-* \since 3.14
-*/
-extern void GEOS_DLL GEOS_interruptThread(void);
-
 /**
 * Cancel a pending interruption request
 * \since 3.4
 */
 extern void GEOS_DLL GEOS_interruptCancel(void);
 
+/* ========== Progress monitoring ========== */
+
+/**
+* Register a function to be called with progress updates
+*
+* \param extHandle the context returned by \ref GEOS_init_r.
+* \param cb Callback function to invoke
+* \param userData optional data to be pe provided as argument to callback
+* \return the previously registered callback, or NULL
+* \see GEOSProgressCallback
+* \since 3.15
+*/
+extern GEOSProgressCallback GEOS_DLL *GEOSContext_setProgressCallback_r(
+       GEOSContextHandle_t extHandle,
+       GEOSProgressCallback* cb,
+       void* userData);
+
 /* ========== Initialization and Cleanup ========== */
 
 /**
@@ -495,6 +535,38 @@ extern GEOSMessageHandler_r GEOS_DLL GEOSContext_setErrorMessageHandler_r(
     GEOSMessageHandler_r ef,
     void *userData);
 
+/**
+* Set parameters to use for converting input curves to lines.
+*
+* These parameters will be used with this context whenever a curved geometry is
+* provided to a function that only supports linear types. If `params` is NULL,
+* no automatic conversion will be performed.
+*
+* \param extHandle the GEOS context
+* \param params the curve conversion parameters
+*
+* \since 3.15
+*/
+extern void GEOS_DLL GEOSContext_setCurveToLineParams_r(
+    GEOSContextHandle_t extHandle,
+    const GEOSCurveToLineParams* params);
+
+/**
+* Set parameters to use for converting output lines to curves.
+*
+* These parameters will be used with this context whenever a curved geometry is
+* provided to a function that only supports linear types. If `params` is NULL,
+* no automatic conversion will be performed.
+*
+* \param extHandle the GEOS context
+* \param params the curve conversion parameters
+*
+* \since 3.15
+*/
+extern void GEOS_DLL GEOSContext_setLineToCurveParams_r(
+    GEOSContextHandle_t extHandle,
+    const GEOSLineToCurveParams* params);
+
 /* ========== Coordinate Sequence functions ========== */
 
 /** \see GEOSCoordSeq_create */
@@ -938,6 +1010,13 @@ GEOSCoverageSimplifyVW_r(
     double tolerance,
     int preserveBoundary);
 
+/** \see GEOSCoverageEdges */
+extern GEOSGeometry GEOS_DLL *
+GEOSCoverageEdges_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* input,
+    int edgetype);
+
 /** \see GEOSCoverageCleanParams_create */
 extern GEOSCoverageCleanParams GEOS_DLL *
 GEOSCoverageCleanParams_create_r(
@@ -1029,6 +1108,16 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonHullSimplify_r(
     unsigned int isOuter,
     double vertexNumFraction);
 
+/**
+* Controls the behavior of the GEOSPolygonHullSimplify parameter.
+*/
+enum GEOSPolygonHullParameterModes {
+    /** Fraction of input vertices retained */
+    GEOSHULL_PARAM_VERTEX_RATIO = 1,
+    /** Ratio of simplified hull area to input area */
+    GEOSHULL_PARAM_AREA_RATIO = 2
+};
+
 /** \see GEOSPolygonHullSimplifyMode */
 extern GEOSGeometry GEOS_DLL *GEOSPolygonHullSimplifyMode_r(
     GEOSContextHandle_t handle,
@@ -1161,6 +1250,12 @@ extern GEOSGeometry GEOS_DLL *GEOSNode_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry* g);
 
+/** \see GEOSSplit */
+extern GEOSGeometry GEOS_DLL *GEOSSplit_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g,
+    const GEOSGeometry* edge);
+
 /** \see GEOSClipByRect */
 extern GEOSGeometry GEOS_DLL *GEOSClipByRect_r(
     GEOSContextHandle_t handle,
@@ -1168,6 +1263,15 @@ extern GEOSGeometry GEOS_DLL *GEOSClipByRect_r(
     double xmin, double ymin,
     double xmax, double ymax);
 
+/** \see GEOSSubdivideByGrid */
+extern GEOSGeometry GEOS_DLL *GEOSSubdivideByGrid_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g,
+    double xmin, double ymin,
+    double xmax, double ymax,
+    unsigned nx, unsigned ny,
+    int includeExterior);
+
 /** \see GEOSGridIntersectionFractions */
 extern int GEOS_DLL GEOSGridIntersectionFractions_r(
     GEOSContextHandle_t handle,
@@ -1213,6 +1317,12 @@ extern GEOSGeometry GEOS_DLL *GEOSLineMerge_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry* g);
 
+/** \see GEOSMinimumSpanningTree */
+extern size_t GEOS_DLL *GEOSMinimumSpanningTree_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry * const geoms[],
+    unsigned int ngeoms);
+
 /** \see GEOSLineMergeDirected */
 extern GEOSGeometry GEOS_DLL *GEOSLineMergeDirected_r(
     GEOSContextHandle_t handle,
@@ -1271,6 +1381,17 @@ extern GEOSGeometry GEOS_DLL * GEOSConstrainedDelaunayTriangulation_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry *g);
 
+/** Change behaviour of \ref GEOSVoronoiDiagram */
+enum GEOSVoronoiFlags
+{
+    /** Return only edges of the Voronoi cells, as a MultiLineString **/
+    GEOS_VORONOI_ONLY_EDGES = 1,
+    /** Preserve order of inputs, such that the nth cell in the result corresponds
+     *  to the nth vertex in the input. If this cannot be done, such as for inputs
+     *  that contain repeated points, \ref GEOSVoronoiDiagram will return NULL. **/
+    GEOS_VORONOI_PRESERVE_ORDER = 2
+};
+
 /** \see GEOSVoronoiDiagram */
 extern GEOSGeometry GEOS_DLL * GEOSVoronoiDiagram_r(
     GEOSContextHandle_t extHandle,
@@ -1754,6 +1875,16 @@ extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry* g, int n);
 
+/** \see GEOSGetNumCurves */
+extern int GEOS_DLL GEOSGetNumCurves_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g);
+
+/** \see GEOSGetCurveN */
+extern const GEOSGeometry GEOS_DLL *GEOSGetCurveN_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g, int n);
+
 /** \see GEOSNormalize */
 extern int GEOS_DLL GEOSNormalize_r(
     GEOSContextHandle_t handle,
@@ -1790,6 +1921,48 @@ extern double GEOS_DLL GEOSGeom_getPrecision_r(
     GEOSContextHandle_t handle,
     const GEOSGeometry *g);
 
+/** \see GEOSCurveToLine */
+extern GEOSGeometry GEOS_DLL *GEOSCurveToLine_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g,
+    const GEOSCurveToLineParams* params);
+
+/** \see GEOSCurveToLineParams_setMaxStepDegrees */
+extern int GEOS_DLL GEOSCurveToLineParams_setMaxStepDegrees_r(
+    GEOSContextHandle_t extHandle,
+    GEOSCurveToLineParams* params,
+    double tolerance);
+
+/** \see GEOSCurveToLineParams_setMaxDeviation */
+extern int GEOS_DLL GEOSCurveToLineParams_setMaxDeviation_r(
+    GEOSContextHandle_t extHandle,
+    GEOSCurveToLineParams* params,
+    double tolerance);
+
+/** \see GEOSLineToCurve */
+extern GEOSGeometry GEOS_DLL *GEOSLineToCurve_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry* g,
+    const GEOSLineToCurveParams* params);
+
+/** \see GEOSLineToCurveParams_setRadiusTolerance */
+extern int GEOS_DLL GEOSLineToCurveParams_setRadiusTolerance_r(
+        GEOSContextHandle_t extHandle,
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
+/** \see GEOSLineToCurveParams_setMaxStepDegrees */
+extern int GEOS_DLL GEOSLineToCurveParams_setMaxStepDegrees_r(
+        GEOSContextHandle_t extHandle,
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
+/** \see GEOSLineToCurveParams_setMaxAngleDifferenceDegrees */
+extern int GEOS_DLL GEOSLineToCurveParams_setMaxAngleDifferenceDegrees_r(
+        GEOSContextHandle_t extHandle,
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
 /** \see GEOSGetNumInteriorRings */
 extern int GEOS_DLL GEOSGetNumInteriorRings_r(
     GEOSContextHandle_t handle,
@@ -1945,6 +2118,15 @@ extern int GEOS_DLL GEOSHausdorffDistance_r(
     const GEOSGeometry *g2,
     double *dist);
 
+/** \see GEOSHausdorffDistanceWithPoints */
+extern int GEOS_DLL GEOSHausdorffDistanceWithPoints_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry *g1,
+    const GEOSGeometry *g2,
+    double *dist,
+    double *p1x, double *p1y,
+    double *p2x, double *p2y);
+
 /** \see GEOSHausdorffDistanceDensify */
 extern int GEOS_DLL GEOSHausdorffDistanceDensify_r(
     GEOSContextHandle_t handle,
@@ -1952,6 +2134,15 @@ extern int GEOS_DLL GEOSHausdorffDistanceDensify_r(
     const GEOSGeometry *g2,
     double densifyFrac, double *dist);
 
+/** \see GEOSHausdorffDistanceDensifyWithPoints */
+extern int GEOS_DLL GEOSHausdorffDistanceDensifyWithPoints_r(
+    GEOSContextHandle_t handle,
+    const GEOSGeometry *g1,
+    const GEOSGeometry *g2,
+    double densifyFrac, double* dist,
+    double *p1x, double *p1y,
+    double *p2x, double *p2y);
+
 /** \see GEOSFrechetDistance */
 extern int GEOS_DLL GEOSFrechetDistance_r(
     GEOSContextHandle_t handle,
@@ -2807,7 +2998,7 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_createCircularString(GEOSCoordSequence* s
 * Caller is responsible for freeing with GEOSGeom_destroy().
 * \since 3.13
 */
-extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCircularString();
+extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCircularString(void);
 
 /**
 * Creates a CompoundCurve geometry.
@@ -2826,7 +3017,7 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_createCompoundCurve(GEOSGeometry** curves
 * Caller is responsible for freeing with GEOSGeom_destroy().
 * \since 3.13
 */
-extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCompoundCurve();
+extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCompoundCurve(void);
 
 /**
 * Creates a CurvePolygon geometry from ring geometries.
@@ -2852,7 +3043,7 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_createCurvePolygon(
 * Caller is responsible for freeing with GEOSGeom_destroy().
 * \since 3.13
 */
-extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCurvePolygon();
+extern GEOSGeometry GEOS_DLL *GEOSGeom_createEmptyCurvePolygon(void);
 
 /**
 * Create a geometry collection.
@@ -3012,6 +3203,33 @@ extern const GEOSGeometry GEOS_DLL *GEOSGetGeometryN(
     const GEOSGeometry* g,
     int n);
 
+/**
+* Returns the number of simple curves in a CompoundCurve.
+* Returns 1 for a non-empty LineString/CircularString, and 0 
+* for other inputs.
+* \param g Input geometry
+* \return Number of child curves in this geometry
+* \since 3.15
+*/
+extern int GEOS_DLL GEOSGetNumCurves(const GEOSGeometry* g);
+
+/**
+* Returns the specified sub-curve of a geometry. For a simple curve type
+* (LineString/CircularString), returns a pointer to the input.
+* Returns NULL for non-curve types (dimension != 1).
+*
+* Returned object is a pointer to internal storage and must NOT be destroyed
+* directly.
+
+* \param g Input geometry
+* \param n Sub-curve index, zero-based
+* \return A const \ref GEOSGeometry, or NULL
+* \since 3.15
+*/
+extern const GEOSGeometry GEOS_DLL *GEOSGetCurveN(
+    const GEOSGeometry* g,
+    int n);
+
 /**
 * Read the currently set precision value from the
 * geometry and returns the grid size if it is a fixed
@@ -3033,9 +3251,12 @@ extern double GEOS_DLL GEOSGeom_getPrecision(const GEOSGeometry *g);
 extern int GEOS_DLL GEOSGetNumInteriorRings(const GEOSGeometry* g);
 
 /**
-* Returns the number of points, for a LineString input, or
-* an exception otherwise.
-* \param g Input LineString geometry
+* Return the number of points in a linear geometry.
+*
+* CircularString inputs are supported since GEOS 3.14.
+* CompoundCurve inputs are supported since GEOS 3.15.
+*
+* \param g Input geometry, must be a LineString, CircularString, or CompoundCurve
 * \return Number of points, -1 on exception
 * \since 2.2
 */
@@ -3119,7 +3340,7 @@ extern int GEOS_DLL GEOSGetNumCoordinates(
 
 /**
 * Return the coordinate sequence underlying the
-* given geometry (Must be a LineString, LinearRing or Point).
+* given geometry (Must be a LineString, LinearRing, CircularString, or Point).
 * Do not directly free the coordinate sequence, it is owned by
 * the parent geometry.
 * \param g Input geometry
@@ -3132,9 +3353,9 @@ extern const GEOSCoordSequence GEOS_DLL *GEOSGeom_getCoordSeq(
 /**
 * Return the planar dimensionality of the geometry.
 *
-* - 0 for point, multipoint
-* - 1 for linestring, multilinestring
-* - 2 for polygon, multipolygon
+* - 0 for Point, MultiPoint
+* - 1 for LineString, MultiLineString, CircularString, CompoundCurve, MultiCurve
+* - 2 for Polygon, MultiPolygon, CurvePolygon, MultiSurface
 *
 * \see geos::geom::Dimension::DimensionType
 * \param g Input geometry
@@ -3148,7 +3369,8 @@ extern int GEOS_DLL GEOSGeom_getDimensions(
 * Return the cartesian dimension of the geometry.
 *
 * - 2 for XY data
-* - 3 for XYZ data
+* - 3 for XYZ or XYM data
+* - 4 for XYZM data
 *
 * \param g Input geometry
 * \return The dimension
@@ -3159,7 +3381,12 @@ extern int GEOS_DLL GEOSGeom_getCoordinateDimension(
     const GEOSGeometry* g);
 
 /**
-* Finds the minimum X value in the geometry.
+* Gets the minimum X value of the geometry's envelope.
+* For linear geometry types, this is the same as the minimum X
+* coordinate value.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[out] value Pointer to place result
 * \return 0 on exception
@@ -3169,7 +3396,12 @@ extern int GEOS_DLL GEOSGeom_getCoordinateDimension(
 extern int GEOS_DLL GEOSGeom_getXMin(const GEOSGeometry* g, double* value);
 
 /**
-* Finds the minimum Y value in the geometry.
+* Gets the minimum Y value of the geometry's envelope.
+* For linear geometry types, this is the same as the minimum Y
+* coordinate value.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[out] value Pointer to place result
 * \return 0 on exception
@@ -3179,7 +3411,12 @@ extern int GEOS_DLL GEOSGeom_getXMin(const GEOSGeometry* g, double* value);
 extern int GEOS_DLL GEOSGeom_getYMin(const GEOSGeometry* g, double* value);
 
 /**
-* Finds the maximum X value in the geometry.
+* Get the maximum X value of the geometry's envelope.
+* For linear geometry types, this is the same as the maximum X
+* coordinate value.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[out] value Pointer to place result
 * \return 0 on exception
@@ -3189,7 +3426,12 @@ extern int GEOS_DLL GEOSGeom_getYMin(const GEOSGeometry* g, double* value);
 extern int GEOS_DLL GEOSGeom_getXMax(const GEOSGeometry* g, double* value);
 
 /**
-* Finds the maximum Y value in the geometry.
+* Gets the maximum Y value of the geometry's envelope.
+* For linear geometry types, this is the same as the maximum Y
+* coordinate value.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[out] value Pointer to place result
 * \return 0 on exception
@@ -3199,9 +3441,13 @@ extern int GEOS_DLL GEOSGeom_getXMax(const GEOSGeometry* g, double* value);
 extern int GEOS_DLL GEOSGeom_getYMax(const GEOSGeometry* g, double* value);
 
 /**
-* Finds the extent (minimum and maximum X and Y value) of the geometry.
+* Finds the extent (minimum and maximum X and Y value) of the
+* geometry's envelope.
+*
 * Raises an exception for empty geometry input.
 *
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[out] xmin Pointer to place result for minimum X value
 * \param[out] ymin Pointer to place result for minimum Y value
@@ -3219,8 +3465,12 @@ extern int GEOS_DLL GEOSGeom_getExtent(
     double* ymax);
 
 /**
-* Return the N'th point of a LineString
-* \param g Input geometry, must be a LineString
+* Return the N'th point of a linear geometry.
+*
+* CircularString inputs are supported since GEOS 3.14.
+* CompoundCurve inputs are supported since GEOS 3.15.
+*
+* \param g Input geometry, must be a LineString, CircularString, or CompoundCurve
 * \param n Index of desired point (zero based)
 * \return A Point geometry.
 *         Caller must free with GEOSGeom_destroy()
@@ -3230,8 +3480,12 @@ extern int GEOS_DLL GEOSGeom_getExtent(
 extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN(const GEOSGeometry *g, int n);
 
 /**
-* Return the first point of a LineString
-* \param g Input geometry, must be a LineString
+* Return the first point of a linear geometry.
+*
+* CircularString inputs are supported since GEOS 3.14.
+* CompoundCurve inputs are supported since GEOS 3.15.
+*
+* \param g Input geometry, must be a LineString, CircularString, or CompoundCurve
 * \return A Point geometry.
 *         Caller must free with GEOSGeom_destroy()
 *         NULL on exception.
@@ -3240,8 +3494,12 @@ extern GEOSGeometry GEOS_DLL *GEOSGeomGetPointN(const GEOSGeometry *g, int n);
 extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint(const GEOSGeometry *g);
 
 /**
-* Return the last point of a LineString
-* \param g Input geometry, must be a LineString
+* Return the last point of a linear geometry.
+*
+* CircularString inputs are supported since GEOS 3.14.
+* CompoundCurve inputs are supported since GEOS 3.15.
+*
+* \param g Input geometry, must be a LineString, CircularString, or CompoundCurve
 * \return A Point geometry.
 *         Caller must free with GEOSGeom_destroy()
 *         NULL on exception.
@@ -3249,7 +3507,6 @@ extern GEOSGeometry GEOS_DLL *GEOSGeomGetStartPoint(const GEOSGeometry *g);
 */
 extern GEOSGeometry GEOS_DLL *GEOSGeomGetEndPoint(const GEOSGeometry *g);
 
-
 /**
 * Tests whether the input geometry is empty. If the geometry or any
 * component is non-empty, the geometry is non-empty. An empty geometry
@@ -3263,7 +3520,8 @@ extern char GEOS_DLL GEOSisEmpty(const GEOSGeometry* g);
 /**
 * Tests whether the input geometry is a ring. Rings are
 * linestrings, without self-intersections,
-* with start and end point being identical.
+* with start and end point having the same XY values.
+* Z and M values are not considered.
 * \param g The geometry to test
 * \return 1 on true, 0 on false, 2 on exception
 * \since 2.2
@@ -3289,8 +3547,14 @@ extern char GEOS_DLL GEOSHasM(const GEOSGeometry* g);
 
 /**
 * Tests whether the input geometry is closed.
-* A closed geometry is a linestring or multilinestring
-* with the start and end points being the same.
+* A closed geometry is either:
+* - a non-empty LineString, CircularString, or CompoundCurve whose
+*   start and end points having the same XY values; or
+* - a non-empty MultiLineString or MultiCurve whose elements are
+*   all closed.
+*
+* Z and M values are not considered.
+*
 * \param g The geometry to test
 * \return 1 on true, 0 on false, 2 on exception
 * \since 3.3
@@ -3334,7 +3598,11 @@ extern void GEOS_DLL GEOSGeom_setUserData(GEOSGeometry* g, void* userData);
 * - Rings start with their smallest coordinate
 *   (using XY ordering)
 * - Polygon shell rings are oriented CW, and holes CCW
-* - Collection elements are sorted by their first coordinate
+* - Collection elements are sorted by their geometry type and first coordinate
+*
+* Coordinate Z and M values are not modified during normalization.
+*
+* Curved geometry types are supported since GEOS 3.15.
 *
 * Use before calling \ref GEOSEqualsExact to avoid false "not equal" results.
 * \param g Input geometry
@@ -3346,6 +3614,7 @@ extern int GEOS_DLL GEOSNormalize(GEOSGeometry* g);
 /**
 * Enforce a ring orientation on all polygonal elements in the input geometry.
 * Non-polygonal geometries will not be modified.
+* Coordinate Z and M values are not modified.
 *
 * \param g Input geometry
 * \param exteriorCW if 1, exterior rings will be clockwise and interior rings
@@ -3368,6 +3637,13 @@ and geometric quality.
 /**
 * Tests whether the input geometry is "simple". Mostly relevant for
 * linestrings. A "simple" linestring has no self-intersections.
+* Z and M values are not considered.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to test
 * \return 1 on true, 0 on false, 2 on exception
 * \since 2.2
@@ -3378,9 +3654,14 @@ extern char GEOS_DLL GEOSisSimple(const GEOSGeometry* g);
 * In one step, calculate and return whether a geometry is simple
 * and one more more points at which the geometry self-intersects
 * at interior points.
-* Caller has the responsibility to destroy 'location' with 
+* Caller has the responsibility to destroy 'location' with
 * GEOSGeom_destroy()
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to test
 * \param findAllLocations Whether to return all self-intersection locations, or just one
 * \param locations A pointer in which the location GEOSGeometry will be placed
@@ -3401,6 +3682,13 @@ extern char GEOS_DLL GEOSisSimpleDetail(
 *   contained within exterior rings.
 * - Multi-polygon components may not touch or overlap.
 *
+* Z and M values are not considered.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to test
 * \return 1 on true, 0 on false, 2 on exception
 * \see geos::operation::valid::isValidOp
@@ -3411,6 +3699,12 @@ extern char GEOS_DLL GEOSisValid(const GEOSGeometry* g);
 /**
 * Return the human readable reason a geometry is invalid,
 * "Valid Geometry" string otherwise, or NULL on exception.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to test
 * \return A string with the reason, NULL on exception.
 *         Caller must GEOSFree() their result.
@@ -3425,6 +3719,12 @@ extern char GEOS_DLL *GEOSisValidReason(const GEOSGeometry *g);
 * rules are broken.
 * Caller has the responsibility to destroy 'reason' with GEOSFree()
 * and 'location' with GEOSGeom_destroy()
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to test
 * \param flags A value from the \ref GEOSValidFlags enum
 * \param reason A pointer in which the reason string will be places
@@ -3441,6 +3741,16 @@ extern char GEOS_DLL GEOSisValidDetail(
 
 /**
 * Repair an invalid geometry, returning a valid output.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g The geometry to repair
 * \return The repaired geometry. Caller must free with GEOSGeom_destroy().
 *
@@ -3452,6 +3762,16 @@ extern GEOSGeometry GEOS_DLL *GEOSMakeValid(
 /**
 * Repair an invalid geometry, returning a valid output, using the
 * indicated GEOSMakeValidMethods algorithm and options.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g is the geometry to test.
 * \param makeValidParams is a GEOSMakeValidParams with the desired parameters set on it.
 * \return A repaired geometry. Caller must free with GEOSGeom_destroy().
@@ -3522,6 +3842,11 @@ extern int GEOS_DLL GEOSMakeValidParams_setKeepCollapsed(
 * If the minimum clearance cannot be defined for a geometry (such as with a single point, or a multipoint
 * whose points are identical, a value of Infinity will be calculated.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g the input geometry
 * \param d a double to which the result can be stored
 * \return 0 if no exception occurred.
@@ -3533,9 +3858,14 @@ extern int GEOS_DLL GEOSMakeValidParams_setKeepCollapsed(
 extern int GEOS_DLL GEOSMinimumClearance(const GEOSGeometry* g, double* d);
 
 /**
-* Returns a LineString whose endpoints define the minimum clearance of a geometry.
+* Returns a 2D LineString whose endpoints define the minimum clearance of a geometry.
 * If the geometry has no minimum clearance, an empty LineString will be returned.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g the input geometry
 * \return a linestring geometry, or NULL if an exception occurred.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -3554,6 +3884,9 @@ extern GEOSGeometry GEOS_DLL *GEOSMinimumClearanceLine(const GEOSGeometry* g);
 * result in an invalid geometry being returned. Be sure
 * to check and repair validity.
 *
+* Z and M coordinate values are preserved but are not considered when
+* determining if a point is repeated.
+*
 * \return A geometry with all points within the tolerance of each other removed.
 * \param g The geometry to filter
 * \param tolerance Remove all points within this distance of each other. Use 0.0 to remove only exactly repeated points.
@@ -3576,6 +3909,11 @@ extern GEOSGeometry GEOS_DLL *GEOSRemoveRepeatedPoints(
 
 /**
 * Calculate the area of a geometry.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
+* Area is calculated in the XY plane; Z and M values are ignored.
+*
 * \param[in] g Input geometry
 * \param[out] area Pointer to be filled in with area result
 * \return 1 on success, 0 on exception.
@@ -3587,6 +3925,10 @@ extern int GEOS_DLL GEOSArea(
 
 /**
 * Calculate the length of a geometry.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
+* Length is calculated in the XY plane; Z and M values are ignored.
 * \param[in] g Input geometry
 * \param[out] length Pointer to be filled in with length result
 * \return 1 on success, 0 on exception.
@@ -3597,8 +3939,13 @@ extern int GEOS_DLL GEOSLength(
     double *length);
 
 /**
-* Calculate the length of a LineString.
-* Only works for LineString inputs, returns exception otherwise.
+* Calculate the length of a LineString, CircularString, or CompoundCurve.
+*
+* Returns an exception if a different geometry type is provided.
+* Length is calculated in the XY plane; Z and M values are ignored.
+*
+* CircularString and CompoundCurve arguments are supported since
+* GEOS 3.15.
 *
 * \param[in] g Input geometry
 * \param[out] length Pointer to be filled in with length result
@@ -3620,9 +3967,17 @@ extern int GEOS_DLL GEOSGeomGetLength(
 
 /**
 * Calculate the distance between two geometries.
+* Distance is calculated in the XY plane; Z and M values are ignored.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
-* \param[out] dist Pointer to be filled in with distance result
+* \param[out] dist Pointer to be filled in with distance result. Positive
+*                  infinity is returned if one of the geometry is empty.
 * \return 1 on success, 0 on exception.
 * \since 2.2
 */
@@ -3634,6 +3989,13 @@ extern int GEOS_DLL GEOSDistance(
 /**
 * Test whether the distance between two geometries is
 * within the given dist.
+* Distance is calculated in the XY plane; Z and M values are ignored.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g1 Input geometry
 * \param g2 Input geometry
 * \param dist The max distance
@@ -3651,6 +4013,12 @@ extern char GEOS_DLL GEOSDistanceWithin(
 * indexed facet distance, which first indexes the geometries
 * internally, then calculates the distance. Useful when one
 * or both geometries is very large.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
 * \param[out] dist Pointer to be filled in with distance result
@@ -3667,6 +4035,12 @@ extern int GEOS_DLL GEOSDistanceIndexed(
 /**
 * The closest points of the two geometries.
 * The first point comes from g1 geometry and the second point comes from g2.
+* Returned points will not have Z or M values.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
 *
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
@@ -3683,6 +4057,12 @@ extern GEOSCoordSequence GEOS_DLL *GEOSNearestPoints(
 * Calculate the Hausdorff distance between two geometries.
 * [Hausdorff distance](https://en.wikipedia.org/wiki/Hausdorff_distance)
 * is the largest distance between two geometries.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
 * \param[out] dist Pointer to be filled in with distance result
@@ -3695,11 +4075,47 @@ extern int GEOS_DLL GEOSHausdorffDistance(
     const GEOSGeometry *g2,
     double *dist);
 
+
+/**
+* Calculate the Hausdorff distance between two geometries and return
+* the coordinates of the points that determine the distance.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* \param[in] g1 Input geometry
+* \param[in] g2 Input geometry
+* \param[out] dist Pointer to be filled in with distance result
+* \param[out] p1x X coordinate of point on g1
+* \param[out] p1y Y coordinate of point on g1
+* \param[out] p2x X coordinate of point on g2
+* \param[out] p2y Y coordinate of point on g2
+* \return 1 on success, 0 on exception.
+* \see geos::algorithm::distance::DiscreteHausdorffDistance
+* \since 3.15
+*/
+extern int GEOS_DLL GEOSHausdorffDistanceWithPoints(
+    const GEOSGeometry *g1,
+    const GEOSGeometry *g2,
+    double *dist,
+    double *p1x, double *p1y,
+    double *p2x, double *p2y);
+
+
+
 /**
 * Calculate a more precise Hausdorff distance between two geometries,
 * by densifying the inputs before computation.
 * [Hausdorff distance](https://en.wikipedia.org/wiki/Hausdorff_distance)
 * is the largest distance between two geometries.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
 * \param[in] densifyFrac The largest % of the overall line length that
@@ -3715,11 +4131,50 @@ extern int GEOS_DLL GEOSHausdorffDistanceDensify(
     double densifyFrac,
     double *dist);
 
+/**
+* Calculate a more precise Hausdorff distance between two geometries,
+* by densifying the inputs before computation and return the points
+* that determine the distance.
+* [Hausdorff distance](https://en.wikipedia.org/wiki/Hausdorff_distance)
+* is the largest distance between two geometries.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* \param[in] g1 Input geometry
+* \param[in] g2 Input geometry
+* \param[in] densifyFrac The largest % of the overall line length that
+* any given two point segment should be.
+* \param[out] dist Pointer to be filled in with distance result
+* \param[out] p1x X coordinate of point on g1
+* \param[out] p1y Y coordinate of point on g1
+* \param[out] p2x X coordinate of point on g2
+* \param[out] p2y Y coordinate of point on g2
+* \return 1 on success, 0 on exception.
+* \see goes::algorithm::distance::DiscreteHausdorffDistance
+* \since 3.15
+*/
+extern int GEOS_DLL GEOSHausdorffDistanceDensifyWithPoints(
+    const GEOSGeometry *g1,
+    const GEOSGeometry *g2,
+    double densifyFrac,
+    double *dist,
+    double* p1x, double* p1y,
+    double* p2x, double* p2y);
+
 /**
 * Calculate the
 * [Frechet distance](https://en.wikipedia.org/wiki/Fr%C3%A9chet_distance)
 * between two geometries,
 * a similarity measure for linear features.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
 * \param[out] dist Pointer to be filled in with distance result
@@ -3739,6 +4194,12 @@ extern int GEOS_DLL GEOSFrechetDistance(
 * between two geometries,
 * a similarity measure for linear features.
 * The inputs can be densified to provide a more accurate result.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g1 Input geometry
 * \param[in] g2 Input geometry
 * \param[in] densifyFrac The largest % of the overall line length that
@@ -3766,6 +4227,12 @@ extern int GEOS_DLL GEOSFrechetDistanceDensify(
 
 /**
 * Distance of point projected onto line from the start of the line.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param line linear target of projection
 * \param point point to be projected onto 'g'
 * \return distance along line that point projects to, -1 on exception
@@ -3777,10 +4244,18 @@ extern double GEOS_DLL GEOSProject(const GEOSGeometry* line,
                                    const GEOSGeometry* point);
 
 /**
-* Measuring from start of line, return point that is distance
-* the start. Line parameter must be a LineString.
-* The returned point is not guaranteed to intersect the line due to limitations
-* of floating point calculations.
+* Return the point that is the specified 2D distance along a LineString from the start.
+*
+* If applicable, the Z value of the returned point will be interpolated from the input line.
+* Since GEOS 3.15, the M value will also be interpolated.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* If the (converted) input is not a LineString, NULL will be returned.
+*
 * \param line linear target of projection
 * \param d distance from start of line to created point
 * \return The point \ref GEOSGeometry that is distance from the start of line.
@@ -3794,6 +4269,12 @@ extern GEOSGeometry GEOS_DLL *GEOSInterpolate(const GEOSGeometry* line,
 * Project point to line and calculate the **proportion** of
 * the line the point is from the start. For example, a point that
 * projects to the middle of a line would be return 0.5.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param line linear target of projection
 * \param point the point to project
 * \return The proportion of the overall line length that the projected
@@ -3804,8 +4285,19 @@ extern double GEOS_DLL GEOSProjectNormalized(const GEOSGeometry* line,
                                              const GEOSGeometry* point);
 
 /**
-* Measuring from start of line, return point that is a proportion
-* the start. Line parameter must be a LineString.
+* Measuring from start of a LineString, return the point at the specified
+* fraction of the total length.
+*
+* If applicable, the Z value of the returned point will be interpolated from the input line.
+* Since GEOS 3.15, the M value will also be interpolated.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* If the (converted) input is not a LineString, NULL will be returned.
+*
 * \param line linear target of projection
 * \param proportion The proportion from the start of line to created point
 * \return The point \ref GEOSGeometry that is distance from the start of line.
@@ -3828,6 +4320,16 @@ extern GEOSGeometry GEOS_DLL *GEOSInterpolateNormalized(
 /**
 * Returns the intersection of two geometries: the set of points
 * that fall within **both** geometries.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g1 one of the geometries
 * \param g2 the other geometry
 * \return A newly allocated geometry of the intersection. NULL on exception.
@@ -3856,6 +4358,16 @@ extern GEOSGeometry GEOS_DLL *GEOSIntersectionPrec(const GEOSGeometry* g1, const
 /**
 * Returns the difference of two geometries A and B: the set of points
 * that fall within A but **not** within B.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param ga the base geometry
 * \param gb the geometry to subtract from it
 * \return A newly allocated geometry of the difference. NULL on exception.
@@ -3891,6 +4403,16 @@ extern GEOSGeometry GEOS_DLL *GEOSDifferencePrec(
 * Returns the symmetric difference of two geometries A and B: the set of points
 * that fall in A but **not** within B and the set of points that fall in B but
 * **not** in A.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param ga geometry A
 * \param gb geometry B
 * \return A newly allocated geometry of the symmetric difference. NULL on exception.
@@ -3926,6 +4448,16 @@ extern GEOSGeometry GEOS_DLL *GEOSSymDifferencePrec(
 /**
 * Returns the union of two geometries A and B: the set of points
 * that fall in A **or** within B.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param ga geometry A
 * \param gb geometry B
 * \return A newly allocated geometry of the union. NULL on exception.
@@ -3961,6 +4493,16 @@ extern GEOSGeometry GEOS_DLL *GEOSUnionPrec(
 * Returns the union of all components of a single geometry. Usually
 * used to convert a collection into the smallest set of polygons
 * that cover the same area.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the union. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -3993,6 +4535,16 @@ extern GEOSGeometry GEOS_DLL *GEOSUnaryUnionPrec(
 * Optimized union algorithm for inputs that can be divided into subsets
 * that do not intersect. If there is only one such subset, performance
 * can be expected to be worse than GEOSUnionaryUnion.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the union, or NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4005,6 +4557,16 @@ extern GEOSGeometry GEOS_DLL *GEOSDisjointSubsetUnion(const GEOSGeometry *g);
 * Intersection optimized for a rectangular clipping polygon.
 * Supposed to be faster than using GEOSIntersection(). Not
 * guaranteed to return valid results.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g The input geometry to be clipped
 * \param xmin Left bound of clipping rectangle
 * \param ymin Lower bound of clipping rectangle
@@ -4021,9 +4583,55 @@ extern GEOSGeometry GEOS_DLL *GEOSClipByRect(
     double xmin, double ymin,
     double xmax, double ymax);
 
+/**
+* Compute the intersection of a geometry with each polygon in
+* a rectangular grid.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
+* \param g The input geometry to be clipped
+* \param xmin Left bound of grd
+* \param ymin Lower bound of grid
+* \param xmax Right bound of grid
+* \param ymax Upper bound of grid
+* \param nx number of columns in grid
+* \param ny number of rows in grid
+* \param includeExterior whether to include portions of the
+         input geometry that do not intersect the grid in
+         the returned result.
+* \return A geometry collection whose components represent the
+*         intersection with each cell in the grid.
+* Caller is responsible for freeing with GEOSGeom_destroy().
+*
+* This algorithm operates in 2D only; Z and M values in the input will be dropped.
+
+* \see GEOSGetGridIntersectionFractions
+*
+* \since 3.15.0
+*/
+extern GEOSGeometry GEOS_DLL *GEOSSubdivideByGrid(
+    const GEOSGeometry* g,
+    double xmin, double ymin,
+    double xmax, double ymax,
+    unsigned nx, unsigned ny,
+    int includeExterior);
+
 /**
 * Determine the fraction of each cell in a rectangular grid
 * that is covered by a polygon.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \param xmin Left bound of grd
 * \param ymin Lower bound of grid
@@ -4054,6 +4662,11 @@ extern int GEOS_DLL GEOSGridIntersectionFractions(
 * - second element is a MultiLineString containing shared paths
 *   having the _opposite_ direction on the two inputs
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g1 An input geometry
 * \param g2 An input geometry
 * \return The shared paths
@@ -4069,7 +4682,6 @@ extern GEOSGeometry GEOS_DLL *GEOSSharedPaths(
 
 /* ========== Clustering functions ========== */
 /** @name Clustering
-* Functions for clustering geometries
 */
 
 
@@ -4079,36 +4691,51 @@ static const size_t GEOS_CLUSTER_NONE = (size_t) -1;
 
 ///@{
 /**
- * @brief GEOSClusterDBSCAN
- *
- * Cluster geometries using the DBSCAN algorithm
- *
- * @param g a collection of geometries to be clustered
- * @param eps distance parameter for clustering
- * @param minPoints density parameter for clustering
- * @return cluster information object
- */
+* @brief GEOSClusterDBSCAN
+*
+* Cluster geometries using the DBSCAN algorithm
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* @param g a collection of geometries to be clustered
+* @param eps distance parameter for clustering
+* @param minPoints density parameter for clustering
+* @return cluster information object
+*/
 extern GEOSClusterInfo GEOS_DLL* GEOSClusterDBSCAN(const GEOSGeometry* g, double eps, unsigned minPoints);
 
 /**
- * @brief GEOSClusterGeometryDistance
- *
- * Cluster geometries according to a distance threshold
- *
- * @param g a collection of geometries to be clustered
- * @param d minimum distance between geometries in the same cluster
- * @return cluster information object
- */
+* @brief GEOSClusterGeometryDistance
+*
+* Cluster geometries according to a distance threshold
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* @param g a collection of geometries to be clustered
+* @param d minimum distance between geometries in the same cluster
+* @return cluster information object
+*/
 extern GEOSClusterInfo GEOS_DLL* GEOSClusterGeometryDistance(const GEOSGeometry* g, double d);
 
 /**
- * @brief GEOSClusterGeometryIntersects
- *
- * Cluster geometries that intersect
- *
- * @param g a collection of geometries to be clustered
- * @return cluster information object
- */
+* @brief GEOSClusterGeometryIntersects
+*
+* Cluster geometries that intersect
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
+* @param g a collection of geometries to be clustered
+* @return cluster information object
+*/
 extern GEOSClusterInfo GEOS_DLL* GEOSClusterGeometryIntersects(const GEOSGeometry* g);
 
 /**
@@ -4116,6 +4743,8 @@ extern GEOSClusterInfo GEOS_DLL* GEOSClusterGeometryIntersects(const GEOSGeometr
  *
  * Cluster geometries according to an envelope distance threshold
  *
+ * This function supports curved geometry types.
+ *
  * @param g a collection of geometries to be clustered
  * @param d minimum envelope distance between geometries in the same cluster
  * @return cluster information object
@@ -4127,6 +4756,8 @@ extern GEOSClusterInfo GEOS_DLL* GEOSClusterEnvelopeDistance(const GEOSGeometry*
  *
  * Cluster geometries whose envelopes intersect
  *
+ * This function supports curved geometry types.
+ *
  * @param g
  * @return cluster information object
  */
@@ -4193,6 +4824,13 @@ extern void GEOS_DLL GEOSClusterInfo_destroy(GEOSClusterInfo* clusters);
 
 /**
 * Buffer a geometry.
+* The coordinates of the constructed geometry will not have Z or M values.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry to be buffered.
 * \param width The distance by which to expand the geometry (or contract)
 *        if the value is negative.
@@ -4290,6 +4928,12 @@ extern int GEOS_DLL GEOSBufferParams_setSingleSided(
 
 /**
 * Generates a buffer using the special parameters in the GEOSBufferParams
+* 
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to buffer
 * \param p The parameters to apply to the buffer process
 * \param width The buffer distance
@@ -4305,6 +4949,13 @@ extern GEOSGeometry GEOS_DLL *GEOSBufferWithParams(
 
 /**
 * Generate a buffer using the provided style parameters.
+* The coordinates of the constructed geometry will not have Z or M values.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The geometry to buffer
 * \param width Width of the buffer
 * \param quadsegs Number of segments per quadrant
@@ -4326,7 +4977,13 @@ extern GEOSGeometry GEOS_DLL *GEOSBufferWithStyle(
 
 /**
 * Generates offset curve line(s) for a geometry.
-* Handles all geometry types as input.
+* Handles all non-curved geometry types as input.
+* The coordinates of the constructed geometry will not have Z or M values.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
 *
 * - For a LineString the result is a LineString.
 * - For a Point the result is an empty LineString.
@@ -4364,6 +5021,16 @@ extern GEOSGeometry GEOS_DLL *GEOSOffsetCurve(const GEOSGeometry* g,
 * noded and do not overlap. It may generate an error (return NULL)
 * for inputs that do not satisfy this constraint, however this is not
 * guaranteed.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g The input geometry
 * \return A geometry that covers all the points of the input geometry.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4378,6 +5045,11 @@ extern GEOSGeometry GEOS_DLL *GEOSCoverageUnion(const GEOSGeometry *g);
 * with exactly matching edge geometry) to find places where the
 * assumption of exactly matching edges is not met.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param input The polygonal coverage to access,
 *        stored in a geometry collection. All members must be POLYGON
 *        or MULTIPOLYGON.
@@ -4414,6 +5086,15 @@ extern int GEOS_DLL GEOSCoverageIsValid(
 * it will still be simplified, but invalid topology such as crossing
 * edges will still be invalid.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param input The polygonal coverage to access,
 *        stored in a geometry collection. All members must be POLYGON
 *        or MULTIPOLYGON.
@@ -4432,15 +5113,25 @@ extern GEOSGeometry GEOS_DLL * GEOSCoverageSimplifyVW(
     int preserveBoundary);
 
 /**
-* Create a default GEOSCoverageCleanParams object for controlling
-* the way invalid polygon interactions are repaird by \ref GEOSCoverageCleanWithParams.
+ * Returns a MultiLineString representing the unique edges of a polygonal coverage.
+ *
+ * \param input a GeometryCollection or MultiPolygon representing the coverage.
+ * \param edgetype selection type: 0 = ALL, 1 = EXTERIOR (non-shared), 2 = INTERIOR (shared).
+ * \return a MultiLineString of unique edges, or NULL on error.
+ *
+ * \since 3.15
+ */
+extern GEOSGeometry GEOS_DLL *GEOSCoverageEdges(const GEOSGeometry *input, int edgetype);
+
+/**
+ * Create a default GEOSCoverageCleanParams object for controlling* the way invalid polygon interactions are repaired by \ref GEOSCoverageCleanWithParams.
 * \return A newly allocated GEOSCoverageCleanParams. NULL on exception.
 * Caller is responsible for freeing with GEOSCoverageCleanParams_destroy().
 *
 * \since 3.14
 */
 extern GEOSCoverageCleanParams GEOS_DLL *
-GEOSCoverageCleanParams_create();
+GEOSCoverageCleanParams_create(void);
 
 /**
 * Destroy a GEOSCoverageCleanParams and free all associated memory.
@@ -4453,18 +5144,22 @@ GEOSCoverageCleanParams_destroy(
     GEOSCoverageCleanParams* params);
 
 /**
+* Set the snapping distance to use when cleaning a coverage.
+*
 * Snapping to nearby vertices and line segment snapping
 * is used to improve noding robustness
-* and eliminate small errors in an efficient way,
+* and eliminate small errors in an efficient way.
+*
 * By default this uses a very small snapping distance
 * based on the extent of the input data.
-* The snapping distance may be specified explicitly.
-* This can reduce the number of overlaps and gaps that need to be merged,
-* and reduce the risk of spikes formed by merging gaps.
-* However, a large snapping distance may introduce undesirable
+*
+* Specifying a larger snapping distance can reduce the number of overlaps and
+* gaps that need to be merged, and reduce the risk of spikes formed by merging
+* gaps. However, a large snapping distance can also introduce undesirable
 * data alteration.
 *
 * A distance of zero prevents snapping from being used.
+*
 * \see geos::coverage::CoverageCleaner::setSnappingDistance
 * \param params The GEOSCoverageCleanParams to operate on
 * \param snappingDistance Set to 0.0 for no snapping.
@@ -4478,19 +5173,22 @@ GEOSCoverageCleanParams_setSnappingDistance(
     double snappingDistance);
 
 /**
-* Gaps which are wider than a given distance are merged with an adjacent polygon.
-* Polygon width is determined as twice the radius of the MaximumInscribedCircle
-* of the gap polygon.
-* Gaps are merged with the adjacent polygon with longest shared border.
+* Set the maximum width of gaps to merge when cleaning a coverage.
+*
+* Gaps wider than the given distance are merged with the adjacent polygon
+* having the longest shared border with the gap. (The overlap merge strategy
+* is not used.)
+*
+* Gaps are defined as enclosed empty areas with width less than a distance tolerance.
 * Empty holes in input polygons are treated as gaps, and may be filled in.
 * Gaps which are not fully enclosed ("inlets") are not removed.
 *
-* The width of a gap is twice the radius of the Maximum Inscribed Circle in the gap polygon,
+* Width is computed as the diameter of the Maximum Inscribed Circle of the gap polygon.
 * A width of zero prevents gaps from being merged.
 *
 * \see geos::coverage::CoverageCleaner::setGapMaximumWidth
 * \param params The GEOSCoverageCleanParams to operate on
-* \param gapMaximumWidth Set to 0.0 for no snapping.
+* \param gapMaximumWidth Set to 0.0 for no gap merging.
 * \return 0 on exception, 1 on success.
 *
 * \since 3.14
@@ -4500,21 +5198,23 @@ GEOSCoverageCleanParams_setGapMaximumWidth(
     GEOSCoverageCleanParams* params,
     double gapMaximumWidth);
 
-/*
+/**
 * Sets the overlap merge strategy to use, using one from \ref GEOSOverlapMerge.
-* Overlaps are merged with an adjacent polygon chosen according to a specified merge strategy.
-* The supported strategies are:
 *
-*   * **Longest Border**: (default) merge with the polygon with longest shared border (GEOS_MERGE_LONGEST_BORDER.)
-*   * **Maximum/Minimum Area**: merge with the polygon with largest or smallest area (GEOS_MERGE_MAX_AREA, GEOS_MERGE_MIN_AREA.)
-*   * **Minimum Index**: merge with the polygon with the lowest index in the input array (GEOS_MERGE_MIN_INDEX.)
+* Overlaps are merged with an adjacent polygon chosen according to a specified
+* merge strategy. The supported strategies are:
 *
-* This allows sorting the input according to some criteria to provide a priority
-* for merging gaps.
+* - **Longest Border**: (default) merge with the polygon with longest shared
+*   border (GEOS_MERGE_LONGEST_BORDER.)
+* - **Maximum/Minimum Area**: merge with the polygon with largest or smallest
+*   area (GEOS_MERGE_MAX_AREA, GEOS_MERGE_MIN_AREA.)
+* - **Minimum Index**: merge with the polygon with the lowest index in the
+*   input array (GEOS_MERGE_MIN_INDEX.). This allows sorting the input
+*   according to some criteria to provide a priority for merging gaps.
 *
 * The default is GEOS_MERGE_LONGEST_BORDER.
 *
-* \see geos::coverage::CoverageCleaner::setGapMaximumWidth
+* \see geos::coverage::CoverageCleaner::setOverlapMergeStrategy
 * \param params The GEOSCoverageCleanParams to operate on
 * \param overlapMergeStrategy One of \ref GEOSOverlapMerge strategies
 * \return 0 on exception, 1 on success.
@@ -4527,15 +5227,26 @@ GEOSCoverageCleanParams_setOverlapMergeStrategy(
     int overlapMergeStrategy);
 
 /**
+* Clean a coverage.
+*
 * Operates on a list of polygonal geometry with "exactly matching"
-* edge geometry, to fix cases where the geometry does not in fact
-* exactly match.
+* edge geometry. Removes any overlaps and fixes cases where the geometry
+* does not in fact exactly match.
 *
 * The input is a collection of polygons, and the output is a collection
 * with the same number of cleaned polygons, in the same order as
 * the input. Polygons that have collapsed during cleaning will be returned
 * as empties.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param input The dirty polygonal coverage,
 *        stored in a geometry collection. All members must be POLYGON
 *        or MULTIPOLYGON.
@@ -4571,8 +5282,13 @@ GEOSCoverageClean(
 ///@{
 
 /**
-* Returns minimum rectangular polygon or point that contains the geometry,
+* Returns minimum 2D rectangular polygon or point that contains the geometry,
 * or an empty point for empty inputs.
+*
+* Z and M values in the input coordinates are ignored.
+*
+* Cuved geometry types are supported as of GEOS 3.13.
+*
 * \param g The geometry to calculate an envelope for
 * \return A newly allocated polygonal envelope or point. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4588,6 +5304,10 @@ extern GEOSGeometry GEOS_DLL *GEOSEnvelope(const GEOSGeometry* g);
 * - the boundary of a linestring is the end points
 * - the boundary of a point is the point
 *
+* Z and M values in the input coordinates are preserved.
+*
+* Curved geometry types are supported as of GEOS 3.15.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the boundary. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4596,8 +5316,17 @@ extern GEOSGeometry GEOS_DLL *GEOSEnvelope(const GEOSGeometry* g);
 extern GEOSGeometry GEOS_DLL *GEOSBoundary(const GEOSGeometry* g);
 
 /**
-* Returns convex hull of a geometry. The smallest convex Geometry
+* Returns the convex hull of a geometry. The smallest convex Geometry
 * that contains all the points in the input Geometry
+*
+* Z values in the input coordinates will be preserved.
+* M values in the input coordinates will not be preserved.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the convex hull. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4614,6 +5343,9 @@ extern GEOSGeometry GEOS_DLL *GEOSConvexHull(const GEOSGeometry* g);
 * Frequently used to convert a multi-point into a polygonal area.
 * that contains all the points in the input Geometry.
 *
+* Z values in the input coordinates will be preserved.
+* M values in the input coordinates will not be preserved.
+*
 * A set of points has a sequence of hulls of increasing concaveness,
 * determined by a numeric target parameter.
 * The concave hull is constructed by removing the longest outer edges
@@ -4622,6 +5354,11 @@ extern GEOSGeometry GEOS_DLL *GEOSConvexHull(const GEOSGeometry* g);
 * This can be expressed as a ratio between the lengths of the longest and shortest edges.
 * 1 produces the convex hull; 0 produces a hull with maximum concaveness
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \param ratio The edge length ratio value, between 0 and 1.
 * \param allowHoles When non-zero, the polygonal output may contain holes.
@@ -4649,13 +5386,21 @@ extern GEOSGeometry GEOS_DLL *GEOSConcaveHull(
 * Frequently used to convert a multi-point into a polygonal area.
 * that contains all the points in the input Geometry.
 *
+* Z values in the input coordinates will be preserved.
+* M values in the input coordinates will not be preserved.
+*
 * A set of points has a sequence of hulls of increasing concaveness,
 * determined by a numeric target parameter.
 * The concave hull is constructed by removing the longest outer edges
 * of the Delaunay Triangulation of the space between the polygons,
-* until the specified maximm edge length is reached.
+* until the specified maximum edge length is reached.
 * A large value produces the convex hull, 0 produces the hull of maximum concaveness.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \param length The maximum edge length (0 or greater)
 * \param allowHoles When non-zero, the polygonal output may contain holes.
@@ -4694,6 +5439,11 @@ extern GEOSGeometry GEOS_DLL *GEOSConcaveHullByLength(
 * The input polygons *must* be a *valid* MultiPolygon
 * (i.e. they must be non-overlapping).
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g the valid MultiPolygon geometry to process
 * \param lengthRatio specifies the Maximum Edge Length as a
 *        fraction of the difference between the longest and
@@ -4701,8 +5451,8 @@ extern GEOSGeometry GEOS_DLL *GEOSConcaveHullByLength(
 *        This normalizes the Maximum Edge Length to be scale-free.
 *        A value of 1 produces the convex hull; a value of 0 produces
 *        the original polygons.
+* \param isTight does the hull follow the outer boundaries of the input polygons?
 * \param isHolesAllowed is the concave hull allowed to contain holes?
-* \param isTight does the hull follow the outer boundaries of the input polygons.
 * \return A newly allocated geometry of the concave hull. NULL on exception.
 *
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4728,6 +5478,15 @@ extern GEOSGeometry GEOS_DLL *GEOSConcaveHullOfPolygons(
 * An outer hull is computed if the parameter is positive,
 * an inner hull is computed if it is negative.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g the polygonal geometry to process
 * \param isOuter indicates whether to compute an outer or inner hull (1 for outer hull, 0 for inner)
 * \param vertexNumFraction the target fraction of the count of input vertices to retain in result
@@ -4744,16 +5503,6 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonHullSimplify(
     double vertexNumFraction);
 
 
-/**
-* Controls the behavior of the GEOSPolygonHullSimplify parameter.
-*/
-enum GEOSPolygonHullParameterModes {
-    /** Fraction of input vertices retained */
-    GEOSHULL_PARAM_VERTEX_RATIO = 1,
-    /** Ratio of simplified hull area to input area */
-    GEOSHULL_PARAM_AREA_RATIO = 2
-};
-
 /**
 * Computes a topology-preserving simplified hull of a polygonal geometry,
 * with hull shape determined by the parameter, controlled by a parameter
@@ -4762,6 +5511,15 @@ enum GEOSPolygonHullParameterModes {
 * produces the original geometry.
 * Either outer or inner hulls can be computed.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+* This function outputs linear geometry types only. If line-to-curve
+* conversion parameters are registered with the context, and a 
+* curved input was provided, outputs will be automatically 
+* converted to curved types.
+*
 * \param g the polygonal geometry to process
 * \param isOuter indicates whether to compute an outer or inner hull (1 for outer hull, 0 for inner)
 * \param parameterMode the interpretation to apply to the parameter argument; see \ref GEOSPolygonHullParameterModes
@@ -4788,6 +5546,12 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonHullSimplifyMode(
 * the input is degenerate (a line or point) a linestring or point
 * is returned. The minimum rotated rectangle can be used as an
 * extremely generalized representation for the given geometry.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the rotated envelope. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4812,6 +5576,12 @@ extern GEOSGeometry GEOS_DLL *GEOSMinimumRotatedRectangle(const GEOSGeometry* g)
 * way by using spatial indexes.
 * Returns a two-point linestring, with one point at the center of the inscribed circle and the other
 * on the boundary of the inscribed circle.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g Input geometry
 * \param tolerance Stop the algorithm when the search area is smaller than this tolerance
 * \return A newly allocated geometry of the MIC. NULL on exception.
@@ -4837,17 +5607,22 @@ extern GEOSGeometry GEOS_DLL *GEOSMaximumInscribedCircle(
 * the obstacles (up to the given distance tolerance).
 * The LEC is determined by the center point and a point indicating the circle radius
 * (which will lie on an obstacle).
-* \n
+*
 * To compute an LEC which lies **wholly** within a polygonal boundary,
 * include the boundary of the polygon(s) as a linear obstacle.
-* \n
+*
 * The implementation uses a successive-approximation technique over a grid of square cells covering the obstacles and boundary.
 * The grid is refined using a branch-and-bound algorithm.  Point containment and distance are computed in a performant
 * way by using spatial indexes.
-* \n
+*
 * Returns the LEC radius as a two-point linestring, with the start point at the center of the inscribed circle and the end
 * on the boundary of the circle.
 *
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param obstacles The geometries that the LEC must not cross
 * \param boundary The area to contain the LEC center (may be null or empty)
 * \param tolerance Stop the algorithm when the search area is smaller than this tolerance
@@ -4868,6 +5643,12 @@ extern GEOSGeometry GEOS_DLL *GEOSLargestEmptyCircle(
 * contains the geometry, where a band is a strip of the plane defined
 * by two parallel lines. This can be thought of as the smallest hole that the geometry
 * can be moved through, with a single rotation.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \return A newly allocated geometry of the LEC. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4879,7 +5660,13 @@ extern GEOSGeometry GEOS_DLL *GEOSMinimumWidth(const GEOSGeometry* g);
 
 
 /**
-* Returns a point that is inside the boundary of a polygonal geometry.
+* Returns a 2D point that is inside the boundary of a polygonal geometry.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \return A point that is inside the input
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4890,7 +5677,13 @@ extern GEOSGeometry GEOS_DLL *GEOSMinimumWidth(const GEOSGeometry* g);
 extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface(const GEOSGeometry* g);
 
 /**
-* Returns a point at the center of mass of the input.
+* Returns a 2D point at the center of mass of the input.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g The input geometry
 * \return A point at the center of mass of the input
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4901,8 +5694,14 @@ extern GEOSGeometry GEOS_DLL *GEOSPointOnSurface(const GEOSGeometry* g);
 extern GEOSGeometry GEOS_DLL *GEOSGetCentroid(const GEOSGeometry* g);
 
 /**
-* Returns a geometry which represents the "minimum bounding circle",
+* Returns a 2D geometry which represents the "minimum bounding circle",
 * the smallest circle that contains the input.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param[in] g The input geometry
 * \param[out] radius Pointer will be filled with output radius.
 * \param[out] center Pointer will be filled with output circle center. Caller must free.
@@ -4920,6 +5719,12 @@ extern GEOSGeometry GEOS_DLL *GEOSMinimumBoundingCircle(
 /**
 * Return a Delaunay triangulation of the vertices of the given geometry.
 *
+* Z values from the input points will be propagated to the generated polygons.
+* M values from the input points will be ignored.
+*
+* Curved geometries are supported since GEOS 3.15. For curved geometries,
+* the control point and endpoints of each arc will be used as input vertices.
+*
 * \param g the input geometry whose vertices will be used as "sites"
 * \param tolerance optional snapping tolerance to use for improved robustness
 * \param onlyEdges if non-zero will return a MultiLineString, otherwise it will
@@ -4940,6 +5745,14 @@ extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation(
 * given polygon(s).
 * For non-polygonal inputs, returns an empty geometry collection.
 *
+* Z values from the input points will be propagated to the generated polygons.
+* M values from the input points will be ignored.
+*
+* This function does not support curved types directly. If curve-to-line
+* conversion parameters are registered with the context, curved
+* inputs will be automatically converted to lines. Otherwise, the
+* operation will fail.
+*
 * \param g the input geometry whose rings will be used as input
 * \return A newly allocated geometry. NULL on exception.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -4949,19 +5762,12 @@ extern GEOSGeometry GEOS_DLL * GEOSDelaunayTriangulation(
 extern GEOSGeometry GEOS_DLL * GEOSConstrainedDelaunayTriangulation(
     const GEOSGeometry *g);
 
-/** Change behaviour of \ref GEOSVoronoiDiagram */
-enum GEOSVoronoiFlags
-{
-    /** Return only edges of the Voronoi cells, as a MultiLineString **/
-    GEOS_VORONOI_ONLY_EDGES = 1,
-    /** Preserve order of inputs, such that the nth cell in the result corresponds
-     *  to the nth vertex in the input. If this cannot be done, such as for inputs
-     *  that contain repeated points, \ref GEOSVoronoiDiagram will return NULL. **/
-    GEOS_VORONOI_PRESERVE_ORDER = 2
-};
-
 /**
-* Returns the Voronoi polygons or edges of the vertices of the given geometry.
+* Returns the 2D Voronoi polygons or edges computed from the vertices
+* of the given geometry.
+*
+* Curved geometries are supported since GEOS 3.15. For curved geometries,
+* the control point and endpoints of each arc will be used as input vertices.
 *
 * \param g the input geometry whose vertices will be used as sites.
 * \param tolerance snapping tolerance to use for improved robustness. A
@@ -4997,6 +5803,12 @@ extern GEOSGeometry GEOS_DLL * GEOSVoronoiDiagram(
 /**
 * For linear inputs, returns a new geometry in which no lines cross
 * each other, and all touching occurs at end points.
+*
+* Z and M values of input coordinates will be preserved.
+* Z and M values at constructed points will be interpolated.
+*
+* Curved geometry types are supported since GEOS 3.15.
+*
 * \param g The input geometry
 * \return The noded geometry or NULL on exception
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5006,13 +5818,34 @@ extern GEOSGeometry GEOS_DLL * GEOSVoronoiDiagram(
 */
 extern GEOSGeometry GEOS_DLL *GEOSNode(const GEOSGeometry* g);
 
+
+/** Split a linear or polygonal input 
+* 
+* Linear inputs can be split with points, lines, and/or polygons.
+* Polygons can be split with lines and/or polygons.
+*
+* The returned geometry will be a GeometryCollection containing the
+* split elements.
+*
+* \param g The geometry to split
+* \param edge the geometry containing splitting edges/points
+* \return the split geometry or NULL on exception.
+*  Caller is responsible for freeing with GEOSGeom_destroy().
+*
+* \since 3.15
+*/
+extern GEOSGeometry GEOS_DLL *GEOSSplit(const GEOSGeometry* g, const GEOSGeometry* edge);
+
 /**
 * Polygonizes a set of Geometries which contain linework that
 * represents the edges of a planar graph.
 *
-* All types of Geometry are accepted as input; the constituent
+* All non-curved types of Geometry are accepted as input; the constituent
 * linework is extracted as the edges to be polygonized.
 *
+* Z and M values from the input linework will be preserved.
+* Curved geometries are supported since GEOS 3.15.
+*
 * The edges must be correctly noded; that is, they must only meet
 * at their endpoints and not overlap anywhere. If your edges are not
 * already noded, run them through GEOSUnaryUnion() first.
@@ -5040,7 +5873,7 @@ extern GEOSGeometry GEOS_DLL *GEOSNode(const GEOSGeometry* g);
 * that the input lines form a valid polygonal geometry (which may
 * include holes or nested polygons).
 *
-* \param geoms Array of linear geometries to polygons. Caller retains ownersihp of both array container and objects.
+* \param geoms Array of linear geometries to polygonize. Caller retains ownership of both array container and objects.
 * \param ngeoms Size of the geoms array.
 * \return The polygonal output geometry.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5057,7 +5890,10 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonize(
 * but returns a result which is a valid polygonal geometry.
 * The result will not contain any edge-adjacent elements.
 *
-* \param geoms Array of linear geometries to polygons. Caller retains ownersihp of both array container and objects.
+* Z and M values from the input linework will be preserved.
+* Curved geometries are supported since GEOS 3.15.
+*
+* \param geoms Array of linear geometries to polygonize. Caller retains ownership of both array container and objects.
 * \param ngeoms Size of the geoms array.
 * \return The polygonal output geometry.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5075,7 +5911,10 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonize_valid(
 * "cut edges", the linear features that are connected at both ends,
 * do *not* participate in the final polygon.
 *
-* \param geoms Array of linear geometries to polygons. Caller retains ownersihp of both array container and objects.
+* Z and M values from the input linework will be preserved.
+* Curved geometries are supported since GEOS 3.15.
+*
+* \param geoms Array of linear geometries to polygonize. Caller retains ownership of both array container and objects.
 * \param ngeoms Size of the geoms array.
 * \return The "cut edges"
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5091,6 +5930,9 @@ extern GEOSGeometry GEOS_DLL *GEOSPolygonizer_getCutEdges(
 * Perform the polygonization as GEOSPolygonize() and return the
 * polygonal result as well as all extra outputs.
 *
+* Z and M values from the input linework will be preserved.
+* Curved geometries are supported since GEOS 3.15.
+*
 * \param[in] input A single geometry with all the input lines to polygonize.
 * \param[out] cuts Pointer to hold "cut edges", connected on both ends but not part of output. Caller must free.
 * \param[out] dangles Pointer to hold "dangles", connected one end but not part of output. Caller must free.
@@ -5132,8 +5974,14 @@ extern GEOSGeometry GEOS_DLL *GEOSBuildArea(const GEOSGeometry* g);
 * Densifies a geometry using a given distance tolerance.
 * Additional vertices will be added to every line segment
 * that is greater this tolerance; these vertices will
-* evenly subdivide that segment.
+* evenly subdivide that segment. Z and M values of added
+* vertices will be interpolated.
 * Only linear components of input geometry are densified.
+* 
+* Curved geometries are not supported, unless curve-to-line parameters are
+* registered with the context handle. Output geometries will not contain
+* curves.
+*
 * \param g The geometry to densify
 * \param tolerance the distance tolerance to densify
 * \return The densified geometry, or NULL on exception.
@@ -5149,7 +5997,13 @@ extern GEOSGeometry GEOS_DLL *GEOSDensify(
 * Merges a set of LineStrings,
 * joining them at nodes which have cardinality 2.
 * Lines may have their direction reversed.
-
+*
+* Z and M values from the input will be preserved. If the Z and M
+* values differ at the points where two lines are joined, the values
+* from one of the points will be selected.
+*
+* Curved geometry types are supported since GEOS 3.15.
+*
 * \param g The input linework
 * \return The merged linework.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5159,11 +6013,34 @@ extern GEOSGeometry GEOS_DLL *GEOSDensify(
 extern GEOSGeometry GEOS_DLL *GEOSLineMerge(const GEOSGeometry* g);
 
 /**
-* Merges a set of LineStrings,
-* joining them at nodes which have cardinality 2.
+ * Computes the Minimum Spanning Tree of the given Curves.
+ *
+ * The input is an array of Curves (LineString, CircularString, CompoundCurve)
+ * which form the edges of a graph.
+ * The nodes of the graph are the endpoints of the Curves.
+ * Coincident endpoints are treated as the same node.
+ *
+ * \param geoms Input array of Curves. Non-Curve geometries are ignored.
+ * \param ngeoms Number of geometries in the input array.
+ * \return An array of size_t of size ngeoms. 0 if the edge is not in the MST.
+ *         Values > 0 indicate the component ID of the subtree the edge belongs to.
+ *         The caller is responsible for freeing the returned array using GEOSFree().
+ *         Returns NULL if ngeoms is 0 or on error.
+ * \since 3.15.0
+ */
+extern size_t GEOS_DLL *GEOSMinimumSpanningTree(const GEOSGeometry * const geoms[], unsigned int ngeoms);
+
+/**
+ * Merges a set of LineStrings,* joining them at nodes which have cardinality 2.
 * and where the lines have the same direction.
 * This means that lines do not have their direction reversed.
-
+*
+* Z and M values from the input will be preserved. If the Z and M
+* values differ at the points where two lines are joined, the values
+* from one of the points will be selected.
+*
+* Curved geometry types are supported since GEOS 3.15.
+*
 * \param g The input linework
 * \return The merged linework.
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5176,6 +6053,10 @@ extern GEOSGeometry GEOS_DLL *GEOSLineMergeDirected(const GEOSGeometry* g);
 /**
  *  Computes the line which is the section of the input LineString starting and
  *  ending at the given length fractions.
+ *
+ *  Z values will be interpolated from the input.
+ *  M values from the input will be ignored.
+ *
  *  \param g The input LineString
  *  \param start_fraction start fraction (0-1) along the length of g
  *  \param end_fraction end fraction (0-1) along the length of g
@@ -5192,7 +6073,11 @@ extern GEOSGeometry GEOS_DLL *GEOSLineSubstring(
 /**
 * For geometries with coordinate sequences, reverses the order
 * of the sequences. Converts CCW rings to CW. Reverses direction
-* of LineStrings.
+* of LineStrings. Z and M values of the input coordinates are
+* preserved.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param g The input geometry
 * \return The reversed geometry
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5207,6 +6092,7 @@ extern GEOSGeometry GEOS_DLL *GEOSReverse(const GEOSGeometry* g);
 * to the coordinate sequences of the input geometry.
 * Removes "unnecessary" vertices, vertices
 * that are co-linear within the tolerance distance.
+* Z and M values on the retained coordinates will be preserved.
 * \param g The input geometry
 * \param tolerance The tolerance to apply. Larger tolerance leads to simpler output.
 * \return The simplified geometry
@@ -5227,6 +6113,8 @@ extern GEOSGeometry GEOS_DLL *GEOSSimplify(
 * that are co-linear within the tolerance distance.
 * Returns a valid output geometry, checking for collapses, ring-intersections, etc
 * and attempting to avoid. More computationally expensive than GEOSSimplify()
+* Z values on the retained coordinates will be preserved.
+* M values will not be preserved.
 * \param g The input geometry
 * \param tolerance The tolerance to apply. Larger tolerance leads to simpler output.
 * \return The simplified geometry
@@ -5243,6 +6131,12 @@ extern GEOSGeometry GEOS_DLL *GEOSTopologyPreserveSimplify(
 * Return all distinct vertices of input geometry as a MultiPoint.
 * Note that only 2 dimensions of the vertices are considered when
 * testing for equality.
+*
+* Z values on the retained coordinates will be preserved.
+* M values will not be preserved.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param g The input geometry
 * \return The distinct points
 * Caller is responsible for freeing with GEOSGeom_destroy().
@@ -5255,10 +6149,13 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_extractUniquePoints(
 /**
 * Calculate the
 * [Hilbert code](https://en.wikipedia.org/wiki/Hilbert_curve)
-* of the centroid of a geometry relative to an extent.
+* of the center of a geometry's bounding box relative to a larger extent.
 * This allows sorting geometries in a deterministic way, such that similar Hilbert codes are
 * likely to be near each other in two-dimensional space.
 * The caller must ensure that the geometry is contained within the extent.
+*
+* Curved geometries are supported since GEOS 3.13.
+*
 * \param[in] geom Input geometry, must be non-empty
 * \param[in] extent Extent within which to calculate the Hilbert code for geom
 * \param[in] level The level of precision of the Hilbert curve, up to 16
@@ -5278,6 +6175,9 @@ extern int GEOS_DLL GEOSHilbertCode(
 * Apply XY coordinate transform callback to all coordinates in a copy of
 * input geometry.  If the callback returns an error, returned geometry will be
 * NULL.  Z and M values, if present, are not modified by this function.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[in] callback a function to be executed for each coordinate in the
                 geometry.  The callback takes 3 parameters: x and y coordinate
@@ -5297,6 +6197,9 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_transformXY(
 * Apply XYZ coordinate transform callback to all coordinates in a copy of
 * input geometry.  If the callback returns an error, returned geometry will be
 * NULL.  M values, if present, are not modified by this function.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param[in] g Input geometry
 * \param[in] callback a function to be executed for each coordinate in the
                 geometry.  The callback takes 4 parameters: x, y and z coordinate
@@ -5357,6 +6260,9 @@ extern GEOSGeometry GEOS_DLL *GEOSSnap(
 * So the combination GEOS_PREC_NO_TOPO || GEOS_PREC_KEEP_COLLAPSED
 * has the same semantics as GEOS_PREC_NO_TOPO
 *
+* Z and M values in the input are preserved.
+* Curved geometries are supported since GEOS 3.15 if GEOS_PREC_NO_TOPO is used.
+*
 * \param g Input geometry
 * \param gridSize cell size of grid to round coordinates to,
 *        or 0 for FLOATING precision
@@ -5374,6 +6280,124 @@ extern GEOSGeometry GEOS_DLL *GEOSGeom_setPrecision(
 
 ///@}
 
+/* ============================================================== */
+
+/** @name Line/Curve conversion
+* Functions for converting between curved and linear geometry types.
+*/
+///@{
+
+/** Approximate all circular arcs in a geometry using line segments.
+*   If the input has no circular arcs, a copy will be returned.
+*   \param g the geometry to convert
+*   \param params parameters to use in the linearization.
+*   \return The linearized geometry.
+*           Caller must free with GEOSGeom_destroy()
+*           NULL on exception
+*
+*   \since 3.15
+*/ 
+extern GEOSGeometry GEOS_DLL *GEOSCurveToLine(
+    const GEOSGeometry* g,
+    const GEOSCurveToLineParams* params);
+
+extern GEOSCurveToLineParams GEOS_DLL *GEOSCurveToLineParams_create();
+
+extern void GEOS_DLL GEOSCurveToLineParams_destroy(GEOSCurveToLineParams* params);
+
+/** Set the maximum step (in degrees) between subsequent points.
+*
+*   \param params parameters to use in the conversion.
+*   \param tolerance the maximum step size
+*   \return 1 if the operation succeeded, 0 otherwise
+*
+*   \since 3.15
+*/ 
+extern int GEOS_DLL GEOSCurveToLineParams_setMaxStepDegrees(
+    GEOSCurveToLineParams* params,
+    double tolerance);
+
+/** Set the maximum deviation between an arc and its linear approximate.
+*
+*   \param params parameters to use in the conversion.
+*   \param tolerance the maximum deviation
+*   \return 1 if the operation succeeded, 0 otherwise
+*
+*   \since 3.15
+*/ 
+extern int GEOS_DLL GEOSCurveToLineParams_setMaxDeviation(
+    GEOSCurveToLineParams* params,
+    double tolerance);
+
+/** Replace line segments in the geometry with circular arcs, where possible.
+*
+*   \param g the geometry to convert
+*   \param params parameters to use in the conversion.
+*   \return The converted geometry.
+*           Caller must free with GEOSGeom_destroy()
+*           NULL on exception
+*
+*   \since 3.15
+*/ 
+extern GEOSGeometry GEOS_DLL *GEOSLineToCurve(
+    const GEOSGeometry* g,
+    const GEOSLineToCurveParams* params);
+
+extern GEOSLineToCurveParams GEOS_DLL *GEOSLineToCurveParams_create();
+
+extern void GEOS_DLL GEOSLineToCurveParams_destroy(GEOSLineToCurveParams* params);
+
+/** Set the radius tolerance used in line-to-curve conversion.
+*
+*   A vertex may be considered to continue a circular arc if its distance to the
+*   previously-computed circle center is within the specified fraction of the
+*   circle radius.
+* 
+*   \param params the parameters object
+*   \param tolerance the tolerance value
+*   \return 1 on success, 0 on failure
+*   \since 3.15
+*/
+extern int GEOS_DLL GEOSLineToCurveParams_setRadiusTolerance(
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
+/** Set the maximum angle spacing used in line-to-curve conversion.
+*
+*   A point may be considered to continue a circular arc if the angle between
+*   the point and the final point in the arc is less than the specified
+*   tolerance. Because of round-off errors, this value should be slightly
+*   greater than the one used in \ref GEOSCurveToLineParams_setMaxStepDegrees.
+* 
+*   \param params the parameters object
+*   \param tolerance the tolerance value
+*   \return 1 on success, 0 on failure
+*   \since 3.15
+*/
+extern int GEOS_DLL GEOSLineToCurveParams_setMaxStepDegrees(
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
+/** Set the maximum angle difference used in line-to-curve conversion
+*
+*   A point may be considered to continue a circular arc if the angle between
+*   the point and the final point in the arc is within the specified
+*   tolerance of the angle calculated when the final point in the arc was
+*   added. This tolerance can be used to ensure that the step spacing is
+*   regular, which is an indication of a line that was generated by 
+*   linearizing a curve.
+* 
+*   \param params the parameters object
+*   \param tolerance the tolerance value
+*   \return 1 on success, 0 on failure
+*   \since 3.15
+*/
+extern int GEOS_DLL GEOSLineToCurveParams_setMaxAngleDifferenceDegrees(
+        GEOSLineToCurveParams* params,
+        double tolerance);
+
+///@}
+
 /* ============================================================== */
 /** @name Spatial Predicates
 * Functions computing binary spatial predicates using the DE-9IM topology model.
@@ -5423,7 +6447,7 @@ extern char GEOS_DLL GEOSIntersects(const GEOSGeometry* g1, const GEOSGeometry*
 extern char GEOS_DLL GEOSCrosses(const GEOSGeometry* g1, const GEOSGeometry* g2);
 
 /**
-* Tests if geometry g1 is completely within g2, 
+* Tests if geometry g1 is completely within g2,
 * but not wholly contained in the boundary of g2.
 * \param g1 Input geometry
 * \param g2 Input geometry
@@ -5499,6 +6523,9 @@ extern char GEOS_DLL GEOSCoveredBy(const GEOSGeometry* g1, const GEOSGeometry* g
 * Unlike GEOSEquals(), geometries that are topologically equivalent but have different
 * representations (e.g., LINESTRING (0 0, 1 1) and MULTILINESTRING ((0 0, 1 1)) ) are not
 * considered equal by GEOSEqualsExact().
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param g1 Input geometry
 * \param g2 Input geometry
 * \param tolerance Tolerance to determine vertex equality
@@ -5512,11 +6539,13 @@ extern char GEOS_DLL GEOSEqualsExact(
     double tolerance);
 
 /**
- * Determine pointwise equality of two geometries by checking
- * that the structure, ordering, and values of all vertices are
- * identical in all dimensions. NaN values are considered to be
- * equal to other NaN values.
- *
+* Determine pointwise equality of two geometries by checking
+* that the structure, ordering, and values of all vertices are
+* identical in all dimensions. NaN values are considered to be
+* equal to other NaN values.
+*
+* Curved geometry types are supported since GEOS 3.13.
+*
 * \param g1 Input geometry
 * \param g2 Input geometry
 * \returns 1 on true, 0 on false, 2 on exception
@@ -6707,7 +7736,7 @@ extern GEOSGeometry GEOS_DLL *GEOSGeomFromWKB_buf(const unsigned char *wkb, size
 extern unsigned char GEOS_DLL *GEOSGeomToWKB_buf(const GEOSGeometry* g, size_t *size);
 
 /**
-* \deprecated use \ref GEOSWKBReader and GEOSWKBWriter_readHEX()
+* \deprecated use \ref GEOSWKBReader and GEOSWKBReader_readHEX()
 */
 extern GEOSGeometry GEOS_DLL *GEOSGeomFromHEX_buf(const unsigned char *hex, size_t size);