From 3cdcedc975c871b5defe229cf26dc926b1998668 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20Zim=C3=A1nyi?= Date: Wed, 2 Sep 2026 09:49:11 +0200 Subject: [PATCH] Build every family and take the wasm surface from the catalog The generator emits a wrapper for every function the catalog marks public and builds the `#include` preamble from the headers those functions come from, so the emitted set and the declared set are one set. A header named in one list and absent from the other is what leaves a wrapper calling a function no header declares, which is how `interval_eq` and its siblings arrive undeclared. The image builds MobilityDB with `-DALL=ON` and carries the wasm stages the families that turns on need: zlib 1.3.1 and libxml2 2.13.5 for pgPointCloud's libpc, and GDAL 3.9.3 for raster band sampling. GDAL takes every optional driver off, since MEOS reads bands through the generic API, and the dependencies it keeps, PROJ and SQLite, are ones this image already builds. The emcc line asks `pkg-config` for the MEOS flags rather than naming an include path. The installed `meos.pc` reports the include directory together with the family macros the library carries, and the public headers gate declarations on those macros, so a path given without them compiles the negative branch and loses declarations whose symbols the archive exports. The configure step names the install prefix for the same reason: `meos.pc` records the prefix given at configure time, so a prefix supplied only to the install step leaves the file naming the emscripten sysroot. `EMULATE_FUNCTION_POINTER_CASTS` gives every indirect call one signature, as wide as the widest function type linked in, and GDAL carries the widest, so the `fpcast-emu` pass takes the parameter cap it names in its own diagnostic. The surface is 3470 wrappers, 0 skipped and 0 duplicates, against 2839 exports. `pkg-config` inside the image reports all ten families through `-DS2CELL=1`, and the built `meos.wasm` carries `tpcbox_make`, `meos_initialize_pointcloud`, `posechain_in`, `s2cell_in`, `raster_value` and `timetz_in`. `TNumber.avgValue()` goes with it. The catalog marks `tnumber_avg_value` internal, so the projection does not emit it, and the typed layers of the two mature bindings agree: PyMEOS's `TNumber` and JMEOS's `TNumber` each expose `integral` and the time-weighted average and neither exposes the plain one. `timeWeightedAverage()` stays, on the public `tnumber_twavg`. --- Dockerfile | 160 +- codegen/FunctionsGenerator.ts | 75 +- codegen/res/bindings_c_header.c.template | 10 +- core/c-src/bindings.c | 4970 +++++++++++++++---- core/functions/functions.generated.ts | 5572 ++++++++++++++++++---- core/types/basic/tnumber/TNumber.ts | 3 - 6 files changed, 9110 insertions(+), 1680 deletions(-) diff --git a/Dockerfile b/Dockerfile index b584255..51c2088 100644 --- a/Dockerfile +++ b/Dockerfile @@ -99,6 +99,122 @@ RUN mkdir -p build && cd build \ && cp /root/json-c/build/*.h /root/json-c-install/include/json-c/ \ && cp /root/json-c/build/libjson-c.a /root/json-c-install/lib/ +# COMPILING ZLIB WITH EMSCRIPTEN +# +# pgPointCloud's libpc links zlib and libxml2, so POINTCLOUD needs both on the +# wasm build path. Emscripten ships a zlib port, but MEOS reaches it through +# find_package(ZLIB), which wants a prefix it can point at rather than a linker +# flag, so it is built here like every other dependency. +FROM base AS zlib + +RUN curl -fL "https://github.com/madler/zlib/releases/download/v1.3.1/zlib-1.3.1.tar.gz" \ + | tar xz -C /root \ + && mv /root/zlib-1.3.1 /root/zlib + +WORKDIR /root/zlib +RUN mkdir -p build && cd build \ + && emcmake cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/root/zlib-install \ + -DBUILD_SHARED_LIBS=OFF \ + -DZLIB_BUILD_EXAMPLES=OFF \ + -DCMAKE_C_FLAGS=-sMEMORY64=1 \ + && emmake make -j"$(nproc)" zlibstatic \ + && emmake make install + +# COMPILING LIBXML2 WITH EMSCRIPTEN +# +# The other half of libpc's link line. Every optional feature is off: libpc uses +# libxml2 to read a point cloud's XML schema, so the parser is all that is +# needed, and the extras (python, http, lzma, iconv) each drag in a dependency +# this image would then have to cross-compile too. +FROM base AS libxml2 + +COPY --from=zlib /root/zlib-install /root/zlib-install + +RUN curl -fL "https://download.gnome.org/sources/libxml2/2.13/libxml2-2.13.5.tar.xz" \ + | tar xJ -C /root \ + && mv /root/libxml2-2.13.5 /root/libxml2 + +WORKDIR /root/libxml2 +RUN mkdir -p build && cd build \ + && emcmake cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/root/libxml2-install \ + -DZLIB_INCLUDE_DIR=/root/zlib-install/include \ + -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \ + -DBUILD_SHARED_LIBS=OFF \ + -DLIBXML2_WITH_PYTHON=OFF \ + -DLIBXML2_WITH_HTTP=OFF \ + -DLIBXML2_WITH_LZMA=OFF \ + -DLIBXML2_WITH_ICONV=OFF \ + -DLIBXML2_WITH_ZLIB=ON \ + -DLIBXML2_WITH_PROGRAMS=OFF \ + -DLIBXML2_WITH_TESTS=OFF \ + -DCMAKE_C_FLAGS=-sMEMORY64=1 \ + && emmake make -j"$(nproc)" \ + && emmake make install + +# COMPILING GDAL WITH EMSCRIPTEN +# +# RASTER samples raster bands along a trajectory through GDAL, and -DALL=ON turns +# RASTER on, so GDAL has to be on the wasm build path for the family set +# MobilityDB's own CMakeLists defines. +# +# Every optional driver is off. GDAL's driver set is where its bulk and its +# dependency surface live (curl, netcdf, hdf5, the proprietary SDKs), and MEOS +# reads raster bands through the generic API rather than naming a format, so the +# core plus the built-in drivers is the whole requirement. The dependencies it +# does take — PROJ and SQLite — are ones this image already builds for MEOS +# itself, so GDAL adds no third-party library that was not already here. +# +# GEOS is off in GDAL: it backs OGR's geometry predicates, which raster band +# sampling does not reach, and MEOS links its own GEOS regardless. Handing it +# this tree's GEOS would also need two include directories — `geos_c.h` takes +# `geos/export.h` from the source tree while the header itself is generated into +# the build tree — and GEOS_INCLUDE_DIR names one. +FROM base AS gdal + +COPY --from=sqlite /root/sqlite3 /root/sqlite3 +COPY --from=proj /root/PROJ /root/PROJ +COPY --from=geos /root/geos /root/geos +COPY --from=zlib /root/zlib-install /root/zlib-install + +RUN curl -fL "https://github.com/OSGeo/gdal/releases/download/v3.9.3/gdal-3.9.3.tar.gz" \ + | tar xz -C /root \ + && mv /root/gdal-3.9.3 /root/gdal + +WORKDIR /root/gdal +RUN mkdir -p build && cd build \ + && emcmake cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/root/gdal-install \ + -DBUILD_SHARED_LIBS=OFF \ + -DBUILD_APPS=OFF \ + -DBUILD_TESTING=OFF \ + -DBUILD_DOCS=OFF \ + -DBUILD_PYTHON_BINDINGS=OFF \ + -DBUILD_JAVA_BINDINGS=OFF \ + -DBUILD_CSHARP_BINDINGS=OFF \ + -DGDAL_BUILD_OPTIONAL_DRIVERS=OFF \ + -DOGR_BUILD_OPTIONAL_DRIVERS=OFF \ + -DGDAL_USE_EXTERNAL_LIBS=OFF \ + -DGDAL_USE_INTERNAL_LIBS=ON \ + -DGDAL_USE_PROJ=ON \ + -DPROJ_INCLUDE_DIR=/root/PROJ/src \ + -DPROJ_LIBRARY=/root/PROJ/build/lib/libproj.a \ + -DGDAL_USE_GEOS=OFF \ + -DGDAL_USE_SQLITE3=ON \ + -DSQLite3_INCLUDE_DIR=/root/sqlite3 \ + -DSQLite3_LIBRARY=/root/sqlite3/libsqlite3.a \ + -DGDAL_USE_ZLIB=ON \ + -DZLIB_INCLUDE_DIR=/root/zlib-install/include \ + -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \ + -DCMAKE_C_FLAGS=-sMEMORY64=1 \ + -DCMAKE_CXX_FLAGS=-sMEMORY64=1 \ + && emmake make -j"$(nproc)" \ + && emmake make install + # COMPILING GSL WITH EMSCRIPTEN FROM base AS gsl @@ -163,6 +279,9 @@ COPY --from=proj /root/PROJ /root/PROJ COPY --from=jsonc /root/json-c-install /root/json-c-install COPY --from=gsl /root/gsl-wasm /root/gsl-wasm COPY --from=h3 /root/h3-install /root/h3-install +COPY --from=zlib /root/zlib-install /root/zlib-install +COPY --from=libxml2 /root/libxml2-install /root/libxml2-install +COPY --from=gdal /root/gdal-install /root/gdal-install COPY --from=mobilitydb_src /root/MobilityDB /root/MobilityDB WORKDIR /app @@ -176,16 +295,17 @@ WORKDIR /app COPY . . # CMAKE: configure MobilityDB +# +# The install prefix is named HERE, not only on the install line: `meos.pc` is +# generated at configure time and records the prefix it is given then, so a +# prefix supplied later relocates the files while the `.pc` keeps pointing at +# the emscripten sysroot, and `pkg-config --cflags` then reports an include +# directory that holds no MEOS header. RUN INCLUDES="-I/root/geos/include -I/root/geos/build/capi -I/root/json-c-install/include -I/root/json-c-install/include/json-c" \ && emcmake cmake -S /root/MobilityDB -B /root/MobilityDB/build \ -DMEOS=ON \ - -DCBUFFER=ON \ - -DNPOINT=ON \ - -DPOSE=ON \ - -DRGEO=ON \ - -DH3=ON \ - -DJSON=ON \ - -DQUADBIN=ON \ + -DALL=ON \ + -DCMAKE_INSTALL_PREFIX=/root/meos-install \ -DH3_LIBRARY=/root/h3-install/lib/libh3.a \ -DH3_INCLUDE_DIR=/root/h3-install/include \ -DBUILD_SHARED_LIBS=OFF \ @@ -199,6 +319,12 @@ RUN INCLUDES="-I/root/geos/include -I/root/geos/build/capi -I/root/json-c-instal -DGSL_INCLUDE_DIR=/root/gsl-wasm/include \ -DGSL_LIBRARY=/root/gsl-wasm/lib/libgsl.a \ -DGSL_CBLAS_LIBRARY=/root/gsl-wasm/lib/libgslcblas.a \ + -DZLIB_INCLUDE_DIR=/root/zlib-install/include \ + -DZLIB_LIBRARY=/root/zlib-install/lib/libz.a \ + -DLIBXML2_INCLUDE_DIR=/root/libxml2-install/include/libxml2 \ + -DLIBXML2_LIBRARY=/root/libxml2-install/lib/libxml2.a \ + -DGDAL_INCLUDE_DIR=/root/gdal-install/include \ + -DGDAL_LIBRARY=/root/gdal-install/lib/libgdal.a \ "-DCMAKE_C_FLAGS=-sMEMORY64=1 $INCLUDES" \ "-DCMAKE_CXX_FLAGS=-sMEMORY64=1 $INCLUDES" @@ -264,8 +390,23 @@ RUN cmake --build /root/MobilityDB/build --target meos --parallel "$(nproc)" \ # 8 MB is reserved address space, not committed RAM, so it is cheap and # pushes the practical limit from ~2500 to hundreds of thousands of # instants. +# +# The installed MEOS describes itself: `pkg-config --cflags meos` reports its +# include directory together with the family macros it is compiled with. Both +# halves matter, because the public headers gate declarations on those macros -- +# `meos.h` holds `#if POINTCLOUD` and `#if JSON` blocks -- so an include path +# written here without them compiles the negative branch and loses declarations +# whose symbols the archive exports. +# +# EMULATE_FUNCTION_POINTER_CASTS makes wasm-opt give every indirect call one +# signature, as wide as the widest function type in the module, and it refuses +# to run when that exceeds its default cap. GDAL, which RASTER samples raster +# bands through, carries the widest of them. The pass names the minimum it needs +# in its own error, and the value is kept at that minimum because the width it +# sets is paid by every thunk. RUN mkdir -p /app/wasm \ && emcc -sMEMORY64=1 -sEMULATE_FUNCTION_POINTER_CASTS=1 -O1 \ + -sBINARYEN_EXTRA_PASSES=pass-arg=max-func-params@23 \ /app/core/c-src/bindings.c \ /root/meos-install/lib/libmeos.a \ /root/geos/build/lib/libgeos.a \ @@ -276,7 +417,10 @@ RUN mkdir -p /app/wasm \ /root/gsl-wasm/lib/libgslcblas.a \ /root/json-c-install/lib/libjson-c.a \ /root/h3-install/lib/libh3.a \ - -I/root/meos-install/include \ + /root/gdal-install/lib/libgdal.a \ + /root/libxml2-install/lib/libxml2.a \ + /root/zlib-install/lib/libz.a \ + $(PKG_CONFIG_PATH=/root/meos-install/lib/pkgconfig pkg-config --cflags meos) \ -I/root/geos/include \ -I/root/geos/build/capi \ -I/root/PROJ/src \ diff --git a/codegen/FunctionsGenerator.ts b/codegen/FunctionsGenerator.ts index 6ffd924..622b9d5 100644 --- a/codegen/FunctionsGenerator.ts +++ b/codegen/FunctionsGenerator.ts @@ -41,6 +41,8 @@ interface Param { interface IdlFunction { name: string; file: string; + api: string; + family: string; returnType: ReturnType; params: Param[]; } @@ -842,62 +844,21 @@ function main(): void { console.log('Reading IDL:', idlPath); const idl: Idl = JSON.parse(fs.readFileSync(idlPath, 'utf-8')); - // The binding compiles C wrappers that CALL each MEOS function, so it can only - // use symbols that are DECLARED in a header the wrapper preamble #includes — the - // public meos_*.h umbrella headers (bindings_c_header.c.template). A function the - // catalog attributes to an internal fine-grained header (e.g. cbuffer.h, - // tcbuffer.h, temporal.h, meos_internal.h) is not declared there and often uses - // non-marshalable internal types (double2, Datum), so emitting a wrapper for it - // fails the emcc compile. The catalog attributes each public function to its - // umbrella and each internal-only function to the fine-grained header, so the - // public API is exactly the set of umbrella headers below — the same list the - // template #includes and the Dockerfile builds (CBUFFER/NPOINT/POSE/RGEO + H3 via - // libh3, JSON via json-c, QUADBIN via libm). The two families whose native - // libraries do not yet cross-compile to wasm — POINTCLOUD (pgpointcloud: libpc + - // lazperf) and RASTER (GDAL) — are excluded by leaving their umbrellas - // (meos_pointcloud.h, meos_raster.h) out. To add a family: add its umbrella here, - // #include it in the template, and flip its -D=ON in the Dockerfile. - // Only top-level meos/include/*.h umbrellas belong here; meos_catalog.h lives in - // meos/include/temporal/ and is an internal type-system header (its accessors are - // `inline`, hence unlinkable from a separate TU), so it is deliberately excluded. - const API_HEADERS = new Set([ - 'meos.h', - 'meos_error.h', - 'meos_geo.h', - 'meos_cbuffer.h', - 'meos_npoint.h', - 'meos_pose.h', - 'meos_rgeo.h', - 'meos_h3.h', - 'meos_json.h', - 'meos_quadbin.h', - // The PostgreSQL-compat base I/O (interval_in, interval_out, …). MEOS - // splices these declarations into the installed at build time - // (meos/CMakeLists.txt), so they are reachable through the umbrella this - // preamble already includes, even though the catalog attributes them to - // their own declaring header. Both spellings are listed because that - // attribution has moved: an older catalog says postgres_ext_defs.in.h, - // a current one says pg_interval.h. - 'postgres_ext_defs.in.h', - 'pg_interval.h', - ]); - // A few disabled-family symbols are declared (under #if POINTCLOUD guards) inside - // otherwise-public umbrellas — meos.h and meos_catalog.h — so the umbrella - // allow-list alone does not exclude them. The guard compiles them out when the - // family is off, so a wrapper for them would reference an undeclared symbol. - // Exclude them by name; drop an entry here when its family is enabled. - const DISABLED_FAMILY_FUNCTIONS = new Set([ - // POINTCLOUD (guarded in meos.h / meos_catalog.h) - 'meos_initialize_pointcloud', - 'rtree_create_tpcbox', - 'pointcloud_basetype', - 'pointcloudset_type', - 'tpointcloud_temptype', - ]); - const fns: IdlFunction[] = (idl.functions ?? []).filter( - f => API_HEADERS.has(f.file) && !DISABLED_FAMILY_FUNCTIONS.has(f.name) - ); - + // The emitted surface is every function the catalog calls public. `api` is + // derived from the @ingroup doxygen tag in MEOS's own sources, so the binding + // asks MEOS what it publishes rather than deciding from the header a symbol + // happens to be declared in. + // + // The preamble is the set of headers those functions come from, taken from the + // catalog too. A header list written here is a copy of that set kept by hand, + // and it goes stale in one direction only: a family MobilityDB adds is absent + // from the copy, so its whole surface is dropped with nothing reporting it. + // MEOS installs a family's umbrella only when the family is built, and the + // image builds them all, so every header named here is present. + const fns: IdlFunction[] = (idl.functions ?? []).filter(f => f.api === 'public'); + + const includes = [...new Set(fns.map(f => f.file))].sort() + .map(h => `#include <${h}>`).join('\n'); // The marker banner is emitted here rather than stored in the source templates // (which are hand-edited). Its text is assembled from parts so this generator is // not itself flagged by tooling that scans for the marker. @@ -905,7 +866,7 @@ function main(): void { let cOut = BANNER + fs.readFileSync( path.resolve(__dirname, 'res/bindings_c_header.c.template'), 'utf-8' - ); + ).replace('/* @GENERATED_INCLUDES@ */', includes); let tsOut = BANNER + fs.readFileSync( path.resolve(__dirname, 'res/functions_ts_header.ts.template'), 'utf-8' diff --git a/codegen/res/bindings_c_header.c.template b/codegen/res/bindings_c_header.c.template index ecd4463..8660ee3 100644 --- a/codegen/res/bindings_c_header.c.template +++ b/codegen/res/bindings_c_header.c.template @@ -16,15 +16,7 @@ * accessors are missing from it, and they are defined below beside the * Int64GetDatum/Float8GetDatum this file already supplies for the same reason. */ -#include -#include -#include -#include -#include -#include -#include -#include -#include +/* @GENERATED_INCLUDES@ */ #include /* diff --git a/core/c-src/bindings.c b/core/c-src/bindings.c index c7cbbd9..a0f8da7 100644 --- a/core/c-src/bindings.c +++ b/core/c-src/bindings.c @@ -18,14 +18,26 @@ * Int64GetDatum/Float8GetDatum this file already supplies for the same reason. */ #include -#include #include -#include -#include -#include +#include +#include #include #include +#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include /* @@ -440,13 +452,6 @@ int text_cmp_w(const char * txt1, const char * txt2, Oid collid) { return text_cmp(cstring_to_text(txt1), cstring_to_text(txt2), collid); } -EMSCRIPTEN_KEEPALIVE -char * text_copy_w(const char * txt) { - text *_t = text_copy(cstring_to_text(txt)); - if (!_t) return NULL; - return text_to_cstring(_t); -} - EMSCRIPTEN_KEEPALIVE char * text_initcap_w(const char * txt) { text *_t = text_initcap(cstring_to_text(txt)); @@ -570,6 +575,11 @@ RTree * rtree_create_stbox_w() { return rtree_create_stbox(); } +EMSCRIPTEN_KEEPALIVE +RTree * rtree_create_tpcbox_w() { + return rtree_create_tpcbox(); +} + EMSCRIPTEN_KEEPALIVE void rtree_free_w(RTree * rtree) { rtree_free(rtree); @@ -625,11 +635,6 @@ int rtree_search_temporal_w(const RTree * rtree, IndexSearchOp op, const Tempora return rtree_search_temporal(rtree, op, temp, result); } -EMSCRIPTEN_KEEPALIVE -int rtree_search_temporal_dedup_w(const RTree * rtree, IndexSearchOp op, const Temporal * temp, int maxboxes, MeosArray * result) { - return rtree_search_temporal_dedup(rtree, op, temp, maxboxes, result); -} - EMSCRIPTEN_KEEPALIVE RTreeNNCursor * rtree_nn_cursor_open_w(const RTree * rtree, const void * query) { return rtree_nn_cursor_open(rtree, query); @@ -740,11 +745,6 @@ int sptree_search_temporal_w(const SPTree * sptree, IndexSearchOp op, const Temp return sptree_search_temporal(sptree, op, temp, result); } -EMSCRIPTEN_KEEPALIVE -int sptree_search_temporal_dedup_w(const SPTree * sptree, IndexSearchOp op, const Temporal * temp, int maxboxes, MeosArray * result) { - return sptree_search_temporal_dedup(sptree, op, temp, maxboxes, result); -} - EMSCRIPTEN_KEEPALIVE SPNNCursor * sptree_nn_cursor_open_w(const SPTree * sptree, const void * query) { return sptree_nn_cursor_open(sptree, query); @@ -780,6 +780,11 @@ void meos_finalize_collation_w() { meos_finalize_collation(); } +EMSCRIPTEN_KEEPALIVE +void meos_initialize_pointcloud_w() { + meos_initialize_pointcloud(); +} + EMSCRIPTEN_KEEPALIVE int meos_set_datestyle_w(const char * newval, void * extra) { return (int) meos_set_datestyle(newval, extra); @@ -4877,11 +4882,6 @@ int64_t * tbigint_values_w(const Temporal * temp, int32 * count) { return tbigint_values(temp, count); } -EMSCRIPTEN_KEEPALIVE -double tnumber_avg_value_w(const Temporal * temp) { - return tnumber_avg_value(temp); -} - EMSCRIPTEN_KEEPALIVE double tnumber_integral_w(const Temporal * temp) { return tnumber_integral(temp); @@ -6320,6 +6320,11 @@ int overlaps_temporal_temporal_w(const Temporal * temp1, const Temporal * temp2) return (int) overlaps_temporal_temporal(temp1, temp2); } +EMSCRIPTEN_KEEPALIVE +int temporal_time_overlaps_w(const Temporal * temp1, const Temporal * temp2) { + return (int) temporal_time_overlaps(temp1, temp2); +} + EMSCRIPTEN_KEEPALIVE int overlaps_temporal_tstzspan_w(const Temporal * temp, const Span * s) { return (int) overlaps_temporal_tstzspan(temp, s); @@ -9197,11 +9202,6 @@ int acontains_tgeo_geo_w(const Temporal * temp, const GSERIALIZED * gs) { return acontains_tgeo_geo(temp, gs); } -EMSCRIPTEN_KEEPALIVE -int acontains_tgeo_tgeo_w(const Temporal * temp1, const Temporal * temp2) { - return acontains_tgeo_tgeo(temp1, temp2); -} - EMSCRIPTEN_KEEPALIVE int acovers_geo_tgeo_w(const GSERIALIZED * gs, const Temporal * temp) { return acovers_geo_tgeo(gs, temp); @@ -10389,11 +10389,6 @@ int atouches_tcbuffer_cbuffer_w(const Temporal * temp, const Cbuffer * cb) { return atouches_tcbuffer_cbuffer(temp, cb); } -EMSCRIPTEN_KEEPALIVE -int atouches_tcbuffer_tcbuffer_w(const Temporal * temp1, const Temporal * temp2) { - return atouches_tcbuffer_tcbuffer(temp1, temp2); -} - EMSCRIPTEN_KEEPALIVE int econtains_cbuffer_tcbuffer_w(const Cbuffer * cb, const Temporal * temp) { return econtains_cbuffer_tcbuffer(cb, temp); @@ -10640,6 +10635,39 @@ Temporal * ttouches_tcbuffer_tcbuffer_w(const Temporal * temp1, const Temporal * } +/* === meos_cellindex.h === */ + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_get_resolution_w(const Temporal * temp) { + return tcellindex_get_resolution(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_is_valid_cell_w(const Temporal * temp) { + return tcellindex_is_valid_cell(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_cell_to_parent_w(const Temporal * temp, int32 resolution) { + return tcellindex_cell_to_parent(temp, resolution); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_cell_to_point_w(const Temporal * temp) { + return tcellindex_cell_to_point(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_cell_to_boundary_w(const Temporal * temp) { + return tcellindex_cell_to_boundary(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tcellindex_cell_area_w(const Temporal * temp) { + return tcellindex_cell_area(temp); +} + + /* === meos_h3.h === */ EMSCRIPTEN_KEEPALIVE @@ -11768,21 +11796,6 @@ char * tjsonb_out_w(const Temporal * temp) { return tjsonb_out(temp); } -EMSCRIPTEN_KEEPALIVE -TInstant * tjsonbinst_in_w(const char * str) { - return tjsonbinst_in(str); -} - -EMSCRIPTEN_KEEPALIVE -TSequence * tjsonbseq_in_w(const char * str, interpType interp) { - return tjsonbseq_in(str, interp); -} - -EMSCRIPTEN_KEEPALIVE -TSequenceSet * tjsonbseqset_in_w(const char * str) { - return tjsonbseqset_in(str); -} - EMSCRIPTEN_KEEPALIVE Temporal * tjsonb_from_base_temp_w(const Jsonb * jsonb, const Temporal * temp) { return tjsonb_from_base_temp(jsonb, temp); @@ -12753,1062 +12766,2783 @@ Temporal * tne_tnpoint_npoint_w(const Temporal * temp, const Npoint * np) { } -/* === meos_pose.h === */ +/* === meos_pointcloud.h === */ EMSCRIPTEN_KEEPALIVE -char * pose_as_ewkt_w(const Pose * pose, int maxdd) { - return pose_as_ewkt(pose, maxdd); +Pcpoint * pcpoint_hex_in_w(const char * str) { + return pcpoint_hex_in(str); } EMSCRIPTEN_KEEPALIVE -char * pose_as_hexwkb_w(const Pose * pose, uint8_t variant, size_t * size_out) { - return pose_as_hexwkb(pose, variant, size_out); +char * pcpoint_hex_out_w(const Pcpoint * pt, int maxdd) { + return pcpoint_hex_out(pt, maxdd); } EMSCRIPTEN_KEEPALIVE -char * pose_as_text_w(const Pose * pose, int maxdd) { - return pose_as_text(pose, maxdd); +Pcpoint * pcpoint_from_hexwkb_w(const char * hexwkb) { + return pcpoint_from_hexwkb(hexwkb); } EMSCRIPTEN_KEEPALIVE -uint8_t * pose_as_wkb_w(const Pose * pose, uint8_t variant, size_t * size_out) { - return pose_as_wkb(pose, variant, size_out); +char * pcpoint_as_hexwkb_w(const Pcpoint * pt) { + return pcpoint_as_hexwkb(pt); } EMSCRIPTEN_KEEPALIVE -Pose * pose_from_wkb_w(const uint8_t * wkb, size_t size) { - return pose_from_wkb(wkb, size); +Pcpoint * pcpoint_make_w(uint32_t pcid, const double * values, int count) { + return pcpoint_make(pcid, values, count); } EMSCRIPTEN_KEEPALIVE -Pose * pose_from_hexwkb_w(const char * hexwkb) { - return pose_from_hexwkb(hexwkb); +Pcpoint * pcpoint_copy_w(const Pcpoint * pt) { + return pcpoint_copy(pt); } EMSCRIPTEN_KEEPALIVE -Pose * pose_in_w(const char * str) { - return pose_in(str); +uint32_t pcpoint_get_pcid_w(const Pcpoint * pt) { + return pcpoint_get_pcid(pt); } EMSCRIPTEN_KEEPALIVE -char * pose_out_w(const Pose * pose, int maxdd) { - return pose_out(pose, maxdd); +uint32_t pcpoint_hash_w(const Pcpoint * pt) { + return pcpoint_hash(pt); } EMSCRIPTEN_KEEPALIVE -Pose * pose_from_geopose_w(const char * json) { - return pose_from_geopose(json); +uint64_t pcpoint_hash_extended_w(const Pcpoint * pt, uint64_t seed) { + return pcpoint_hash_extended(pt, seed); } EMSCRIPTEN_KEEPALIVE -char * pose_as_geopose_w(const Pose * pose, int conformance, int precision) { - return pose_as_geopose(pose, conformance, precision); +int pcpoint_get_x_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) { + return (int) pcpoint_get_x(pt, schema, out); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_from_geopose_w(const char * json) { - return tpose_from_geopose(json); +int pcpoint_get_y_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) { + return (int) pcpoint_get_y(pt, schema, out); } EMSCRIPTEN_KEEPALIVE -char * tpose_as_geopose_w(const Temporal * temp, int conformance, int precision) { - return tpose_as_geopose(temp, conformance, precision); +int pcpoint_get_z_w(const Pcpoint * pt, PCSCHEMA * schema, double * out) { + return (int) pcpoint_get_z(pt, schema, out); } EMSCRIPTEN_KEEPALIVE -char * tpose_as_geopose_stream_header_w(const Temporal * temp, int precision) { - return tpose_as_geopose_stream_header(temp, precision); +int pcpoint_get_dim_w(const Pcpoint * pt, PCSCHEMA * schema, const char * name, double * out) { + return (int) pcpoint_get_dim(pt, schema, name, out); } EMSCRIPTEN_KEEPALIVE -char * tpose_as_geopose_stream_element_w(const Temporal * temp, const TInstant * inst, int precision) { - return tpose_as_geopose_stream_element(temp, inst, precision); +TPCBox * pcpoint_to_tpcbox_w(const Pcpoint * pt, PCSCHEMA * schema) { + return pcpoint_to_tpcbox(pt, schema); } EMSCRIPTEN_KEEPALIVE -char * tpose_as_geopose_stream_w(const Temporal * temp, int precision) { - return tpose_as_geopose_stream(temp, precision); +PCSCHEMA * meos_pc_schema_w(uint32_t pcid) { + return meos_pc_schema(pcid); } EMSCRIPTEN_KEEPALIVE -const GeoPoseFrame * geopose_frames_w(int * count) { - return geopose_frames(count); +void meos_pc_schema_register_w(uint32_t pcid, PCSCHEMA * schema) { + meos_pc_schema_register(pcid, schema); } EMSCRIPTEN_KEEPALIVE -const GeoPoseFrame * geopose_frame_w(int32_t frame_id) { - return geopose_frame(frame_id); +PCSCHEMA * meos_pc_schema_from_dims_w(uint32_t pcid, int32_t srid, const char * compression, const PCDimensionSpec * dims, int ndims) { + return meos_pc_schema_from_dims(pcid, srid, compression, dims, ndims); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * pose_apply_geo_w(const Pose * pose, const GSERIALIZED * body) { - return pose_apply_geo(pose, body); +int meos_pc_schema_register_dims_w(uint32_t pcid, int32_t srid, const char * compression, const PCDimensionSpec * dims, int ndims) { + return (int) meos_pc_schema_register_dims(pcid, srid, compression, dims, ndims); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_apply_geo_w(const Temporal * temp, const GSERIALIZED * body) { - return tpose_apply_geo(temp, body); +void meos_pc_schema_register_xml_w(uint32_t pcid, PCSCHEMA * schema, const char * xml_text) { + meos_pc_schema_register_xml(pcid, schema, xml_text); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_compose_pose_w(const Temporal * body, const Pose * frame) { - return tpose_compose_pose(body, frame); +const char * meos_pc_schema_xml_w(uint32_t pcid) { + return meos_pc_schema_xml(pcid); } EMSCRIPTEN_KEEPALIVE -Temporal * pose_compose_tpose_w(const Pose * body, const Temporal * frame) { - return pose_compose_tpose(body, frame); +void meos_pc_schema_clear_w() { + meos_pc_schema_clear(); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_compose_tpose_w(const Temporal * body, const Temporal * frame) { - return tpose_compose_tpose(body, frame); +int32_t meos_pc_schema_srid_w(uint32_t pcid) { + return meos_pc_schema_srid(pcid); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_inverse_w(const Temporal * temp) { - return tpose_inverse(temp); +const char * meos_pc_schema_compression_w(uint32_t pcid) { + return meos_pc_schema_compression(pcid); } EMSCRIPTEN_KEEPALIVE -Pose * pose_copy_w(const Pose * pose) { - return pose_copy(pose); +int32_t meos_pc_schema_ndims_w(uint32_t pcid) { + return meos_pc_schema_ndims(pcid); } EMSCRIPTEN_KEEPALIVE -Pose * pose_make_2d_w(double x, double y, double theta, int geodetic, int32_t srid) { - return pose_make_2d(x, y, theta, (bool) geodetic, srid); +void meos_set_pointcloud_schemas_xml_w(const char * path) { + meos_set_pointcloud_schemas_xml(path); } EMSCRIPTEN_KEEPALIVE -Pose * pose_make_3d_w(double x, double y, double z, double W, double X, double Y, double Z, int geodetic, int32_t srid) { - return pose_make_3d(x, y, z, W, X, Y, Z, (bool) geodetic, srid); +int pcpoint_cmp_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return pcpoint_cmp(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -Pose * pose_make_point2d_w(const GSERIALIZED * gs, double theta) { - return pose_make_point2d(gs, theta); +int pcpoint_eq_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_eq(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -Pose * pose_make_point3d_w(const GSERIALIZED * gs, double W, double X, double Y, double Z) { - return pose_make_point3d(gs, W, X, Y, Z); +int pcpoint_ne_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_ne(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -Pose * pose_make_point3d_ypr_w(const GSERIALIZED * gs, double yaw, double pitch, double roll) { - return pose_make_point3d_ypr(gs, yaw, pitch, roll); +int pcpoint_lt_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_lt(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * pose_to_point_w(const Pose * pose) { - return pose_to_point(pose); +int pcpoint_le_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_le(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -STBox * pose_to_stbox_w(const Pose * pose) { - return pose_to_stbox(pose); +int pcpoint_gt_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_gt(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -uint32_t pose_hash_w(const Pose * pose) { - return pose_hash(pose); +int pcpoint_ge_w(const Pcpoint * pt1, const Pcpoint * pt2) { + return (int) pcpoint_ge(pt1, pt2); } EMSCRIPTEN_KEEPALIVE -uint64_t pose_hash_extended_w(const Pose * pose, uint64_t seed) { - return pose_hash_extended(pose, seed); +Pcpatch * pcpatch_hex_in_w(const char * str) { + return pcpatch_hex_in(str); } EMSCRIPTEN_KEEPALIVE -double * pose_quaternion_w(const Pose * pose, int * count) { - return pose_quaternion(pose, count); +char * pcpatch_hex_out_w(const Pcpatch * pa, int maxdd) { + return pcpatch_hex_out(pa, maxdd); } EMSCRIPTEN_KEEPALIVE -double * pose_ypr_w(const Pose * pose, int * count) { - return pose_ypr(pose, count); +Pcpatch * pcpatch_from_hexwkb_w(const char * hexwkb) { + return pcpatch_from_hexwkb(hexwkb); } EMSCRIPTEN_KEEPALIVE -double pose_yaw_w(const Pose * pose) { - return pose_yaw(pose); +char * pcpatch_as_hexwkb_w(const Pcpatch * pa) { + return pcpatch_as_hexwkb(pa); } EMSCRIPTEN_KEEPALIVE -double pose_pitch_w(const Pose * pose) { - return pose_pitch(pose); +Pcpatch * pcpatch_make_w(const Pcpoint ** points, int count) { + return pcpatch_make(points, count); } EMSCRIPTEN_KEEPALIVE -double pose_roll_w(const Pose * pose) { - return pose_roll(pose); +Pcpatch * pcpatch_make_coords_w(uint32_t pcid, const double * values, int count) { + return pcpatch_make_coords(pcid, values, count); } EMSCRIPTEN_KEEPALIVE -double pose_angular_distance_w(const Pose * pose1, const Pose * pose2) { - return pose_angular_distance(pose1, pose2); +Pcpatch * pcpatch_copy_w(const Pcpatch * pa) { + return pcpatch_copy(pa); } EMSCRIPTEN_KEEPALIVE -Pose * pose_compose_w(const Pose * body, const Pose * frame) { - return pose_compose(body, frame); +uint32_t pcpatch_get_pcid_w(const Pcpatch * pa) { + return pcpatch_get_pcid(pa); } EMSCRIPTEN_KEEPALIVE -Pose * pose_inverse_w(const Pose * pose) { - return pose_inverse(pose); +uint32_t pcpatch_npoints_w(const Pcpatch * pa) { + return pcpatch_npoints(pa); } EMSCRIPTEN_KEEPALIVE -Pose * pose_normalize_w(const Pose * pose) { - return pose_normalize(pose); +uint32_t pcpatch_hash_w(const Pcpatch * pa) { + return pcpatch_hash(pa); } EMSCRIPTEN_KEEPALIVE -Pose * pose_round_w(const Pose * pose, int maxdd) { - return pose_round(pose, maxdd); +uint64_t pcpatch_hash_extended_w(const Pcpatch * pa, uint64_t seed) { + return pcpatch_hash_extended(pa, seed); } EMSCRIPTEN_KEEPALIVE -Pose ** posearr_round_w(const Pose ** posearr, int count, int maxdd) { - return posearr_round(posearr, count, maxdd); +GSERIALIZED * pcpatch_to_geom_w(const Pcpatch * pa) { + return pcpatch_to_geom(pa); } EMSCRIPTEN_KEEPALIVE -Pose * pose_set_srid_w(const Pose * pose, int32_t srid) { - return pose_set_srid(pose, srid); +int pcpatch_cmp_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return pcpatch_cmp(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -int32_t pose_srid_w(const Pose * pose) { - return pose_srid(pose); +int pcpatch_eq_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_eq(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -Pose * pose_transform_w(const Pose * pose, int32_t srid) { - return pose_transform(pose, srid); +int pcpatch_ne_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_ne(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -Pose * pose_transform_pipeline_w(const Pose * pose, const char * pipelinestr, int32_t srid, int is_forward) { - return pose_transform_pipeline(pose, pipelinestr, srid, (bool) is_forward); +int pcpatch_lt_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_lt(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -STBox * pose_tstzspan_to_stbox_w(const Pose * pose, const Span * s) { - return pose_tstzspan_to_stbox(pose, s); +int pcpatch_le_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_le(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -STBox * pose_timestamptz_to_stbox_w(const Pose * pose, long long t) { - return pose_timestamptz_to_stbox(pose, (TimestampTz) t); +int pcpatch_gt_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_gt(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -double distance_pose_geo_w(const Pose * pose, const GSERIALIZED * gs) { - return distance_pose_geo(pose, gs); +int pcpatch_ge_w(const Pcpatch * pa1, const Pcpatch * pa2) { + return (int) pcpatch_ge(pa1, pa2); } EMSCRIPTEN_KEEPALIVE -double distance_pose_pose_w(const Pose * pose1, const Pose * pose2) { - return distance_pose_pose(pose1, pose2); +Set * pcpointset_in_w(const char * str) { + return pcpointset_in(str); } EMSCRIPTEN_KEEPALIVE -double distance_pose_stbox_w(const Pose * pose, const STBox * box) { - return distance_pose_stbox(pose, box); +char * pcpointset_out_w(const Set * s, int maxdd) { + return pcpointset_out(s, maxdd); } EMSCRIPTEN_KEEPALIVE -int pose_cmp_w(const Pose * pose1, const Pose * pose2) { - return pose_cmp(pose1, pose2); +Set * pcpointset_make_w(Pcpoint ** values, int count) { + return pcpointset_make(values, count); } EMSCRIPTEN_KEEPALIVE -int pose_eq_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_eq(pose1, pose2); +Set * pcpoint_to_set_w(const Pcpoint * pt) { + return pcpoint_to_set(pt); } EMSCRIPTEN_KEEPALIVE -int pose_ge_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_ge(pose1, pose2); +Pcpoint * pcpointset_start_value_w(const Set * s) { + return pcpointset_start_value(s); } EMSCRIPTEN_KEEPALIVE -int pose_gt_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_gt(pose1, pose2); +Pcpoint * pcpointset_end_value_w(const Set * s) { + return pcpointset_end_value(s); } EMSCRIPTEN_KEEPALIVE -int pose_le_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_le(pose1, pose2); +Pcpoint * pcpointset_value_n_w(const Set * s, int n) { + Pcpoint * r; + if (!pcpointset_value_n(s, n, &r)) return NULL; + return r; } EMSCRIPTEN_KEEPALIVE -int pose_lt_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_lt(pose1, pose2); +Pcpoint ** pcpointset_values_w(const Set * s, int * count) { + return pcpointset_values(s, count); } EMSCRIPTEN_KEEPALIVE -int pose_ne_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_ne(pose1, pose2); +int contains_set_pcpoint_w(const Set * s, Pcpoint * pt) { + return (int) contains_set_pcpoint(s, pt); } EMSCRIPTEN_KEEPALIVE -int pose_nsame_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_nsame(pose1, pose2); +int contained_pcpoint_set_w(const Pcpoint * pt, const Set * s) { + return (int) contained_pcpoint_set(pt, s); } EMSCRIPTEN_KEEPALIVE -int pose_same_w(const Pose * pose1, const Pose * pose2) { - return (int) pose_same(pose1, pose2); +Set * intersection_pcpoint_set_w(const Pcpoint * pt, const Set * s) { + return intersection_pcpoint_set(pt, s); } EMSCRIPTEN_KEEPALIVE -Set * poseset_in_w(const char * str) { - return poseset_in(str); +Set * intersection_set_pcpoint_w(const Set * s, const Pcpoint * pt) { + return intersection_set_pcpoint(s, pt); } EMSCRIPTEN_KEEPALIVE -char * poseset_out_w(const Set * s, int maxdd) { - return poseset_out(s, maxdd); +Set * minus_pcpoint_set_w(const Pcpoint * pt, const Set * s) { + return minus_pcpoint_set(pt, s); } EMSCRIPTEN_KEEPALIVE -Set * poseset_make_w(const Pose ** values, int count) { - return poseset_make(values, count); +Set * minus_set_pcpoint_w(const Set * s, const Pcpoint * pt) { + return minus_set_pcpoint(s, pt); } EMSCRIPTEN_KEEPALIVE -Set * pose_to_set_w(const Pose * pose) { - return pose_to_set(pose); +Set * union_pcpoint_set_w(const Pcpoint * pt, const Set * s) { + return union_pcpoint_set(pt, s); } EMSCRIPTEN_KEEPALIVE -Pose * poseset_end_value_w(const Set * s) { - return poseset_end_value(s); +Set * union_set_pcpoint_w(const Set * s, const Pcpoint * pt) { + return union_set_pcpoint(s, pt); } EMSCRIPTEN_KEEPALIVE -Pose * poseset_start_value_w(const Set * s) { - return poseset_start_value(s); +Set * pcpoint_union_transfn_w(Set * state, const Pcpoint * pt) { + return pcpoint_union_transfn(state, pt); } EMSCRIPTEN_KEEPALIVE -Pose * poseset_value_n_w(const Set * s, int n) { - Pose * r; - if (!poseset_value_n(s, n, &r)) return NULL; - return r; +Set * pcpatchset_in_w(const char * str) { + return pcpatchset_in(str); } EMSCRIPTEN_KEEPALIVE -Pose ** poseset_values_w(const Set * s, int * count) { - return poseset_values(s, count); +char * pcpatchset_out_w(const Set * s, int maxdd) { + return pcpatchset_out(s, maxdd); } EMSCRIPTEN_KEEPALIVE -int contained_pose_set_w(const Pose * pose, const Set * s) { - return (int) contained_pose_set(pose, s); +Set * pcpatchset_make_w(Pcpatch ** values, int count) { + return pcpatchset_make(values, count); } EMSCRIPTEN_KEEPALIVE -int contains_set_pose_w(const Set * s, Pose * pose) { - return (int) contains_set_pose(s, pose); +Set * pcpatch_to_set_w(const Pcpatch * pa) { + return pcpatch_to_set(pa); } EMSCRIPTEN_KEEPALIVE -Set * intersection_pose_set_w(const Pose * pose, const Set * s) { - return intersection_pose_set(pose, s); +Pcpatch * pcpatchset_start_value_w(const Set * s) { + return pcpatchset_start_value(s); } EMSCRIPTEN_KEEPALIVE -Set * intersection_set_pose_w(const Set * s, const Pose * pose) { - return intersection_set_pose(s, pose); +Pcpatch * pcpatchset_end_value_w(const Set * s) { + return pcpatchset_end_value(s); } EMSCRIPTEN_KEEPALIVE -Set * minus_pose_set_w(const Pose * pose, const Set * s) { - return minus_pose_set(pose, s); +Pcpatch * pcpatchset_value_n_w(const Set * s, int n) { + Pcpatch * r; + if (!pcpatchset_value_n(s, n, &r)) return NULL; + return r; } EMSCRIPTEN_KEEPALIVE -Set * minus_set_pose_w(const Set * s, const Pose * pose) { - return minus_set_pose(s, pose); +Pcpatch ** pcpatchset_values_w(const Set * s, int * count) { + return pcpatchset_values(s, count); } EMSCRIPTEN_KEEPALIVE -Set * pose_union_transfn_w(Set * state, const Pose * pose) { - return pose_union_transfn(state, pose); +int contains_set_pcpatch_w(const Set * s, Pcpatch * pa) { + return (int) contains_set_pcpatch(s, pa); } EMSCRIPTEN_KEEPALIVE -Set * union_pose_set_w(const Pose * pose, const Set * s) { - return union_pose_set(pose, s); +int contained_pcpatch_set_w(const Pcpatch * pa, const Set * s) { + return (int) contained_pcpatch_set(pa, s); } EMSCRIPTEN_KEEPALIVE -Set * union_set_pose_w(const Set * s, const Pose * pose) { - return union_set_pose(s, pose); +Set * intersection_pcpatch_set_w(const Pcpatch * pa, const Set * s) { + return intersection_pcpatch_set(pa, s); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_from_mfjson_w(const char * str) { - return tpose_from_mfjson(str); +Set * intersection_set_pcpatch_w(const Set * s, const Pcpatch * pa) { + return intersection_set_pcpatch(s, pa); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_in_w(const char * str) { - return tpose_in(str); +Set * minus_pcpatch_set_w(const Pcpatch * pa, const Set * s) { + return minus_pcpatch_set(pa, s); } EMSCRIPTEN_KEEPALIVE -TInstant * tposeinst_make_w(const Pose * pose, long long t) { - return tposeinst_make(pose, (TimestampTz) t); +Set * minus_set_pcpatch_w(const Set * s, const Pcpatch * pa) { + return minus_set_pcpatch(s, pa); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_from_base_temp_w(const Pose * pose, const Temporal * temp) { - return tpose_from_base_temp(pose, temp); +Set * union_pcpatch_set_w(const Pcpatch * pa, const Set * s) { + return union_pcpatch_set(pa, s); } EMSCRIPTEN_KEEPALIVE -TSequence * tposeseq_from_base_tstzset_w(const Pose * pose, const Set * s) { - return tposeseq_from_base_tstzset(pose, s); +Set * union_set_pcpatch_w(const Set * s, const Pcpatch * pa) { + return union_set_pcpatch(s, pa); } EMSCRIPTEN_KEEPALIVE -TSequence * tposeseq_from_base_tstzspan_w(const Pose * pose, const Span * s, interpType interp) { - return tposeseq_from_base_tstzspan(pose, s, interp); +Set * pcpatch_union_transfn_w(Set * state, const Pcpatch * pa) { + return pcpatch_union_transfn(state, pa); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * tposeseqset_from_base_tstzspanset_w(const Pose * pose, const SpanSet * ss, interpType interp) { - return tposeseqset_from_base_tstzspanset(pose, ss, interp); +TPCBox * tpcbox_in_w(const char * str) { + return tpcbox_in(str); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_make_w(const Temporal * tpoint, const Temporal * ttheta) { - return tpose_make(tpoint, ttheta); +char * tpcbox_out_w(const TPCBox * box, int maxdd) { + return tpcbox_out(box, maxdd); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_to_tpoint_w(const Temporal * temp) { - return tpose_to_tpoint(temp); +TPCBox * tpcbox_make_w(int hasx, int hasz, int hast, int geodetic, int32_t srid, uint32_t pcid, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, const Span * period) { + return tpcbox_make((bool) hasx, (bool) hasz, (bool) hast, (bool) geodetic, srid, pcid, xmin, xmax, ymin, ymax, zmin, zmax, period); } EMSCRIPTEN_KEEPALIVE -Pose * tpose_end_value_w(const Temporal * temp) { - return tpose_end_value(temp); +TPCBox * tpcbox_copy_w(const TPCBox * box) { + return tpcbox_copy(box); } EMSCRIPTEN_KEEPALIVE -Set * tpose_points_w(const Temporal * temp) { - return tpose_points(temp); +TPCBox * pcpatch_to_tpcbox_w(const Pcpatch * pa, int32_t srid) { + return pcpatch_to_tpcbox(pa, srid); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_yaw_w(const Temporal * temp) { - return tpose_yaw(temp); +int tpcbox_hasx_w(const TPCBox * box) { + return (int) tpcbox_hasx(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_pitch_w(const Temporal * temp) { - return tpose_pitch(temp); +int tpcbox_hasz_w(const TPCBox * box) { + return (int) tpcbox_hasz(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_roll_w(const Temporal * temp) { - return tpose_roll(temp); +int tpcbox_hast_w(const TPCBox * box) { + return (int) tpcbox_hast(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_speed_w(const Temporal * temp) { - return tpose_speed(temp); +int tpcbox_geodetic_w(const TPCBox * box) { + return (int) tpcbox_geodetic(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_angular_speed_w(const Temporal * temp) { - return tpose_angular_speed(temp); +double tpcbox_xmin_w(const TPCBox * box) { + double r; + if (!tpcbox_xmin(box, &r)) return 0.0; + return r; } EMSCRIPTEN_KEEPALIVE -Pose * tpose_start_value_w(const Temporal * temp) { - return tpose_start_value(temp); +double tpcbox_xmax_w(const TPCBox * box) { + double r; + if (!tpcbox_xmax(box, &r)) return 0.0; + return r; } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * tpose_trajectory_w(const Temporal * temp) { - return tpose_trajectory(temp); +double tpcbox_ymin_w(const TPCBox * box) { + double r; + if (!tpcbox_ymin(box, &r)) return 0.0; + return r; } EMSCRIPTEN_KEEPALIVE -Pose * tpose_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) { - Pose * r; - if (!tpose_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return NULL; +double tpcbox_ymax_w(const TPCBox * box) { + double r; + if (!tpcbox_ymax(box, &r)) return 0.0; return r; } EMSCRIPTEN_KEEPALIVE -Pose * tpose_value_n_w(const Temporal * temp, int n) { - Pose * r; - if (!tpose_value_n(temp, n, &r)) return NULL; +double tpcbox_zmin_w(const TPCBox * box) { + double r; + if (!tpcbox_zmin(box, &r)) return 0.0; return r; } EMSCRIPTEN_KEEPALIVE -Pose ** tpose_values_w(const Temporal * temp, int * count) { - return tpose_values(temp, count); +double tpcbox_zmax_w(const TPCBox * box) { + double r; + if (!tpcbox_zmax(box, &r)) return 0.0; + return r; } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_at_elevation_w(const Temporal * temp, const Span * s) { - return tpose_at_elevation(temp, s); +long long tpcbox_tmin_w(const TPCBox * box) { + TimestampTz r; + if (!tpcbox_tmin(box, &r)) return 0; + return (long long) r; } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) { - return tpose_at_geom(temp, gs); +int tpcbox_tmin_inc_w(const TPCBox * box) { + bool r; + if (!tpcbox_tmin_inc(box, &r)) return 0; + return (int) r; } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { - return tpose_at_stbox(temp, box, (bool) border_inc); +long long tpcbox_tmax_w(const TPCBox * box) { + TimestampTz r; + if (!tpcbox_tmax(box, &r)) return 0; + return (long long) r; } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_at_pose_w(const Temporal * temp, const Pose * pose) { - return tpose_at_pose(temp, pose); +int tpcbox_tmax_inc_w(const TPCBox * box) { + bool r; + if (!tpcbox_tmax_inc(box, &r)) return 0; + return (int) r; } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_minus_elevation_w(const Temporal * temp, const Span * s) { - return tpose_minus_elevation(temp, s); +int32_t tpcbox_srid_w(const TPCBox * box) { + return tpcbox_srid(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) { - return tpose_minus_geom(temp, gs); +uint32_t tpcbox_pcid_w(const TPCBox * box) { + return tpcbox_pcid(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_minus_pose_w(const Temporal * temp, const Pose * pose) { - return tpose_minus_pose(temp, pose); +STBox * tpcbox_to_stbox_w(const TPCBox * box) { + return tpcbox_to_stbox(box); } EMSCRIPTEN_KEEPALIVE -Temporal * tpose_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { - return tpose_minus_stbox(temp, box, (bool) border_inc); +TPCBox * tpcbox_round_w(const TPCBox * box, int maxdd) { + return tpcbox_round(box, maxdd); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return tdistance_tpose_pose(temp, pose); +TPCBox * tpcbox_set_srid_w(const TPCBox * box, int32_t srid) { + return tpcbox_set_srid(box, srid); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return tdistance_tpose_geo(temp, gs); +TPCBox * union_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2, int strict) { + return union_tpcbox_tpcbox(box1, box2, (bool) strict); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return tdistance_tpose_tpose(temp1, temp2); +TPCBox * intersection_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return intersection_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -double nad_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return nad_tpose_geo(temp, gs); +int contains_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) contains_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -double nad_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return nad_tpose_pose(temp, pose); +int contained_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) contained_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -double nad_tpose_stbox_w(const Temporal * temp, const STBox * box) { - return nad_tpose_stbox(temp, box); +int overlaps_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overlaps_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -double nad_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return nad_tpose_tpose(temp1, temp2); +int same_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) same_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -TInstant * nai_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return nai_tpose_geo(temp, gs); +int adjacent_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) adjacent_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -TInstant * nai_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return nai_tpose_pose(temp, pose); +int tpcbox_cmp_w(const TPCBox * box1, const TPCBox * box2) { + return tpcbox_cmp(box1, box2); } EMSCRIPTEN_KEEPALIVE -TInstant * nai_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return nai_tpose_tpose(temp1, temp2); +int tpcbox_eq_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_eq(box1, box2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return shortestline_tpose_geo(temp, gs); +int tpcbox_ne_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_ne(box1, box2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return shortestline_tpose_pose(temp, pose); +int tpcbox_lt_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_lt(box1, box2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return shortestline_tpose_tpose(temp1, temp2); +int tpcbox_le_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_le(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return always_eq_pose_tpose(pose, temp); +int tpcbox_gt_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_gt(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return always_eq_tpose_pose(temp, pose); +int tpcbox_ge_w(const TPCBox * box1, const TPCBox * box2) { + return (int) tpcbox_ge(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return always_eq_tpose_tpose(temp1, temp2); +int left_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) left_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return always_ne_pose_tpose(pose, temp); +int overleft_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overleft_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return always_ne_tpose_pose(temp, pose); +int right_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) right_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int always_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return always_ne_tpose_tpose(temp1, temp2); +int overright_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overright_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return ever_eq_pose_tpose(pose, temp); +int below_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) below_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return ever_eq_tpose_pose(temp, pose); +int overbelow_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overbelow_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return ever_eq_tpose_tpose(temp1, temp2); +int above_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) above_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return ever_ne_pose_tpose(pose, temp); +int overabove_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overabove_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return ever_ne_tpose_pose(temp, pose); +int front_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) front_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int ever_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { - return ever_ne_tpose_tpose(temp1, temp2); +int overfront_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overfront_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return teq_pose_tpose(pose, temp); +int back_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) back_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return teq_tpose_pose(temp, pose); +int overback_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overback_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_pose_tpose_w(const Pose * pose, const Temporal * temp) { - return tne_pose_tpose(pose, temp); +int before_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) before_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_tpose_pose_w(const Temporal * temp, const Pose * pose) { - return tne_tpose_pose(temp, pose); +int overbefore_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overbefore_tpcbox_tpcbox(box1, box2); } - -/* === meos_quadbin.h === */ - EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_in_w(const char * str) { - return quadbin_in(str); +int after_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) after_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int quadbin_eq_w(uint64_t a, uint64_t b) { - return (int) quadbin_eq(a, b); +int overafter_tpcbox_tpcbox_w(const TPCBox * box1, const TPCBox * box2) { + return (int) overafter_tpcbox_tpcbox(box1, box2); } EMSCRIPTEN_KEEPALIVE -int quadbin_ne_w(uint64_t a, uint64_t b) { - return (int) quadbin_ne(a, b); +Temporal * tpointcloud_to_tgeompoint_w(const Temporal * temp) { + return tpointcloud_to_tgeompoint(temp); } EMSCRIPTEN_KEEPALIVE -int quadbin_lt_w(uint64_t a, uint64_t b) { - return (int) quadbin_lt(a, b); +Temporal * tpcpatch_to_tgeometry_w(const Temporal * temp) { + return tpcpatch_to_tgeometry(temp); } EMSCRIPTEN_KEEPALIVE -int quadbin_le_w(uint64_t a, uint64_t b) { - return (int) quadbin_le(a, b); +TInstant * tpcpointinst_make_w(const Pcpoint * pt, long long t) { + return tpcpointinst_make(pt, (TimestampTz) t); } EMSCRIPTEN_KEEPALIVE -int quadbin_gt_w(uint64_t a, uint64_t b) { - return (int) quadbin_gt(a, b); +TSequence * tpcpointseq_from_base_tstzset_w(const Pcpoint * pt, const Set * s) { + return tpcpointseq_from_base_tstzset(pt, s); } EMSCRIPTEN_KEEPALIVE -int quadbin_ge_w(uint64_t a, uint64_t b) { - return (int) quadbin_ge(a, b); +TSequence * tpcpointseq_from_base_tstzspan_w(const Pcpoint * pt, const Span * sp) { + return tpcpointseq_from_base_tstzspan(pt, sp); } EMSCRIPTEN_KEEPALIVE -int quadbin_cmp_w(uint64_t a, uint64_t b) { - return quadbin_cmp(a, b); +TSequenceSet * tpcpointseqset_from_base_tstzspanset_w(const Pcpoint * pt, const SpanSet * ss) { + return tpcpointseqset_from_base_tstzspanset(pt, ss); } EMSCRIPTEN_KEEPALIVE -uint32_t quadbin_hash_w(uint64_t cell) { - return quadbin_hash(cell); +Temporal * tpcpoint_from_base_temp_w(const Pcpoint * pt, const Temporal * temp) { + return tpcpoint_from_base_temp(pt, temp); } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_hash_extended_w(uint64_t cell, uint64_t seed) { - return quadbin_hash_extended(cell, seed); +Pcpoint * tpcpoint_start_value_w(const Temporal * temp) { + return tpcpoint_start_value(temp); } EMSCRIPTEN_KEEPALIVE -int quadbin_is_valid_index_w(uint64_t index) { - return (int) quadbin_is_valid_index(index); +Pcpoint * tpcpoint_end_value_w(const Temporal * temp) { + return tpcpoint_end_value(temp); } EMSCRIPTEN_KEEPALIVE -int quadbin_is_valid_cell_w(uint64_t cell) { - return (int) quadbin_is_valid_cell(cell); +Pcpoint * tpcpoint_value_n_w(const Temporal * temp, int n) { + Pcpoint * r; + if (!tpcpoint_value_n(temp, n, &r)) return NULL; + return r; } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_tile_to_cell_w(uint32_t x, uint32_t y, uint32_t z) { - return quadbin_tile_to_cell(x, y, z); +Pcpoint ** tpcpoint_values_w(const Temporal * temp, int * count) { + return tpcpoint_values(temp, count); } EMSCRIPTEN_KEEPALIVE -int quadbin_cell_to_tile_w(uint64_t cell, uint32_t * x, uint32_t * y, uint32_t * z) { - return (int) quadbin_cell_to_tile(cell, x, y, z); +int tpcpoint_value_at_timestamptz_w(const Temporal * temp, long long t, int strict, Pcpoint ** value) { + return (int) tpcpoint_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, value); } EMSCRIPTEN_KEEPALIVE -uint32_t quadbin_get_resolution_w(uint64_t cell) { - return quadbin_get_resolution(cell); +Temporal * tpcpoint_at_value_w(const Temporal * temp, const Pcpoint * pt) { + return tpcpoint_at_value(temp, pt); } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_cell_to_parent_w(uint64_t cell, uint32_t parent_resolution) { - return quadbin_cell_to_parent(cell, parent_resolution); +Temporal * tpcpoint_minus_value_w(const Temporal * temp, const Pcpoint * pt) { + return tpcpoint_minus_value(temp, pt); } EMSCRIPTEN_KEEPALIVE -uint64_t * quadbin_cell_to_children_w(uint64_t cell, uint32_t children_resolution, int * count) { - return quadbin_cell_to_children(cell, children_resolution, count); +TInstant * tpcpatchinst_make_w(const Pcpatch * pa, long long t) { + return tpcpatchinst_make(pa, (TimestampTz) t); } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_cell_sibling_w(uint64_t cell, const char * direction) { - return quadbin_cell_sibling(cell, direction); +TSequence * tpcpatchseq_from_base_tstzset_w(const Pcpatch * pa, const Set * s) { + return tpcpatchseq_from_base_tstzset(pa, s); } EMSCRIPTEN_KEEPALIVE -uint64_t * quadbin_k_ring_w(uint64_t cell, int k, int * count) { - return quadbin_k_ring(cell, k, count); +TSequence * tpcpatchseq_from_base_tstzspan_w(const Pcpatch * pa, const Span * sp) { + return tpcpatchseq_from_base_tstzspan(pa, sp); } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_point_to_cell_w(double longitude, double latitude, uint32_t resolution) { - return quadbin_point_to_cell(longitude, latitude, resolution); +TSequenceSet * tpcpatchseqset_from_base_tstzspanset_w(const Pcpatch * pa, const SpanSet * ss) { + return tpcpatchseqset_from_base_tstzspanset(pa, ss); } EMSCRIPTEN_KEEPALIVE -uint64_t geo_to_quadbin_cell_w(const GSERIALIZED * point, int32 resolution) { - return geo_to_quadbin_cell(point, resolution); +Temporal * tpcpatch_from_base_temp_w(const Pcpatch * pa, const Temporal * temp) { + return tpcpatch_from_base_temp(pa, temp); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * quadbin_cell_to_geompoint_w(uint64_t cell) { - return quadbin_cell_to_geompoint(cell); +Pcpatch * tpcpatch_start_value_w(const Temporal * temp) { + return tpcpatch_start_value(temp); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * quadbin_cell_to_geom_w(uint64_t cell) { - return quadbin_cell_to_geom(cell); +Pcpatch * tpcpatch_end_value_w(const Temporal * temp) { + return tpcpatch_end_value(temp); } EMSCRIPTEN_KEEPALIVE -STBox * quadbin_to_stbox_w(uint64_t cell) { - return quadbin_to_stbox(cell); +Pcpatch * tpcpatch_value_n_w(const Temporal * temp, int n) { + Pcpatch * r; + if (!tpcpatch_value_n(temp, n, &r)) return NULL; + return r; } EMSCRIPTEN_KEEPALIVE -STBox * quadbin_timestamptz_to_stbox_w(uint64_t cell, long long t) { - return quadbin_timestamptz_to_stbox(cell, (TimestampTz) t); +Pcpatch ** tpcpatch_values_w(const Temporal * temp, int * count) { + return tpcpatch_values(temp, count); } EMSCRIPTEN_KEEPALIVE -STBox * quadbin_tstzspan_to_stbox_w(uint64_t cell, const Span * s) { - return quadbin_tstzspan_to_stbox(cell, s); +int tpcpatch_value_at_timestamptz_w(const Temporal * temp, long long t, int strict, Pcpatch ** value) { + return (int) tpcpatch_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, value); } EMSCRIPTEN_KEEPALIVE -double quadbin_cell_area_w(uint64_t cell) { - return quadbin_cell_area(cell); +Temporal * tpcpatch_at_value_w(const Temporal * temp, const Pcpatch * pa) { + return tpcpatch_at_value(temp, pa); } EMSCRIPTEN_KEEPALIVE -char * quadbin_index_to_string_w(uint64_t index) { - return quadbin_index_to_string(index); +Temporal * tpcpatch_minus_value_w(const Temporal * temp, const Pcpatch * pa) { + return tpcpatch_minus_value(temp, pa); } EMSCRIPTEN_KEEPALIVE -uint64_t quadbin_string_to_index_w(const char * str) { - return quadbin_string_to_index(str); +int ever_eq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return ever_eq_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -char * quadbin_cell_to_quadkey_w(uint64_t cell) { - return quadbin_cell_to_quadkey(cell); +int ever_eq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return ever_eq_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -Set * quadbin_grid_disk_w(uint64_t origin, int k) { - return quadbin_grid_disk(origin, k); +int ever_eq_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_tpcpoint_tpcpoint(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -Set * quadbin_cell_to_children_set_w(uint64_t origin, int children_resolution) { - return quadbin_cell_to_children_set(origin, children_resolution); +int ever_ne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return ever_ne_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -Temporal * tquadbin_in_w(const char * str) { - return tquadbin_in(str); +int ever_ne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return ever_ne_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -TInstant * tquadbininst_in_w(const char * str) { - return tquadbininst_in(str); +int ever_ne_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_tpcpoint_tpcpoint(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -TSequence * tquadbinseq_in_w(const char * str, interpType interp) { - return tquadbinseq_in(str, interp); +int always_eq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return always_eq_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * tquadbinseqset_in_w(const char * str) { - return tquadbinseqset_in(str); +int always_eq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return always_eq_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -Temporal * tquadbin_make_w(uint64_t value, long long t) { - return tquadbin_make(value, (TimestampTz) t); +int always_eq_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_tpcpoint_tpcpoint(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -TInstant * tquadbininst_make_w(uint64_t value, long long t) { - return tquadbininst_make(value, (TimestampTz) t); +int always_ne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return always_ne_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -TSequence * tquadbinseq_make_w(const uint64_t * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) { - return tquadbinseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc); +int always_ne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return always_ne_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * tquadbinseqset_make_w(const TSequence ** sequences, int count) { - return tquadbinseqset_make(sequences, count); +int always_ne_tpcpoint_tpcpoint_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_tpcpoint_tpcpoint(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -uint64_t tquadbin_start_value_w(const Temporal * temp) { - return tquadbin_start_value(temp); +int ever_eq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return ever_eq_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -uint64_t tquadbin_end_value_w(const Temporal * temp) { - return tquadbin_end_value(temp); +int ever_eq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return ever_eq_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -long long tquadbin_value_n_w(const Temporal * temp, int n) { - uint64_t r; - if (!tquadbin_value_n(temp, n, &r)) return 0; - return (long long) r; +int ever_eq_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_tpcpatch_tpcpatch(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -uint64_t * tquadbin_values_w(const Temporal * temp, int * count) { - return tquadbin_values(temp, count); +int ever_ne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return ever_ne_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -long long tquadbin_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) { - uint64_t r; - if (!tquadbin_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0; - return (long long) r; +int ever_ne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return ever_ne_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -Set * quadbin_to_set_w(uint64_t cell) { - return quadbin_to_set(cell); +int ever_ne_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_tpcpatch_tpcpatch(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -Temporal * tbigint_to_tquadbin_w(const Temporal * temp) { - return tbigint_to_tquadbin(temp); +int always_eq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return always_eq_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -Temporal * tquadbin_to_tbigint_w(const Temporal * temp) { - return tquadbin_to_tbigint(temp); +int always_eq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return always_eq_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -int ever_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return ever_eq_quadbin_tquadbin(cell, temp); +int always_eq_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_tpcpatch_tpcpatch(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return ever_eq_tquadbin_quadbin(temp, cell); +int always_ne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return always_ne_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -int ever_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return ever_ne_quadbin_tquadbin(cell, temp); +int always_ne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return always_ne_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -int ever_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return ever_ne_tquadbin_quadbin(temp, cell); +int always_ne_tpcpatch_tpcpatch_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_tpcpatch_tpcpatch(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -int always_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return always_eq_quadbin_tquadbin(cell, temp); +Temporal * teq_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return teq_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -int always_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return always_eq_tquadbin_quadbin(temp, cell); +Temporal * teq_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return teq_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -int always_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return always_ne_quadbin_tquadbin(cell, temp); +Temporal * tne_pcpoint_tpcpoint_w(const Pcpoint * pt, const Temporal * temp) { + return tne_pcpoint_tpcpoint(pt, temp); } EMSCRIPTEN_KEEPALIVE -int always_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return always_ne_tquadbin_quadbin(temp, cell); +Temporal * tne_tpcpoint_pcpoint_w(const Temporal * temp, const Pcpoint * pt) { + return tne_tpcpoint_pcpoint(temp, pt); } EMSCRIPTEN_KEEPALIVE -int ever_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return ever_eq_tquadbin_tquadbin(temp1, temp2); +Temporal * teq_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return teq_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -int ever_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return ever_ne_tquadbin_tquadbin(temp1, temp2); +Temporal * teq_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return teq_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -int always_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return always_eq_tquadbin_tquadbin(temp1, temp2); +Temporal * tne_pcpatch_tpcpatch_w(const Pcpatch * pa, const Temporal * temp) { + return tne_pcpatch_tpcpatch(pa, temp); } EMSCRIPTEN_KEEPALIVE -int always_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return always_ne_tquadbin_tquadbin(temp1, temp2); +Temporal * tne_tpcpatch_pcpatch_w(const Temporal * temp, const Pcpatch * pa) { + return tne_tpcpatch_pcpatch(temp, pa); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return teq_quadbin_tquadbin(cell, temp); +int adjacent_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) { + return (int) adjacent_tpcbox_tpointcloud(box, temp); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return teq_tquadbin_quadbin(temp, cell); +int adjacent_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) { + return (int) adjacent_tpointcloud_tpcbox(temp, box); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return teq_tquadbin_tquadbin(temp1, temp2); +int adjacent_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) { + return (int) adjacent_tpointcloud_tpointcloud(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { - return tne_quadbin_tquadbin(cell, temp); +int contained_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) { + return (int) contained_tpcbox_tpointcloud(box, temp); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { - return tne_tquadbin_quadbin(temp, cell); +int contained_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) { + return (int) contained_tpointcloud_tpcbox(temp, box); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { - return tne_tquadbin_tquadbin(temp1, temp2); +int contained_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) { + return (int) contained_tpointcloud_tpointcloud(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -Temporal * tquadbin_cell_to_quadkey_w(const Temporal * temp) { - return tquadbin_cell_to_quadkey(temp); +int contains_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) { + return (int) contains_tpcbox_tpointcloud(box, temp); } - -/* === meos_rgeo.h === */ +EMSCRIPTEN_KEEPALIVE +int contains_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) { + return (int) contains_tpointcloud_tpcbox(temp, box); +} EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_in_w(const char * str) { - return trgeometry_in(str); +int contains_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) { + return (int) contains_tpointcloud_tpointcloud(temp1, temp2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_from_mfjson_w(const char * mfjson) { - return trgeometry_from_mfjson(mfjson); +int overlaps_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) { + return (int) overlaps_tpcbox_tpointcloud(box, temp); } EMSCRIPTEN_KEEPALIVE -char * trgeometry_out_w(const Temporal * temp) { - return trgeometry_out(temp); +int overlaps_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) { + return (int) overlaps_tpointcloud_tpcbox(temp, box); } EMSCRIPTEN_KEEPALIVE -char * trgeometry_as_text_w(const Temporal * temp, int maxdd) { - return trgeometry_as_text(temp, maxdd); +int overlaps_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) { + return (int) overlaps_tpointcloud_tpointcloud(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int same_tpcbox_tpointcloud_w(const TPCBox * box, const Temporal * temp) { + return (int) same_tpcbox_tpointcloud(box, temp); +} + +EMSCRIPTEN_KEEPALIVE +int same_tpointcloud_tpcbox_w(const Temporal * temp, const TPCBox * box) { + return (int) same_tpointcloud_tpcbox(temp, box); +} + +EMSCRIPTEN_KEEPALIVE +int same_tpointcloud_tpointcloud_w(const Temporal * temp1, const Temporal * temp2) { + return (int) same_tpointcloud_tpointcloud(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int eintersects_tpcpoint_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return (int) eintersects_tpcpoint_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +double nad_tpcpoint_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return nad_tpcpoint_geo(temp, gs); +} + + +/* === meos_pose.h === */ + +EMSCRIPTEN_KEEPALIVE +char * pose_as_ewkt_w(const Pose * pose, int maxdd) { + return pose_as_ewkt(pose, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +char * pose_as_hexwkb_w(const Pose * pose, uint8_t variant, size_t * size_out) { + return pose_as_hexwkb(pose, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +char * pose_as_text_w(const Pose * pose, int maxdd) { + return pose_as_text(pose, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +uint8_t * pose_as_wkb_w(const Pose * pose, uint8_t variant, size_t * size_out) { + return pose_as_wkb(pose, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_from_wkb_w(const uint8_t * wkb, size_t size) { + return pose_from_wkb(wkb, size); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_from_hexwkb_w(const char * hexwkb) { + return pose_from_hexwkb(hexwkb); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_in_w(const char * str) { + return pose_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * pose_out_w(const Pose * pose, int maxdd) { + return pose_out(pose, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_from_geopose_w(const char * json) { + return pose_from_geopose(json); +} + +EMSCRIPTEN_KEEPALIVE +char * pose_as_geopose_w(const Pose * pose, int conformance, int precision) { + return pose_as_geopose(pose, conformance, precision); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_from_geopose_w(const char * json) { + return tpose_from_geopose(json); +} + +EMSCRIPTEN_KEEPALIVE +char * tpose_as_geopose_w(const Temporal * temp, int conformance, int precision) { + return tpose_as_geopose(temp, conformance, precision); +} + +EMSCRIPTEN_KEEPALIVE +char * tpose_as_geopose_stream_element_w(const Temporal * temp, const TInstant * inst, int precision) { + return tpose_as_geopose_stream_element(temp, inst, precision); +} + +EMSCRIPTEN_KEEPALIVE +char * tpose_as_geopose_stream_w(const Temporal * temp, int precision) { + return tpose_as_geopose_stream(temp, precision); +} + +EMSCRIPTEN_KEEPALIVE +const GeoPoseFrame * geopose_frames_w(int * count) { + return geopose_frames(count); +} + +EMSCRIPTEN_KEEPALIVE +const GeoPoseFrame * geopose_frame_w(int32_t frame_id) { + return geopose_frame(frame_id); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * pose_apply_geo_w(const Pose * pose, const GSERIALIZED * body) { + return pose_apply_geo(pose, body); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_apply_geo_w(const Temporal * temp, const GSERIALIZED * body) { + return tpose_apply_geo(temp, body); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_compose_pose_w(const Temporal * body, const Pose * frame) { + return tpose_compose_pose(body, frame); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * pose_compose_tpose_w(const Pose * body, const Temporal * frame) { + return pose_compose_tpose(body, frame); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_compose_tpose_w(const Temporal * body, const Temporal * frame) { + return tpose_compose_tpose(body, frame); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_inverse_w(const Temporal * temp) { + return tpose_inverse(temp); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_copy_w(const Pose * pose) { + return pose_copy(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_make_2d_w(double x, double y, double theta, int geodetic, int32_t srid) { + return pose_make_2d(x, y, theta, (bool) geodetic, srid); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_make_3d_w(double x, double y, double z, double W, double X, double Y, double Z, int geodetic, int32_t srid) { + return pose_make_3d(x, y, z, W, X, Y, Z, (bool) geodetic, srid); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_make_point2d_w(const GSERIALIZED * gs, double theta) { + return pose_make_point2d(gs, theta); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_make_point3d_w(const GSERIALIZED * gs, double W, double X, double Y, double Z) { + return pose_make_point3d(gs, W, X, Y, Z); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_make_point3d_ypr_w(const GSERIALIZED * gs, double yaw, double pitch, double roll) { + return pose_make_point3d_ypr(gs, yaw, pitch, roll); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * pose_to_point_w(const Pose * pose) { + return pose_to_point(pose); +} + +EMSCRIPTEN_KEEPALIVE +STBox * pose_to_stbox_w(const Pose * pose) { + return pose_to_stbox(pose); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t pose_hash_w(const Pose * pose) { + return pose_hash(pose); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t pose_hash_extended_w(const Pose * pose, uint64_t seed) { + return pose_hash_extended(pose, seed); +} + +EMSCRIPTEN_KEEPALIVE +double * pose_quaternion_w(const Pose * pose, int * count) { + return pose_quaternion(pose, count); +} + +EMSCRIPTEN_KEEPALIVE +double * pose_ypr_w(const Pose * pose, int * count) { + return pose_ypr(pose, count); +} + +EMSCRIPTEN_KEEPALIVE +double pose_yaw_w(const Pose * pose) { + return pose_yaw(pose); +} + +EMSCRIPTEN_KEEPALIVE +double pose_pitch_w(const Pose * pose) { + return pose_pitch(pose); +} + +EMSCRIPTEN_KEEPALIVE +double pose_roll_w(const Pose * pose) { + return pose_roll(pose); +} + +EMSCRIPTEN_KEEPALIVE +double pose_angular_distance_w(const Pose * pose1, const Pose * pose2) { + return pose_angular_distance(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_compose_w(const Pose * body, const Pose * frame) { + return pose_compose(body, frame); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_inverse_w(const Pose * pose) { + return pose_inverse(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_normalize_w(const Pose * pose) { + return pose_normalize(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_round_w(const Pose * pose, int maxdd) { + return pose_round(pose, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Pose ** posearr_round_w(const Pose ** posearr, int count, int maxdd) { + return posearr_round(posearr, count, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_set_srid_w(const Pose * pose, int32_t srid) { + return pose_set_srid(pose, srid); +} + +EMSCRIPTEN_KEEPALIVE +int32_t pose_srid_w(const Pose * pose) { + return pose_srid(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_transform_w(const Pose * pose, int32_t srid) { + return pose_transform(pose, srid); +} + +EMSCRIPTEN_KEEPALIVE +Pose * pose_transform_pipeline_w(const Pose * pose, const char * pipelinestr, int32_t srid, int is_forward) { + return pose_transform_pipeline(pose, pipelinestr, srid, (bool) is_forward); +} + +EMSCRIPTEN_KEEPALIVE +STBox * pose_tstzspan_to_stbox_w(const Pose * pose, const Span * s) { + return pose_tstzspan_to_stbox(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +STBox * pose_timestamptz_to_stbox_w(const Pose * pose, long long t) { + return pose_timestamptz_to_stbox(pose, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +double distance_pose_geo_w(const Pose * pose, const GSERIALIZED * gs) { + return distance_pose_geo(pose, gs); +} + +EMSCRIPTEN_KEEPALIVE +double distance_pose_pose_w(const Pose * pose1, const Pose * pose2) { + return distance_pose_pose(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +double distance_pose_stbox_w(const Pose * pose, const STBox * box) { + return distance_pose_stbox(pose, box); +} + +EMSCRIPTEN_KEEPALIVE +int pose_cmp_w(const Pose * pose1, const Pose * pose2) { + return pose_cmp(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_eq_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_eq(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_ge_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_ge(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_gt_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_gt(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_le_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_le(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_lt_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_lt(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_ne_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_ne(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_nsame_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_nsame(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +int pose_same_w(const Pose * pose1, const Pose * pose2) { + return (int) pose_same(pose1, pose2); +} + +EMSCRIPTEN_KEEPALIVE +Set * poseset_in_w(const char * str) { + return poseset_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * poseset_out_w(const Set * s, int maxdd) { + return poseset_out(s, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Set * poseset_make_w(const Pose ** values, int count) { + return poseset_make(values, count); +} + +EMSCRIPTEN_KEEPALIVE +Set * pose_to_set_w(const Pose * pose) { + return pose_to_set(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * poseset_end_value_w(const Set * s) { + return poseset_end_value(s); +} + +EMSCRIPTEN_KEEPALIVE +Pose * poseset_start_value_w(const Set * s) { + return poseset_start_value(s); +} + +EMSCRIPTEN_KEEPALIVE +Pose * poseset_value_n_w(const Set * s, int n) { + Pose * r; + if (!poseset_value_n(s, n, &r)) return NULL; + return r; +} + +EMSCRIPTEN_KEEPALIVE +Pose ** poseset_values_w(const Set * s, int * count) { + return poseset_values(s, count); +} + +EMSCRIPTEN_KEEPALIVE +int contained_pose_set_w(const Pose * pose, const Set * s) { + return (int) contained_pose_set(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +int contains_set_pose_w(const Set * s, Pose * pose) { + return (int) contains_set_pose(s, pose); +} + +EMSCRIPTEN_KEEPALIVE +Set * intersection_pose_set_w(const Pose * pose, const Set * s) { + return intersection_pose_set(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * intersection_set_pose_w(const Set * s, const Pose * pose) { + return intersection_set_pose(s, pose); +} + +EMSCRIPTEN_KEEPALIVE +Set * minus_pose_set_w(const Pose * pose, const Set * s) { + return minus_pose_set(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * minus_set_pose_w(const Set * s, const Pose * pose) { + return minus_set_pose(s, pose); +} + +EMSCRIPTEN_KEEPALIVE +Set * pose_union_transfn_w(Set * state, const Pose * pose) { + return pose_union_transfn(state, pose); +} + +EMSCRIPTEN_KEEPALIVE +Set * union_pose_set_w(const Pose * pose, const Set * s) { + return union_pose_set(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * union_set_pose_w(const Set * s, const Pose * pose) { + return union_set_pose(s, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_from_mfjson_w(const char * str) { + return tpose_from_mfjson(str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_in_w(const char * str) { + return tpose_in(str); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * tposeinst_make_w(const Pose * pose, long long t) { + return tposeinst_make(pose, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_from_base_temp_w(const Pose * pose, const Temporal * temp) { + return tpose_from_base_temp(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * tposeseq_from_base_tstzset_w(const Pose * pose, const Set * s) { + return tposeseq_from_base_tstzset(pose, s); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * tposeseq_from_base_tstzspan_w(const Pose * pose, const Span * s, interpType interp) { + return tposeseq_from_base_tstzspan(pose, s, interp); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * tposeseqset_from_base_tstzspanset_w(const Pose * pose, const SpanSet * ss, interpType interp) { + return tposeseqset_from_base_tstzspanset(pose, ss, interp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_make_w(const Temporal * tpoint, const Temporal * ttheta) { + return tpose_make(tpoint, ttheta); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_to_tpoint_w(const Temporal * temp) { + return tpose_to_tpoint(temp); +} + +EMSCRIPTEN_KEEPALIVE +Pose * tpose_end_value_w(const Temporal * temp) { + return tpose_end_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +Set * tpose_points_w(const Temporal * temp) { + return tpose_points(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_yaw_w(const Temporal * temp) { + return tpose_yaw(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_pitch_w(const Temporal * temp) { + return tpose_pitch(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_roll_w(const Temporal * temp) { + return tpose_roll(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_speed_w(const Temporal * temp) { + return tpose_speed(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_angular_speed_w(const Temporal * temp) { + return tpose_angular_speed(temp); +} + +EMSCRIPTEN_KEEPALIVE +Pose * tpose_start_value_w(const Temporal * temp) { + return tpose_start_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * tpose_trajectory_w(const Temporal * temp) { + return tpose_trajectory(temp); +} + +EMSCRIPTEN_KEEPALIVE +Pose * tpose_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) { + Pose * r; + if (!tpose_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return NULL; + return r; +} + +EMSCRIPTEN_KEEPALIVE +Pose * tpose_value_n_w(const Temporal * temp, int n) { + Pose * r; + if (!tpose_value_n(temp, n, &r)) return NULL; + return r; +} + +EMSCRIPTEN_KEEPALIVE +Pose ** tpose_values_w(const Temporal * temp, int * count) { + return tpose_values(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_at_elevation_w(const Temporal * temp, const Span * s) { + return tpose_at_elevation(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) { + return tpose_at_geom(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { + return tpose_at_stbox(temp, box, (bool) border_inc); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_at_pose_w(const Temporal * temp, const Pose * pose) { + return tpose_at_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_minus_elevation_w(const Temporal * temp, const Span * s) { + return tpose_minus_elevation(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) { + return tpose_minus_geom(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_minus_pose_w(const Temporal * temp, const Pose * pose) { + return tpose_minus_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tpose_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { + return tpose_minus_stbox(temp, box, (bool) border_inc); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return tdistance_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return tdistance_tpose_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return tdistance_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +double nad_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return nad_tpose_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +double nad_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return nad_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +double nad_tpose_stbox_w(const Temporal * temp, const STBox * box) { + return nad_tpose_stbox(temp, box); +} + +EMSCRIPTEN_KEEPALIVE +double nad_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return nad_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return nai_tpose_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return nai_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return nai_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_tpose_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return shortestline_tpose_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return shortestline_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return shortestline_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return always_eq_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return always_eq_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return always_ne_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return always_ne_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return ever_eq_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return ever_eq_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return ever_ne_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return ever_ne_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tpose_tpose_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_tpose_tpose(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return teq_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return teq_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_pose_tpose_w(const Pose * pose, const Temporal * temp) { + return tne_pose_tpose(pose, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_tpose_pose_w(const Temporal * temp, const Pose * pose) { + return tne_tpose_pose(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_in_w(const char * str) { + return posechain_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * posechain_out_w(const PoseChain * pc, int maxdd) { + return posechain_out(pc, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +char * posechain_as_text_w(const PoseChain * pc, int maxdd) { + return posechain_as_text(pc, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +char * posechain_as_ewkt_w(const PoseChain * pc, int maxdd) { + return posechain_as_ewkt(pc, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +uint8_t * posechain_as_wkb_w(const PoseChain * pc, uint8_t variant, size_t * size_out) { + return posechain_as_wkb(pc, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +char * posechain_as_hexwkb_w(const PoseChain * pc, uint8_t variant, size_t * size_out) { + return posechain_as_hexwkb(pc, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_from_wkb_w(const uint8_t * wkb, size_t size) { + return posechain_from_wkb(wkb, size); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_from_hexwkb_w(const char * hexwkb) { + return posechain_from_hexwkb(hexwkb); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_make_w(const Pose ** poses, int count) { + return posechain_make(poses, count); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_copy_w(const PoseChain * pc) { + return posechain_copy(pc); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_append_w(const PoseChain * pc, const Pose * pose) { + return posechain_append(pc, pose); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * pose_to_posechain_w(const Pose * pose) { + return pose_to_posechain(pose); +} + +EMSCRIPTEN_KEEPALIVE +Pose * posechain_to_pose_w(const PoseChain * pc) { + return posechain_to_pose(pc); +} + +EMSCRIPTEN_KEEPALIVE +Pose * posechain_prefix_pose_w(const PoseChain * pc, int n) { + return posechain_prefix_pose(pc, n); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * posechain_to_point_w(const PoseChain * pc) { + return posechain_to_point(pc); +} + +EMSCRIPTEN_KEEPALIVE +STBox * posechain_to_stbox_w(const PoseChain * pc) { + return posechain_to_stbox(pc); +} + +EMSCRIPTEN_KEEPALIVE +STBox * posechain_timestamptz_to_stbox_w(const PoseChain * pc, long long t) { + return posechain_timestamptz_to_stbox(pc, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +STBox * posechain_tstzspan_to_stbox_w(const PoseChain * pc, const Span * s) { + return posechain_tstzspan_to_stbox(pc, s); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_num_poses_w(const PoseChain * pc) { + return posechain_num_poses(pc); +} + +EMSCRIPTEN_KEEPALIVE +Pose * posechain_start_pose_w(const PoseChain * pc) { + return posechain_start_pose(pc); +} + +EMSCRIPTEN_KEEPALIVE +Pose * posechain_end_pose_w(const PoseChain * pc) { + return posechain_end_pose(pc); +} + +EMSCRIPTEN_KEEPALIVE +Pose * posechain_pose_n_w(const PoseChain * pc, int n) { + return posechain_pose_n(pc, n); +} + +EMSCRIPTEN_KEEPALIVE +Pose ** posechain_poses_w(const PoseChain * pc, int * count) { + return posechain_poses(pc, count); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t posechain_hash_w(const PoseChain * pc) { + return posechain_hash(pc); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t posechain_hash_extended_w(const PoseChain * pc, uint64_t seed) { + return posechain_hash_extended(pc, seed); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_round_w(const PoseChain * pc, int maxdd) { + return posechain_round(pc, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +int32_t posechain_srid_w(const PoseChain * pc) { + return posechain_srid(pc); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_set_srid_w(const PoseChain * pc, int32_t srid) { + return posechain_set_srid(pc, srid); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_transform_w(const PoseChain * pc, int32_t srid_to) { + return posechain_transform(pc, srid_to); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechain_transform_pipeline_w(const PoseChain * pc, const char * pipeline, int32_t srid_to, int is_forward) { + return posechain_transform_pipeline(pc, pipeline, srid_to, (bool) is_forward); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tposechain_from_geopose_w(const char * json) { + return tposechain_from_geopose(json); +} + +EMSCRIPTEN_KEEPALIVE +char * tposechain_as_geopose_w(const Temporal * temp, int precision) { + return tposechain_as_geopose(temp, precision); +} + +EMSCRIPTEN_KEEPALIVE +char * tposechainarr_as_geopose_w(const Temporal ** temparr, int count, int precision) { + return tposechainarr_as_geopose(temparr, count, precision); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_eq_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_eq(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_ne_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_ne(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_same_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_same(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_nsame_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_nsame(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_cmp_w(const PoseChain * pc1, const PoseChain * pc2) { + return posechain_cmp(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_lt_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_lt(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_le_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_le(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_gt_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_gt(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +int posechain_ge_w(const PoseChain * pc1, const PoseChain * pc2) { + return (int) posechain_ge(pc1, pc2); +} + +EMSCRIPTEN_KEEPALIVE +Set * posechainset_in_w(const char * str) { + return posechainset_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * posechainset_out_w(const Set * s, int maxdd) { + return posechainset_out(s, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Set * posechainset_make_w(const PoseChain ** values, int count) { + return posechainset_make(values, count); +} + +EMSCRIPTEN_KEEPALIVE +Set * posechain_to_set_w(const PoseChain * pc) { + return posechain_to_set(pc); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechainset_end_value_w(const Set * s) { + return posechainset_end_value(s); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechainset_start_value_w(const Set * s) { + return posechainset_start_value(s); +} + +EMSCRIPTEN_KEEPALIVE +PoseChain * posechainset_value_n_w(const Set * s, int n) { + PoseChain * r; + if (!posechainset_value_n(s, n, &r)) return NULL; + return r; +} + +EMSCRIPTEN_KEEPALIVE +PoseChain ** posechainset_values_w(const Set * s, int * count) { + return posechainset_values(s, count); +} + +EMSCRIPTEN_KEEPALIVE +int contained_posechain_set_w(const PoseChain * pc, const Set * s) { + return (int) contained_posechain_set(pc, s); +} + +EMSCRIPTEN_KEEPALIVE +int contains_set_posechain_w(const Set * s, PoseChain * pc) { + return (int) contains_set_posechain(s, pc); +} + +EMSCRIPTEN_KEEPALIVE +Set * intersection_posechain_set_w(const PoseChain * pc, const Set * s) { + return intersection_posechain_set(pc, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * intersection_set_posechain_w(const Set * s, const PoseChain * pc) { + return intersection_set_posechain(s, pc); +} + +EMSCRIPTEN_KEEPALIVE +Set * minus_posechain_set_w(const PoseChain * pc, const Set * s) { + return minus_posechain_set(pc, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * minus_set_posechain_w(const Set * s, const PoseChain * pc) { + return minus_set_posechain(s, pc); +} + +EMSCRIPTEN_KEEPALIVE +Set * posechain_union_transfn_w(Set * state, const PoseChain * pc) { + return posechain_union_transfn(state, pc); +} + +EMSCRIPTEN_KEEPALIVE +Set * union_posechain_set_w(const PoseChain * pc, const Set * s) { + return union_posechain_set(pc, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * union_set_posechain_w(const Set * s, const PoseChain * pc) { + return union_set_posechain(s, pc); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tposechain_in_w(const char * str) { + return tposechain_in(str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tposechain_from_mfjson_w(const char * mfjson) { + return tposechain_from_mfjson(mfjson); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tposechain_from_base_temp_w(const PoseChain * pc, const Temporal * temp) { + return tposechain_from_base_temp(pc, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tposechain_to_tpose_w(const Temporal * temp) { + return tposechain_to_tpose(temp); +} + +EMSCRIPTEN_KEEPALIVE +int tposechain_num_poses_w(const Temporal * temp) { + return tposechain_num_poses(temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return always_eq_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return always_eq_tposechain_posechain(temp, posechain); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_tposechain_tposechain(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return always_ne_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return always_ne_tposechain_posechain(temp, posechain); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_tposechain_tposechain(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return ever_eq_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return ever_eq_tposechain_posechain(temp, posechain); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_tposechain_tposechain(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return ever_ne_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return ever_ne_tposechain_posechain(temp, posechain); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tposechain_tposechain_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_tposechain_tposechain(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return teq_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return teq_tposechain_posechain(temp, posechain); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_posechain_tposechain_w(const PoseChain * posechain, const Temporal * temp) { + return tne_posechain_tposechain(posechain, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_tposechain_posechain_w(const Temporal * temp, const PoseChain * posechain) { + return tne_tposechain_posechain(temp, posechain); +} + + +/* === meos_quadbin.h === */ + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_in_w(const char * str) { + return quadbin_in(str); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_eq_w(uint64_t a, uint64_t b) { + return (int) quadbin_eq(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_ne_w(uint64_t a, uint64_t b) { + return (int) quadbin_ne(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_lt_w(uint64_t a, uint64_t b) { + return (int) quadbin_lt(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_le_w(uint64_t a, uint64_t b) { + return (int) quadbin_le(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_gt_w(uint64_t a, uint64_t b) { + return (int) quadbin_gt(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_ge_w(uint64_t a, uint64_t b) { + return (int) quadbin_ge(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_cmp_w(uint64_t a, uint64_t b) { + return quadbin_cmp(a, b); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t quadbin_hash_w(uint64_t cell) { + return quadbin_hash(cell); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_hash_extended_w(uint64_t cell, uint64_t seed) { + return quadbin_hash_extended(cell, seed); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_is_valid_index_w(uint64_t index) { + return (int) quadbin_is_valid_index(index); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_is_valid_cell_w(uint64_t cell) { + return (int) quadbin_is_valid_cell(cell); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_tile_to_cell_w(uint32_t x, uint32_t y, uint32_t z) { + return quadbin_tile_to_cell(x, y, z); +} + +EMSCRIPTEN_KEEPALIVE +int quadbin_cell_to_tile_w(uint64_t cell, uint32_t * x, uint32_t * y, uint32_t * z) { + return (int) quadbin_cell_to_tile(cell, x, y, z); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t quadbin_get_resolution_w(uint64_t cell) { + return quadbin_get_resolution(cell); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_cell_to_parent_w(uint64_t cell, uint32_t parent_resolution) { + return quadbin_cell_to_parent(cell, parent_resolution); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t * quadbin_cell_to_children_w(uint64_t cell, uint32_t children_resolution, int * count) { + return quadbin_cell_to_children(cell, children_resolution, count); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_cell_sibling_w(uint64_t cell, const char * direction) { + return quadbin_cell_sibling(cell, direction); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t * quadbin_k_ring_w(uint64_t cell, int k, int * count) { + return quadbin_k_ring(cell, k, count); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_point_to_cell_w(double longitude, double latitude, uint32_t resolution) { + return quadbin_point_to_cell(longitude, latitude, resolution); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t geo_to_quadbin_cell_w(const GSERIALIZED * point, int32 resolution) { + return geo_to_quadbin_cell(point, resolution); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * quadbin_cell_to_geompoint_w(uint64_t cell) { + return quadbin_cell_to_geompoint(cell); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * quadbin_cell_to_geom_w(uint64_t cell) { + return quadbin_cell_to_geom(cell); +} + +EMSCRIPTEN_KEEPALIVE +STBox * quadbin_to_stbox_w(uint64_t cell) { + return quadbin_to_stbox(cell); +} + +EMSCRIPTEN_KEEPALIVE +STBox * quadbin_timestamptz_to_stbox_w(uint64_t cell, long long t) { + return quadbin_timestamptz_to_stbox(cell, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +STBox * quadbin_tstzspan_to_stbox_w(uint64_t cell, const Span * s) { + return quadbin_tstzspan_to_stbox(cell, s); +} + +EMSCRIPTEN_KEEPALIVE +double quadbin_cell_area_w(uint64_t cell) { + return quadbin_cell_area(cell); +} + +EMSCRIPTEN_KEEPALIVE +char * quadbin_index_to_string_w(uint64_t index) { + return quadbin_index_to_string(index); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t quadbin_string_to_index_w(const char * str) { + return quadbin_string_to_index(str); +} + +EMSCRIPTEN_KEEPALIVE +char * quadbin_cell_to_quadkey_w(uint64_t cell) { + return quadbin_cell_to_quadkey(cell); +} + +EMSCRIPTEN_KEEPALIVE +Set * quadbin_grid_disk_w(uint64_t origin, int k) { + return quadbin_grid_disk(origin, k); +} + +EMSCRIPTEN_KEEPALIVE +Set * quadbin_cell_to_children_set_w(uint64_t origin, int children_resolution) { + return quadbin_cell_to_children_set(origin, children_resolution); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tquadbin_in_w(const char * str) { + return tquadbin_in(str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tquadbin_make_w(uint64_t value, long long t) { + return tquadbin_make(value, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * tquadbininst_make_w(uint64_t value, long long t) { + return tquadbininst_make(value, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * tquadbinseq_make_w(const uint64_t * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) { + return tquadbinseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * tquadbinseqset_make_w(const TSequence ** sequences, int count) { + return tquadbinseqset_make(sequences, count); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t tquadbin_start_value_w(const Temporal * temp) { + return tquadbin_start_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t tquadbin_end_value_w(const Temporal * temp) { + return tquadbin_end_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +long long tquadbin_value_n_w(const Temporal * temp, int n) { + uint64_t r; + if (!tquadbin_value_n(temp, n, &r)) return 0; + return (long long) r; +} + +EMSCRIPTEN_KEEPALIVE +uint64_t * tquadbin_values_w(const Temporal * temp, int * count) { + return tquadbin_values(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +long long tquadbin_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) { + uint64_t r; + if (!tquadbin_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0; + return (long long) r; +} + +EMSCRIPTEN_KEEPALIVE +Set * quadbin_to_set_w(uint64_t cell) { + return quadbin_to_set(cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tbigint_to_tquadbin_w(const Temporal * temp) { + return tbigint_to_tquadbin(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tquadbin_to_tbigint_w(const Temporal * temp) { + return tquadbin_to_tbigint(temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return ever_eq_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return ever_eq_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return ever_ne_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return ever_ne_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return always_eq_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return always_eq_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return always_ne_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return always_ne_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return teq_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return teq_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return teq_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_quadbin_tquadbin_w(uint64_t cell, const Temporal * temp) { + return tne_quadbin_tquadbin(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_tquadbin_quadbin_w(const Temporal * temp, uint64_t cell) { + return tne_tquadbin_quadbin(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_tquadbin_tquadbin_w(const Temporal * temp1, const Temporal * temp2) { + return tne_tquadbin_tquadbin(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tquadbin_cell_to_quadkey_w(const Temporal * temp) { + return tquadbin_cell_to_quadkey(temp); +} + + +/* === meos_raster.h === */ + +EMSCRIPTEN_KEEPALIVE +size_t raquet_pixtype_size_w(MeosPixType pixtype) { + return raquet_pixtype_size(pixtype); +} + +EMSCRIPTEN_KEEPALIVE +MeosPixType raquet_pixtype_from_string_w(const char * str) { + return raquet_pixtype_from_string(str); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_in_w(const char * str) { + return raquet_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * raquet_out_w(const Raquet * rq) { + return raquet_out(rq); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_from_wkb_w(const uint8_t * wkb, size_t size) { + return raquet_from_wkb(wkb, size); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_from_hexwkb_w(const char * hexwkb) { + return raquet_from_hexwkb(hexwkb); +} + +EMSCRIPTEN_KEEPALIVE +uint8_t * raquet_as_wkb_w(const Raquet * rq, uint8_t variant, size_t * size_out) { + return raquet_as_wkb(rq, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +char * raquet_as_hexwkb_w(const Raquet * rq, uint8_t variant, size_t * size_out) { + return raquet_as_hexwkb(rq, variant, size_out); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_make_w(uint64_t quadbin, int32 width, int32 height, MeosPixType pixtype, double nodata, int has_nodata, const uint8_t * pixels, size_t pixels_size) { + return raquet_make(quadbin, width, height, pixtype, nodata, (bool) has_nodata, pixels, pixels_size); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_copy_w(const Raquet * rq) { + return raquet_copy(rq); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_read_w(const char * path, uint64_t quadbin) { + return raquet_read(path, quadbin); +} + +EMSCRIPTEN_KEEPALIVE +Raquet * raquet_read_bytes_w(const uint8_t * data, size_t size, uint64_t quadbin) { + return raquet_read_bytes(data, size, quadbin); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t raquet_quadbin_w(const Raquet * rq) { + return raquet_quadbin(rq); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_width_w(const Raquet * rq) { + return raquet_width(rq); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_height_w(const Raquet * rq) { + return raquet_height(rq); +} + +EMSCRIPTEN_KEEPALIVE +double raquet_nodata_w(const Raquet * rq) { + return raquet_nodata(rq); +} + +EMSCRIPTEN_KEEPALIVE +char * raquet_pixtype_w(const Raquet * rq) { + return raquet_pixtype(rq); +} + +EMSCRIPTEN_KEEPALIVE +uint8_t * raquet_pixels_w(const Raquet * rq, size_t * size_out) { + return raquet_pixels(rq, size_out); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t raquet_hash_w(const Raquet * rq) { + return raquet_hash(rq); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t raquet_hash_extended_w(const Raquet * rq, uint64_t seed) { + return raquet_hash_extended(rq, seed); +} + +EMSCRIPTEN_KEEPALIVE +Raster * raster_from_wkb_w(const uint8_t * wkb, size_t size) { + return raster_from_wkb(wkb, size); +} + +EMSCRIPTEN_KEEPALIVE +Raster * raster_from_hexwkb_w(const char * hexwkb) { + return raster_from_hexwkb(hexwkb); +} + +EMSCRIPTEN_KEEPALIVE +uint8_t * raster_as_wkb_w(const Raster * rast, size_t * size_out) { + return raster_as_wkb(rast, size_out); +} + +EMSCRIPTEN_KEEPALIVE +char * raster_as_hexwkb_w(const Raster * rast, size_t * size_out) { + return raster_as_hexwkb(rast, size_out); +} + +EMSCRIPTEN_KEEPALIVE +int raster_num_bands_w(const Raster * rast) { + return raster_num_bands(rast); +} + +EMSCRIPTEN_KEEPALIVE +STBox * raquet_to_stbox_w(const Raquet * rq) { + return raquet_to_stbox(rq); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_cmp_w(const Raquet * rq1, const Raquet * rq2) { + return raquet_cmp(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_eq_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_eq(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_ne_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_ne(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_lt_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_lt(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_le_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_le(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_ge_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_ge(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +int raquet_gt_w(const Raquet * rq1, const Raquet * rq2) { + return (int) raquet_gt(rq1, rq2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx) { + return raster_value(traj, box, sample, ctx); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_at_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) { + return raster_at_value(traj, box, sample, ctx, vspan); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_minus_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) { + return raster_minus_value(traj, box, sample, ctx, vspan); +} + +EMSCRIPTEN_KEEPALIVE +int eraster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) { + return eraster_value(traj, box, sample, ctx, vspan); +} + +EMSCRIPTEN_KEEPALIVE +int araster_value_w(const Temporal * traj, const STBox * box, raster_sample_fn sample, void * ctx, const Span * vspan) { + return araster_value(traj, box, sample, ctx, vspan); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_value_gdal_w(const Temporal * traj, const char * path, int band) { + return raster_value_gdal(traj, path, band); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_at_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) { + return raster_at_value_gdal(traj, path, band, vspan); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_minus_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) { + return raster_minus_value_gdal(traj, path, band, vspan); +} + +EMSCRIPTEN_KEEPALIVE +int eraster_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) { + return eraster_value_gdal(traj, path, band, vspan); +} + +EMSCRIPTEN_KEEPALIVE +int araster_value_gdal_w(const Temporal * traj, const char * path, int band, const Span * vspan) { + return araster_value_gdal(traj, path, band, vspan); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_tile_value_quadbin_w(const Temporal * traj, const uint8_t * pixels, size_t pixels_size, int32 width, int32 height, uint64_t quadbin, MeosPixType pixtype, double nodata, int has_nodata) { + return raster_tile_value_quadbin(traj, pixels, pixels_size, width, height, quadbin, pixtype, nodata, (bool) has_nodata); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_tile_value_w(const Temporal * traj, const Raquet * rq) { + return raster_tile_value(traj, rq); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * raster_tile_value_array_w(const Temporal * traj, const Raquet ** rqarr, int count) { + return raster_tile_value_array(traj, rqarr, count); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t * trajectory_quadbins_w(const Temporal * traj, uint32_t zoom, int * count) { + return trajectory_quadbins(traj, zoom, count); +} + + +/* === meos_rgeo.h === */ + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_in_w(const char * str) { + return trgeometry_in(str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_from_mfjson_w(const char * mfjson) { + return trgeometry_from_mfjson(mfjson); +} + +EMSCRIPTEN_KEEPALIVE +char * trgeometry_out_w(const Temporal * temp) { + return trgeometry_out(temp); +} + +EMSCRIPTEN_KEEPALIVE +char * trgeometry_as_text_w(const Temporal * temp, int maxdd) { + return trgeometry_as_text(temp, maxdd); } EMSCRIPTEN_KEEPALIVE @@ -13817,797 +15551,2429 @@ char * trgeometry_as_ewkt_w(const Temporal * temp, int maxdd) { } EMSCRIPTEN_KEEPALIVE -TInstant * trgeometryinst_make_w(const GSERIALIZED * geom, const Pose * pose, long long t) { - return trgeometryinst_make(geom, pose, (TimestampTz) t); +TInstant * trgeometryinst_make_w(const GSERIALIZED * geom, const Pose * pose, long long t) { + return trgeometryinst_make(geom, pose, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * trgeometryseq_make_w(const GSERIALIZED * geom, TInstant ** instants, int count, int lower_inc, int upper_inc, interpType interp, int normalize) { + return trgeometryseq_make(geom, instants, count, (bool) lower_inc, (bool) upper_inc, interp, (bool) normalize); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * trgeometryseqset_make_w(const GSERIALIZED * geom, TSequence ** sequences, int count, int normalize) { + return trgeometryseqset_make(geom, sequences, count, (bool) normalize); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * trgeometryseqset_make_gaps_w(const GSERIALIZED * geom, TInstant ** instants, int count, interpType interp, const Interval * maxt, double maxdist) { + return trgeometryseqset_make_gaps(geom, instants, count, interp, maxt, maxdist); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * geometry_tpose_to_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return geometry_tpose_to_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_to_tpose_w(const Temporal * temp) { + return trgeometry_to_tpose(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_to_tgeompoint_w(const Temporal * temp) { + return trgeometry_to_tgeompoint(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_to_tgeometry_w(const Temporal * temp) { + return trgeometry_to_tgeometry(temp); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * trgeometry_end_instant_w(const Temporal * temp) { + return trgeometry_end_instant(temp); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * trgeometry_end_sequence_w(const Temporal * temp) { + return trgeometry_end_sequence(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_end_value_w(const Temporal * temp) { + return trgeometry_end_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_geom_w(const Temporal * temp) { + return trgeometry_geom(temp); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * trgeometry_instant_n_w(const Temporal * temp, int n) { + return trgeometry_instant_n(temp, n); +} + +EMSCRIPTEN_KEEPALIVE +TInstant ** trgeometry_instants_w(const Temporal * temp, int * count) { + return trgeometry_instants(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +Set * trgeometry_points_w(const Temporal * temp) { + return trgeometry_points(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_yaw_w(const Temporal * temp) { + return trgeometry_yaw(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_pitch_w(const Temporal * temp) { + return trgeometry_pitch(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_roll_w(const Temporal * temp) { + return trgeometry_roll(temp); +} + +EMSCRIPTEN_KEEPALIVE +TSequence ** trgeometry_segments_w(const Temporal * temp, int * count) { + return trgeometry_segments(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * trgeometry_sequence_n_w(const Temporal * temp, int i) { + return trgeometry_sequence_n(temp, i); +} + +EMSCRIPTEN_KEEPALIVE +TSequence ** trgeometry_sequences_w(const Temporal * temp, int * count) { + return trgeometry_sequences(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * trgeometry_start_instant_w(const Temporal * temp) { + return trgeometry_start_instant(temp); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * trgeometry_start_sequence_w(const Temporal * temp) { + return trgeometry_start_sequence(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_start_value_w(const Temporal * temp) { + return trgeometry_start_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_value_n_w(const Temporal * temp, int n) { + GSERIALIZED * r; + if (!trgeometry_value_n(temp, n, &r)) return NULL; + return r; +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_traversed_area_w(const Temporal * temp, int unary_union) { + return trgeometry_traversed_area(temp, (bool) unary_union); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_centroid_w(const Temporal * temp) { + return trgeometry_centroid(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_convex_hull_w(const Temporal * temp) { + return trgeometry_convex_hull(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_body_point_trajectory_w(const Temporal * temp, const GSERIALIZED * gs) { + return trgeometry_body_point_trajectory(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +STBox * trgeometry_space_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const GSERIALIZED * sorigin, int bitmatrix, int border_inc, int * count) { + return trgeometry_space_boxes(temp, xsize, ysize, zsize, sorigin, (bool) bitmatrix, (bool) border_inc, count); +} + +EMSCRIPTEN_KEEPALIVE +STBox * trgeometry_space_time_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const Interval * duration, const GSERIALIZED * sorigin, long long torigin, int bitmatrix, int border_inc, int * count) { + return trgeometry_space_time_boxes(temp, xsize, ysize, zsize, duration, sorigin, (TimestampTz) torigin, (bool) bitmatrix, (bool) border_inc, count); +} + +EMSCRIPTEN_KEEPALIVE +STBox * trgeometry_stboxes_w(const Temporal * temp, int * count) { + return trgeometry_stboxes(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +STBox * trgeometry_split_n_stboxes_w(const Temporal * temp, int box_count, int * count) { + return trgeometry_split_n_stboxes(temp, box_count, count); +} + +EMSCRIPTEN_KEEPALIVE +STBox * trgeometry_split_each_n_stboxes_w(const Temporal * temp, int elem_count, int * count) { + return trgeometry_split_each_n_stboxes(temp, elem_count, count); +} + +EMSCRIPTEN_KEEPALIVE +double trgeometry_hausdorff_distance_w(const Temporal * temp1, const Temporal * temp2) { + return trgeometry_hausdorff_distance(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +double trgeometry_frechet_distance_w(const Temporal * temp1, const Temporal * temp2) { + return trgeometry_frechet_distance(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +double trgeometry_dyntimewarp_distance_w(const Temporal * temp1, const Temporal * temp2) { + return trgeometry_dyntimewarp_distance(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Match * trgeometry_frechet_path_w(const Temporal * temp1, const Temporal * temp2, int * count) { + return trgeometry_frechet_path(temp1, temp2, count); +} + +EMSCRIPTEN_KEEPALIVE +Match * trgeometry_dyntimewarp_path_w(const Temporal * temp1, const Temporal * temp2, int * count) { + return trgeometry_dyntimewarp_path(temp1, temp2, count); +} + +EMSCRIPTEN_KEEPALIVE +double trgeometry_length_w(const Temporal * temp) { + return trgeometry_length(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_cumulative_length_w(const Temporal * temp) { + return trgeometry_cumulative_length(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_angular_speed_w(const Temporal * temp) { + return trgeometry_angular_speed(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_speed_w(const Temporal * temp) { + return trgeometry_speed(temp); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * trgeometry_twcentroid_w(const Temporal * temp) { + return trgeometry_twcentroid(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_append_tinstant_w(Temporal * temp, const TInstant * inst, interpType interp, double maxdist, const Interval * maxt, int expand) { + return trgeometry_append_tinstant(temp, inst, interp, maxdist, maxt, (bool) expand); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_append_tsequence_w(Temporal * temp, const TSequence * seq, int expand) { + return trgeometry_append_tsequence(temp, seq, (bool) expand); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_delete_timestamptz_w(const Temporal * temp, long long t, int connect) { + return trgeometry_delete_timestamptz(temp, (TimestampTz) t, (bool) connect); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_delete_tstzset_w(const Temporal * temp, const Set * s, int connect) { + return trgeometry_delete_tstzset(temp, s, (bool) connect); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_delete_tstzspan_w(const Temporal * temp, const Span * s, int connect) { + return trgeometry_delete_tstzspan(temp, s, (bool) connect); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_delete_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int connect) { + return trgeometry_delete_tstzspanset(temp, ss, (bool) connect); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_merge_w(const Temporal * temp1, const Temporal * temp2) { + return trgeometry_merge(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_merge_array_w(Temporal ** temparr, int count) { + return trgeometry_merge_array(temparr, count); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_round_w(const Temporal * temp, int maxdd) { + return trgeometry_round(temp, maxdd); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_set_interp_w(const Temporal * temp, interpType interp) { + return trgeometry_set_interp(temp, interp); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * trgeometry_as_tinstant_w(const Temporal * temp) { + return trgeometry_as_tinstant(temp); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * trgeometry_as_tsequence_w(const Temporal * temp, const char * interp_str) { + return trgeometry_as_tsequence(temp, interp_str); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * trgeometry_as_tsequenceset_w(const Temporal * temp, const char * interp_str) { + return trgeometry_as_tsequenceset(temp, interp_str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_after_timestamptz_w(const Temporal * temp, long long t, int strict) { + return trgeometry_after_timestamptz(temp, (TimestampTz) t, (bool) strict); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_before_timestamptz_w(const Temporal * temp, long long t, int strict) { + return trgeometry_before_timestamptz(temp, (TimestampTz) t, (bool) strict); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) { + return trgeometry_at_geom(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) { + return trgeometry_minus_geom(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { + return trgeometry_at_stbox(temp, box, (bool) border_inc); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { + return trgeometry_minus_stbox(temp, box, (bool) border_inc); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_value_w(const Temporal * temp, const Pose * pose) { + return trgeometry_at_value(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_value_w(const Temporal * temp, const Pose * pose) { + return trgeometry_minus_value(temp, pose); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_values_w(const Temporal * temp, const Set * s) { + return trgeometry_at_values(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_values_w(const Temporal * temp, const Set * s) { + return trgeometry_minus_values(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_timestamptz_w(const Temporal * temp, long long t) { + return trgeometry_at_timestamptz(temp, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_timestamptz_w(const Temporal * temp, long long t) { + return trgeometry_minus_timestamptz(temp, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_tstzset_w(const Temporal * temp, const Set * s) { + return trgeometry_at_tstzset(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_tstzset_w(const Temporal * temp, const Set * s) { + return trgeometry_minus_tstzset(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_tstzspan_w(const Temporal * temp, const Span * s) { + return trgeometry_at_tstzspan(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_tstzspan_w(const Temporal * temp, const Span * s) { + return trgeometry_minus_tstzspan(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_tstzspanset_w(const Temporal * temp, const SpanSet * ss) { + return trgeometry_at_tstzspanset(temp, ss); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_tstzspanset_w(const Temporal * temp, const SpanSet * ss) { + return trgeometry_minus_tstzspanset(temp, ss); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_at_elevation_w(const Temporal * temp, const Span * s) { + return trgeometry_at_elevation(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * trgeometry_minus_elevation_w(const Temporal * temp, const Span * s) { + return trgeometry_minus_elevation(temp, s); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return tdistance_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { + return tdistance_trgeometry_tpoint(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tdistance_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return tdistance_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +double nad_stbox_trgeometry_w(const STBox * box, const Temporal * temp) { + return nad_stbox_trgeometry(box, temp); +} + +EMSCRIPTEN_KEEPALIVE +double nad_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return nad_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +double nad_trgeometry_stbox_w(const Temporal * temp, const STBox * box) { + return nad_trgeometry_stbox(temp, box); +} + +EMSCRIPTEN_KEEPALIVE +double nad_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { + return nad_trgeometry_tpoint(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +double nad_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return nad_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return nai_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { + return nai_trgeometry_tpoint(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * nai_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return nai_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return shortestline_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { + return shortestline_trgeometry_tpoint(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * shortestline_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return shortestline_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return always_eq_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return always_eq_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return always_ne_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return always_ne_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return ever_eq_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return ever_eq_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return ever_ne_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return ever_ne_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return teq_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return teq_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return tne_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return tne_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int econtains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return econtains_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int acontains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return acontains_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ecovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return ecovers_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int acovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { + return acovers_geo_trgeometry(gs, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ecovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return ecovers_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int acovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return acovers_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int edisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return edisjoint_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int adisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return adisjoint_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int eintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return eintersects_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int aintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return aintersects_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int etouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return etouches_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int atouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { + return atouches_trgeometry_geo(temp, gs); +} + +EMSCRIPTEN_KEEPALIVE +int edwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) { + return edwithin_trgeometry_geo(temp, gs, dist); +} + +EMSCRIPTEN_KEEPALIVE +int adwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) { + return adwithin_trgeometry_geo(temp, gs, dist); +} + +EMSCRIPTEN_KEEPALIVE +int edisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return edisjoint_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int adisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return adisjoint_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int eintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return eintersects_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int aintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { + return aintersects_trgeometry_trgeometry(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int edwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) { + return edwithin_trgeometry_trgeometry(temp1, temp2, dist); +} + +EMSCRIPTEN_KEEPALIVE +int adwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) { + return adwithin_trgeometry_trgeometry(temp1, temp2, dist); +} + + +/* === meos_s2cell.h === */ + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_in_w(const char * str) { + return s2cell_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * s2cell_out_w(S2CellId cell) { + return s2cell_out(cell); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_eq_w(S2CellId a, S2CellId b) { + return (int) s2cell_eq(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_ne_w(S2CellId a, S2CellId b) { + return (int) s2cell_ne(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_lt_w(S2CellId a, S2CellId b) { + return (int) s2cell_lt(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_le_w(S2CellId a, S2CellId b) { + return (int) s2cell_le(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_gt_w(S2CellId a, S2CellId b) { + return (int) s2cell_gt(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_ge_w(S2CellId a, S2CellId b) { + return (int) s2cell_ge(a, b); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_cmp_w(S2CellId a, S2CellId b) { + return s2cell_cmp(a, b); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t s2cell_hash_w(S2CellId cell) { + return s2cell_hash(cell); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t s2cell_hash_extended_w(S2CellId cell, uint64_t seed) { + return s2cell_hash_extended(cell, seed); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_is_valid_cell_w(S2CellId cell) { + return (int) s2cell_is_valid_cell(cell); +} + +EMSCRIPTEN_KEEPALIVE +char * s2cell_cell_to_token_w(S2CellId cell) { + return s2cell_cell_to_token(cell); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_token_to_cell_w(const char * token) { + return s2cell_token_to_cell(token); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t s2cell_get_resolution_w(S2CellId cell) { + return s2cell_get_resolution(cell); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t s2cell_get_face_w(S2CellId cell) { + return s2cell_get_face(cell); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_cell_to_parent_w(S2CellId cell, uint32_t level) { + return s2cell_cell_to_parent(cell, level); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_cell_to_child_w(S2CellId cell, uint32_t level, uint32_t position) { + return s2cell_cell_to_child(cell, level, position); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId * s2cell_cell_to_children_w(S2CellId cell, uint32_t level, int * count) { + return s2cell_cell_to_children(cell, level, count); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_cell_contains_w(S2CellId cell, S2CellId other) { + return (int) s2cell_cell_contains(cell, other); +} + +EMSCRIPTEN_KEEPALIVE +int s2cell_common_ancestor_level_w(S2CellId a, S2CellId b) { + return s2cell_common_ancestor_level(a, b); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_range_min_w(S2CellId cell) { + return s2cell_range_min(cell); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_range_max_w(S2CellId cell) { + return s2cell_range_max(cell); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId * s2cell_edge_neighbors_w(S2CellId cell, int * count) { + return s2cell_edge_neighbors(cell, count); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId s2cell_point_to_cell_w(double longitude, double latitude, uint32_t level) { + return s2cell_point_to_cell(longitude, latitude, level); +} + +EMSCRIPTEN_KEEPALIVE +double s2cell_cell_area_w(S2CellId cell) { + return s2cell_cell_area(cell); +} + +EMSCRIPTEN_KEEPALIVE +double s2cell_edge_length_w(S2CellId cell, uint32_t edge) { + return s2cell_edge_length(cell, edge); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId geo_to_s2cell_cell_w(const GSERIALIZED * point, int32 level) { + return geo_to_s2cell_cell(point, level); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * s2cell_cell_to_geogpoint_w(S2CellId cell) { + return s2cell_cell_to_geogpoint(cell); +} + +EMSCRIPTEN_KEEPALIVE +GSERIALIZED * s2cell_cell_to_geog_w(S2CellId cell) { + return s2cell_cell_to_geog(cell); +} + +EMSCRIPTEN_KEEPALIVE +STBox * s2cell_to_stbox_w(S2CellId cell) { + return s2cell_to_stbox(cell); +} + +EMSCRIPTEN_KEEPALIVE +STBox * s2cell_timestamptz_to_stbox_w(S2CellId cell, long long t) { + return s2cell_timestamptz_to_stbox(cell, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +STBox * s2cell_tstzspan_to_stbox_w(S2CellId cell, const Span * s) { + return s2cell_tstzspan_to_stbox(cell, s); +} + +EMSCRIPTEN_KEEPALIVE +Set * s2cell_edge_neighbors_set_w(S2CellId cell) { + return s2cell_edge_neighbors_set(cell); +} + +EMSCRIPTEN_KEEPALIVE +Set * s2cell_cell_to_children_set_w(S2CellId cell, int children_level) { + return s2cell_cell_to_children_set(cell, children_level); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * ts2cell_in_w(const char * str) { + return ts2cell_in(str); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * ts2cell_make_w(S2CellId value, long long t) { + return ts2cell_make(value, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +TInstant * ts2cellinst_make_w(S2CellId value, long long t) { + return ts2cellinst_make(value, (TimestampTz) t); +} + +EMSCRIPTEN_KEEPALIVE +TSequence * ts2cellseq_make_w(const S2CellId * values, const TimestampTz * times, int count, int lower_inc, int upper_inc) { + return ts2cellseq_make(values, times, count, (bool) lower_inc, (bool) upper_inc); +} + +EMSCRIPTEN_KEEPALIVE +TSequenceSet * ts2cellseqset_make_w(const TSequence ** sequences, int count) { + return ts2cellseqset_make(sequences, count); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId ts2cell_start_value_w(const Temporal * temp) { + return ts2cell_start_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId ts2cell_end_value_w(const Temporal * temp) { + return ts2cell_end_value(temp); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId ts2cell_value_n_w(const Temporal * temp, int n) { + S2CellId r; + if (!ts2cell_value_n(temp, n, &r)) return 0; + return r; +} + +EMSCRIPTEN_KEEPALIVE +S2CellId * ts2cell_values_w(const Temporal * temp, int * count) { + return ts2cell_values(temp, count); +} + +EMSCRIPTEN_KEEPALIVE +S2CellId ts2cell_value_at_timestamptz_w(const Temporal * temp, long long t, int strict) { + S2CellId r; + if (!ts2cell_value_at_timestamptz(temp, (TimestampTz) t, (bool) strict, &r)) return 0; + return r; +} + +EMSCRIPTEN_KEEPALIVE +Set * s2cell_to_set_w(S2CellId cell) { + return s2cell_to_set(cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tbigint_to_ts2cell_w(const Temporal * temp) { + return tbigint_to_ts2cell(temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * ts2cell_to_tbigint_w(const Temporal * temp) { + return ts2cell_to_tbigint(temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return ever_eq_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return ever_eq_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return ever_ne_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return ever_ne_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return always_eq_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return always_eq_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return always_ne_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return always_ne_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +int ever_eq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return ever_eq_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int ever_ne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return ever_ne_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_eq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return always_eq_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +int always_ne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return always_ne_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return teq_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return teq_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * teq_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return teq_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_s2cell_ts2cell_w(S2CellId cell, const Temporal * temp) { + return tne_s2cell_ts2cell(cell, temp); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_ts2cell_s2cell_w(const Temporal * temp, S2CellId cell) { + return tne_ts2cell_s2cell(temp, cell); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * tne_ts2cell_ts2cell_w(const Temporal * temp1, const Temporal * temp2) { + return tne_ts2cell_ts2cell(temp1, temp2); +} + +EMSCRIPTEN_KEEPALIVE +Temporal * ts2cell_cell_to_token_w(const Temporal * temp) { + return ts2cell_cell_to_token(temp); +} + + +/* === pg_bool.h === */ + +EMSCRIPTEN_KEEPALIVE +int bool_eq_w(int arg1, int arg2) { + return (int) bool_eq((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +int bool_ge_w(int arg1, int arg2) { + return (int) bool_ge((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +int bool_gt_w(int arg1, int arg2) { + return (int) bool_gt((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t bool_hash_w(int arg) { + return bool_hash((bool) arg); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t bool_hash_extended_w(int arg, int64_t seed) { + return bool_hash_extended((bool) arg, seed); +} + +EMSCRIPTEN_KEEPALIVE +int bool_le_w(int arg1, int arg2) { + return (int) bool_le((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +int bool_lt_w(int arg1, int arg2) { + return (int) bool_lt((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +int bool_ne_w(int arg1, int arg2) { + return (int) bool_ne((bool) arg1, (bool) arg2); +} + +EMSCRIPTEN_KEEPALIVE +char * bool_to_text_w(int b) { + text *_t = bool_to_text((bool) b); + if (!_t) return NULL; + return text_to_cstring(_t); +} + + +/* === pg_date.h === */ + +EMSCRIPTEN_KEEPALIVE +DateADT add_date_int_w(DateADT date, int32 days) { + return add_date_int(date, days); +} + +EMSCRIPTEN_KEEPALIVE +DateADT add_date_interval_w(DateADT date, Interval * interv) { + return add_date_interval(date, interv); +} + +EMSCRIPTEN_KEEPALIVE +int32 cmp_date_timestamp_w(DateADT date, long long ts) { + return cmp_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int cmp_date_date_w(DateADT date1, DateADT date2) { + return cmp_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int32 cmp_date_timestamptz_w(DateADT date, long long tstz) { + return cmp_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int32 cmp_timestamp_date_w(long long ts, DateADT date) { + return cmp_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int32 cmp_timestamptz_date_w(long long tstz, DateADT date) { + return cmp_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +Numeric date_extract_w(DateADT date, const char * units) { + return date_extract(date, cstring_to_text(units)); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t date_hash_w(DateADT date) { + return date_hash(date); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t date_hash_extended_w(DateADT date, int64_t seed) { + return date_hash_extended(date, seed); +} + +EMSCRIPTEN_KEEPALIVE +int date_is_finite_w(DateADT date) { + return (int) date_is_finite(date); +} + +EMSCRIPTEN_KEEPALIVE +DateADT date_larger_w(DateADT date1, DateADT date2) { + return date_larger(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +DateADT date_make_w(int year, int mon, int mday) { + return date_make(year, mon, mday); +} + +EMSCRIPTEN_KEEPALIVE +DateADT date_smaller_w(DateADT date1, DateADT date2) { + return date_smaller(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +long long date_time_to_timestamp_w(DateADT date, TimeADT time) { + return date_time_to_timestamp(date, time); +} + +EMSCRIPTEN_KEEPALIVE +long long date_to_timestamp_w(DateADT date) { + return date_to_timestamp(date); +} + +EMSCRIPTEN_KEEPALIVE +long long date_to_timestamptz_w(DateADT date) { + return date_to_timestamptz(date); +} + +EMSCRIPTEN_KEEPALIVE +int eq_date_date_w(DateADT date1, DateADT date2) { + return (int) eq_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int eq_date_timestamp_w(DateADT date, long long ts) { + return (int) eq_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int eq_date_timestamptz_w(DateADT date, long long tstz) { + return (int) eq_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int eq_timestamp_date_w(long long ts, DateADT date) { + return (int) eq_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int eq_timestamptz_date_w(long long tstz, DateADT date) { + return (int) eq_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +int ge_date_date_w(DateADT date1, DateADT date2) { + return (int) ge_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int ge_date_timestamp_w(DateADT date, long long ts) { + return (int) ge_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int ge_date_timestamptz_w(DateADT date, long long tstz) { + return (int) ge_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int ge_timestamp_date_w(long long ts, DateADT date) { + return (int) ge_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int ge_timestamptz_date_w(long long tstz, DateADT date) { + return (int) ge_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +int gt_date_date_w(DateADT date1, DateADT date2) { + return (int) gt_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int gt_date_timestamp_w(DateADT date, long long ts) { + return (int) gt_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int gt_date_timestamptz_w(DateADT date, long long tstz) { + return (int) gt_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int gt_timestamp_date_w(long long ts, DateADT date) { + return (int) gt_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int gt_timestamptz_date_w(long long tstz, DateADT date) { + return (int) gt_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +int le_date_date_w(DateADT date1, DateADT date2) { + return (int) le_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int le_date_timestamp_w(DateADT date, long long ts) { + return (int) le_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int le_date_timestamptz_w(DateADT date, long long tstz) { + return (int) le_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int le_timestamp_date_w(long long ts, DateADT date) { + return (int) le_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int le_timestamptz_date_w(long long tstz, DateADT date) { + return (int) le_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +int lt_date_date_w(DateADT date1, DateADT date2) { + return (int) lt_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int lt_date_timestamp_w(DateADT date, long long ts) { + return (int) lt_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int lt_date_timestamptz_w(DateADT date, long long tstz) { + return (int) lt_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int lt_timestamp_date_w(long long ts, DateADT date) { + return (int) lt_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int lt_timestamptz_date_w(long long tstz, DateADT date) { + return (int) lt_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +int32 minus_date_date_w(DateADT date1, DateADT date2) { + return minus_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +DateADT minus_date_int_w(DateADT date, int32 days) { + return minus_date_int(date, days); +} + +EMSCRIPTEN_KEEPALIVE +DateADT minus_date_interval_w(DateADT date, Interval * span) { + return minus_date_interval(date, span); +} + +EMSCRIPTEN_KEEPALIVE +int ne_date_date_w(DateADT date1, DateADT date2) { + return (int) ne_date_date(date1, date2); +} + +EMSCRIPTEN_KEEPALIVE +int ne_date_timestamp_w(DateADT date, long long ts) { + return (int) ne_date_timestamp(date, (Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +int ne_date_timestamptz_w(DateADT date, long long tstz) { + return (int) ne_date_timestamptz(date, (TimestampTz) tstz); +} + +EMSCRIPTEN_KEEPALIVE +int ne_timestamp_date_w(long long ts, DateADT date) { + return (int) ne_timestamp_date((Timestamp) ts, date); +} + +EMSCRIPTEN_KEEPALIVE +int ne_timestamptz_date_w(long long tstz, DateADT date) { + return (int) ne_timestamptz_date((TimestampTz) tstz, date); +} + +EMSCRIPTEN_KEEPALIVE +DateADT timestamp_to_date_w(long long ts) { + return timestamp_to_date((Timestamp) ts); +} + +EMSCRIPTEN_KEEPALIVE +DateADT timestamptz_to_date_w(long long tstz) { + return timestamptz_to_date((TimestampTz) tstz); +} + + +/* === pg_float.h === */ + +EMSCRIPTEN_KEEPALIVE +float8 add_float8_float8_w(float8 num1, float8 num2) { + return add_float8_float8(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +float8 div_float8_float8_w(float8 num1, float8 num2) { + return div_float8_float8(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int eq_float8_float8_w(float8 num1, float8 num2) { + return (int) eq_float8_float8(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_abs_w(float8 num) { + return float8_abs(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_ceil_w(float8 num) { + return float8_ceil(num); +} + +EMSCRIPTEN_KEEPALIVE +int float8_cmp_w(float8 num1, float8 num2) { + return float8_cmp(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_cos_w(float8 num) { + return float8_cos(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_degrees_w(float8 num) { + return float8_degrees(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_exp_w(float8 num) { + return float8_exp(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_floor_w(float8 num) { + return float8_floor(num); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t float8_hash_w(float8 num) { + return float8_hash(num); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t float8_hash_extended_w(float8 num, uint64_t seed) { + return float8_hash_extended(num, seed); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_in_w(const char * str) { + return float8_in(str); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_ln_w(float8 num) { + return float8_ln(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_log10_w(float8 num) { + return float8_log10(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_radians_w(float8 num) { + return float8_radians(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_sin_w(float8 num) { + return float8_sin(num); +} + +EMSCRIPTEN_KEEPALIVE +float8 float8_tan_w(float8 num) { + return float8_tan(num); +} + +EMSCRIPTEN_KEEPALIVE +int ge_float8_float8_w(float8 num1, float8 num2) { + return (int) ge_float8_float8(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int gt_float8_float8_w(float8 num1, float8 num2) { + return (int) gt_float8_float8(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int le_float8_float8_w(float8 num1, float8 num2) { + return (int) le_float8_float8(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequence * trgeometryseq_make_w(const GSERIALIZED * geom, TInstant ** instants, int count, int lower_inc, int upper_inc, interpType interp, int normalize) { - return trgeometryseq_make(geom, instants, count, (bool) lower_inc, (bool) upper_inc, interp, (bool) normalize); +int lt_float8_float8_w(float8 num1, float8 num2) { + return (int) lt_float8_float8(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * trgeometryseqset_make_w(const GSERIALIZED * geom, TSequence ** sequences, int count, int normalize) { - return trgeometryseqset_make(geom, sequences, count, (bool) normalize); +float8 minus_float8_float8_w(float8 num1, float8 num2) { + return minus_float8_float8(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * trgeometryseqset_make_gaps_w(const GSERIALIZED * geom, TInstant ** instants, int count, interpType interp, const Interval * maxt, double maxdist) { - return trgeometryseqset_make_gaps(geom, instants, count, interp, maxt, maxdist); +float8 mul_float8_float8_w(float8 num1, float8 num2) { + return mul_float8_float8(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * geometry_tpose_to_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return geometry_tpose_to_trgeometry(gs, temp); +int ne_float8_float8_w(float8 num1, float8 num2) { + return (int) ne_float8_float8(num1, num2); } + +/* === pg_int.h === */ + EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_to_tpose_w(const Temporal * temp) { - return trgeometry_to_tpose(temp); +int32 add_int32_int32_w(int32 num1, int32 num2) { + return add_int32_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_to_tgeompoint_w(const Temporal * temp) { - return trgeometry_to_tgeompoint(temp); +int64_t add_int64_int64_w(int64_t num1, int64_t num2) { + return add_int64_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_to_tgeometry_w(const Temporal * temp) { - return trgeometry_to_tgeometry(temp); +int32 div_int32_int32_w(int32 num1, int32 num2) { + return div_int32_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -TInstant * trgeometry_end_instant_w(const Temporal * temp) { - return trgeometry_end_instant(temp); +int64_t div_int64_int64_w(int64_t num1, int64_t num2) { + return div_int64_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequence * trgeometry_end_sequence_w(const Temporal * temp) { - return trgeometry_end_sequence(temp); +int eq_int32_int32_w(int32 num1, int32 num2) { + return (int) eq_int32_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_end_value_w(const Temporal * temp) { - return trgeometry_end_value(temp); +int eq_int32_int64_w(int32 num1, int64_t num2) { + return (int) eq_int32_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_geom_w(const Temporal * temp) { - return trgeometry_geom(temp); +int eq_int64_int32_w(int64_t num1, int32 num2) { + return (int) eq_int64_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -TInstant * trgeometry_instant_n_w(const Temporal * temp, int n) { - return trgeometry_instant_n(temp, n); +int eq_int64_int64_w(int64_t num1, int64_t num2) { + return (int) eq_int64_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -TInstant ** trgeometry_instants_w(const Temporal * temp, int * count) { - return trgeometry_instants(temp, count); +int ge_int32_int32_w(int32 num1, int32 num2) { + return (int) ge_int32_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -Set * trgeometry_points_w(const Temporal * temp) { - return trgeometry_points(temp); +int ge_int32_int64_w(int32 num1, int64_t num2) { + return (int) ge_int32_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_yaw_w(const Temporal * temp) { - return trgeometry_yaw(temp); +int ge_int64_int32_w(int64_t num1, int32 num2) { + return (int) ge_int64_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_pitch_w(const Temporal * temp) { - return trgeometry_pitch(temp); +int ge_int64_int64_w(int64_t num1, int64_t num2) { + return (int) ge_int64_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_roll_w(const Temporal * temp) { - return trgeometry_roll(temp); +int gt_int32_int32_w(int32 num1, int32 num2) { + return (int) gt_int32_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequence ** trgeometry_segments_w(const Temporal * temp, int * count) { - return trgeometry_segments(temp, count); +int gt_int32_int64_w(int32 num1, int64_t num2) { + return (int) gt_int32_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequence * trgeometry_sequence_n_w(const Temporal * temp, int i) { - return trgeometry_sequence_n(temp, i); +int gt_int64_int32_w(int64_t num1, int32 num2) { + return (int) gt_int64_int32(num1, num2); } EMSCRIPTEN_KEEPALIVE -TSequence ** trgeometry_sequences_w(const Temporal * temp, int * count) { - return trgeometry_sequences(temp, count); +int gt_int64_int64_w(int64_t num1, int64_t num2) { + return (int) gt_int64_int64(num1, num2); } EMSCRIPTEN_KEEPALIVE -TInstant * trgeometry_start_instant_w(const Temporal * temp) { - return trgeometry_start_instant(temp); +int32 int32_abs_w(int32 num) { + return int32_abs(num); } EMSCRIPTEN_KEEPALIVE -TSequence * trgeometry_start_sequence_w(const Temporal * temp) { - return trgeometry_start_sequence(temp); +int int32_cmp_w(int32 l, int32 r) { + return int32_cmp(l, r); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_start_value_w(const Temporal * temp) { - return trgeometry_start_value(temp); +uint32_t int32_hash_w(int32 val) { + return int32_hash(val); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_value_n_w(const Temporal * temp, int n) { - GSERIALIZED * r; - if (!trgeometry_value_n(temp, n, &r)) return NULL; - return r; +uint64_t int32_hash_extended_w(int32 val, uint64_t seed) { + return int32_hash_extended(val, seed); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_traversed_area_w(const Temporal * temp, int unary_union) { - return trgeometry_traversed_area(temp, (bool) unary_union); +int32 int32_in_w(const char * str) { + return int32_in(str); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_centroid_w(const Temporal * temp) { - return trgeometry_centroid(temp); +char * int32_out_w(int32 num) { + return int32_out(num); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_convex_hull_w(const Temporal * temp) { - return trgeometry_convex_hull(temp); +int64_t int64_abs_w(int64_t num) { + return int64_abs(num); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_body_point_trajectory_w(const Temporal * temp, const GSERIALIZED * gs) { - return trgeometry_body_point_trajectory(temp, gs); +int int64_cmp_w(int64_t l, int64_t r) { + return int64_cmp(l, r); } EMSCRIPTEN_KEEPALIVE -STBox * trgeometry_space_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const GSERIALIZED * sorigin, int bitmatrix, int border_inc, int * count) { - return trgeometry_space_boxes(temp, xsize, ysize, zsize, sorigin, (bool) bitmatrix, (bool) border_inc, count); +uint32_t int64_hash_w(int64_t num) { + return int64_hash(num); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t int64_hash_extended_w(int64_t num, uint64_t seed) { + return int64_hash_extended(num, seed); +} + +EMSCRIPTEN_KEEPALIVE +int64_t int64_in_w(const char * str) { + return int64_in(str); +} + +EMSCRIPTEN_KEEPALIVE +char * int64_out_w(int64_t num) { + return int64_out(num); +} + +EMSCRIPTEN_KEEPALIVE +int le_int32_int32_w(int32 num1, int32 num2) { + return (int) le_int32_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int le_int32_int64_w(int32 num1, int64_t num2) { + return (int) le_int32_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int le_int64_int32_w(int64_t num1, int32 num2) { + return (int) le_int64_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int le_int64_int64_w(int64_t num1, int64_t num2) { + return (int) le_int64_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int lt_int32_int32_w(int32 num1, int32 num2) { + return (int) lt_int32_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int lt_int32_int64_w(int32 num1, int64_t num2) { + return (int) lt_int32_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int lt_int64_int32_w(int64_t num1, int32 num2) { + return (int) lt_int64_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int lt_int64_int64_w(int64_t num1, int64_t num2) { + return (int) lt_int64_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int32 minus_int32_int32_w(int32 num1, int32 num2) { + return minus_int32_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int64_t minus_int64_int64_w(int64_t num1, int64_t num2) { + return minus_int64_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int32 mul_int32_int32_w(int32 num1, int32 num2) { + return mul_int32_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int64_t mul_int64_int64_w(int64_t num1, int64_t num2) { + return mul_int64_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int ne_int32_int32_w(int32 num1, int32 num2) { + return (int) ne_int32_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int ne_int32_int64_w(int32 num1, int64_t num2) { + return (int) ne_int32_int64(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int ne_int64_int32_w(int64_t num1, int32 num2) { + return (int) ne_int64_int32(num1, num2); +} + +EMSCRIPTEN_KEEPALIVE +int ne_int64_int64_w(int64_t num1, int64_t num2) { + return (int) ne_int64_int64(num1, num2); +} + + +/* === pg_interval.h === */ + +EMSCRIPTEN_KEEPALIVE +Interval * add_interval_interval_w(const Interval * interv1, const Interval * interv2) { + return add_interval_interval(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Interval * div_interval_float8_w(const Interval * interv, float8 factor) { + return div_interval_float8(interv, factor); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_copy_w(const Interval * interv) { + return interval_copy(interv); +} + +EMSCRIPTEN_KEEPALIVE +int interval_eq_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_eq(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Numeric interval_extract_w(const Interval * interv, const char * units) { + return interval_extract(interv, cstring_to_text(units)); +} + +EMSCRIPTEN_KEEPALIVE +int interval_ge_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_ge(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +int interval_gt_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_gt(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +uint32_t interval_hash_w(const Interval * interv) { + return interval_hash(interv); +} + +EMSCRIPTEN_KEEPALIVE +uint64_t interval_hash_extended_w(const Interval * interv, uint64_t seed) { + return interval_hash_extended(interv, seed); +} + +EMSCRIPTEN_KEEPALIVE +int interval_is_finite_w(const Interval * interv) { + return (int) interval_is_finite(interv); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_justify_days_w(const Interval * interv) { + return interval_justify_days(interv); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_justify_hours_w(const Interval * interv) { + return interval_justify_hours(interv); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_justify_interval_w(const Interval * interv) { + return interval_justify_interval(interv); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_larger_w(const Interval * interv1, const Interval * interv2) { + return interval_larger(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +int interval_le_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_le(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +int interval_lt_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_lt(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_make_w(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, float8 secs) { + return interval_make(years, months, weeks, days, hours, mins, secs); +} + +EMSCRIPTEN_KEEPALIVE +int interval_ne_w(const Interval * interv1, const Interval * interv2) { + return (int) interval_ne(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_negate_w(const Interval * interv) { + return interval_negate(interv); +} + +EMSCRIPTEN_KEEPALIVE +float8 interval_part_w(const Interval * interv, const char * units) { + return interval_part(interv, cstring_to_text(units)); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_scale_w(const Interval * interv, int32 typmod) { + return interval_scale(interv, typmod); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_smaller_w(const Interval * interv1, const Interval * interv2) { + return interval_smaller(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Interval * interval_trunc_w(const Interval * interv, const char * units) { + return interval_trunc(interv, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -STBox * trgeometry_space_time_boxes_w(const Temporal * temp, double xsize, double ysize, double zsize, const Interval * duration, const GSERIALIZED * sorigin, long long torigin, int bitmatrix, int border_inc, int * count) { - return trgeometry_space_time_boxes(temp, xsize, ysize, zsize, duration, sorigin, (TimestampTz) torigin, (bool) bitmatrix, (bool) border_inc, count); +Interval * minus_interval_interval_w(const Interval * interv1, const Interval * interv2) { + return minus_interval_interval(interv1, interv2); +} + +EMSCRIPTEN_KEEPALIVE +Interval * mul_float8_interval_w(float8 factor, const Interval * interv) { + return mul_float8_interval(factor, interv); +} + +EMSCRIPTEN_KEEPALIVE +Interval * mul_interval_float8_w(const Interval * interv, float8 factor) { + return mul_interval_float8(interv, factor); +} + + +/* === pg_text.h === */ + +EMSCRIPTEN_KEEPALIVE +int text_eq_w(const char * txt1, const char * txt2) { + return (int) text_eq(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -STBox * trgeometry_stboxes_w(const Temporal * temp, int * count) { - return trgeometry_stboxes(temp, count); +int text_ge_w(const char * txt1, const char * txt2) { + return (int) text_ge(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -STBox * trgeometry_split_n_stboxes_w(const Temporal * temp, int box_count, int * count) { - return trgeometry_split_n_stboxes(temp, box_count, count); +int text_gt_w(const char * txt1, const char * txt2) { + return (int) text_gt(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -STBox * trgeometry_split_each_n_stboxes_w(const Temporal * temp, int elem_count, int * count) { - return trgeometry_split_each_n_stboxes(temp, elem_count, count); +uint32_t text_hash_w(const char * txt, Oid collid) { + return text_hash(cstring_to_text(txt), collid); } EMSCRIPTEN_KEEPALIVE -double trgeometry_hausdorff_distance_w(const Temporal * temp1, const Temporal * temp2) { - return trgeometry_hausdorff_distance(temp1, temp2); +uint64_t text_hash_extended_w(const char * txt, uint64_t seed, Oid collid) { + return text_hash_extended(cstring_to_text(txt), seed, collid); } EMSCRIPTEN_KEEPALIVE -double trgeometry_frechet_distance_w(const Temporal * temp1, const Temporal * temp2) { - return trgeometry_frechet_distance(temp1, temp2); +int text_le_w(const char * txt1, const char * txt2) { + return (int) text_le(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -double trgeometry_dyntimewarp_distance_w(const Temporal * temp1, const Temporal * temp2) { - return trgeometry_dyntimewarp_distance(temp1, temp2); +int text_lt_w(const char * txt1, const char * txt2) { + return (int) text_lt(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -Match * trgeometry_frechet_path_w(const Temporal * temp1, const Temporal * temp2, int * count) { - return trgeometry_frechet_path(temp1, temp2, count); +int text_ne_w(const char * txt1, const char * txt2) { + return (int) text_ne(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -Match * trgeometry_dyntimewarp_path_w(const Temporal * temp1, const Temporal * temp2, int * count) { - return trgeometry_dyntimewarp_path(temp1, temp2, count); +int text_pattern_ge_w(const char * txt1, const char * txt2) { + return (int) text_pattern_ge(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -double trgeometry_length_w(const Temporal * temp) { - return trgeometry_length(temp); +int text_pattern_gt_w(const char * txt1, const char * txt2) { + return (int) text_pattern_gt(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_cumulative_length_w(const Temporal * temp) { - return trgeometry_cumulative_length(temp); +int text_pattern_le_w(const char * txt1, const char * txt2) { + return (int) text_pattern_le(cstring_to_text(txt1), cstring_to_text(txt2)); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_angular_speed_w(const Temporal * temp) { - return trgeometry_angular_speed(temp); +int text_pattern_lt_w(const char * txt1, const char * txt2) { + return (int) text_pattern_lt(cstring_to_text(txt1), cstring_to_text(txt2)); } + +/* === pg_time.h === */ + EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_speed_w(const Temporal * temp) { - return trgeometry_speed(temp); +long long date_timetz_to_timestamptz_w(DateADT date, const TimeTzADT * timetz) { + return date_timetz_to_timestamptz(date, timetz); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * trgeometry_twcentroid_w(const Temporal * temp) { - return trgeometry_twcentroid(temp); +TimeADT interval_to_time_w(const Interval * interv) { + return interval_to_time(interv); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_append_tinstant_w(Temporal * temp, const TInstant * inst, interpType interp, double maxdist, const Interval * maxt, int expand) { - return trgeometry_append_tinstant(temp, inst, interp, maxdist, maxt, (bool) expand); +TimeADT minus_time_interval_w(TimeADT time, const Interval * interv) { + return minus_time_interval(time, interv); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_append_tsequence_w(Temporal * temp, const TSequence * seq, int expand) { - return trgeometry_append_tsequence(temp, seq, (bool) expand); +Interval * minus_time_time_w(TimeADT time1, TimeADT time2) { + return minus_time_time(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_delete_timestamptz_w(const Temporal * temp, long long t, int connect) { - return trgeometry_delete_timestamptz(temp, (TimestampTz) t, (bool) connect); +TimeTzADT * minus_timetz_interval_w(const TimeTzADT * timetz, const Interval * interv) { + return minus_timetz_interval(timetz, interv); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_delete_tstzset_w(const Temporal * temp, const Set * s, int connect) { - return trgeometry_delete_tstzset(temp, s, (bool) connect); +TimeADT plus_time_interval_w(TimeADT time, Interval * interv) { + return plus_time_interval(time, interv); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_delete_tstzspan_w(const Temporal * temp, const Span * s, int connect) { - return trgeometry_delete_tstzspan(temp, s, (bool) connect); +TimeTzADT * plus_timetz_interval_w(const TimeTzADT * timetz, const Interval * interv) { + return plus_timetz_interval(timetz, interv); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_delete_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int connect) { - return trgeometry_delete_tstzspanset(temp, ss, (bool) connect); +int time_cmp_w(TimeADT time1, TimeADT time2) { + return time_cmp(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_merge_w(const Temporal * temp1, const Temporal * temp2) { - return trgeometry_merge(temp1, temp2); +int time_eq_w(TimeADT time1, TimeADT time2) { + return (int) time_eq(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_merge_array_w(Temporal ** temparr, int count) { - return trgeometry_merge_array(temparr, count); +Numeric time_extract_w(TimeADT time, const char * units) { + return time_extract(time, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_round_w(const Temporal * temp, int maxdd) { - return trgeometry_round(temp, maxdd); +int time_ge_w(TimeADT time1, TimeADT time2) { + return (int) time_ge(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_set_interp_w(const Temporal * temp, interpType interp) { - return trgeometry_set_interp(temp, interp); +int time_gt_w(TimeADT time1, TimeADT time2) { + return (int) time_gt(time1, time2); } EMSCRIPTEN_KEEPALIVE -TInstant * trgeometry_as_tinstant_w(const Temporal * temp) { - return trgeometry_as_tinstant(temp); +uint32_t time_hash_w(TimeADT time) { + return time_hash(time); } EMSCRIPTEN_KEEPALIVE -TSequence * trgeometry_as_tsequence_w(const Temporal * temp, const char * interp_str) { - return trgeometry_as_tsequence(temp, interp_str); +uint64_t time_hash_extended_w(TimeADT time, int32 seed) { + return time_hash_extended(time, seed); } EMSCRIPTEN_KEEPALIVE -TSequenceSet * trgeometry_as_tsequenceset_w(const Temporal * temp, const char * interp_str) { - return trgeometry_as_tsequenceset(temp, interp_str); +TimeADT time_larger_w(TimeADT time1, TimeADT time2) { + return time_larger(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_after_timestamptz_w(const Temporal * temp, long long t, int strict) { - return trgeometry_after_timestamptz(temp, (TimestampTz) t, (bool) strict); +int time_le_w(TimeADT time1, TimeADT time2) { + return (int) time_le(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_before_timestamptz_w(const Temporal * temp, long long t, int strict) { - return trgeometry_before_timestamptz(temp, (TimestampTz) t, (bool) strict); +int time_lt_w(TimeADT time1, TimeADT time2) { + return (int) time_lt(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_restrict_values_w(const Temporal * temp, const Set * s, int atfunc) { - return trgeometry_restrict_values(temp, s, (bool) atfunc); +TimeADT time_make_w(int tm_hour, int tm_min, double sec) { + return time_make(tm_hour, tm_min, sec); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_restrict_timestamptz_w(const Temporal * temp, long long t, int atfunc) { - return trgeometry_restrict_timestamptz(temp, (TimestampTz) t, (bool) atfunc); +int time_ne_w(TimeADT time1, TimeADT time2) { + return (int) time_ne(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_restrict_tstzset_w(const Temporal * temp, const Set * s, int atfunc) { - return trgeometry_restrict_tstzset(temp, s, (bool) atfunc); +int time_overlaps_w(TimeADT ts1, TimeADT te1, TimeADT ts2, TimeADT te2) { + return (int) time_overlaps(ts1, te1, ts2, te2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_restrict_tstzspan_w(const Temporal * temp, const Span * s, int atfunc) { - return trgeometry_restrict_tstzspan(temp, s, (bool) atfunc); +float8 time_part_w(TimeADT time, const char * units) { + return time_part(time, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_restrict_tstzspanset_w(const Temporal * temp, const SpanSet * ss, int atfunc) { - return trgeometry_restrict_tstzspanset(temp, ss, (bool) atfunc); +TimeADT time_scale_w(TimeADT date, int32 typmod) { + return time_scale(date, typmod); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_geom_w(const Temporal * temp, const GSERIALIZED * gs) { - return trgeometry_at_geom(temp, gs); +TimeADT time_smaller_w(TimeADT time1, TimeADT time2) { + return time_smaller(time1, time2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_geom_w(const Temporal * temp, const GSERIALIZED * gs) { - return trgeometry_minus_geom(temp, gs); +Interval * time_to_interval_w(TimeADT time) { + return time_to_interval(time); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { - return trgeometry_at_stbox(temp, box, (bool) border_inc); +TimeTzADT * time_to_timetz_w(TimeADT time) { + return time_to_timetz(time); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_stbox_w(const Temporal * temp, const STBox * box, int border_inc) { - return trgeometry_minus_stbox(temp, box, (bool) border_inc); +TimeADT timestamp_to_time_w(long long ts) { + return timestamp_to_time((Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_value_w(const Temporal * temp, const Pose * pose) { - return trgeometry_at_value(temp, pose); +TimeADT timestamptz_to_time_w(long long tztz) { + return timestamptz_to_time((TimestampTz) tztz); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_value_w(const Temporal * temp, const Pose * pose) { - return trgeometry_minus_value(temp, pose); +TimeTzADT * timestamptz_to_timetz_w(long long tztz) { + return timestamptz_to_timetz((TimestampTz) tztz); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_values_w(const Temporal * temp, const Set * s) { - return trgeometry_at_values(temp, s); +TimeTzADT * timetz_at_local_w(const TimeTzADT * timetz) { + return timetz_at_local(timetz); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_values_w(const Temporal * temp, const Set * s) { - return trgeometry_minus_values(temp, s); +int32 timetz_cmp_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return timetz_cmp(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_timestamptz_w(const Temporal * temp, long long t) { - return trgeometry_at_timestamptz(temp, (TimestampTz) t); +int timetz_eq_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_eq(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_timestamptz_w(const Temporal * temp, long long t) { - return trgeometry_minus_timestamptz(temp, (TimestampTz) t); +Numeric timetz_extract_w(const TimeTzADT * timetz, const char * units) { + return timetz_extract(timetz, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_tstzset_w(const Temporal * temp, const Set * s) { - return trgeometry_at_tstzset(temp, s); +int timetz_ge_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_ge(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_tstzset_w(const Temporal * temp, const Set * s) { - return trgeometry_minus_tstzset(temp, s); +int timetz_gt_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_gt(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_tstzspan_w(const Temporal * temp, const Span * s) { - return trgeometry_at_tstzspan(temp, s); +uint32_t timetz_hash_w(const TimeTzADT * timetz) { + return timetz_hash(timetz); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_tstzspan_w(const Temporal * temp, const Span * s) { - return trgeometry_minus_tstzspan(temp, s); +uint64_t timetz_hash_extended_w(const TimeTzADT * timetz, int64_t seed) { + return timetz_hash_extended(timetz, seed); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_tstzspanset_w(const Temporal * temp, const SpanSet * ss) { - return trgeometry_at_tstzspanset(temp, ss); +TimeTzADT * timetz_in_w(const char * str, int32 typmod) { + return timetz_in(str, typmod); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_tstzspanset_w(const Temporal * temp, const SpanSet * ss) { - return trgeometry_minus_tstzspanset(temp, ss); +TimeTzADT * timetz_izone_w(const TimeTzADT * timetz, const Interval * zone) { + return timetz_izone(timetz, zone); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_at_elevation_w(const Temporal * temp, const Span * s) { - return trgeometry_at_elevation(temp, s); +TimeTzADT * timetz_larger_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return timetz_larger(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * trgeometry_minus_elevation_w(const Temporal * temp, const Span * s) { - return trgeometry_minus_elevation(temp, s); +int timetz_le_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_le(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return tdistance_trgeometry_geo(temp, gs); +int timetz_lt_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_lt(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { - return tdistance_trgeometry_tpoint(temp1, temp2); +int timetz_ne_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return (int) timetz_ne(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -Temporal * tdistance_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return tdistance_trgeometry_trgeometry(temp1, temp2); +TimeTzADT * timetz_copy_w(const TimeTzADT * timetz) { + return timetz_copy(timetz); } EMSCRIPTEN_KEEPALIVE -double nad_stbox_trgeometry_w(const STBox * box, const Temporal * temp) { - return nad_stbox_trgeometry(box, temp); +char * timetz_out_w(const TimeTzADT * timetz) { + return timetz_out(timetz); } EMSCRIPTEN_KEEPALIVE -double nad_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return nad_trgeometry_geo(temp, gs); +int timetz_overlaps_w(const TimeTzADT * ts1, const TimeTzADT * te1, const TimeTzADT * ts2, const TimeTzADT * te2) { + return (int) timetz_overlaps(ts1, te1, ts2, te2); } EMSCRIPTEN_KEEPALIVE -double nad_trgeometry_stbox_w(const Temporal * temp, const STBox * box) { - return nad_trgeometry_stbox(temp, box); +float8 timetz_part_w(const TimeTzADT * timetz, const char * units) { + return timetz_part(timetz, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -double nad_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { - return nad_trgeometry_tpoint(temp1, temp2); +TimeTzADT * timetz_scale_w(const TimeTzADT * timetz, int32 typmod) { + return timetz_scale(timetz, typmod); } EMSCRIPTEN_KEEPALIVE -double nad_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return nad_trgeometry_trgeometry(temp1, temp2); +TimeTzADT * timetz_smaller_w(const TimeTzADT * timetz1, const TimeTzADT * timetz2) { + return timetz_smaller(timetz1, timetz2); } EMSCRIPTEN_KEEPALIVE -TInstant * nai_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return nai_trgeometry_geo(temp, gs); +TimeADT timetz_to_time_w(const TimeTzADT * timetz) { + return timetz_to_time(timetz); } EMSCRIPTEN_KEEPALIVE -TInstant * nai_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { - return nai_trgeometry_tpoint(temp1, temp2); +TimeTzADT * timetz_zone_w(const TimeTzADT * timetz, const char * zone) { + return timetz_zone(timetz, cstring_to_text(zone)); } + +/* === pg_timestamp.h === */ + EMSCRIPTEN_KEEPALIVE -TInstant * nai_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return nai_trgeometry_trgeometry(temp1, temp2); +long long add_timestamp_interval_w(long long ts, const Interval * interv) { + return add_timestamp_interval((Timestamp) ts, interv); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return shortestline_trgeometry_geo(temp, gs); +long long add_timestamptz_interval_w(long long tstz, const Interval * interv) { + return add_timestamptz_interval((TimestampTz) tstz, interv); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_trgeometry_tpoint_w(const Temporal * temp1, const Temporal * temp2) { - return shortestline_trgeometry_tpoint(temp1, temp2); +long long add_timestamptz_interval_at_zone_w(long long tstz, const Interval * interv, const char * zone) { + return add_timestamptz_interval_at_zone((TimestampTz) tstz, interv, cstring_to_text(zone)); } EMSCRIPTEN_KEEPALIVE -GSERIALIZED * shortestline_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return shortestline_trgeometry_trgeometry(temp1, temp2); +int32 cmp_timestamp_timestamp_w(long long ts1, long long ts2) { + return cmp_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int always_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return always_eq_geo_trgeometry(gs, temp); +int32 cmp_timestamp_timestamptz_w(long long ts, long long tstz) { + return cmp_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int always_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return always_eq_trgeometry_geo(temp, gs); +int32 cmp_timestamptz_timestamp_w(long long tstz, long long ts) { + return cmp_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int always_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return always_eq_trgeometry_trgeometry(temp1, temp2); +int eq_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) eq_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int always_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return always_ne_geo_trgeometry(gs, temp); +int eq_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) eq_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int always_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return always_ne_trgeometry_geo(temp, gs); +int eq_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) eq_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int always_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return always_ne_trgeometry_trgeometry(temp1, temp2); +int eq_timestamptz_timestamptz_w(long long tstz1, long long tstz2) { + return (int) eq_timestamptz_timestamptz((TimestampTz) tstz1, (TimestampTz) tstz2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return ever_eq_geo_trgeometry(gs, temp); +long long float8_to_timestamptz_w(float8 seconds) { + return float8_to_timestamptz(seconds); } EMSCRIPTEN_KEEPALIVE -int ever_eq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return ever_eq_trgeometry_geo(temp, gs); +int gt_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) gt_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int ever_eq_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return ever_eq_trgeometry_trgeometry(temp1, temp2); +int gt_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) gt_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int ever_ne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return ever_ne_geo_trgeometry(gs, temp); +int gt_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) gt_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int ever_ne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return ever_ne_trgeometry_geo(temp, gs); +int ge_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) ge_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int ever_ne_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return ever_ne_trgeometry_trgeometry(temp1, temp2); +int ge_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) ge_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return teq_geo_trgeometry(gs, temp); +int ge_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) ge_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -Temporal * teq_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return teq_trgeometry_geo(temp, gs); +int le_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) le_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return tne_geo_trgeometry(gs, temp); +int le_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) le_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -Temporal * tne_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return tne_trgeometry_geo(temp, gs); +int le_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) le_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int econtains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return econtains_geo_trgeometry(gs, temp); +int lt_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) lt_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int acontains_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return acontains_geo_trgeometry(gs, temp); +int lt_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) lt_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int ecovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return ecovers_geo_trgeometry(gs, temp); +int lt_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) lt_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int acovers_geo_trgeometry_w(const GSERIALIZED * gs, const Temporal * temp) { - return acovers_geo_trgeometry(gs, temp); +long long minus_timestamp_interval_w(long long ts, const Interval * interv) { + return minus_timestamp_interval((Timestamp) ts, interv); } EMSCRIPTEN_KEEPALIVE -int ecovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return ecovers_trgeometry_geo(temp, gs); +Interval * minus_timestamp_timestamp_w(long long ts1, long long ts2) { + return minus_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int acovers_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return acovers_trgeometry_geo(temp, gs); +long long minus_timestamptz_interval_w(long long tstz, const Interval * interv) { + return minus_timestamptz_interval((TimestampTz) tstz, interv); } EMSCRIPTEN_KEEPALIVE -int edisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return edisjoint_trgeometry_geo(temp, gs); +long long minus_timestamptz_interval_at_zone_w(long long tstz, const Interval * interv, const char * zone) { + return minus_timestamptz_interval_at_zone((TimestampTz) tstz, interv, cstring_to_text(zone)); } EMSCRIPTEN_KEEPALIVE -int adisjoint_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return adisjoint_trgeometry_geo(temp, gs); +Interval * minus_timestamptz_timestamptz_w(long long tstz1, long long tstz2) { + return minus_timestamptz_timestamptz((TimestampTz) tstz1, (TimestampTz) tstz2); } EMSCRIPTEN_KEEPALIVE -int eintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return eintersects_trgeometry_geo(temp, gs); +int ne_timestamp_timestamp_w(long long ts1, long long ts2) { + return (int) ne_timestamp_timestamp((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int aintersects_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return aintersects_trgeometry_geo(temp, gs); +int ne_timestamp_timestamptz_w(long long ts, long long tstz) { + return (int) ne_timestamp_timestamptz((Timestamp) ts, (TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int etouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return etouches_trgeometry_geo(temp, gs); +int ne_timestamptz_timestamp_w(long long tstz, long long ts) { + return (int) ne_timestamptz_timestamp((TimestampTz) tstz, (Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int atouches_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs) { - return atouches_trgeometry_geo(temp, gs); +Interval * timestamp_age_w(long long ts1, long long ts2) { + return timestamp_age((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int edwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) { - return edwithin_trgeometry_geo(temp, gs, dist); +long long timestamp_at_local_w(long long ts) { + return timestamp_at_local((Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int adwithin_trgeometry_geo_w(const Temporal * temp, const GSERIALIZED * gs, double dist) { - return adwithin_trgeometry_geo(temp, gs, dist); +long long timestamp_bin_w(long long ts, const Interval * stride, long long origin) { + return timestamp_bin((Timestamp) ts, stride, (Timestamp) origin); } EMSCRIPTEN_KEEPALIVE -int edisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return edisjoint_trgeometry_trgeometry(temp1, temp2); +Numeric timestamp_extract_w(long long ts, const char * units) { + return timestamp_extract((Timestamp) ts, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -int adisjoint_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return adisjoint_trgeometry_trgeometry(temp1, temp2); +uint32_t timestamp_hash_w(long long ts) { + return timestamp_hash((Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int eintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return eintersects_trgeometry_trgeometry(temp1, temp2); +uint64_t timestamp_hash_extended_w(long long tstz, uint64_t seed) { + return timestamp_hash_extended((TimestampTz) tstz, seed); } EMSCRIPTEN_KEEPALIVE -int aintersects_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2) { - return aintersects_trgeometry_trgeometry(temp1, temp2); +int timestamp_is_finite_w(long long ts) { + return (int) timestamp_is_finite((Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -int edwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) { - return edwithin_trgeometry_trgeometry(temp1, temp2, dist); +long long timestamp_izone_w(long long ts, const Interval * zone) { + return timestamp_izone((Timestamp) ts, zone); } EMSCRIPTEN_KEEPALIVE -int adwithin_trgeometry_trgeometry_w(const Temporal * temp1, const Temporal * temp2, double dist) { - return adwithin_trgeometry_trgeometry(temp1, temp2, dist); +char * time_of_day_w() { + text *_t = time_of_day(); + if (!_t) return NULL; + return text_to_cstring(_t); } - -/* === pg_interval.h === */ - EMSCRIPTEN_KEEPALIVE -Interval * add_interval_interval_w(const Interval * interv1, const Interval * interv2) { - return add_interval_interval(interv1, interv2); +long long timestamp_larger_w(long long ts1, long long ts2) { + return timestamp_larger((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -Interval * div_interval_float8_w(const Interval * interv, float8 factor) { - return div_interval_float8(interv, factor); +long long timestamp_make_w(int32 year, int32 month, int32 mday, int32 hour, int32 min, float8 sec) { + return timestamp_make(year, month, mday, hour, min, sec); } EMSCRIPTEN_KEEPALIVE -Interval * interval_copy_w(const Interval * interv) { - return interval_copy(interv); +int timestamp_overlaps_w(long long ts1, long long te1, long long ts2, long long te2) { + return (int) timestamp_overlaps((Timestamp) ts1, (Timestamp) te1, (Timestamp) ts2, (Timestamp) te2); } EMSCRIPTEN_KEEPALIVE -int interval_eq_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_eq(interv1, interv2); +float8 timestamp_part_w(long long ts, const char * units) { + return timestamp_part((Timestamp) ts, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Numeric interval_extract_w(const Interval * interv, const char * units) { - return interval_extract(interv, cstring_to_text(units)); +long long timestamp_scale_w(long long ts, int32 typmod) { + return timestamp_scale((Timestamp) ts, typmod); } EMSCRIPTEN_KEEPALIVE -int interval_ge_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_ge(interv1, interv2); +long long timestamp_smaller_w(long long ts1, long long ts2) { + return timestamp_smaller((Timestamp) ts1, (Timestamp) ts2); } EMSCRIPTEN_KEEPALIVE -int interval_gt_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_gt(interv1, interv2); +long long timestamp_to_timestamptz_w(long long ts) { + return timestamp_to_timestamptz((Timestamp) ts); } EMSCRIPTEN_KEEPALIVE -uint32_t interval_hash_w(const Interval * interv) { - return interval_hash(interv); +long long timestamp_trunc_w(long long ts, const char * units) { + return timestamp_trunc((Timestamp) ts, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -uint64_t interval_hash_extended_w(const Interval * interv, uint64_t seed) { - return interval_hash_extended(interv, seed); +long long timestamp_zone_w(long long ts, const char * zone) { + return timestamp_zone((Timestamp) ts, cstring_to_text(zone)); } EMSCRIPTEN_KEEPALIVE -int interval_is_finite_w(const Interval * interv) { - return (int) interval_is_finite(interv); +Interval * timestamptz_age_w(long long tstz1, long long tstz2) { + return timestamptz_age((TimestampTz) tstz1, (TimestampTz) tstz2); } EMSCRIPTEN_KEEPALIVE -Interval * interval_justify_days_w(const Interval * interv) { - return interval_justify_days(interv); +long long timestamptz_at_local_w(long long tstz) { + return timestamptz_at_local((TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -Interval * interval_justify_hours_w(const Interval * interv) { - return interval_justify_hours(interv); +long long timestamptz_bin_w(long long tstz, const Interval * stride, long long origin) { + return timestamptz_bin((TimestampTz) tstz, stride, (TimestampTz) origin); } EMSCRIPTEN_KEEPALIVE -Interval * interval_justify_interval_w(const Interval * interv) { - return interval_justify_interval(interv); +Numeric timestamptz_extract_w(long long tstz, const char * units) { + return timestamptz_extract((TimestampTz) tstz, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Interval * interval_larger_w(const Interval * interv1, const Interval * interv2) { - return interval_larger(interv1, interv2); +int32 timestamptz_hash_w(long long tstz) { + return timestamptz_hash((TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -int interval_le_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_le(interv1, interv2); +uint64_t timestamptz_hash_extended_w(long long tstz, uint64_t seed) { + return timestamptz_hash_extended((TimestampTz) tstz, seed); } EMSCRIPTEN_KEEPALIVE -int interval_lt_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_lt(interv1, interv2); +long long timestamptz_izone_w(long long tstz, const Interval * zone) { + return timestamptz_izone((TimestampTz) tstz, zone); } EMSCRIPTEN_KEEPALIVE -Interval * interval_make_w(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, float8 secs) { - return interval_make(years, months, weeks, days, hours, mins, secs); +long long timestamptz_make_w(int32 year, int32 month, int32 day, int32 hour, int32 min, float8 sec) { + return timestamptz_make(year, month, day, hour, min, sec); } EMSCRIPTEN_KEEPALIVE -int interval_ne_w(const Interval * interv1, const Interval * interv2) { - return (int) interval_ne(interv1, interv2); +long long timestamptz_make_at_timezone_w(int32 year, int32 month, int32 day, int32 hour, int32 min, float8 sec, const char * zone) { + return timestamptz_make_at_timezone(year, month, day, hour, min, sec, cstring_to_text(zone)); } EMSCRIPTEN_KEEPALIVE -Interval * interval_negate_w(const Interval * interv) { - return interval_negate(interv); +int timestamptz_overlaps_w(long long ts1, long long te1, long long ts2, long long te2) { + return (int) timestamptz_overlaps((TimestampTz) ts1, (TimestampTz) te1, (TimestampTz) ts2, (TimestampTz) te2); } EMSCRIPTEN_KEEPALIVE -float8 interval_part_w(const Interval * interv, const char * units) { - return interval_part(interv, cstring_to_text(units)); +float8 timestamptz_part_w(long long tstz, const char * units) { + return timestamptz_part((TimestampTz) tstz, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Interval * interval_scale_w(const Interval * interv, int32 typmod) { - return interval_scale(interv, typmod); +long long timestamptz_scale_w(long long tstz, int32 typmod) { + return timestamptz_scale((TimestampTz) tstz, typmod); } EMSCRIPTEN_KEEPALIVE -Interval * interval_smaller_w(const Interval * interv1, const Interval * interv2) { - return interval_smaller(interv1, interv2); +long long timestamptz_shift_w(long long tstz, const Interval * interv) { + return timestamptz_shift((TimestampTz) tstz, interv); } EMSCRIPTEN_KEEPALIVE -Interval * interval_trunc_w(const Interval * interv, const char * units) { - return interval_trunc(interv, cstring_to_text(units)); +long long timestamptz_to_timestamp_w(long long tstz) { + return timestamptz_to_timestamp((TimestampTz) tstz); } EMSCRIPTEN_KEEPALIVE -Interval * minus_interval_interval_w(const Interval * interv1, const Interval * interv2) { - return minus_interval_interval(interv1, interv2); +long long timestamptz_trunc_w(long long tstz, const char * units) { + return timestamptz_trunc((TimestampTz) tstz, cstring_to_text(units)); } EMSCRIPTEN_KEEPALIVE -Interval * mul_float8_interval_w(float8 factor, const Interval * interv) { - return mul_float8_interval(factor, interv); +long long timestamptz_trunc_zone_w(long long tstz, const char * units, const char * zone) { + return timestamptz_trunc_zone((TimestampTz) tstz, cstring_to_text(units), cstring_to_text(zone)); } EMSCRIPTEN_KEEPALIVE -Interval * mul_interval_float8_w(const Interval * interv, float8 factor) { - return mul_interval_float8(interv, factor); +long long timestamptz_zone_w(long long tstz, const char * zone) { + return timestamptz_zone((TimestampTz) tstz, cstring_to_text(zone)); } diff --git a/core/functions/functions.generated.ts b/core/functions/functions.generated.ts index 0d0a627..5f17e08 100644 --- a/core/functions/functions.generated.ts +++ b/core/functions/functions.generated.ts @@ -381,12 +381,6 @@ export function text_cmp(txt1: string, txt2: string, collid: number): number { return _r; } -export function text_copy(txt: string): string { - const _r = call('text_copy_w', 'string', ['string'], [txt]); - checkMeosError(); - return _r; -} - export function text_initcap(txt: string): string { const _r = call('text_initcap_w', 'string', ['string'], [txt]); checkMeosError(); @@ -520,6 +514,12 @@ export function rtree_create_stbox(): Ptr { return _r; } +export function rtree_create_tpcbox(): Ptr { + const _r = callPtr('rtree_create_tpcbox_w', [], []); + checkMeosError(); + return _r; +} + export function rtree_free(rtree: Ptr): void { call('rtree_free_w', null, [ptrArgType()], [ptrArgVal(rtree)]); checkMeosError(); @@ -585,12 +585,6 @@ export function rtree_search_temporal(rtree: Ptr, op: number, temp: Ptr, result: return _r; } -export function rtree_search_temporal_dedup(rtree: Ptr, op: number, temp: Ptr, maxboxes: number, result: Ptr): number { - const _r = call('rtree_search_temporal_dedup_w', 'number', [ptrArgType(), 'number', ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rtree), op, ptrArgVal(temp), maxboxes, ptrArgVal(result)]); - checkMeosError(); - return _r; -} - export function rtree_nn_cursor_open(rtree: Ptr, query: Ptr): Ptr { const _r = callPtr('rtree_nn_cursor_open_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rtree), ptrArgVal(query)]); checkMeosError(); @@ -721,12 +715,6 @@ export function sptree_search_temporal(sptree: Ptr, op: number, temp: Ptr, resul return _r; } -export function sptree_search_temporal_dedup(sptree: Ptr, op: number, temp: Ptr, maxboxes: number, result: Ptr): number { - const _r = call('sptree_search_temporal_dedup_w', 'number', [ptrArgType(), 'number', ptrArgType(), 'number', ptrArgType()], [ptrArgVal(sptree), op, ptrArgVal(temp), maxboxes, ptrArgVal(result)]); - checkMeosError(); - return _r; -} - export function sptree_nn_cursor_open(sptree: Ptr, query: Ptr): Ptr { const _r = callPtr('sptree_nn_cursor_open_w', [ptrArgType(), ptrArgType()], [ptrArgVal(sptree), ptrArgVal(query)]); checkMeosError(); @@ -764,6 +752,11 @@ export function meos_finalize_collation(): void { checkMeosError(); } +export function meos_initialize_pointcloud(): void { + call('meos_initialize_pointcloud_w', null, [], []); + checkMeosError(); +} + export function meos_set_datestyle(newval: string, extra: Ptr): boolean { const _r = call('meos_set_datestyle_w', 'number', ['string', ptrArgType()], [newval, ptrArgVal(extra)]) !== 0; checkMeosError(); @@ -5616,12 +5609,6 @@ export function tbigint_values(temp: Ptr, count: Ptr): Ptr { return _r; } -export function tnumber_avg_value(temp: Ptr): number { - const _r = call('tnumber_avg_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); - checkMeosError(); - return _r; -} - export function tnumber_integral(temp: Ptr): number { const _r = call('tnumber_integral_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); @@ -7338,6 +7325,12 @@ export function overlaps_temporal_temporal(temp1: Ptr, temp2: Ptr): boolean { return _r; } +export function temporal_time_overlaps(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('temporal_time_overlaps_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; + checkMeosError(); + return _r; +} + export function overlaps_temporal_tstzspan(temp: Ptr, s: Ptr): boolean { const _r = call('overlaps_temporal_tstzspan_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]) !== 0; checkMeosError(); @@ -10749,12 +10742,6 @@ export function acontains_tgeo_geo(temp: Ptr, gs: Ptr): number { return _r; } -export function acontains_tgeo_tgeo(temp1: Ptr, temp2: Ptr): number { - const _r = call('acontains_tgeo_tgeo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); - checkMeosError(); - return _r; -} - export function acovers_geo_tgeo(gs: Ptr, temp: Ptr): number { const _r = call('acovers_geo_tgeo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); checkMeosError(); @@ -12174,12 +12161,6 @@ export function atouches_tcbuffer_cbuffer(temp: Ptr, cb: Ptr): number { return _r; } -export function atouches_tcbuffer_tcbuffer(temp1: Ptr, temp2: Ptr): number { - const _r = call('atouches_tcbuffer_tcbuffer_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); - checkMeosError(); - return _r; -} - export function econtains_cbuffer_tcbuffer(cb: Ptr, temp: Ptr): number { const _r = call('econtains_cbuffer_tcbuffer_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(cb), ptrArgVal(temp)]); checkMeosError(); @@ -12475,6 +12456,45 @@ export function ttouches_tcbuffer_tcbuffer(temp1: Ptr, temp2: Ptr): Ptr { } +// === meos_cellindex.h === + +export function tcellindex_get_resolution(temp: Ptr): Ptr { + const _r = callPtr('tcellindex_get_resolution_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tcellindex_is_valid_cell(temp: Ptr): Ptr { + const _r = callPtr('tcellindex_is_valid_cell_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tcellindex_cell_to_parent(temp: Ptr, resolution: number): Ptr { + const _r = callPtr('tcellindex_cell_to_parent_w', [ptrArgType(), 'number'], [ptrArgVal(temp), resolution]); + checkMeosError(); + return _r; +} + +export function tcellindex_cell_to_point(temp: Ptr): Ptr { + const _r = callPtr('tcellindex_cell_to_point_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tcellindex_cell_to_boundary(temp: Ptr): Ptr { + const _r = callPtr('tcellindex_cell_to_boundary_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tcellindex_cell_area(temp: Ptr): Ptr { + const _r = callPtr('tcellindex_cell_area_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + + // === meos_h3.h === export function h3index_in(str: string): number { @@ -13782,24 +13802,6 @@ export function tjsonb_out(temp: Ptr): string { return _r; } -export function tjsonbinst_in(str: string): Ptr { - const _r = callPtr('tjsonbinst_in_w', ['string'], [str]); - checkMeosError(); - return _r; -} - -export function tjsonbseq_in(str: string, interp: number): Ptr { - const _r = callPtr('tjsonbseq_in_w', ['string', 'number'], [str, interp]); - checkMeosError(); - return _r; -} - -export function tjsonbseqset_in(str: string): Ptr { - const _r = callPtr('tjsonbseqset_in_w', ['string'], [str]); - checkMeosError(); - return _r; -} - export function tjsonb_from_base_temp(jsonb: Ptr, temp: Ptr): Ptr { const _r = callPtr('tjsonb_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(jsonb), ptrArgVal(temp)]); checkMeosError(); @@ -14956,2215 +14958,6183 @@ export function tne_tnpoint_npoint(temp: Ptr, np: Ptr): Ptr { } -// === meos_pose.h === +// === meos_pointcloud.h === -export function pose_as_ewkt(pose: Ptr, maxdd: number): string { - const _r = call('pose_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); +export function pcpoint_hex_in(str: string): Ptr { + const _r = callPtr('pcpoint_hex_in_w', ['string'], [str]); checkMeosError(); return _r; } -export function pose_as_hexwkb(pose: Ptr, variant: number, size_out: Ptr): string { - const _r = call('pose_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]); +export function pcpoint_hex_out(pt: Ptr, maxdd: number): string { + const _r = call('pcpoint_hex_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pt), maxdd]); checkMeosError(); return _r; } -export function pose_as_text(pose: Ptr, maxdd: number): string { - const _r = call('pose_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); +export function pcpoint_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('pcpoint_from_hexwkb_w', ['string'], [hexwkb]); checkMeosError(); return _r; } -export function pose_as_wkb(pose: Ptr, variant: number, size_out: Ptr): Ptr { - const _r = callPtr('pose_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]); +export function pcpoint_as_hexwkb(pt: Ptr): string { + const _r = call('pcpoint_as_hexwkb_w', 'string', [ptrArgType()], [ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_from_wkb(wkb: Ptr, size: number): Ptr { - const _r = callPtr('pose_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]); +export function pcpoint_make(pcid: number, values: Ptr, count: number): Ptr { + const _r = callPtr('pcpoint_make_w', ['number', ptrArgType(), 'number'], [pcid, ptrArgVal(values), count]); checkMeosError(); return _r; } -export function pose_from_hexwkb(hexwkb: string): Ptr { - const _r = callPtr('pose_from_hexwkb_w', ['string'], [hexwkb]); +export function pcpoint_copy(pt: Ptr): Ptr { + const _r = callPtr('pcpoint_copy_w', [ptrArgType()], [ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_in(str: string): Ptr { - const _r = callPtr('pose_in_w', ['string'], [str]); +export function pcpoint_get_pcid(pt: Ptr): number { + const _r = call('pcpoint_get_pcid_w', 'number', [ptrArgType()], [ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_out(pose: Ptr, maxdd: number): string { - const _r = call('pose_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); +export function pcpoint_hash(pt: Ptr): number { + const _r = call('pcpoint_hash_w', 'number', [ptrArgType()], [ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_from_geopose(json: string): Ptr { - const _r = callPtr('pose_from_geopose_w', ['string'], [json]); +export function pcpoint_hash_extended(pt: Ptr, seed: number): number { + const _r = Number(call('pcpoint_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pt), BigInt(seed)])); checkMeosError(); return _r; } -export function pose_as_geopose(pose: Ptr, conformance: number, precision: number): string { - const _r = call('pose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(pose), conformance, precision]); +export function pcpoint_get_x(pt: Ptr, schema: Ptr, out: Ptr): boolean { + const _r = call('pcpoint_get_x_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0; checkMeosError(); return _r; } -export function tpose_from_geopose(json: string): Ptr { - const _r = callPtr('tpose_from_geopose_w', ['string'], [json]); +export function pcpoint_get_y(pt: Ptr, schema: Ptr, out: Ptr): boolean { + const _r = call('pcpoint_get_y_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0; checkMeosError(); return _r; } -export function tpose_as_geopose(temp: Ptr, conformance: number, precision: number): string { - const _r = call('tpose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temp), conformance, precision]); +export function pcpoint_get_z(pt: Ptr, schema: Ptr, out: Ptr): boolean { + const _r = call('pcpoint_get_z_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), ptrArgVal(out)]) !== 0; checkMeosError(); return _r; } -export function tpose_as_geopose_stream_header(temp: Ptr, precision: number): string { - const _r = call('tpose_as_geopose_stream_header_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]); +export function pcpoint_get_dim(pt: Ptr, schema: Ptr, name: string, out: Ptr): boolean { + const _r = call('pcpoint_get_dim_w', 'number', [ptrArgType(), ptrArgType(), 'string', ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema), name, ptrArgVal(out)]) !== 0; checkMeosError(); return _r; } -export function tpose_as_geopose_stream_element(temp: Ptr, inst: Ptr, precision: number): string { - const _r = call('tpose_as_geopose_stream_element_w', 'string', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), precision]); +export function pcpoint_to_tpcbox(pt: Ptr, schema: Ptr): Ptr { + const _r = callPtr('pcpoint_to_tpcbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(schema)]); checkMeosError(); return _r; } -export function tpose_as_geopose_stream(temp: Ptr, precision: number): string { - const _r = call('tpose_as_geopose_stream_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]); +export function meos_pc_schema(pcid: number): Ptr { + const _r = callPtr('meos_pc_schema_w', ['number'], [pcid]); checkMeosError(); return _r; } -export function geopose_frames(count: Ptr): Ptr { - const _r = callPtr('geopose_frames_w', [ptrArgType()], [ptrArgVal(count)]); +export function meos_pc_schema_register(pcid: number, schema: Ptr): void { + call('meos_pc_schema_register_w', null, ['number', ptrArgType()], [pcid, ptrArgVal(schema)]); checkMeosError(); - return _r; } -export function geopose_frame(frame_id: number): Ptr { - const _r = callPtr('geopose_frame_w', ['number'], [frame_id]); +export function meos_pc_schema_from_dims(pcid: number, srid: number, compression: string, dims: Ptr, ndims: number): Ptr { + const _r = callPtr('meos_pc_schema_from_dims_w', ['number', 'number', 'string', ptrArgType(), 'number'], [pcid, srid, compression, ptrArgVal(dims), ndims]); checkMeosError(); return _r; } -export function pose_apply_geo(pose: Ptr, body: Ptr): Ptr { - const _r = callPtr('pose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(body)]); +export function meos_pc_schema_register_dims(pcid: number, srid: number, compression: string, dims: Ptr, ndims: number): boolean { + const _r = call('meos_pc_schema_register_dims_w', 'number', ['number', 'number', 'string', ptrArgType(), 'number'], [pcid, srid, compression, ptrArgVal(dims), ndims]) !== 0; checkMeosError(); return _r; } -export function tpose_apply_geo(temp: Ptr, body: Ptr): Ptr { - const _r = callPtr('tpose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(body)]); +export function meos_pc_schema_register_xml(pcid: number, schema: Ptr, xml_text: string): void { + call('meos_pc_schema_register_xml_w', null, ['number', ptrArgType(), 'string'], [pcid, ptrArgVal(schema), xml_text]); checkMeosError(); - return _r; } -export function tpose_compose_pose(body: Ptr, frame: Ptr): Ptr { - const _r = callPtr('tpose_compose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); +export function meos_pc_schema_xml(pcid: number): string { + const _r = call('meos_pc_schema_xml_w', 'string', ['number'], [pcid]); checkMeosError(); return _r; } -export function pose_compose_tpose(body: Ptr, frame: Ptr): Ptr { - const _r = callPtr('pose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); +export function meos_pc_schema_clear(): void { + call('meos_pc_schema_clear_w', null, [], []); checkMeosError(); - return _r; } -export function tpose_compose_tpose(body: Ptr, frame: Ptr): Ptr { - const _r = callPtr('tpose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); +export function meos_pc_schema_srid(pcid: number): number { + const _r = call('meos_pc_schema_srid_w', 'number', ['number'], [pcid]); checkMeosError(); return _r; } -export function tpose_inverse(temp: Ptr): Ptr { - const _r = callPtr('tpose_inverse_w', [ptrArgType()], [ptrArgVal(temp)]); +export function meos_pc_schema_compression(pcid: number): string { + const _r = call('meos_pc_schema_compression_w', 'string', ['number'], [pcid]); checkMeosError(); return _r; } -export function pose_copy(pose: Ptr): Ptr { - const _r = callPtr('pose_copy_w', [ptrArgType()], [ptrArgVal(pose)]); +export function meos_pc_schema_ndims(pcid: number): number { + const _r = call('meos_pc_schema_ndims_w', 'number', ['number'], [pcid]); checkMeosError(); return _r; } -export function pose_make_2d(x: number, y: number, theta: number, geodetic: boolean, srid: number): Ptr { - const _r = callPtr('pose_make_2d_w', ['number', 'number', 'number', 'number', 'number'], [x, y, theta, geodetic ? 1 : 0, srid]); +export function meos_set_pointcloud_schemas_xml(path: string): void { + call('meos_set_pointcloud_schemas_xml_w', null, ['string'], [path]); checkMeosError(); - return _r; } -export function pose_make_3d(x: number, y: number, z: number, W: number, X: number, Y: number, Z: number, geodetic: boolean, srid: number): Ptr { - const _r = callPtr('pose_make_3d_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'], [x, y, z, W, X, Y, Z, geodetic ? 1 : 0, srid]); +export function pcpoint_cmp(pt1: Ptr, pt2: Ptr): number { + const _r = call('pcpoint_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]); checkMeosError(); return _r; } -export function pose_make_point2d(gs: Ptr, theta: number): Ptr { - const _r = callPtr('pose_make_point2d_w', [ptrArgType(), 'number'], [ptrArgVal(gs), theta]); +export function pcpoint_eq(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_make_point3d(gs: Ptr, W: number, X: number, Y: number, Z: number): Ptr { - const _r = callPtr('pose_make_point3d_w', [ptrArgType(), 'number', 'number', 'number', 'number'], [ptrArgVal(gs), W, X, Y, Z]); +export function pcpoint_ne(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_make_point3d_ypr(gs: Ptr, yaw: number, pitch: number, roll: number): Ptr { - const _r = callPtr('pose_make_point3d_ypr_w', [ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(gs), yaw, pitch, roll]); +export function pcpoint_lt(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_to_point(pose: Ptr): Ptr { - const _r = callPtr('pose_to_point_w', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpoint_le(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_to_stbox(pose: Ptr): Ptr { - const _r = callPtr('pose_to_stbox_w', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpoint_gt(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_hash(pose: Ptr): number { - const _r = call('pose_hash_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpoint_ge(pt1: Ptr, pt2: Ptr): boolean { + const _r = call('pcpoint_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt1), ptrArgVal(pt2)]) !== 0; checkMeosError(); return _r; } -export function pose_hash_extended(pose: Ptr, seed: number): number { - const _r = Number(call('pose_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(seed)])); +export function pcpatch_hex_in(str: string): Ptr { + const _r = callPtr('pcpatch_hex_in_w', ['string'], [str]); checkMeosError(); return _r; } -export function pose_quaternion(pose: Ptr, count: Ptr): Ptr { - const _r = callPtr('pose_quaternion_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]); +export function pcpatch_hex_out(pa: Ptr, maxdd: number): string { + const _r = call('pcpatch_hex_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pa), maxdd]); checkMeosError(); return _r; } -export function pose_ypr(pose: Ptr, count: Ptr): Ptr { - const _r = callPtr('pose_ypr_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]); +export function pcpatch_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('pcpatch_from_hexwkb_w', ['string'], [hexwkb]); checkMeosError(); return _r; } -export function pose_yaw(pose: Ptr): number { - const _r = call('pose_yaw_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_as_hexwkb(pa: Ptr): string { + const _r = call('pcpatch_as_hexwkb_w', 'string', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_pitch(pose: Ptr): number { - const _r = call('pose_pitch_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_make(points: Ptr, count: number): Ptr { + const _r = callPtr('pcpatch_make_w', [ptrArgType(), 'number'], [ptrArgVal(points), count]); checkMeosError(); return _r; } -export function pose_roll(pose: Ptr): number { - const _r = call('pose_roll_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_make_coords(pcid: number, values: Ptr, count: number): Ptr { + const _r = callPtr('pcpatch_make_coords_w', ['number', ptrArgType(), 'number'], [pcid, ptrArgVal(values), count]); checkMeosError(); return _r; } -export function pose_angular_distance(pose1: Ptr, pose2: Ptr): number { - const _r = call('pose_angular_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); +export function pcpatch_copy(pa: Ptr): Ptr { + const _r = callPtr('pcpatch_copy_w', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_compose(body: Ptr, frame: Ptr): Ptr { - const _r = callPtr('pose_compose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); +export function pcpatch_get_pcid(pa: Ptr): number { + const _r = call('pcpatch_get_pcid_w', 'number', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_inverse(pose: Ptr): Ptr { - const _r = callPtr('pose_inverse_w', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_npoints(pa: Ptr): number { + const _r = call('pcpatch_npoints_w', 'number', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_normalize(pose: Ptr): Ptr { - const _r = callPtr('pose_normalize_w', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_hash(pa: Ptr): number { + const _r = call('pcpatch_hash_w', 'number', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_round(pose: Ptr, maxdd: number): Ptr { - const _r = callPtr('pose_round_w', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); +export function pcpatch_hash_extended(pa: Ptr, seed: number): number { + const _r = Number(call('pcpatch_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pa), BigInt(seed)])); checkMeosError(); return _r; } -export function posearr_round(posearr: Ptr, count: number, maxdd: number): Ptr { - const _r = callPtr('posearr_round_w', [ptrArgType(), 'number', 'number'], [ptrArgVal(posearr), count, maxdd]); +export function pcpatch_to_geom(pa: Ptr): Ptr { + const _r = callPtr('pcpatch_to_geom_w', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function pose_set_srid(pose: Ptr, srid: number): Ptr { - const _r = callPtr('pose_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]); +export function pcpatch_cmp(pa1: Ptr, pa2: Ptr): number { + const _r = call('pcpatch_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]); checkMeosError(); return _r; } -export function pose_srid(pose: Ptr): number { - const _r = call('pose_srid_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); +export function pcpatch_eq(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function pose_transform(pose: Ptr, srid: number): Ptr { - const _r = callPtr('pose_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]); +export function pcpatch_ne(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function pose_transform_pipeline(pose: Ptr, pipelinestr: string, srid: number, is_forward: boolean): Ptr { - const _r = callPtr('pose_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pose), pipelinestr, srid, is_forward ? 1 : 0]); +export function pcpatch_lt(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function pose_tstzspan_to_stbox(pose: Ptr, s: Ptr): Ptr { - const _r = callPtr('pose_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); +export function pcpatch_le(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function pose_timestamptz_to_stbox(pose: Ptr, t: TimestampTz): Ptr { - const _r = callPtr('pose_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]); +export function pcpatch_gt(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function distance_pose_geo(pose: Ptr, gs: Ptr): number { - const _r = call('distance_pose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(gs)]); +export function pcpatch_ge(pa1: Ptr, pa2: Ptr): boolean { + const _r = call('pcpatch_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa1), ptrArgVal(pa2)]) !== 0; checkMeosError(); return _r; } -export function distance_pose_pose(pose1: Ptr, pose2: Ptr): number { - const _r = call('distance_pose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); +export function pcpointset_in(str: string): Ptr { + const _r = callPtr('pcpointset_in_w', ['string'], [str]); checkMeosError(); return _r; } -export function distance_pose_stbox(pose: Ptr, box: Ptr): number { - const _r = call('distance_pose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(box)]); +export function pcpointset_out(s: Ptr, maxdd: number): string { + const _r = call('pcpointset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]); checkMeosError(); return _r; } -export function pose_cmp(pose1: Ptr, pose2: Ptr): number { - const _r = call('pose_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); +export function pcpointset_make(values: Ptr, count: number): Ptr { + const _r = callPtr('pcpointset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]); checkMeosError(); return _r; } -export function pose_eq(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function pcpoint_to_set(pt: Ptr): Ptr { + const _r = callPtr('pcpoint_to_set_w', [ptrArgType()], [ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_ge(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function pcpointset_start_value(s: Ptr): Ptr { + const _r = callPtr('pcpointset_start_value_w', [ptrArgType()], [ptrArgVal(s)]); checkMeosError(); return _r; } -export function pose_gt(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function pcpointset_end_value(s: Ptr): Ptr { + const _r = callPtr('pcpointset_end_value_w', [ptrArgType()], [ptrArgVal(s)]); checkMeosError(); return _r; } -export function pose_le(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function pcpointset_value_n(s: Ptr, n: number): Ptr { + const _r = callPtr('pcpointset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]); checkMeosError(); return _r; } -export function pose_lt(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function pcpointset_values(s: Ptr, count: Ptr): Ptr { + const _r = callPtr('pcpointset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]); checkMeosError(); return _r; } -export function pose_ne(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function contains_set_pcpoint(s: Ptr, pt: Ptr): boolean { + const _r = call('contains_set_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]) !== 0; checkMeosError(); return _r; } -export function pose_nsame(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function contained_pcpoint_set(pt: Ptr, s: Ptr): boolean { + const _r = call('contained_pcpoint_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]) !== 0; checkMeosError(); return _r; } -export function pose_same(pose1: Ptr, pose2: Ptr): boolean { - const _r = call('pose_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; +export function intersection_pcpoint_set(pt: Ptr, s: Ptr): Ptr { + const _r = callPtr('intersection_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]); checkMeosError(); return _r; } -export function poseset_in(str: string): Ptr { - const _r = callPtr('poseset_in_w', ['string'], [str]); +export function intersection_set_pcpoint(s: Ptr, pt: Ptr): Ptr { + const _r = callPtr('intersection_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function poseset_out(s: Ptr, maxdd: number): string { - const _r = call('poseset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]); +export function minus_pcpoint_set(pt: Ptr, s: Ptr): Ptr { + const _r = callPtr('minus_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]); checkMeosError(); return _r; } -export function poseset_make(values: Ptr, count: number): Ptr { - const _r = callPtr('poseset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]); +export function minus_set_pcpoint(s: Ptr, pt: Ptr): Ptr { + const _r = callPtr('minus_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function pose_to_set(pose: Ptr): Ptr { - const _r = callPtr('pose_to_set_w', [ptrArgType()], [ptrArgVal(pose)]); +export function union_pcpoint_set(pt: Ptr, s: Ptr): Ptr { + const _r = callPtr('union_pcpoint_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]); checkMeosError(); return _r; } -export function poseset_end_value(s: Ptr): Ptr { - const _r = callPtr('poseset_end_value_w', [ptrArgType()], [ptrArgVal(s)]); +export function union_set_pcpoint(s: Ptr, pt: Ptr): Ptr { + const _r = callPtr('union_set_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function poseset_start_value(s: Ptr): Ptr { - const _r = callPtr('poseset_start_value_w', [ptrArgType()], [ptrArgVal(s)]); +export function pcpoint_union_transfn(state: Ptr, pt: Ptr): Ptr { + const _r = callPtr('pcpoint_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function poseset_value_n(s: Ptr, n: number): Ptr { - const _r = callPtr('poseset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]); +export function pcpatchset_in(str: string): Ptr { + const _r = callPtr('pcpatchset_in_w', ['string'], [str]); checkMeosError(); return _r; } -export function poseset_values(s: Ptr, count: Ptr): Ptr { - const _r = callPtr('poseset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]); +export function pcpatchset_out(s: Ptr, maxdd: number): string { + const _r = call('pcpatchset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]); checkMeosError(); return _r; } -export function contained_pose_set(pose: Ptr, s: Ptr): boolean { - const _r = call('contained_pose_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]) !== 0; +export function pcpatchset_make(values: Ptr, count: number): Ptr { + const _r = callPtr('pcpatchset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]); checkMeosError(); return _r; } -export function contains_set_pose(s: Ptr, pose: Ptr): boolean { - const _r = call('contains_set_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]) !== 0; +export function pcpatch_to_set(pa: Ptr): Ptr { + const _r = callPtr('pcpatch_to_set_w', [ptrArgType()], [ptrArgVal(pa)]); checkMeosError(); return _r; } -export function intersection_pose_set(pose: Ptr, s: Ptr): Ptr { - const _r = callPtr('intersection_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); +export function pcpatchset_start_value(s: Ptr): Ptr { + const _r = callPtr('pcpatchset_start_value_w', [ptrArgType()], [ptrArgVal(s)]); checkMeosError(); return _r; } -export function intersection_set_pose(s: Ptr, pose: Ptr): Ptr { - const _r = callPtr('intersection_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); +export function pcpatchset_end_value(s: Ptr): Ptr { + const _r = callPtr('pcpatchset_end_value_w', [ptrArgType()], [ptrArgVal(s)]); checkMeosError(); return _r; } -export function minus_pose_set(pose: Ptr, s: Ptr): Ptr { - const _r = callPtr('minus_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); +export function pcpatchset_value_n(s: Ptr, n: number): Ptr { + const _r = callPtr('pcpatchset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]); checkMeosError(); return _r; } -export function minus_set_pose(s: Ptr, pose: Ptr): Ptr { - const _r = callPtr('minus_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); +export function pcpatchset_values(s: Ptr, count: Ptr): Ptr { + const _r = callPtr('pcpatchset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]); checkMeosError(); return _r; } -export function pose_union_transfn(state: Ptr, pose: Ptr): Ptr { - const _r = callPtr('pose_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pose)]); +export function contains_set_pcpatch(s: Ptr, pa: Ptr): boolean { + const _r = call('contains_set_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]) !== 0; checkMeosError(); return _r; } -export function union_pose_set(pose: Ptr, s: Ptr): Ptr { - const _r = callPtr('union_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); +export function contained_pcpatch_set(pa: Ptr, s: Ptr): boolean { + const _r = call('contained_pcpatch_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]) !== 0; checkMeosError(); return _r; } -export function union_set_pose(s: Ptr, pose: Ptr): Ptr { - const _r = callPtr('union_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); +export function intersection_pcpatch_set(pa: Ptr, s: Ptr): Ptr { + const _r = callPtr('intersection_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]); checkMeosError(); return _r; } -export function tpose_from_mfjson(str: string): Ptr { - const _r = callPtr('tpose_from_mfjson_w', ['string'], [str]); +export function intersection_set_pcpatch(s: Ptr, pa: Ptr): Ptr { + const _r = callPtr('intersection_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function tpose_in(str: string): Ptr { - const _r = callPtr('tpose_in_w', ['string'], [str]); +export function minus_pcpatch_set(pa: Ptr, s: Ptr): Ptr { + const _r = callPtr('minus_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]); checkMeosError(); return _r; } -export function tposeinst_make(pose: Ptr, t: TimestampTz): Ptr { - const _r = callPtr('tposeinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]); +export function minus_set_pcpatch(s: Ptr, pa: Ptr): Ptr { + const _r = callPtr('minus_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function tpose_from_base_temp(pose: Ptr, temp: Ptr): Ptr { - const _r = callPtr('tpose_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function union_pcpatch_set(pa: Ptr, s: Ptr): Ptr { + const _r = callPtr('union_pcpatch_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]); checkMeosError(); return _r; } -export function tposeseq_from_base_tstzset(pose: Ptr, s: Ptr): Ptr { - const _r = callPtr('tposeseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); +export function union_set_pcpatch(s: Ptr, pa: Ptr): Ptr { + const _r = callPtr('union_set_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function tposeseq_from_base_tstzspan(pose: Ptr, s: Ptr, interp: number): Ptr { - const _r = callPtr('tposeseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(s), interp]); +export function pcpatch_union_transfn(state: Ptr, pa: Ptr): Ptr { + const _r = callPtr('pcpatch_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function tposeseqset_from_base_tstzspanset(pose: Ptr, ss: Ptr, interp: number): Ptr { - const _r = callPtr('tposeseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(ss), interp]); +export function tpcbox_in(str: string): Ptr { + const _r = callPtr('tpcbox_in_w', ['string'], [str]); checkMeosError(); return _r; } -export function tpose_make(tpoint: Ptr, ttheta: Ptr): Ptr { - const _r = callPtr('tpose_make_w', [ptrArgType(), ptrArgType()], [ptrArgVal(tpoint), ptrArgVal(ttheta)]); +export function tpcbox_out(box: Ptr, maxdd: number): string { + const _r = call('tpcbox_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(box), maxdd]); checkMeosError(); return _r; } -export function tpose_to_tpoint(temp: Ptr): Ptr { - const _r = callPtr('tpose_to_tpoint_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_make(hasx: boolean, hasz: boolean, hast: boolean, geodetic: boolean, srid: number, pcid: number, xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number, period: Ptr): Ptr { + const _r = callPtr('tpcbox_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', ptrArgType()], [hasx ? 1 : 0, hasz ? 1 : 0, hast ? 1 : 0, geodetic ? 1 : 0, srid, pcid, xmin, xmax, ymin, ymax, zmin, zmax, ptrArgVal(period)]); checkMeosError(); return _r; } -export function tpose_end_value(temp: Ptr): Ptr { - const _r = callPtr('tpose_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_copy(box: Ptr): Ptr { + const _r = callPtr('tpcbox_copy_w', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_points(temp: Ptr): Ptr { - const _r = callPtr('tpose_points_w', [ptrArgType()], [ptrArgVal(temp)]); +export function pcpatch_to_tpcbox(pa: Ptr, srid: number): Ptr { + const _r = callPtr('pcpatch_to_tpcbox_w', [ptrArgType(), 'number'], [ptrArgVal(pa), srid]); checkMeosError(); return _r; } -export function tpose_yaw(temp: Ptr): Ptr { - const _r = callPtr('tpose_yaw_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_hasx(box: Ptr): boolean { + const _r = call('tpcbox_hasx_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_pitch(temp: Ptr): Ptr { - const _r = callPtr('tpose_pitch_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_hasz(box: Ptr): boolean { + const _r = call('tpcbox_hasz_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_roll(temp: Ptr): Ptr { - const _r = callPtr('tpose_roll_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_hast(box: Ptr): boolean { + const _r = call('tpcbox_hast_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_speed(temp: Ptr): Ptr { - const _r = callPtr('tpose_speed_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_geodetic(box: Ptr): boolean { + const _r = call('tpcbox_geodetic_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_angular_speed(temp: Ptr): Ptr { - const _r = callPtr('tpose_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_xmin(box: Ptr): number { + const _r = call('tpcbox_xmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_start_value(temp: Ptr): Ptr { - const _r = callPtr('tpose_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_xmax(box: Ptr): number { + const _r = call('tpcbox_xmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_trajectory(temp: Ptr): Ptr { - const _r = callPtr('tpose_trajectory_w', [ptrArgType()], [ptrArgVal(temp)]); +export function tpcbox_ymin(box: Ptr): number { + const _r = call('tpcbox_ymin_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { - const _r = callPtr('tpose_value_at_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); +export function tpcbox_ymax(box: Ptr): number { + const _r = call('tpcbox_ymax_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_value_n(temp: Ptr, n: number): Ptr { - const _r = callPtr('tpose_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); +export function tpcbox_zmin(box: Ptr): number { + const _r = call('tpcbox_zmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_values(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('tpose_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function tpcbox_zmax(box: Ptr): number { + const _r = call('tpcbox_zmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_at_elevation(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('tpose_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function tpcbox_tmin(box: Ptr): TimestampTz { + const _r = call('tpcbox_tmin_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_at_geom(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('tpose_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function tpcbox_tmin_inc(box: Ptr): boolean { + const _r = call('tpcbox_tmin_inc_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { - const _r = callPtr('tpose_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); +export function tpcbox_tmax(box: Ptr): TimestampTz { + const _r = call('tpcbox_tmax_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_at_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('tpose_at_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_tmax_inc(box: Ptr): boolean { + const _r = call('tpcbox_tmax_inc_w', 'number', [ptrArgType()], [ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tpose_minus_elevation(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('tpose_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function tpcbox_srid(box: Ptr): number { + const _r = call('tpcbox_srid_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_minus_geom(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('tpose_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function tpcbox_pcid(box: Ptr): number { + const _r = call('tpcbox_pcid_w', 'number', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_minus_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('tpose_minus_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_to_stbox(box: Ptr): Ptr { + const _r = callPtr('tpcbox_to_stbox_w', [ptrArgType()], [ptrArgVal(box)]); checkMeosError(); return _r; } -export function tpose_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { - const _r = callPtr('tpose_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); +export function tpcbox_round(box: Ptr, maxdd: number): Ptr { + const _r = callPtr('tpcbox_round_w', [ptrArgType(), 'number'], [ptrArgVal(box), maxdd]); checkMeosError(); return _r; } -export function tdistance_tpose_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('tdistance_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_set_srid(box: Ptr, srid: number): Ptr { + const _r = callPtr('tpcbox_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(box), srid]); checkMeosError(); return _r; } -export function tdistance_tpose_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('tdistance_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function union_tpcbox_tpcbox(box1: Ptr, box2: Ptr, strict: boolean): Ptr { + const _r = callPtr('union_tpcbox_tpcbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(box1), ptrArgVal(box2), strict ? 1 : 0]); checkMeosError(); return _r; } -export function tdistance_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('tdistance_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function intersection_tpcbox_tpcbox(box1: Ptr, box2: Ptr): Ptr { + const _r = callPtr('intersection_tpcbox_tpcbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]); checkMeosError(); return _r; } -export function nad_tpose_geo(temp: Ptr, gs: Ptr): number { - const _r = call('nad_tpose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function contains_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('contains_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function nad_tpose_pose(temp: Ptr, pose: Ptr): number { - const _r = call('nad_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function contained_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('contained_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function nad_tpose_stbox(temp: Ptr, box: Ptr): number { - const _r = call('nad_tpose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]); +export function overlaps_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overlaps_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function nad_tpose_tpose(temp1: Ptr, temp2: Ptr): number { - const _r = call('nad_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function same_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('same_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function nai_tpose_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('nai_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function adjacent_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('adjacent_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function nai_tpose_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('nai_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_cmp(box1: Ptr, box2: Ptr): number { + const _r = call('tpcbox_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]); checkMeosError(); return _r; } -export function nai_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('nai_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function tpcbox_eq(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function shortestline_tpose_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('shortestline_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function tpcbox_ne(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function shortestline_tpose_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('shortestline_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_lt(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function shortestline_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('shortestline_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function tpcbox_le(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_eq_pose_tpose(pose: Ptr, temp: Ptr): number { - const _r = call('always_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function tpcbox_gt(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_eq_tpose_pose(temp: Ptr, pose: Ptr): number { - const _r = call('always_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function tpcbox_ge(box1: Ptr, box2: Ptr): boolean { + const _r = call('tpcbox_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function left_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('left_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_ne_pose_tpose(pose: Ptr, temp: Ptr): number { - const _r = call('always_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function overleft_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overleft_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_ne_tpose_pose(temp: Ptr, pose: Ptr): number { - const _r = call('always_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function right_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('right_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function always_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function overright_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overright_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_eq_pose_tpose(pose: Ptr, temp: Ptr): number { - const _r = call('ever_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function below_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('below_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_eq_tpose_pose(temp: Ptr, pose: Ptr): number { - const _r = call('ever_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function overbelow_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overbelow_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function above_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('above_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_pose_tpose(pose: Ptr, temp: Ptr): number { - const _r = call('ever_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function overabove_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overabove_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_tpose_pose(temp: Ptr, pose: Ptr): number { - const _r = call('ever_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function front_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('front_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function overfront_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overfront_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function teq_pose_tpose(pose: Ptr, temp: Ptr): Ptr { - const _r = callPtr('teq_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function back_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('back_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function teq_tpose_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('teq_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function overback_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overback_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function tne_pose_tpose(pose: Ptr, temp: Ptr): Ptr { - const _r = callPtr('tne_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); +export function before_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('before_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function tne_tpose_pose(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('tne_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function overbefore_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overbefore_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } - -// === meos_quadbin.h === - -export function quadbin_in(str: string): number { - const _r = Number(call('quadbin_in_w', 'bigint', ['string'], [str])); +export function after_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('after_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function quadbin_eq(a: number, b: number): boolean { - const _r = call('quadbin_eq_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function overafter_tpcbox_tpcbox(box1: Ptr, box2: Ptr): boolean { + const _r = call('overafter_tpcbox_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box1), ptrArgVal(box2)]) !== 0; checkMeosError(); return _r; } -export function quadbin_ne(a: number, b: number): boolean { - const _r = call('quadbin_ne_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function tpointcloud_to_tgeompoint(temp: Ptr): Ptr { + const _r = callPtr('tpointcloud_to_tgeompoint_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_lt(a: number, b: number): boolean { - const _r = call('quadbin_lt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function tpcpatch_to_tgeometry(temp: Ptr): Ptr { + const _r = callPtr('tpcpatch_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_le(a: number, b: number): boolean { - const _r = call('quadbin_le_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function tpcpointinst_make(pt: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('tpcpointinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pt), BigInt(t)]); checkMeosError(); return _r; } -export function quadbin_gt(a: number, b: number): boolean { - const _r = call('quadbin_gt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function tpcpointseq_from_base_tstzset(pt: Ptr, s: Ptr): Ptr { + const _r = callPtr('tpcpointseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(s)]); checkMeosError(); return _r; } -export function quadbin_ge(a: number, b: number): boolean { - const _r = call('quadbin_ge_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; +export function tpcpointseq_from_base_tstzspan(pt: Ptr, sp: Ptr): Ptr { + const _r = callPtr('tpcpointseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(sp)]); checkMeosError(); return _r; } -export function quadbin_cmp(a: number, b: number): number { - const _r = call('quadbin_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]); +export function tpcpointseqset_from_base_tstzspanset(pt: Ptr, ss: Ptr): Ptr { + const _r = callPtr('tpcpointseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(ss)]); checkMeosError(); return _r; } -export function quadbin_hash(cell: number): number { - const _r = call('quadbin_hash_w', 'number', ['bigint'], [BigInt(cell)]); +export function tpcpoint_from_base_temp(pt: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tpcpoint_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_hash_extended(cell: number, seed: number): number { - const _r = Number(call('quadbin_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(cell), BigInt(seed)])); +export function tpcpoint_start_value(temp: Ptr): Ptr { + const _r = callPtr('tpcpoint_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_is_valid_index(index: number): boolean { - const _r = call('quadbin_is_valid_index_w', 'number', ['bigint'], [BigInt(index)]) !== 0; +export function tpcpoint_end_value(temp: Ptr): Ptr { + const _r = callPtr('tpcpoint_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_is_valid_cell(cell: number): boolean { - const _r = call('quadbin_is_valid_cell_w', 'number', ['bigint'], [BigInt(cell)]) !== 0; +export function tpcpoint_value_n(temp: Ptr, n: number): Ptr { + const _r = callPtr('tpcpoint_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); checkMeosError(); return _r; } -export function quadbin_tile_to_cell(x: number, y: number, z: number): number { - const _r = Number(call('quadbin_tile_to_cell_w', 'bigint', ['number', 'number', 'number'], [x, y, z])); +export function tpcpoint_values(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('tpcpoint_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); checkMeosError(); return _r; } -export function quadbin_cell_to_tile(cell: number, x: Ptr, y: Ptr, z: Ptr): boolean { - const _r = call('quadbin_cell_to_tile_w', 'number', ['bigint', ptrArgType(), ptrArgType(), ptrArgType()], [BigInt(cell), ptrArgVal(x), ptrArgVal(y), ptrArgVal(z)]) !== 0; +export function tpcpoint_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean, value: Ptr): boolean { + const _r = call('tpcpoint_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number', ptrArgType()], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0, ptrArgVal(value)]) !== 0; checkMeosError(); return _r; } -export function quadbin_get_resolution(cell: number): number { - const _r = call('quadbin_get_resolution_w', 'number', ['bigint'], [BigInt(cell)]); +export function tpcpoint_at_value(temp: Ptr, pt: Ptr): Ptr { + const _r = callPtr('tpcpoint_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function quadbin_cell_to_parent(cell: number, parent_resolution: number): number { - const _r = Number(call('quadbin_cell_to_parent_w', 'bigint', ['bigint', 'number'], [BigInt(cell), parent_resolution])); +export function tpcpoint_minus_value(temp: Ptr, pt: Ptr): Ptr { + const _r = callPtr('tpcpoint_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function quadbin_cell_to_children(cell: number, children_resolution: number, count: Ptr): Ptr { - const _r = callPtr('quadbin_cell_to_children_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), children_resolution, ptrArgVal(count)]); +export function tpcpatchinst_make(pa: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('tpcpatchinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pa), BigInt(t)]); checkMeosError(); return _r; } -export function quadbin_cell_sibling(cell: number, direction: string): number { - const _r = Number(call('quadbin_cell_sibling_w', 'bigint', ['bigint', 'string'], [BigInt(cell), direction])); +export function tpcpatchseq_from_base_tstzset(pa: Ptr, s: Ptr): Ptr { + const _r = callPtr('tpcpatchseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(s)]); checkMeosError(); return _r; } -export function quadbin_k_ring(cell: number, k: number, count: Ptr): Ptr { - const _r = callPtr('quadbin_k_ring_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), k, ptrArgVal(count)]); +export function tpcpatchseq_from_base_tstzspan(pa: Ptr, sp: Ptr): Ptr { + const _r = callPtr('tpcpatchseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(sp)]); checkMeosError(); return _r; } -export function quadbin_point_to_cell(longitude: number, latitude: number, resolution: number): number { - const _r = Number(call('quadbin_point_to_cell_w', 'bigint', ['number', 'number', 'number'], [longitude, latitude, resolution])); +export function tpcpatchseqset_from_base_tstzspanset(pa: Ptr, ss: Ptr): Ptr { + const _r = callPtr('tpcpatchseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(ss)]); checkMeosError(); return _r; } -export function geo_to_quadbin_cell(point: Ptr, resolution: number): number { - const _r = Number(call('geo_to_quadbin_cell_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(point), resolution])); +export function tpcpatch_from_base_temp(pa: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tpcpatch_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_cell_to_geompoint(cell: number): Ptr { - const _r = callPtr('quadbin_cell_to_geompoint_w', ['bigint'], [BigInt(cell)]); +export function tpcpatch_start_value(temp: Ptr): Ptr { + const _r = callPtr('tpcpatch_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_cell_to_geom(cell: number): Ptr { - const _r = callPtr('quadbin_cell_to_geom_w', ['bigint'], [BigInt(cell)]); +export function tpcpatch_end_value(temp: Ptr): Ptr { + const _r = callPtr('tpcpatch_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_to_stbox(cell: number): Ptr { - const _r = callPtr('quadbin_to_stbox_w', ['bigint'], [BigInt(cell)]); +export function tpcpatch_value_n(temp: Ptr, n: number): Ptr { + const _r = callPtr('tpcpatch_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); checkMeosError(); return _r; } -export function quadbin_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr { - const _r = callPtr('quadbin_timestamptz_to_stbox_w', ['bigint', 'bigint'], [BigInt(cell), BigInt(t)]); +export function tpcpatch_values(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('tpcpatch_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); checkMeosError(); return _r; } -export function quadbin_tstzspan_to_stbox(cell: number, s: Ptr): Ptr { - const _r = callPtr('quadbin_tstzspan_to_stbox_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(s)]); +export function tpcpatch_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean, value: Ptr): boolean { + const _r = call('tpcpatch_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number', ptrArgType()], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0, ptrArgVal(value)]) !== 0; checkMeosError(); return _r; } -export function quadbin_cell_area(cell: number): number { - const _r = call('quadbin_cell_area_w', 'number', ['bigint'], [BigInt(cell)]); +export function tpcpatch_at_value(temp: Ptr, pa: Ptr): Ptr { + const _r = callPtr('tpcpatch_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function quadbin_index_to_string(index: number): string { - const _r = call('quadbin_index_to_string_w', 'string', ['bigint'], [BigInt(index)]); +export function tpcpatch_minus_value(temp: Ptr, pa: Ptr): Ptr { + const _r = callPtr('tpcpatch_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function quadbin_string_to_index(str: string): number { - const _r = Number(call('quadbin_string_to_index_w', 'bigint', ['string'], [str])); +export function ever_eq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number { + const _r = call('ever_eq_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function quadbin_cell_to_quadkey(cell: number): string { - const _r = call('quadbin_cell_to_quadkey_w', 'string', ['bigint'], [BigInt(cell)]); +export function ever_eq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number { + const _r = call('ever_eq_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function quadbin_grid_disk(origin: number, k: number): Ptr { - const _r = callPtr('quadbin_grid_disk_w', ['bigint', 'number'], [BigInt(origin), k]); +export function ever_eq_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function quadbin_cell_to_children_set(origin: number, children_resolution: number): Ptr { - const _r = callPtr('quadbin_cell_to_children_set_w', ['bigint', 'number'], [BigInt(origin), children_resolution]); +export function ever_ne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number { + const _r = call('ever_ne_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbin_in(str: string): Ptr { - const _r = callPtr('tquadbin_in_w', ['string'], [str]); +export function ever_ne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number { + const _r = call('ever_ne_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function tquadbininst_in(str: string): Ptr { - const _r = callPtr('tquadbininst_in_w', ['string'], [str]); +export function ever_ne_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function tquadbinseq_in(str: string, interp: number): Ptr { - const _r = callPtr('tquadbinseq_in_w', ['string', 'number'], [str, interp]); +export function always_eq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number { + const _r = call('always_eq_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbinseqset_in(str: string): Ptr { - const _r = callPtr('tquadbinseqset_in_w', ['string'], [str]); +export function always_eq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number { + const _r = call('always_eq_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function tquadbin_make(value: number, t: TimestampTz): Ptr { - const _r = callPtr('tquadbin_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]); +export function always_eq_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function tquadbininst_make(value: number, t: TimestampTz): Ptr { - const _r = callPtr('tquadbininst_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]); +export function always_ne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): number { + const _r = call('always_ne_pcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbinseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr { - const _r = callPtr('tquadbinseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]); +export function always_ne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): number { + const _r = call('always_ne_tpcpoint_pcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function tquadbinseqset_make(sequences: Ptr, count: number): Ptr { - const _r = callPtr('tquadbinseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]); +export function always_ne_tpcpoint_tpcpoint(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_tpcpoint_tpcpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function tquadbin_start_value(temp: Ptr): number { - const _r = Number(call('tquadbin_start_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)])); +export function ever_eq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number { + const _r = call('ever_eq_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbin_end_value(temp: Ptr): number { - const _r = Number(call('tquadbin_end_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)])); +export function ever_eq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number { + const _r = call('ever_eq_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function tquadbin_value_n(temp: Ptr, n: number): number { - const _r = Number(call('tquadbin_value_n_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(temp), n])); +export function ever_eq_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function tquadbin_values(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('tquadbin_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function ever_ne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number { + const _r = call('ever_ne_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbin_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number { - const _r = Number(call('tquadbin_value_at_timestamptz_w', 'bigint', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0])); +export function ever_ne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number { + const _r = call('ever_ne_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function quadbin_to_set(cell: number): Ptr { - const _r = callPtr('quadbin_to_set_w', ['bigint'], [BigInt(cell)]); +export function ever_ne_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function tbigint_to_tquadbin(temp: Ptr): Ptr { - const _r = callPtr('tbigint_to_tquadbin_w', [ptrArgType()], [ptrArgVal(temp)]); +export function always_eq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number { + const _r = call('always_eq_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function tquadbin_to_tbigint(temp: Ptr): Ptr { - const _r = callPtr('tquadbin_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]); +export function always_eq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number { + const _r = call('always_eq_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function ever_eq_quadbin_tquadbin(cell: number, temp: Ptr): number { - const _r = call('ever_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function always_eq_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function ever_eq_tquadbin_quadbin(temp: Ptr, cell: number): number { - const _r = call('ever_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function always_ne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): number { + const _r = call('always_ne_pcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function ever_ne_quadbin_tquadbin(cell: number, temp: Ptr): number { - const _r = call('ever_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function always_ne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): number { + const _r = call('always_ne_tpcpatch_pcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function ever_ne_tquadbin_quadbin(temp: Ptr, cell: number): number { - const _r = call('ever_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function always_ne_tpcpatch_tpcpatch(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_tpcpatch_tpcpatch_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); checkMeosError(); return _r; } -export function always_eq_quadbin_tquadbin(cell: number, temp: Ptr): number { - const _r = call('always_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function teq_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): Ptr { + const _r = callPtr('teq_pcpoint_tpcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function always_eq_tquadbin_quadbin(temp: Ptr, cell: number): number { - const _r = call('always_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function teq_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): Ptr { + const _r = callPtr('teq_tpcpoint_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function always_ne_quadbin_tquadbin(cell: number, temp: Ptr): number { - const _r = call('always_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function tne_pcpoint_tpcpoint(pt: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tne_pcpoint_tpcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pt), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function always_ne_tquadbin_quadbin(temp: Ptr, cell: number): number { - const _r = call('always_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function tne_tpcpoint_pcpoint(temp: Ptr, pt: Ptr): Ptr { + const _r = callPtr('tne_tpcpoint_pcpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pt)]); checkMeosError(); return _r; } -export function ever_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function teq_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): Ptr { + const _r = callPtr('teq_pcpatch_tpcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function ever_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function teq_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): Ptr { + const _r = callPtr('teq_tpcpatch_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function always_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function tne_pcpatch_tpcpatch(pa: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tne_pcpatch_tpcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pa), ptrArgVal(temp)]); checkMeosError(); return _r; } -export function always_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function tne_tpcpatch_pcpatch(temp: Ptr, pa: Ptr): Ptr { + const _r = callPtr('tne_tpcpatch_pcpatch_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pa)]); checkMeosError(); return _r; } -export function teq_quadbin_tquadbin(cell: number, temp: Ptr): Ptr { - const _r = callPtr('teq_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function adjacent_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean { + const _r = call('adjacent_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0; checkMeosError(); return _r; } -export function teq_tquadbin_quadbin(temp: Ptr, cell: number): Ptr { - const _r = callPtr('teq_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function adjacent_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean { + const _r = call('adjacent_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function teq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('teq_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function adjacent_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('adjacent_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; checkMeosError(); return _r; } -export function tne_quadbin_tquadbin(cell: number, temp: Ptr): Ptr { - const _r = callPtr('tne_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); +export function contained_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean { + const _r = call('contained_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0; checkMeosError(); return _r; } -export function tne_tquadbin_quadbin(temp: Ptr, cell: number): Ptr { - const _r = callPtr('tne_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); +export function contained_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean { + const _r = call('contained_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function tne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('tne_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function contained_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('contained_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; checkMeosError(); return _r; } -export function tquadbin_cell_to_quadkey(temp: Ptr): Ptr { - const _r = callPtr('tquadbin_cell_to_quadkey_w', [ptrArgType()], [ptrArgVal(temp)]); +export function contains_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean { + const _r = call('contains_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0; checkMeosError(); return _r; } - -// === meos_rgeo.h === - -export function trgeometry_in(str: string): Ptr { - const _r = callPtr('trgeometry_in_w', ['string'], [str]); +export function contains_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean { + const _r = call('contains_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_from_mfjson(mfjson: string): Ptr { - const _r = callPtr('trgeometry_from_mfjson_w', ['string'], [mfjson]); +export function contains_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('contains_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_out(temp: Ptr): string { - const _r = call('trgeometry_out_w', 'string', [ptrArgType()], [ptrArgVal(temp)]); +export function overlaps_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean { + const _r = call('overlaps_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_as_text(temp: Ptr, maxdd: number): string { - const _r = call('trgeometry_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); +export function overlaps_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean { + const _r = call('overlaps_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_as_ewkt(temp: Ptr, maxdd: number): string { - const _r = call('trgeometry_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); +export function overlaps_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('overlaps_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; checkMeosError(); return _r; } -export function trgeometryinst_make(geom: Ptr, pose: Ptr, t: TimestampTz): Ptr { - const _r = callPtr('trgeometryinst_make_w', [ptrArgType(), ptrArgType(), 'bigint'], [ptrArgVal(geom), ptrArgVal(pose), BigInt(t)]); +export function same_tpcbox_tpointcloud(box: Ptr, temp: Ptr): boolean { + const _r = call('same_tpcbox_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]) !== 0; checkMeosError(); return _r; } -export function trgeometryseq_make(geom: Ptr, instants: Ptr, count: number, lower_inc: boolean, upper_inc: boolean, interp: number, normalize: boolean): Ptr { - const _r = callPtr('trgeometryseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'number', 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0, interp, normalize ? 1 : 0]); +export function same_tpointcloud_tpcbox(temp: Ptr, box: Ptr): boolean { + const _r = call('same_tpointcloud_tpcbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]) !== 0; checkMeosError(); return _r; } -export function trgeometryseqset_make(geom: Ptr, sequences: Ptr, count: number, normalize: boolean): Ptr { - const _r = callPtr('trgeometryseqset_make_w', [ptrArgType(), ptrArgType(), 'number', 'number'], [ptrArgVal(geom), ptrArgVal(sequences), count, normalize ? 1 : 0]); +export function same_tpointcloud_tpointcloud(temp1: Ptr, temp2: Ptr): boolean { + const _r = call('same_tpointcloud_tpointcloud_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]) !== 0; checkMeosError(); return _r; } -export function trgeometryseqset_make_gaps(geom: Ptr, instants: Ptr, count: number, interp: number, maxt: Ptr, maxdist: number): Ptr { - const _r = callPtr('trgeometryseqset_make_gaps_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, interp, ptrArgVal(maxt), maxdist]); +export function eintersects_tpcpoint_geo(temp: Ptr, gs: Ptr): boolean { + const _r = call('eintersects_tpcpoint_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]) !== 0; checkMeosError(); return _r; } -export function geometry_tpose_to_trgeometry(gs: Ptr, temp: Ptr): Ptr { - const _r = callPtr('geometry_tpose_to_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function nad_tpcpoint_geo(temp: Ptr, gs: Ptr): number { + const _r = call('nad_tpcpoint_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); checkMeosError(); return _r; } -export function trgeometry_to_tpose(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]); + +// === meos_pose.h === + +export function pose_as_ewkt(pose: Ptr, maxdd: number): string { + const _r = call('pose_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); checkMeosError(); return _r; } -export function trgeometry_to_tgeompoint(temp: Ptr): Ptr { +export function pose_as_hexwkb(pose: Ptr, variant: number, size_out: Ptr): string { + const _r = call('pose_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function pose_as_text(pose: Ptr, maxdd: number): string { + const _r = call('pose_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); + checkMeosError(); + return _r; +} + +export function pose_as_wkb(pose: Ptr, variant: number, size_out: Ptr): Ptr { + const _r = callPtr('pose_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pose), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function pose_from_wkb(wkb: Ptr, size: number): Ptr { + const _r = callPtr('pose_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]); + checkMeosError(); + return _r; +} + +export function pose_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('pose_from_hexwkb_w', ['string'], [hexwkb]); + checkMeosError(); + return _r; +} + +export function pose_in(str: string): Ptr { + const _r = callPtr('pose_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function pose_out(pose: Ptr, maxdd: number): string { + const _r = call('pose_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); + checkMeosError(); + return _r; +} + +export function pose_from_geopose(json: string): Ptr { + const _r = callPtr('pose_from_geopose_w', ['string'], [json]); + checkMeosError(); + return _r; +} + +export function pose_as_geopose(pose: Ptr, conformance: number, precision: number): string { + const _r = call('pose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(pose), conformance, precision]); + checkMeosError(); + return _r; +} + +export function tpose_from_geopose(json: string): Ptr { + const _r = callPtr('tpose_from_geopose_w', ['string'], [json]); + checkMeosError(); + return _r; +} + +export function tpose_as_geopose(temp: Ptr, conformance: number, precision: number): string { + const _r = call('tpose_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temp), conformance, precision]); + checkMeosError(); + return _r; +} + +export function tpose_as_geopose_stream_element(temp: Ptr, inst: Ptr, precision: number): string { + const _r = call('tpose_as_geopose_stream_element_w', 'string', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), precision]); + checkMeosError(); + return _r; +} + +export function tpose_as_geopose_stream(temp: Ptr, precision: number): string { + const _r = call('tpose_as_geopose_stream_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]); + checkMeosError(); + return _r; +} + +export function geopose_frames(count: Ptr): Ptr { + const _r = callPtr('geopose_frames_w', [ptrArgType()], [ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function geopose_frame(frame_id: number): Ptr { + const _r = callPtr('geopose_frame_w', ['number'], [frame_id]); + checkMeosError(); + return _r; +} + +export function pose_apply_geo(pose: Ptr, body: Ptr): Ptr { + const _r = callPtr('pose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(body)]); + checkMeosError(); + return _r; +} + +export function tpose_apply_geo(temp: Ptr, body: Ptr): Ptr { + const _r = callPtr('tpose_apply_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(body)]); + checkMeosError(); + return _r; +} + +export function tpose_compose_pose(body: Ptr, frame: Ptr): Ptr { + const _r = callPtr('tpose_compose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); + checkMeosError(); + return _r; +} + +export function pose_compose_tpose(body: Ptr, frame: Ptr): Ptr { + const _r = callPtr('pose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); + checkMeosError(); + return _r; +} + +export function tpose_compose_tpose(body: Ptr, frame: Ptr): Ptr { + const _r = callPtr('tpose_compose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); + checkMeosError(); + return _r; +} + +export function tpose_inverse(temp: Ptr): Ptr { + const _r = callPtr('tpose_inverse_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function pose_copy(pose: Ptr): Ptr { + const _r = callPtr('pose_copy_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_make_2d(x: number, y: number, theta: number, geodetic: boolean, srid: number): Ptr { + const _r = callPtr('pose_make_2d_w', ['number', 'number', 'number', 'number', 'number'], [x, y, theta, geodetic ? 1 : 0, srid]); + checkMeosError(); + return _r; +} + +export function pose_make_3d(x: number, y: number, z: number, W: number, X: number, Y: number, Z: number, geodetic: boolean, srid: number): Ptr { + const _r = callPtr('pose_make_3d_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number'], [x, y, z, W, X, Y, Z, geodetic ? 1 : 0, srid]); + checkMeosError(); + return _r; +} + +export function pose_make_point2d(gs: Ptr, theta: number): Ptr { + const _r = callPtr('pose_make_point2d_w', [ptrArgType(), 'number'], [ptrArgVal(gs), theta]); + checkMeosError(); + return _r; +} + +export function pose_make_point3d(gs: Ptr, W: number, X: number, Y: number, Z: number): Ptr { + const _r = callPtr('pose_make_point3d_w', [ptrArgType(), 'number', 'number', 'number', 'number'], [ptrArgVal(gs), W, X, Y, Z]); + checkMeosError(); + return _r; +} + +export function pose_make_point3d_ypr(gs: Ptr, yaw: number, pitch: number, roll: number): Ptr { + const _r = callPtr('pose_make_point3d_ypr_w', [ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(gs), yaw, pitch, roll]); + checkMeosError(); + return _r; +} + +export function pose_to_point(pose: Ptr): Ptr { + const _r = callPtr('pose_to_point_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_to_stbox(pose: Ptr): Ptr { + const _r = callPtr('pose_to_stbox_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_hash(pose: Ptr): number { + const _r = call('pose_hash_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_hash_extended(pose: Ptr, seed: number): number { + const _r = Number(call('pose_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function pose_quaternion(pose: Ptr, count: Ptr): Ptr { + const _r = callPtr('pose_quaternion_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function pose_ypr(pose: Ptr, count: Ptr): Ptr { + const _r = callPtr('pose_ypr_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function pose_yaw(pose: Ptr): number { + const _r = call('pose_yaw_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_pitch(pose: Ptr): number { + const _r = call('pose_pitch_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_roll(pose: Ptr): number { + const _r = call('pose_roll_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_angular_distance(pose1: Ptr, pose2: Ptr): number { + const _r = call('pose_angular_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); + checkMeosError(); + return _r; +} + +export function pose_compose(body: Ptr, frame: Ptr): Ptr { + const _r = callPtr('pose_compose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(body), ptrArgVal(frame)]); + checkMeosError(); + return _r; +} + +export function pose_inverse(pose: Ptr): Ptr { + const _r = callPtr('pose_inverse_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_normalize(pose: Ptr): Ptr { + const _r = callPtr('pose_normalize_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_round(pose: Ptr, maxdd: number): Ptr { + const _r = callPtr('pose_round_w', [ptrArgType(), 'number'], [ptrArgVal(pose), maxdd]); + checkMeosError(); + return _r; +} + +export function posearr_round(posearr: Ptr, count: number, maxdd: number): Ptr { + const _r = callPtr('posearr_round_w', [ptrArgType(), 'number', 'number'], [ptrArgVal(posearr), count, maxdd]); + checkMeosError(); + return _r; +} + +export function pose_set_srid(pose: Ptr, srid: number): Ptr { + const _r = callPtr('pose_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]); + checkMeosError(); + return _r; +} + +export function pose_srid(pose: Ptr): number { + const _r = call('pose_srid_w', 'number', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_transform(pose: Ptr, srid: number): Ptr { + const _r = callPtr('pose_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pose), srid]); + checkMeosError(); + return _r; +} + +export function pose_transform_pipeline(pose: Ptr, pipelinestr: string, srid: number, is_forward: boolean): Ptr { + const _r = callPtr('pose_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pose), pipelinestr, srid, is_forward ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function pose_tstzspan_to_stbox(pose: Ptr, s: Ptr): Ptr { + const _r = callPtr('pose_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function pose_timestamptz_to_stbox(pose: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('pose_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function distance_pose_geo(pose: Ptr, gs: Ptr): number { + const _r = call('distance_pose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function distance_pose_pose(pose1: Ptr, pose2: Ptr): number { + const _r = call('distance_pose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); + checkMeosError(); + return _r; +} + +export function distance_pose_stbox(pose: Ptr, box: Ptr): number { + const _r = call('distance_pose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(box)]); + checkMeosError(); + return _r; +} + +export function pose_cmp(pose1: Ptr, pose2: Ptr): number { + const _r = call('pose_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]); + checkMeosError(); + return _r; +} + +export function pose_eq(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_ge(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_gt(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_le(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_lt(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_ne(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_nsame(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function pose_same(pose1: Ptr, pose2: Ptr): boolean { + const _r = call('pose_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose1), ptrArgVal(pose2)]) !== 0; + checkMeosError(); + return _r; +} + +export function poseset_in(str: string): Ptr { + const _r = callPtr('poseset_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function poseset_out(s: Ptr, maxdd: number): string { + const _r = call('poseset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]); + checkMeosError(); + return _r; +} + +export function poseset_make(values: Ptr, count: number): Ptr { + const _r = callPtr('poseset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]); + checkMeosError(); + return _r; +} + +export function pose_to_set(pose: Ptr): Ptr { + const _r = callPtr('pose_to_set_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function poseset_end_value(s: Ptr): Ptr { + const _r = callPtr('poseset_end_value_w', [ptrArgType()], [ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function poseset_start_value(s: Ptr): Ptr { + const _r = callPtr('poseset_start_value_w', [ptrArgType()], [ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function poseset_value_n(s: Ptr, n: number): Ptr { + const _r = callPtr('poseset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]); + checkMeosError(); + return _r; +} + +export function poseset_values(s: Ptr, count: Ptr): Ptr { + const _r = callPtr('poseset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function contained_pose_set(pose: Ptr, s: Ptr): boolean { + const _r = call('contained_pose_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]) !== 0; + checkMeosError(); + return _r; +} + +export function contains_set_pose(s: Ptr, pose: Ptr): boolean { + const _r = call('contains_set_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]) !== 0; + checkMeosError(); + return _r; +} + +export function intersection_pose_set(pose: Ptr, s: Ptr): Ptr { + const _r = callPtr('intersection_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function intersection_set_pose(s: Ptr, pose: Ptr): Ptr { + const _r = callPtr('intersection_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function minus_pose_set(pose: Ptr, s: Ptr): Ptr { + const _r = callPtr('minus_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function minus_set_pose(s: Ptr, pose: Ptr): Ptr { + const _r = callPtr('minus_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_union_transfn(state: Ptr, pose: Ptr): Ptr { + const _r = callPtr('pose_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function union_pose_set(pose: Ptr, s: Ptr): Ptr { + const _r = callPtr('union_pose_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function union_set_pose(s: Ptr, pose: Ptr): Ptr { + const _r = callPtr('union_set_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function tpose_from_mfjson(str: string): Ptr { + const _r = callPtr('tpose_from_mfjson_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function tpose_in(str: string): Ptr { + const _r = callPtr('tpose_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function tposeinst_make(pose: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('tposeinst_make_w', [ptrArgType(), 'bigint'], [ptrArgVal(pose), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function tpose_from_base_temp(pose: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tpose_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tposeseq_from_base_tstzset(pose: Ptr, s: Ptr): Ptr { + const _r = callPtr('tposeseq_from_base_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function tposeseq_from_base_tstzspan(pose: Ptr, s: Ptr, interp: number): Ptr { + const _r = callPtr('tposeseq_from_base_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(s), interp]); + checkMeosError(); + return _r; +} + +export function tposeseqset_from_base_tstzspanset(pose: Ptr, ss: Ptr, interp: number): Ptr { + const _r = callPtr('tposeseqset_from_base_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(pose), ptrArgVal(ss), interp]); + checkMeosError(); + return _r; +} + +export function tpose_make(tpoint: Ptr, ttheta: Ptr): Ptr { + const _r = callPtr('tpose_make_w', [ptrArgType(), ptrArgType()], [ptrArgVal(tpoint), ptrArgVal(ttheta)]); + checkMeosError(); + return _r; +} + +export function tpose_to_tpoint(temp: Ptr): Ptr { + const _r = callPtr('tpose_to_tpoint_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_end_value(temp: Ptr): Ptr { + const _r = callPtr('tpose_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_points(temp: Ptr): Ptr { + const _r = callPtr('tpose_points_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_yaw(temp: Ptr): Ptr { + const _r = callPtr('tpose_yaw_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_pitch(temp: Ptr): Ptr { + const _r = callPtr('tpose_pitch_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_roll(temp: Ptr): Ptr { + const _r = callPtr('tpose_roll_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_speed(temp: Ptr): Ptr { + const _r = callPtr('tpose_speed_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_angular_speed(temp: Ptr): Ptr { + const _r = callPtr('tpose_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_start_value(temp: Ptr): Ptr { + const _r = callPtr('tpose_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_trajectory(temp: Ptr): Ptr { + const _r = callPtr('tpose_trajectory_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tpose_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { + const _r = callPtr('tpose_value_at_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function tpose_value_n(temp: Ptr, n: number): Ptr { + const _r = callPtr('tpose_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); + checkMeosError(); + return _r; +} + +export function tpose_values(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('tpose_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function tpose_at_elevation(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('tpose_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function tpose_at_geom(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('tpose_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function tpose_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { + const _r = callPtr('tpose_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function tpose_at_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('tpose_at_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function tpose_minus_elevation(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('tpose_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function tpose_minus_geom(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('tpose_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function tpose_minus_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('tpose_minus_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function tpose_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { + const _r = callPtr('tpose_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function tdistance_tpose_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('tdistance_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function tdistance_tpose_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('tdistance_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function tdistance_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('tdistance_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nad_tpose_geo(temp: Ptr, gs: Ptr): number { + const _r = call('nad_tpose_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function nad_tpose_pose(temp: Ptr, pose: Ptr): number { + const _r = call('nad_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function nad_tpose_stbox(temp: Ptr, box: Ptr): number { + const _r = call('nad_tpose_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]); + checkMeosError(); + return _r; +} + +export function nad_tpose_tpose(temp1: Ptr, temp2: Ptr): number { + const _r = call('nad_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nai_tpose_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('nai_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function nai_tpose_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('nai_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function nai_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('nai_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function shortestline_tpose_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('shortestline_tpose_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function shortestline_tpose_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('shortestline_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function shortestline_tpose_tpose(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('shortestline_tpose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_eq_pose_tpose(pose: Ptr, temp: Ptr): number { + const _r = call('always_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_tpose_pose(temp: Ptr, pose: Ptr): number { + const _r = call('always_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function always_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_ne_pose_tpose(pose: Ptr, temp: Ptr): number { + const _r = call('always_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_ne_tpose_pose(temp: Ptr, pose: Ptr): number { + const _r = call('always_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function always_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_eq_pose_tpose(pose: Ptr, temp: Ptr): number { + const _r = call('ever_eq_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tpose_pose(temp: Ptr, pose: Ptr): number { + const _r = call('ever_eq_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tpose_tpose(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_ne_pose_tpose(pose: Ptr, temp: Ptr): number { + const _r = call('ever_ne_pose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tpose_pose(temp: Ptr, pose: Ptr): number { + const _r = call('ever_ne_tpose_pose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tpose_tpose(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_tpose_tpose_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function teq_pose_tpose(pose: Ptr, temp: Ptr): Ptr { + const _r = callPtr('teq_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function teq_tpose_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('teq_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function tne_pose_tpose(pose: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tne_pose_tpose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pose), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tne_tpose_pose(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('tne_tpose_pose_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function posechain_in(str: string): Ptr { + const _r = callPtr('posechain_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function posechain_out(pc: Ptr, maxdd: number): string { + const _r = call('posechain_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]); + checkMeosError(); + return _r; +} + +export function posechain_as_text(pc: Ptr, maxdd: number): string { + const _r = call('posechain_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]); + checkMeosError(); + return _r; +} + +export function posechain_as_ewkt(pc: Ptr, maxdd: number): string { + const _r = call('posechain_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]); + checkMeosError(); + return _r; +} + +export function posechain_as_wkb(pc: Ptr, variant: number, size_out: Ptr): Ptr { + const _r = callPtr('posechain_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pc), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function posechain_as_hexwkb(pc: Ptr, variant: number, size_out: Ptr): string { + const _r = call('posechain_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(pc), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function posechain_from_wkb(wkb: Ptr, size: number): Ptr { + const _r = callPtr('posechain_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]); + checkMeosError(); + return _r; +} + +export function posechain_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('posechain_from_hexwkb_w', ['string'], [hexwkb]); + checkMeosError(); + return _r; +} + +export function posechain_make(poses: Ptr, count: number): Ptr { + const _r = callPtr('posechain_make_w', [ptrArgType(), 'number'], [ptrArgVal(poses), count]); + checkMeosError(); + return _r; +} + +export function posechain_copy(pc: Ptr): Ptr { + const _r = callPtr('posechain_copy_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_append(pc: Ptr, pose: Ptr): Ptr { + const _r = callPtr('posechain_append_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function pose_to_posechain(pose: Ptr): Ptr { + const _r = callPtr('pose_to_posechain_w', [ptrArgType()], [ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function posechain_to_pose(pc: Ptr): Ptr { + const _r = callPtr('posechain_to_pose_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_prefix_pose(pc: Ptr, n: number): Ptr { + const _r = callPtr('posechain_prefix_pose_w', [ptrArgType(), 'number'], [ptrArgVal(pc), n]); + checkMeosError(); + return _r; +} + +export function posechain_to_point(pc: Ptr): Ptr { + const _r = callPtr('posechain_to_point_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_to_stbox(pc: Ptr): Ptr { + const _r = callPtr('posechain_to_stbox_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_timestamptz_to_stbox(pc: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('posechain_timestamptz_to_stbox_w', [ptrArgType(), 'bigint'], [ptrArgVal(pc), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function posechain_tstzspan_to_stbox(pc: Ptr, s: Ptr): Ptr { + const _r = callPtr('posechain_tstzspan_to_stbox_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function posechain_num_poses(pc: Ptr): number { + const _r = call('posechain_num_poses_w', 'number', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_start_pose(pc: Ptr): Ptr { + const _r = callPtr('posechain_start_pose_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_end_pose(pc: Ptr): Ptr { + const _r = callPtr('posechain_end_pose_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_pose_n(pc: Ptr, n: number): Ptr { + const _r = callPtr('posechain_pose_n_w', [ptrArgType(), 'number'], [ptrArgVal(pc), n]); + checkMeosError(); + return _r; +} + +export function posechain_poses(pc: Ptr, count: Ptr): Ptr { + const _r = callPtr('posechain_poses_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function posechain_hash(pc: Ptr): number { + const _r = call('posechain_hash_w', 'number', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_hash_extended(pc: Ptr, seed: number): number { + const _r = Number(call('posechain_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(pc), BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function posechain_round(pc: Ptr, maxdd: number): Ptr { + const _r = callPtr('posechain_round_w', [ptrArgType(), 'number'], [ptrArgVal(pc), maxdd]); + checkMeosError(); + return _r; +} + +export function posechain_srid(pc: Ptr): number { + const _r = call('posechain_srid_w', 'number', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_set_srid(pc: Ptr, srid: number): Ptr { + const _r = callPtr('posechain_set_srid_w', [ptrArgType(), 'number'], [ptrArgVal(pc), srid]); + checkMeosError(); + return _r; +} + +export function posechain_transform(pc: Ptr, srid_to: number): Ptr { + const _r = callPtr('posechain_transform_w', [ptrArgType(), 'number'], [ptrArgVal(pc), srid_to]); + checkMeosError(); + return _r; +} + +export function posechain_transform_pipeline(pc: Ptr, pipeline: string, srid_to: number, is_forward: boolean): Ptr { + const _r = callPtr('posechain_transform_pipeline_w', [ptrArgType(), 'string', 'number', 'number'], [ptrArgVal(pc), pipeline, srid_to, is_forward ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function tposechain_from_geopose(json: string): Ptr { + const _r = callPtr('tposechain_from_geopose_w', ['string'], [json]); + checkMeosError(); + return _r; +} + +export function tposechain_as_geopose(temp: Ptr, precision: number): string { + const _r = call('tposechain_as_geopose_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), precision]); + checkMeosError(); + return _r; +} + +export function tposechainarr_as_geopose(temparr: Ptr, count: number, precision: number): string { + const _r = call('tposechainarr_as_geopose_w', 'string', [ptrArgType(), 'number', 'number'], [ptrArgVal(temparr), count, precision]); + checkMeosError(); + return _r; +} + +export function posechain_eq(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_ne(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_same(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_same_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_nsame(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_nsame_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_cmp(pc1: Ptr, pc2: Ptr): number { + const _r = call('posechain_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]); + checkMeosError(); + return _r; +} + +export function posechain_lt(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_le(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_gt(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechain_ge(pc1: Ptr, pc2: Ptr): boolean { + const _r = call('posechain_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc1), ptrArgVal(pc2)]) !== 0; + checkMeosError(); + return _r; +} + +export function posechainset_in(str: string): Ptr { + const _r = callPtr('posechainset_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function posechainset_out(s: Ptr, maxdd: number): string { + const _r = call('posechainset_out_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(s), maxdd]); + checkMeosError(); + return _r; +} + +export function posechainset_make(values: Ptr, count: number): Ptr { + const _r = callPtr('posechainset_make_w', [ptrArgType(), 'number'], [ptrArgVal(values), count]); + checkMeosError(); + return _r; +} + +export function posechain_to_set(pc: Ptr): Ptr { + const _r = callPtr('posechain_to_set_w', [ptrArgType()], [ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechainset_end_value(s: Ptr): Ptr { + const _r = callPtr('posechainset_end_value_w', [ptrArgType()], [ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function posechainset_start_value(s: Ptr): Ptr { + const _r = callPtr('posechainset_start_value_w', [ptrArgType()], [ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function posechainset_value_n(s: Ptr, n: number): Ptr { + const _r = callPtr('posechainset_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(s), n]); + checkMeosError(); + return _r; +} + +export function posechainset_values(s: Ptr, count: Ptr): Ptr { + const _r = callPtr('posechainset_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function contained_posechain_set(pc: Ptr, s: Ptr): boolean { + const _r = call('contained_posechain_set_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]) !== 0; + checkMeosError(); + return _r; +} + +export function contains_set_posechain(s: Ptr, pc: Ptr): boolean { + const _r = call('contains_set_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]) !== 0; + checkMeosError(); + return _r; +} + +export function intersection_posechain_set(pc: Ptr, s: Ptr): Ptr { + const _r = callPtr('intersection_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function intersection_set_posechain(s: Ptr, pc: Ptr): Ptr { + const _r = callPtr('intersection_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function minus_posechain_set(pc: Ptr, s: Ptr): Ptr { + const _r = callPtr('minus_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function minus_set_posechain(s: Ptr, pc: Ptr): Ptr { + const _r = callPtr('minus_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function posechain_union_transfn(state: Ptr, pc: Ptr): Ptr { + const _r = callPtr('posechain_union_transfn_w', [ptrArgType(), ptrArgType()], [ptrArgVal(state), ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function union_posechain_set(pc: Ptr, s: Ptr): Ptr { + const _r = callPtr('union_posechain_set_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function union_set_posechain(s: Ptr, pc: Ptr): Ptr { + const _r = callPtr('union_set_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(s), ptrArgVal(pc)]); + checkMeosError(); + return _r; +} + +export function tposechain_in(str: string): Ptr { + const _r = callPtr('tposechain_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function tposechain_from_mfjson(mfjson: string): Ptr { + const _r = callPtr('tposechain_from_mfjson_w', ['string'], [mfjson]); + checkMeosError(); + return _r; +} + +export function tposechain_from_base_temp(pc: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tposechain_from_base_temp_w', [ptrArgType(), ptrArgType()], [ptrArgVal(pc), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tposechain_to_tpose(temp: Ptr): Ptr { + const _r = callPtr('tposechain_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tposechain_num_poses(temp: Ptr): number { + const _r = call('tposechain_num_poses_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_posechain_tposechain(posechain: Ptr, temp: Ptr): number { + const _r = call('always_eq_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_tposechain_posechain(temp: Ptr, posechain: Ptr): number { + const _r = call('always_eq_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + +export function always_eq_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_ne_posechain_tposechain(posechain: Ptr, temp: Ptr): number { + const _r = call('always_ne_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_ne_tposechain_posechain(temp: Ptr, posechain: Ptr): number { + const _r = call('always_ne_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + +export function always_ne_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_eq_posechain_tposechain(posechain: Ptr, temp: Ptr): number { + const _r = call('ever_eq_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tposechain_posechain(temp: Ptr, posechain: Ptr): number { + const _r = call('ever_eq_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_ne_posechain_tposechain(posechain: Ptr, temp: Ptr): number { + const _r = call('ever_ne_posechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tposechain_posechain(temp: Ptr, posechain: Ptr): number { + const _r = call('ever_ne_tposechain_posechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tposechain_tposechain(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_tposechain_tposechain_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function teq_posechain_tposechain(posechain: Ptr, temp: Ptr): Ptr { + const _r = callPtr('teq_posechain_tposechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function teq_tposechain_posechain(temp: Ptr, posechain: Ptr): Ptr { + const _r = callPtr('teq_tposechain_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + +export function tne_posechain_tposechain(posechain: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tne_posechain_tposechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(posechain), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tne_tposechain_posechain(temp: Ptr, posechain: Ptr): Ptr { + const _r = callPtr('tne_tposechain_posechain_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(posechain)]); + checkMeosError(); + return _r; +} + + +// === meos_quadbin.h === + +export function quadbin_in(str: string): number { + const _r = Number(call('quadbin_in_w', 'bigint', ['string'], [str])); + checkMeosError(); + return _r; +} + +export function quadbin_eq(a: number, b: number): boolean { + const _r = call('quadbin_eq_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_ne(a: number, b: number): boolean { + const _r = call('quadbin_ne_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_lt(a: number, b: number): boolean { + const _r = call('quadbin_lt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_le(a: number, b: number): boolean { + const _r = call('quadbin_le_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_gt(a: number, b: number): boolean { + const _r = call('quadbin_gt_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_ge(a: number, b: number): boolean { + const _r = call('quadbin_ge_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_cmp(a: number, b: number): number { + const _r = call('quadbin_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(a), BigInt(b)]); + checkMeosError(); + return _r; +} + +export function quadbin_hash(cell: number): number { + const _r = call('quadbin_hash_w', 'number', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_hash_extended(cell: number, seed: number): number { + const _r = Number(call('quadbin_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(cell), BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function quadbin_is_valid_index(index: number): boolean { + const _r = call('quadbin_is_valid_index_w', 'number', ['bigint'], [BigInt(index)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_is_valid_cell(cell: number): boolean { + const _r = call('quadbin_is_valid_cell_w', 'number', ['bigint'], [BigInt(cell)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_tile_to_cell(x: number, y: number, z: number): number { + const _r = Number(call('quadbin_tile_to_cell_w', 'bigint', ['number', 'number', 'number'], [x, y, z])); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_tile(cell: number, x: Ptr, y: Ptr, z: Ptr): boolean { + const _r = call('quadbin_cell_to_tile_w', 'number', ['bigint', ptrArgType(), ptrArgType(), ptrArgType()], [BigInt(cell), ptrArgVal(x), ptrArgVal(y), ptrArgVal(z)]) !== 0; + checkMeosError(); + return _r; +} + +export function quadbin_get_resolution(cell: number): number { + const _r = call('quadbin_get_resolution_w', 'number', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_parent(cell: number, parent_resolution: number): number { + const _r = Number(call('quadbin_cell_to_parent_w', 'bigint', ['bigint', 'number'], [BigInt(cell), parent_resolution])); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_children(cell: number, children_resolution: number, count: Ptr): Ptr { + const _r = callPtr('quadbin_cell_to_children_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), children_resolution, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function quadbin_cell_sibling(cell: number, direction: string): number { + const _r = Number(call('quadbin_cell_sibling_w', 'bigint', ['bigint', 'string'], [BigInt(cell), direction])); + checkMeosError(); + return _r; +} + +export function quadbin_k_ring(cell: number, k: number, count: Ptr): Ptr { + const _r = callPtr('quadbin_k_ring_w', ['bigint', 'number', ptrArgType()], [BigInt(cell), k, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function quadbin_point_to_cell(longitude: number, latitude: number, resolution: number): number { + const _r = Number(call('quadbin_point_to_cell_w', 'bigint', ['number', 'number', 'number'], [longitude, latitude, resolution])); + checkMeosError(); + return _r; +} + +export function geo_to_quadbin_cell(point: Ptr, resolution: number): number { + const _r = Number(call('geo_to_quadbin_cell_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(point), resolution])); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_geompoint(cell: number): Ptr { + const _r = callPtr('quadbin_cell_to_geompoint_w', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_geom(cell: number): Ptr { + const _r = callPtr('quadbin_cell_to_geom_w', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_to_stbox(cell: number): Ptr { + const _r = callPtr('quadbin_to_stbox_w', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr { + const _r = callPtr('quadbin_timestamptz_to_stbox_w', ['bigint', 'bigint'], [BigInt(cell), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function quadbin_tstzspan_to_stbox(cell: number, s: Ptr): Ptr { + const _r = callPtr('quadbin_tstzspan_to_stbox_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function quadbin_cell_area(cell: number): number { + const _r = call('quadbin_cell_area_w', 'number', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_index_to_string(index: number): string { + const _r = call('quadbin_index_to_string_w', 'string', ['bigint'], [BigInt(index)]); + checkMeosError(); + return _r; +} + +export function quadbin_string_to_index(str: string): number { + const _r = Number(call('quadbin_string_to_index_w', 'bigint', ['string'], [str])); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_quadkey(cell: number): string { + const _r = call('quadbin_cell_to_quadkey_w', 'string', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function quadbin_grid_disk(origin: number, k: number): Ptr { + const _r = callPtr('quadbin_grid_disk_w', ['bigint', 'number'], [BigInt(origin), k]); + checkMeosError(); + return _r; +} + +export function quadbin_cell_to_children_set(origin: number, children_resolution: number): Ptr { + const _r = callPtr('quadbin_cell_to_children_set_w', ['bigint', 'number'], [BigInt(origin), children_resolution]); + checkMeosError(); + return _r; +} + +export function tquadbin_in(str: string): Ptr { + const _r = callPtr('tquadbin_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function tquadbin_make(value: number, t: TimestampTz): Ptr { + const _r = callPtr('tquadbin_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function tquadbininst_make(value: number, t: TimestampTz): Ptr { + const _r = callPtr('tquadbininst_make_w', ['bigint', 'bigint'], [BigInt(value), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function tquadbinseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr { + const _r = callPtr('tquadbinseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function tquadbinseqset_make(sequences: Ptr, count: number): Ptr { + const _r = callPtr('tquadbinseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]); + checkMeosError(); + return _r; +} + +export function tquadbin_start_value(temp: Ptr): number { + const _r = Number(call('tquadbin_start_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)])); + checkMeosError(); + return _r; +} + +export function tquadbin_end_value(temp: Ptr): number { + const _r = Number(call('tquadbin_end_value_w', 'bigint', [ptrArgType()], [ptrArgVal(temp)])); + checkMeosError(); + return _r; +} + +export function tquadbin_value_n(temp: Ptr, n: number): number { + const _r = Number(call('tquadbin_value_n_w', 'bigint', [ptrArgType(), 'number'], [ptrArgVal(temp), n])); + checkMeosError(); + return _r; +} + +export function tquadbin_values(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('tquadbin_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function tquadbin_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number { + const _r = Number(call('tquadbin_value_at_timestamptz_w', 'bigint', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0])); + checkMeosError(); + return _r; +} + +export function quadbin_to_set(cell: number): Ptr { + const _r = callPtr('quadbin_to_set_w', ['bigint'], [BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function tbigint_to_tquadbin(temp: Ptr): Ptr { + const _r = callPtr('tbigint_to_tquadbin_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tquadbin_to_tbigint(temp: Ptr): Ptr { + const _r = callPtr('tquadbin_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_quadbin_tquadbin(cell: number, temp: Ptr): number { + const _r = call('ever_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tquadbin_quadbin(temp: Ptr, cell: number): number { + const _r = call('ever_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function ever_ne_quadbin_tquadbin(cell: number, temp: Ptr): number { + const _r = call('ever_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tquadbin_quadbin(temp: Ptr, cell: number): number { + const _r = call('ever_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function always_eq_quadbin_tquadbin(cell: number, temp: Ptr): number { + const _r = call('always_eq_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_tquadbin_quadbin(temp: Ptr, cell: number): number { + const _r = call('always_eq_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function always_ne_quadbin_tquadbin(cell: number, temp: Ptr): number { + const _r = call('always_ne_quadbin_tquadbin_w', 'number', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_ne_tquadbin_quadbin(temp: Ptr, cell: number): number { + const _r = call('always_ne_tquadbin_quadbin_w', 'number', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function ever_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_eq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_ne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_tquadbin_tquadbin_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function teq_quadbin_tquadbin(cell: number, temp: Ptr): Ptr { + const _r = callPtr('teq_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function teq_tquadbin_quadbin(temp: Ptr, cell: number): Ptr { + const _r = callPtr('teq_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function teq_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('teq_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function tne_quadbin_tquadbin(cell: number, temp: Ptr): Ptr { + const _r = callPtr('tne_quadbin_tquadbin_w', ['bigint', ptrArgType()], [BigInt(cell), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tne_tquadbin_quadbin(temp: Ptr, cell: number): Ptr { + const _r = callPtr('tne_tquadbin_quadbin_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(cell)]); + checkMeosError(); + return _r; +} + +export function tne_tquadbin_tquadbin(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('tne_tquadbin_tquadbin_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function tquadbin_cell_to_quadkey(temp: Ptr): Ptr { + const _r = callPtr('tquadbin_cell_to_quadkey_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + + +// === meos_raster.h === + +export function raquet_pixtype_size(pixtype: number): number { + const _r = call('raquet_pixtype_size_w', 'number', ['number'], [pixtype]); + checkMeosError(); + return _r; +} + +export function raquet_pixtype_from_string(str: string): number { + const _r = call('raquet_pixtype_from_string_w', 'number', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function raquet_in(str: string): Ptr { + const _r = callPtr('raquet_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function raquet_out(rq: Ptr): string { + const _r = call('raquet_out_w', 'string', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_from_wkb(wkb: Ptr, size: number): Ptr { + const _r = callPtr('raquet_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]); + checkMeosError(); + return _r; +} + +export function raquet_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('raquet_from_hexwkb_w', ['string'], [hexwkb]); + checkMeosError(); + return _r; +} + +export function raquet_as_wkb(rq: Ptr, variant: number, size_out: Ptr): Ptr { + const _r = callPtr('raquet_as_wkb_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rq), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function raquet_as_hexwkb(rq: Ptr, variant: number, size_out: Ptr): string { + const _r = call('raquet_as_hexwkb_w', 'string', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(rq), variant, ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function raquet_make(quadbin: number, width: number, height: number, pixtype: number, nodata: number, has_nodata: boolean, pixels: Ptr, pixels_size: number): Ptr { + const _r = callPtr('raquet_make_w', ['bigint', 'number', 'number', 'number', 'number', 'number', ptrArgType(), 'number'], [BigInt(quadbin), width, height, pixtype, nodata, has_nodata ? 1 : 0, ptrArgVal(pixels), pixels_size]); + checkMeosError(); + return _r; +} + +export function raquet_copy(rq: Ptr): Ptr { + const _r = callPtr('raquet_copy_w', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_read(path: string, quadbin: number): Ptr { + const _r = callPtr('raquet_read_w', ['string', 'bigint'], [path, BigInt(quadbin)]); + checkMeosError(); + return _r; +} + +export function raquet_read_bytes(data: Ptr, size: number, quadbin: number): Ptr { + const _r = callPtr('raquet_read_bytes_w', [ptrArgType(), 'number', 'bigint'], [ptrArgVal(data), size, BigInt(quadbin)]); + checkMeosError(); + return _r; +} + +export function raquet_quadbin(rq: Ptr): number { + const _r = Number(call('raquet_quadbin_w', 'bigint', [ptrArgType()], [ptrArgVal(rq)])); + checkMeosError(); + return _r; +} + +export function raquet_width(rq: Ptr): number { + const _r = call('raquet_width_w', 'number', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_height(rq: Ptr): number { + const _r = call('raquet_height_w', 'number', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_nodata(rq: Ptr): number { + const _r = call('raquet_nodata_w', 'number', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_pixtype(rq: Ptr): string { + const _r = call('raquet_pixtype_w', 'string', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_pixels(rq: Ptr, size_out: Ptr): Ptr { + const _r = callPtr('raquet_pixels_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rq), ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function raquet_hash(rq: Ptr): number { + const _r = call('raquet_hash_w', 'number', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_hash_extended(rq: Ptr, seed: number): number { + const _r = Number(call('raquet_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(rq), BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function raster_from_wkb(wkb: Ptr, size: number): Ptr { + const _r = callPtr('raster_from_wkb_w', [ptrArgType(), 'number'], [ptrArgVal(wkb), size]); + checkMeosError(); + return _r; +} + +export function raster_from_hexwkb(hexwkb: string): Ptr { + const _r = callPtr('raster_from_hexwkb_w', ['string'], [hexwkb]); + checkMeosError(); + return _r; +} + +export function raster_as_wkb(rast: Ptr, size_out: Ptr): Ptr { + const _r = callPtr('raster_as_wkb_w', [ptrArgType(), ptrArgType()], [ptrArgVal(rast), ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function raster_as_hexwkb(rast: Ptr, size_out: Ptr): string { + const _r = call('raster_as_hexwkb_w', 'string', [ptrArgType(), ptrArgType()], [ptrArgVal(rast), ptrArgVal(size_out)]); + checkMeosError(); + return _r; +} + +export function raster_num_bands(rast: Ptr): number { + const _r = call('raster_num_bands_w', 'number', [ptrArgType()], [ptrArgVal(rast)]); + checkMeosError(); + return _r; +} + +export function raquet_to_stbox(rq: Ptr): Ptr { + const _r = callPtr('raquet_to_stbox_w', [ptrArgType()], [ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raquet_cmp(rq1: Ptr, rq2: Ptr): number { + const _r = call('raquet_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]); + checkMeosError(); + return _r; +} + +export function raquet_eq(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raquet_ne(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raquet_lt(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raquet_le(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raquet_ge(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raquet_gt(rq1: Ptr, rq2: Ptr): boolean { + const _r = call('raquet_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(rq1), ptrArgVal(rq2)]) !== 0; + checkMeosError(); + return _r; +} + +export function raster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr): Ptr { + const _r = callPtr('raster_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx)]); + checkMeosError(); + return _r; +} + +export function raster_at_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): Ptr { + const _r = callPtr('raster_at_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function raster_minus_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): Ptr { + const _r = callPtr('raster_minus_value_w', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function eraster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): number { + const _r = call('eraster_value_w', 'number', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function araster_value(traj: Ptr, box: Ptr, sample: number, ctx: Ptr, vspan: Ptr): number { + const _r = call('araster_value_w', 'number', [ptrArgType(), ptrArgType(), 'number', ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(box), sample, ptrArgVal(ctx), ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function raster_value_gdal(traj: Ptr, path: string, band: number): Ptr { + const _r = callPtr('raster_value_gdal_w', [ptrArgType(), 'string', 'number'], [ptrArgVal(traj), path, band]); + checkMeosError(); + return _r; +} + +export function raster_at_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): Ptr { + const _r = callPtr('raster_at_value_gdal_w', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function raster_minus_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): Ptr { + const _r = callPtr('raster_minus_value_gdal_w', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function eraster_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): number { + const _r = call('eraster_value_gdal_w', 'number', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function araster_value_gdal(traj: Ptr, path: string, band: number, vspan: Ptr): number { + const _r = call('araster_value_gdal_w', 'number', [ptrArgType(), 'string', 'number', ptrArgType()], [ptrArgVal(traj), path, band, ptrArgVal(vspan)]); + checkMeosError(); + return _r; +} + +export function raster_tile_value_quadbin(traj: Ptr, pixels: Ptr, pixels_size: number, width: number, height: number, quadbin: number, pixtype: number, nodata: number, has_nodata: boolean): Ptr { + const _r = callPtr('raster_tile_value_quadbin_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'bigint', 'number', 'number', 'number'], [ptrArgVal(traj), ptrArgVal(pixels), pixels_size, width, height, BigInt(quadbin), pixtype, nodata, has_nodata ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function raster_tile_value(traj: Ptr, rq: Ptr): Ptr { + const _r = callPtr('raster_tile_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(traj), ptrArgVal(rq)]); + checkMeosError(); + return _r; +} + +export function raster_tile_value_array(traj: Ptr, rqarr: Ptr, count: number): Ptr { + const _r = callPtr('raster_tile_value_array_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(traj), ptrArgVal(rqarr), count]); + checkMeosError(); + return _r; +} + +export function trajectory_quadbins(traj: Ptr, zoom: number, count: Ptr): Ptr { + const _r = callPtr('trajectory_quadbins_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(traj), zoom, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + + +// === meos_rgeo.h === + +export function trgeometry_in(str: string): Ptr { + const _r = callPtr('trgeometry_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function trgeometry_from_mfjson(mfjson: string): Ptr { + const _r = callPtr('trgeometry_from_mfjson_w', ['string'], [mfjson]); + checkMeosError(); + return _r; +} + +export function trgeometry_out(temp: Ptr): string { + const _r = call('trgeometry_out_w', 'string', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_as_text(temp: Ptr, maxdd: number): string { + const _r = call('trgeometry_as_text_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); + checkMeosError(); + return _r; +} + +export function trgeometry_as_ewkt(temp: Ptr, maxdd: number): string { + const _r = call('trgeometry_as_ewkt_w', 'string', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); + checkMeosError(); + return _r; +} + +export function trgeometryinst_make(geom: Ptr, pose: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('trgeometryinst_make_w', [ptrArgType(), ptrArgType(), 'bigint'], [ptrArgVal(geom), ptrArgVal(pose), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function trgeometryseq_make(geom: Ptr, instants: Ptr, count: number, lower_inc: boolean, upper_inc: boolean, interp: number, normalize: boolean): Ptr { + const _r = callPtr('trgeometryseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number', 'number', 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0, interp, normalize ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometryseqset_make(geom: Ptr, sequences: Ptr, count: number, normalize: boolean): Ptr { + const _r = callPtr('trgeometryseqset_make_w', [ptrArgType(), ptrArgType(), 'number', 'number'], [ptrArgVal(geom), ptrArgVal(sequences), count, normalize ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometryseqset_make_gaps(geom: Ptr, instants: Ptr, count: number, interp: number, maxt: Ptr, maxdist: number): Ptr { + const _r = callPtr('trgeometryseqset_make_gaps_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(geom), ptrArgVal(instants), count, interp, ptrArgVal(maxt), maxdist]); + checkMeosError(); + return _r; +} + +export function geometry_tpose_to_trgeometry(gs: Ptr, temp: Ptr): Ptr { + const _r = callPtr('geometry_tpose_to_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_to_tpose(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_to_tpose_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_to_tgeompoint(temp: Ptr): Ptr { const _r = callPtr('trgeometry_to_tgeompoint_w', [ptrArgType()], [ptrArgVal(temp)]); checkMeosError(); return _r; } -export function trgeometry_to_tgeometry(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]); +export function trgeometry_to_tgeometry(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_to_tgeometry_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_end_instant(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_end_instant_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_end_sequence(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_end_sequence_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_end_value(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_geom(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_geom_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_instant_n(temp: Ptr, n: number): Ptr { + const _r = callPtr('trgeometry_instant_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); + checkMeosError(); + return _r; +} + +export function trgeometry_instants(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_instants_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_points(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_points_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_yaw(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_yaw_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_pitch(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_pitch_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_roll(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_roll_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_segments(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_segments_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_sequence_n(temp: Ptr, i: number): Ptr { + const _r = callPtr('trgeometry_sequence_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), i]); + checkMeosError(); + return _r; +} + +export function trgeometry_sequences(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_sequences_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_start_instant(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_start_instant_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_start_sequence(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_start_sequence_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_start_value(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_value_n(temp: Ptr, n: number): Ptr { + const _r = callPtr('trgeometry_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); + checkMeosError(); + return _r; +} + +export function trgeometry_traversed_area(temp: Ptr, unary_union: boolean): Ptr { + const _r = callPtr('trgeometry_traversed_area_w', [ptrArgType(), 'number'], [ptrArgVal(temp), unary_union ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_centroid(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_centroid_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_convex_hull(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_convex_hull_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_body_point_trajectory(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('trgeometry_body_point_trajectory_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function trgeometry_space_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, sorigin: Ptr, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr { + const _r = callPtr('trgeometry_space_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(sorigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_space_time_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, duration: Ptr, sorigin: Ptr, torigin: TimestampTz, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr { + const _r = callPtr('trgeometry_space_time_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), ptrArgType(), 'bigint', 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(duration), ptrArgVal(sorigin), BigInt(torigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_stboxes(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_stboxes_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_split_n_stboxes(temp: Ptr, box_count: number, count: Ptr): Ptr { + const _r = callPtr('trgeometry_split_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), box_count, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_split_each_n_stboxes(temp: Ptr, elem_count: number, count: Ptr): Ptr { + const _r = callPtr('trgeometry_split_each_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), elem_count, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_hausdorff_distance(temp1: Ptr, temp2: Ptr): number { + const _r = call('trgeometry_hausdorff_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function trgeometry_frechet_distance(temp1: Ptr, temp2: Ptr): number { + const _r = call('trgeometry_frechet_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function trgeometry_dyntimewarp_distance(temp1: Ptr, temp2: Ptr): number { + const _r = call('trgeometry_dyntimewarp_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function trgeometry_frechet_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_frechet_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_dyntimewarp_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr { + const _r = callPtr('trgeometry_dyntimewarp_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function trgeometry_length(temp: Ptr): number { + const _r = call('trgeometry_length_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_cumulative_length(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_cumulative_length_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_angular_speed(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_speed(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_speed_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_twcentroid(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_twcentroid_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_append_tinstant(temp: Ptr, inst: Ptr, interp: number, maxdist: number, maxt: Ptr, expand: boolean): Ptr { + const _r = callPtr('trgeometry_append_tinstant_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), interp, maxdist, ptrArgVal(maxt), expand ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_append_tsequence(temp: Ptr, seq: Ptr, expand: boolean): Ptr { + const _r = callPtr('trgeometry_append_tsequence_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(seq), expand ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_delete_timestamptz(temp: Ptr, t: TimestampTz, connect: boolean): Ptr { + const _r = callPtr('trgeometry_delete_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), connect ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_delete_tstzset(temp: Ptr, s: Ptr, connect: boolean): Ptr { + const _r = callPtr('trgeometry_delete_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_delete_tstzspan(temp: Ptr, s: Ptr, connect: boolean): Ptr { + const _r = callPtr('trgeometry_delete_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_delete_tstzspanset(temp: Ptr, ss: Ptr, connect: boolean): Ptr { + const _r = callPtr('trgeometry_delete_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), connect ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_merge(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('trgeometry_merge_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function trgeometry_merge_array(temparr: Ptr, count: number): Ptr { + const _r = callPtr('trgeometry_merge_array_w', [ptrArgType(), 'number'], [ptrArgVal(temparr), count]); + checkMeosError(); + return _r; +} + +export function trgeometry_round(temp: Ptr, maxdd: number): Ptr { + const _r = callPtr('trgeometry_round_w', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); + checkMeosError(); + return _r; +} + +export function trgeometry_set_interp(temp: Ptr, interp: number): Ptr { + const _r = callPtr('trgeometry_set_interp_w', [ptrArgType(), 'number'], [ptrArgVal(temp), interp]); + checkMeosError(); + return _r; +} + +export function trgeometry_as_tinstant(temp: Ptr): Ptr { + const _r = callPtr('trgeometry_as_tinstant_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function trgeometry_as_tsequence(temp: Ptr, interp_str: string): Ptr { + const _r = callPtr('trgeometry_as_tsequence_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]); + checkMeosError(); + return _r; +} + +export function trgeometry_as_tsequenceset(temp: Ptr, interp_str: string): Ptr { + const _r = callPtr('trgeometry_as_tsequenceset_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]); + checkMeosError(); + return _r; +} + +export function trgeometry_after_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { + const _r = callPtr('trgeometry_after_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_before_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { + const _r = callPtr('trgeometry_before_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_geom(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('trgeometry_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_geom(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { + const _r = callPtr('trgeometry_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { + const _r = callPtr('trgeometry_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_value(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('trgeometry_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_value(temp: Ptr, pose: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_values(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_at_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_values(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_timestamptz(temp: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('trgeometry_at_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_timestamptz(temp: Ptr, t: TimestampTz): Ptr { + const _r = callPtr('trgeometry_minus_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_tstzset(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_at_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_tstzset(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_tstzspan(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_at_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_tstzspan(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_tstzspanset(temp: Ptr, ss: Ptr): Ptr { + const _r = callPtr('trgeometry_at_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_tstzspanset(temp: Ptr, ss: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]); + checkMeosError(); + return _r; +} + +export function trgeometry_at_elevation(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function trgeometry_minus_elevation(temp: Ptr, s: Ptr): Ptr { + const _r = callPtr('trgeometry_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function tdistance_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('tdistance_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function tdistance_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('tdistance_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function tdistance_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('tdistance_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nad_stbox_trgeometry(box: Ptr, temp: Ptr): number { + const _r = call('nad_stbox_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function nad_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('nad_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function nad_trgeometry_stbox(temp: Ptr, box: Ptr): number { + const _r = call('nad_trgeometry_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]); + checkMeosError(); + return _r; +} + +export function nad_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): number { + const _r = call('nad_trgeometry_tpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nad_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('nad_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nai_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('nai_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function nai_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('nai_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function nai_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('nai_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function shortestline_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('shortestline_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function shortestline_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('shortestline_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function shortestline_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('shortestline_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('always_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('always_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function always_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('always_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('always_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function always_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('ever_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('ever_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function ever_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('ever_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('ever_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function ever_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function teq_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr { + const _r = callPtr('teq_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function teq_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('teq_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function tne_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr { + const _r = callPtr('tne_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tne_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { + const _r = callPtr('tne_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function econtains_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('econtains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function acontains_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('acontains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ecovers_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('ecovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function acovers_geo_trgeometry(gs: Ptr, temp: Ptr): number { + const _r = call('acovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ecovers_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('ecovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function acovers_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('acovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function edisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('edisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function adisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('adisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function eintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('eintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function aintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('aintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function etouches_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('etouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function atouches_trgeometry_geo(temp: Ptr, gs: Ptr): number { + const _r = call('atouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); + checkMeosError(); + return _r; +} + +export function edwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number { + const _r = call('edwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]); + checkMeosError(); + return _r; +} + +export function adwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number { + const _r = call('adwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]); + checkMeosError(); + return _r; +} + +export function edisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('edisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function adisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('adisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function eintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('eintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function aintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { + const _r = call('aintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function edwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number { + const _r = call('edwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]); + checkMeosError(); + return _r; +} + +export function adwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number { + const _r = call('adwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]); + checkMeosError(); + return _r; +} + + +// === meos_s2cell.h === + +export function s2cell_in(str: string): number { + const _r = call('s2cell_in_w', 'number', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function s2cell_out(cell: number): string { + const _r = call('s2cell_out_w', 'string', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_eq(a: number, b: number): boolean { + const _r = call('s2cell_eq_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_ne(a: number, b: number): boolean { + const _r = call('s2cell_ne_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_lt(a: number, b: number): boolean { + const _r = call('s2cell_lt_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_le(a: number, b: number): boolean { + const _r = call('s2cell_le_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_gt(a: number, b: number): boolean { + const _r = call('s2cell_gt_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_ge(a: number, b: number): boolean { + const _r = call('s2cell_ge_w', 'number', ['number', 'number'], [a, b]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_cmp(a: number, b: number): number { + const _r = call('s2cell_cmp_w', 'number', ['number', 'number'], [a, b]); + checkMeosError(); + return _r; +} + +export function s2cell_hash(cell: number): number { + const _r = call('s2cell_hash_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_hash_extended(cell: number, seed: number): number { + const _r = Number(call('s2cell_hash_extended_w', 'bigint', ['number', 'bigint'], [cell, BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function s2cell_is_valid_cell(cell: number): boolean { + const _r = call('s2cell_is_valid_cell_w', 'number', ['number'], [cell]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_token(cell: number): string { + const _r = call('s2cell_cell_to_token_w', 'string', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_token_to_cell(token: string): number { + const _r = call('s2cell_token_to_cell_w', 'number', ['string'], [token]); + checkMeosError(); + return _r; +} + +export function s2cell_get_resolution(cell: number): number { + const _r = call('s2cell_get_resolution_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_get_face(cell: number): number { + const _r = call('s2cell_get_face_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_parent(cell: number, level: number): number { + const _r = call('s2cell_cell_to_parent_w', 'number', ['number', 'number'], [cell, level]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_child(cell: number, level: number, position: number): number { + const _r = call('s2cell_cell_to_child_w', 'number', ['number', 'number', 'number'], [cell, level, position]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_children(cell: number, level: number, count: Ptr): Ptr { + const _r = callPtr('s2cell_cell_to_children_w', ['number', 'number', ptrArgType()], [cell, level, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_contains(cell: number, other: number): boolean { + const _r = call('s2cell_cell_contains_w', 'number', ['number', 'number'], [cell, other]) !== 0; + checkMeosError(); + return _r; +} + +export function s2cell_common_ancestor_level(a: number, b: number): number { + const _r = call('s2cell_common_ancestor_level_w', 'number', ['number', 'number'], [a, b]); + checkMeosError(); + return _r; +} + +export function s2cell_range_min(cell: number): number { + const _r = call('s2cell_range_min_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_range_max(cell: number): number { + const _r = call('s2cell_range_max_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_edge_neighbors(cell: number, count: Ptr): Ptr { + const _r = callPtr('s2cell_edge_neighbors_w', ['number', ptrArgType()], [cell, ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function s2cell_point_to_cell(longitude: number, latitude: number, level: number): number { + const _r = call('s2cell_point_to_cell_w', 'number', ['number', 'number', 'number'], [longitude, latitude, level]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_area(cell: number): number { + const _r = call('s2cell_cell_area_w', 'number', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_edge_length(cell: number, edge: number): number { + const _r = call('s2cell_edge_length_w', 'number', ['number', 'number'], [cell, edge]); + checkMeosError(); + return _r; +} + +export function geo_to_s2cell_cell(point: Ptr, level: number): number { + const _r = call('geo_to_s2cell_cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(point), level]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_geogpoint(cell: number): Ptr { + const _r = callPtr('s2cell_cell_to_geogpoint_w', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_geog(cell: number): Ptr { + const _r = callPtr('s2cell_cell_to_geog_w', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_to_stbox(cell: number): Ptr { + const _r = callPtr('s2cell_to_stbox_w', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_timestamptz_to_stbox(cell: number, t: TimestampTz): Ptr { + const _r = callPtr('s2cell_timestamptz_to_stbox_w', ['number', 'bigint'], [cell, BigInt(t)]); + checkMeosError(); + return _r; +} + +export function s2cell_tstzspan_to_stbox(cell: number, s: Ptr): Ptr { + const _r = callPtr('s2cell_tstzspan_to_stbox_w', ['number', ptrArgType()], [cell, ptrArgVal(s)]); + checkMeosError(); + return _r; +} + +export function s2cell_edge_neighbors_set(cell: number): Ptr { + const _r = callPtr('s2cell_edge_neighbors_set_w', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function s2cell_cell_to_children_set(cell: number, children_level: number): Ptr { + const _r = callPtr('s2cell_cell_to_children_set_w', ['number', 'number'], [cell, children_level]); + checkMeosError(); + return _r; +} + +export function ts2cell_in(str: string): Ptr { + const _r = callPtr('ts2cell_in_w', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function ts2cell_make(value: number, t: TimestampTz): Ptr { + const _r = callPtr('ts2cell_make_w', ['number', 'bigint'], [value, BigInt(t)]); + checkMeosError(); + return _r; +} + +export function ts2cellinst_make(value: number, t: TimestampTz): Ptr { + const _r = callPtr('ts2cellinst_make_w', ['number', 'bigint'], [value, BigInt(t)]); + checkMeosError(); + return _r; +} + +export function ts2cellseq_make(values: Ptr, times: Ptr, count: number, lower_inc: boolean, upper_inc: boolean): Ptr { + const _r = callPtr('ts2cellseq_make_w', [ptrArgType(), ptrArgType(), 'number', 'number', 'number'], [ptrArgVal(values), ptrArgVal(times), count, lower_inc ? 1 : 0, upper_inc ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function ts2cellseqset_make(sequences: Ptr, count: number): Ptr { + const _r = callPtr('ts2cellseqset_make_w', [ptrArgType(), 'number'], [ptrArgVal(sequences), count]); + checkMeosError(); + return _r; +} + +export function ts2cell_start_value(temp: Ptr): number { + const _r = call('ts2cell_start_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ts2cell_end_value(temp: Ptr): number { + const _r = call('ts2cell_end_value_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ts2cell_value_n(temp: Ptr, n: number): number { + const _r = call('ts2cell_value_n_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); + checkMeosError(); + return _r; +} + +export function ts2cell_values(temp: Ptr, count: Ptr): Ptr { + const _r = callPtr('ts2cell_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); + checkMeosError(); + return _r; +} + +export function ts2cell_value_at_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): number { + const _r = call('ts2cell_value_at_timestamptz_w', 'number', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function s2cell_to_set(cell: number): Ptr { + const _r = callPtr('s2cell_to_set_w', ['number'], [cell]); + checkMeosError(); + return _r; +} + +export function tbigint_to_ts2cell(temp: Ptr): Ptr { + const _r = callPtr('tbigint_to_ts2cell_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ts2cell_to_tbigint(temp: Ptr): Ptr { + const _r = callPtr('ts2cell_to_tbigint_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_s2cell_ts2cell(cell: number, temp: Ptr): number { + const _r = call('ever_eq_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_eq_ts2cell_s2cell(temp: Ptr, cell: number): number { + const _r = call('ever_eq_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function ever_ne_s2cell_ts2cell(cell: number, temp: Ptr): number { + const _r = call('ever_ne_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function ever_ne_ts2cell_s2cell(temp: Ptr, cell: number): number { + const _r = call('ever_ne_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function always_eq_s2cell_ts2cell(cell: number, temp: Ptr): number { + const _r = call('always_eq_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_eq_ts2cell_s2cell(temp: Ptr, cell: number): number { + const _r = call('always_eq_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function always_ne_s2cell_ts2cell(cell: number, temp: Ptr): number { + const _r = call('always_ne_s2cell_ts2cell_w', 'number', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function always_ne_ts2cell_s2cell(temp: Ptr, cell: number): number { + const _r = call('always_ne_ts2cell_s2cell_w', 'number', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function ever_eq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_eq_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ever_ne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number { + const _r = call('ever_ne_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_eq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_eq_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function always_ne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): number { + const _r = call('always_ne_ts2cell_ts2cell_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function teq_s2cell_ts2cell(cell: number, temp: Ptr): Ptr { + const _r = callPtr('teq_s2cell_ts2cell_w', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function teq_ts2cell_s2cell(temp: Ptr, cell: number): Ptr { + const _r = callPtr('teq_ts2cell_s2cell_w', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function teq_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('teq_ts2cell_ts2cell_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function tne_s2cell_ts2cell(cell: number, temp: Ptr): Ptr { + const _r = callPtr('tne_s2cell_ts2cell_w', ['number', ptrArgType()], [cell, ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + +export function tne_ts2cell_s2cell(temp: Ptr, cell: number): Ptr { + const _r = callPtr('tne_ts2cell_s2cell_w', [ptrArgType(), 'number'], [ptrArgVal(temp), cell]); + checkMeosError(); + return _r; +} + +export function tne_ts2cell_ts2cell(temp1: Ptr, temp2: Ptr): Ptr { + const _r = callPtr('tne_ts2cell_ts2cell_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + checkMeosError(); + return _r; +} + +export function ts2cell_cell_to_token(temp: Ptr): Ptr { + const _r = callPtr('ts2cell_cell_to_token_w', [ptrArgType()], [ptrArgVal(temp)]); + checkMeosError(); + return _r; +} + + +// === pg_bool.h === + +export function bool_eq(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_eq_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_ge(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_ge_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_gt(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_gt_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_hash(arg: boolean): number { + const _r = call('bool_hash_w', 'number', ['number'], [arg ? 1 : 0]); + checkMeosError(); + return _r; +} + +export function bool_hash_extended(arg: boolean, seed: number): number { + const _r = Number(call('bool_hash_extended_w', 'bigint', ['number', 'bigint'], [arg ? 1 : 0, BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function bool_le(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_le_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_lt(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_lt_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_ne(arg1: boolean, arg2: boolean): boolean { + const _r = call('bool_ne_w', 'number', ['number', 'number'], [arg1 ? 1 : 0, arg2 ? 1 : 0]) !== 0; + checkMeosError(); + return _r; +} + +export function bool_to_text(b: boolean): string { + const _r = call('bool_to_text_w', 'string', ['number'], [b ? 1 : 0]); + checkMeosError(); + return _r; +} + + +// === pg_date.h === + +export function add_date_int(date: DateADT, days: number): DateADT { + const _r = call('add_date_int_w', 'number', ['number', 'number'], [date, days]); + checkMeosError(); + return _r; +} + +export function add_date_interval(date: DateADT, interv: Ptr): DateADT { + const _r = call('add_date_interval_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function cmp_date_timestamp(date: DateADT, ts: number): number { + const _r = call('cmp_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]); + checkMeosError(); + return _r; +} + +export function cmp_date_date(date1: DateADT, date2: DateADT): number { + const _r = call('cmp_date_date_w', 'number', ['number', 'number'], [date1, date2]); + checkMeosError(); + return _r; +} + +export function cmp_date_timestamptz(date: DateADT, tstz: TimestampTz): number { + const _r = call('cmp_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]); + checkMeosError(); + return _r; +} + +export function cmp_timestamp_date(ts: number, date: DateADT): number { + const _r = call('cmp_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]); + checkMeosError(); + return _r; +} + +export function cmp_timestamptz_date(tstz: TimestampTz, date: DateADT): number { + const _r = call('cmp_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]); + checkMeosError(); + return _r; +} + +export function date_extract(date: DateADT, units: string): number { + const _r = call('date_extract_w', 'number', ['number', 'string'], [date, units]); + checkMeosError(); + return _r; +} + +export function date_hash(date: DateADT): number { + const _r = call('date_hash_w', 'number', ['number'], [date]); + checkMeosError(); + return _r; +} + +export function date_hash_extended(date: DateADT, seed: number): number { + const _r = Number(call('date_hash_extended_w', 'bigint', ['number', 'bigint'], [date, BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function date_is_finite(date: DateADT): boolean { + const _r = call('date_is_finite_w', 'number', ['number'], [date]) !== 0; + checkMeosError(); + return _r; +} + +export function date_larger(date1: DateADT, date2: DateADT): DateADT { + const _r = call('date_larger_w', 'number', ['number', 'number'], [date1, date2]); + checkMeosError(); + return _r; +} + +export function date_make(year: number, mon: number, mday: number): DateADT { + const _r = call('date_make_w', 'number', ['number', 'number', 'number'], [year, mon, mday]); + checkMeosError(); + return _r; +} + +export function date_smaller(date1: DateADT, date2: DateADT): DateADT { + const _r = call('date_smaller_w', 'number', ['number', 'number'], [date1, date2]); + checkMeosError(); + return _r; +} + +export function date_time_to_timestamp(date: DateADT, time: number): number { + const _r = call('date_time_to_timestamp_w', 'number', ['number', 'number'], [date, time]); + checkMeosError(); + return _r; +} + +export function date_to_timestamp(date: DateADT): number { + const _r = call('date_to_timestamp_w', 'number', ['number'], [date]); + checkMeosError(); + return _r; +} + +export function date_to_timestamptz(date: DateADT): TimestampTz { + const _r = call('date_to_timestamptz_w', 'number', ['number'], [date]); + checkMeosError(); + return _r; +} + +export function eq_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('eq_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('eq_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('eq_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('eq_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('eq_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('ge_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('ge_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('ge_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('ge_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('ge_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('gt_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('gt_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('gt_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('gt_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('gt_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function le_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('le_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function le_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('le_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function le_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('le_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function le_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('le_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function le_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('le_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('lt_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('lt_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('lt_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('lt_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('lt_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function minus_date_date(date1: DateADT, date2: DateADT): number { + const _r = call('minus_date_date_w', 'number', ['number', 'number'], [date1, date2]); + checkMeosError(); + return _r; +} + +export function minus_date_int(date: DateADT, days: number): DateADT { + const _r = call('minus_date_int_w', 'number', ['number', 'number'], [date, days]); + checkMeosError(); + return _r; +} + +export function minus_date_interval(date: DateADT, span: Ptr): DateADT { + const _r = call('minus_date_interval_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(span)]); + checkMeosError(); + return _r; +} + +export function ne_date_date(date1: DateADT, date2: DateADT): boolean { + const _r = call('ne_date_date_w', 'number', ['number', 'number'], [date1, date2]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_date_timestamp(date: DateADT, ts: number): boolean { + const _r = call('ne_date_timestamp_w', 'number', ['number', 'bigint'], [date, BigInt(ts)]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_date_timestamptz(date: DateADT, tstz: TimestampTz): boolean { + const _r = call('ne_date_timestamptz_w', 'number', ['number', 'bigint'], [date, BigInt(tstz)]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_timestamp_date(ts: number, date: DateADT): boolean { + const _r = call('ne_timestamp_date_w', 'number', ['bigint', 'number'], [BigInt(ts), date]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_timestamptz_date(tstz: TimestampTz, date: DateADT): boolean { + const _r = call('ne_timestamptz_date_w', 'number', ['bigint', 'number'], [BigInt(tstz), date]) !== 0; + checkMeosError(); + return _r; +} + +export function timestamp_to_date(ts: number): DateADT { + const _r = call('timestamp_to_date_w', 'number', ['bigint'], [BigInt(ts)]); + checkMeosError(); + return _r; +} + +export function timestamptz_to_date(tstz: TimestampTz): DateADT { + const _r = call('timestamptz_to_date_w', 'number', ['bigint'], [BigInt(tstz)]); + checkMeosError(); + return _r; +} + + +// === pg_float.h === + +export function add_float8_float8(num1: number, num2: number): number { + const _r = call('add_float8_float8_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function div_float8_float8(num1: number, num2: number): number { + const _r = call('div_float8_float8_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function eq_float8_float8(num1: number, num2: number): boolean { + const _r = call('eq_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function float8_abs(num: number): number { + const _r = call('float8_abs_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_ceil(num: number): number { + const _r = call('float8_ceil_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_cmp(num1: number, num2: number): number { + const _r = call('float8_cmp_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function float8_cos(num: number): number { + const _r = call('float8_cos_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_degrees(num: number): number { + const _r = call('float8_degrees_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_exp(num: number): number { + const _r = call('float8_exp_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_floor(num: number): number { + const _r = call('float8_floor_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_hash(num: number): number { + const _r = call('float8_hash_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_hash_extended(num: number, seed: number): number { + const _r = Number(call('float8_hash_extended_w', 'bigint', ['number', 'bigint'], [num, BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function float8_in(str: string): number { + const _r = call('float8_in_w', 'number', ['string'], [str]); + checkMeosError(); + return _r; +} + +export function float8_ln(num: number): number { + const _r = call('float8_ln_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_log10(num: number): number { + const _r = call('float8_log10_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_radians(num: number): number { + const _r = call('float8_radians_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_sin(num: number): number { + const _r = call('float8_sin_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function float8_tan(num: number): number { + const _r = call('float8_tan_w', 'number', ['number'], [num]); + checkMeosError(); + return _r; +} + +export function ge_float8_float8(num1: number, num2: number): boolean { + const _r = call('ge_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function gt_float8_float8(num1: number, num2: number): boolean { + const _r = call('gt_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function le_float8_float8(num1: number, num2: number): boolean { + const _r = call('le_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_float8_float8(num1: number, num2: number): boolean { + const _r = call('lt_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function minus_float8_float8(num1: number, num2: number): number { + const _r = call('minus_float8_float8_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function mul_float8_float8(num1: number, num2: number): number { + const _r = call('mul_float8_float8_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function ne_float8_float8(num1: number, num2: number): boolean { + const _r = call('ne_float8_float8_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + + +// === pg_int.h === + +export function add_int32_int32(num1: number, num2: number): number { + const _r = call('add_int32_int32_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function add_int64_int64(num1: number, num2: number): number { + const _r = Number(call('add_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)])); + checkMeosError(); + return _r; +} + +export function div_int32_int32(num1: number, num2: number): number { + const _r = call('div_int32_int32_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function div_int64_int64(num1: number, num2: number): number { + const _r = Number(call('div_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)])); + checkMeosError(); + return _r; +} + +export function eq_int32_int32(num1: number, num2: number): boolean { + const _r = call('eq_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_int32_int64(num1: number, num2: number): boolean { + const _r = call('eq_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_int64_int32(num1: number, num2: number): boolean { + const _r = call('eq_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; + checkMeosError(); + return _r; +} + +export function eq_int64_int64(num1: number, num2: number): boolean { + const _r = call('eq_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function ge_int32_int32(num1: number, num2: number): boolean { + const _r = call('ge_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_end_instant(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_end_instant_w', [ptrArgType()], [ptrArgVal(temp)]); +export function ge_int32_int64(num1: number, num2: number): boolean { + const _r = call('ge_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_end_sequence(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_end_sequence_w', [ptrArgType()], [ptrArgVal(temp)]); +export function ge_int64_int32(num1: number, num2: number): boolean { + const _r = call('ge_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_end_value(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_end_value_w', [ptrArgType()], [ptrArgVal(temp)]); +export function ge_int64_int64(num1: number, num2: number): boolean { + const _r = call('ge_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_geom(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_geom_w', [ptrArgType()], [ptrArgVal(temp)]); +export function gt_int32_int32(num1: number, num2: number): boolean { + const _r = call('gt_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_instant_n(temp: Ptr, n: number): Ptr { - const _r = callPtr('trgeometry_instant_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); +export function gt_int32_int64(num1: number, num2: number): boolean { + const _r = call('gt_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_instants(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_instants_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function gt_int64_int32(num1: number, num2: number): boolean { + const _r = call('gt_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_points(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_points_w', [ptrArgType()], [ptrArgVal(temp)]); +export function gt_int64_int64(num1: number, num2: number): boolean { + const _r = call('gt_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_yaw(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_yaw_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int32_abs(num: number): number { + const _r = call('int32_abs_w', 'number', ['number'], [num]); checkMeosError(); return _r; } -export function trgeometry_pitch(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_pitch_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int32_cmp(l: number, r: number): number { + const _r = call('int32_cmp_w', 'number', ['number', 'number'], [l, r]); checkMeosError(); return _r; } -export function trgeometry_roll(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_roll_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int32_hash(val: number): number { + const _r = call('int32_hash_w', 'number', ['number'], [val]); checkMeosError(); return _r; } -export function trgeometry_segments(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_segments_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function int32_hash_extended(val: number, seed: number): number { + const _r = Number(call('int32_hash_extended_w', 'bigint', ['number', 'bigint'], [val, BigInt(seed)])); checkMeosError(); return _r; } -export function trgeometry_sequence_n(temp: Ptr, i: number): Ptr { - const _r = callPtr('trgeometry_sequence_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), i]); +export function int32_in(str: string): number { + const _r = call('int32_in_w', 'number', ['string'], [str]); checkMeosError(); return _r; } -export function trgeometry_sequences(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_sequences_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function int32_out(num: number): string { + const _r = call('int32_out_w', 'string', ['number'], [num]); checkMeosError(); return _r; } -export function trgeometry_start_instant(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_start_instant_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int64_abs(num: number): number { + const _r = Number(call('int64_abs_w', 'bigint', ['bigint'], [BigInt(num)])); checkMeosError(); return _r; } -export function trgeometry_start_sequence(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_start_sequence_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int64_cmp(l: number, r: number): number { + const _r = call('int64_cmp_w', 'number', ['bigint', 'bigint'], [BigInt(l), BigInt(r)]); checkMeosError(); return _r; } -export function trgeometry_start_value(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_start_value_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int64_hash(num: number): number { + const _r = call('int64_hash_w', 'number', ['bigint'], [BigInt(num)]); checkMeosError(); return _r; } -export function trgeometry_value_n(temp: Ptr, n: number): Ptr { - const _r = callPtr('trgeometry_value_n_w', [ptrArgType(), 'number'], [ptrArgVal(temp), n]); +export function int64_hash_extended(num: number, seed: number): number { + const _r = Number(call('int64_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(num), BigInt(seed)])); checkMeosError(); return _r; } -export function trgeometry_traversed_area(temp: Ptr, unary_union: boolean): Ptr { - const _r = callPtr('trgeometry_traversed_area_w', [ptrArgType(), 'number'], [ptrArgVal(temp), unary_union ? 1 : 0]); +export function int64_in(str: string): number { + const _r = Number(call('int64_in_w', 'bigint', ['string'], [str])); checkMeosError(); return _r; } -export function trgeometry_centroid(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_centroid_w', [ptrArgType()], [ptrArgVal(temp)]); +export function int64_out(num: number): string { + const _r = call('int64_out_w', 'string', ['bigint'], [BigInt(num)]); checkMeosError(); return _r; } -export function trgeometry_convex_hull(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_convex_hull_w', [ptrArgType()], [ptrArgVal(temp)]); +export function le_int32_int32(num1: number, num2: number): boolean { + const _r = call('le_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_body_point_trajectory(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('trgeometry_body_point_trajectory_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function le_int32_int64(num1: number, num2: number): boolean { + const _r = call('le_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_space_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, sorigin: Ptr, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr { - const _r = callPtr('trgeometry_space_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(sorigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]); +export function le_int64_int32(num1: number, num2: number): boolean { + const _r = call('le_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; + checkMeosError(); + return _r; +} + +export function le_int64_int64(num1: number, num2: number): boolean { + const _r = call('le_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_int32_int32(num1: number, num2: number): boolean { + const _r = call('lt_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_int32_int64(num1: number, num2: number): boolean { + const _r = call('lt_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_int64_int32(num1: number, num2: number): boolean { + const _r = call('lt_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; + checkMeosError(); + return _r; +} + +export function lt_int64_int64(num1: number, num2: number): boolean { + const _r = call('lt_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function minus_int32_int32(num1: number, num2: number): number { + const _r = call('minus_int32_int32_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function minus_int64_int64(num1: number, num2: number): number { + const _r = Number(call('minus_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)])); + checkMeosError(); + return _r; +} + +export function mul_int32_int32(num1: number, num2: number): number { + const _r = call('mul_int32_int32_w', 'number', ['number', 'number'], [num1, num2]); + checkMeosError(); + return _r; +} + +export function mul_int64_int64(num1: number, num2: number): number { + const _r = Number(call('mul_int64_int64_w', 'bigint', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)])); + checkMeosError(); + return _r; +} + +export function ne_int32_int32(num1: number, num2: number): boolean { + const _r = call('ne_int32_int32_w', 'number', ['number', 'number'], [num1, num2]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_int32_int64(num1: number, num2: number): boolean { + const _r = call('ne_int32_int64_w', 'number', ['number', 'bigint'], [num1, BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_int64_int32(num1: number, num2: number): boolean { + const _r = call('ne_int64_int32_w', 'number', ['bigint', 'number'], [BigInt(num1), num2]) !== 0; + checkMeosError(); + return _r; +} + +export function ne_int64_int64(num1: number, num2: number): boolean { + const _r = call('ne_int64_int64_w', 'number', ['bigint', 'bigint'], [BigInt(num1), BigInt(num2)]) !== 0; + checkMeosError(); + return _r; +} + + +// === pg_interval.h === + +export function add_interval_interval(interv1: Ptr, interv2: Ptr): Ptr { + const _r = callPtr('add_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); + checkMeosError(); + return _r; +} + +export function div_interval_float8(interv: Ptr, factor: number): Ptr { + const _r = callPtr('div_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]); + checkMeosError(); + return _r; +} + +export function interval_copy(interv: Ptr): Ptr { + const _r = callPtr('interval_copy_w', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_eq(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_extract(interv: Ptr, units: string): number { + const _r = call('interval_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); + checkMeosError(); + return _r; +} + +export function interval_ge(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_gt(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_hash(interv: Ptr): number { + const _r = call('interval_hash_w', 'number', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_hash_extended(interv: Ptr, seed: number): number { + const _r = Number(call('interval_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(interv), BigInt(seed)])); + checkMeosError(); + return _r; +} + +export function interval_is_finite(interv: Ptr): boolean { + const _r = call('interval_is_finite_w', 'number', [ptrArgType()], [ptrArgVal(interv)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_justify_days(interv: Ptr): Ptr { + const _r = callPtr('interval_justify_days_w', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_justify_hours(interv: Ptr): Ptr { + const _r = callPtr('interval_justify_hours_w', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_justify_interval(interv: Ptr): Ptr { + const _r = callPtr('interval_justify_interval_w', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_larger(interv1: Ptr, interv2: Ptr): Ptr { + const _r = callPtr('interval_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); + checkMeosError(); + return _r; +} + +export function interval_le(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_lt(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_make(years: number, months: number, weeks: number, days: number, hours: number, mins: number, secs: number): Ptr { + const _r = callPtr('interval_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number'], [years, months, weeks, days, hours, mins, secs]); + checkMeosError(); + return _r; +} + +export function interval_ne(interv1: Ptr, interv2: Ptr): boolean { + const _r = call('interval_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; + checkMeosError(); + return _r; +} + +export function interval_negate(interv: Ptr): Ptr { + const _r = callPtr('interval_negate_w', [ptrArgType()], [ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function interval_part(interv: Ptr, units: string): number { + const _r = call('interval_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); + checkMeosError(); + return _r; +} + +export function interval_scale(interv: Ptr, typmod: number): Ptr { + const _r = callPtr('interval_scale_w', [ptrArgType(), 'number'], [ptrArgVal(interv), typmod]); + checkMeosError(); + return _r; +} + +export function interval_smaller(interv1: Ptr, interv2: Ptr): Ptr { + const _r = callPtr('interval_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); + checkMeosError(); + return _r; +} + +export function interval_trunc(interv: Ptr, units: string): Ptr { + const _r = callPtr('interval_trunc_w', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); + checkMeosError(); + return _r; +} + +export function minus_interval_interval(interv1: Ptr, interv2: Ptr): Ptr { + const _r = callPtr('minus_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); + checkMeosError(); + return _r; +} + +export function mul_float8_interval(factor: number, interv: Ptr): Ptr { + const _r = callPtr('mul_float8_interval_w', ['number', ptrArgType()], [factor, ptrArgVal(interv)]); + checkMeosError(); + return _r; +} + +export function mul_interval_float8(interv: Ptr, factor: number): Ptr { + const _r = callPtr('mul_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]); checkMeosError(); return _r; } -export function trgeometry_space_time_boxes(temp: Ptr, xsize: number, ysize: number, zsize: number, duration: Ptr, sorigin: Ptr, torigin: TimestampTz, bitmatrix: boolean, border_inc: boolean, count: Ptr): Ptr { - const _r = callPtr('trgeometry_space_time_boxes_w', [ptrArgType(), 'number', 'number', 'number', ptrArgType(), ptrArgType(), 'bigint', 'number', 'number', ptrArgType()], [ptrArgVal(temp), xsize, ysize, zsize, ptrArgVal(duration), ptrArgVal(sorigin), BigInt(torigin), bitmatrix ? 1 : 0, border_inc ? 1 : 0, ptrArgVal(count)]); + +// === pg_text.h === + +export function text_eq(txt1: string, txt2: string): boolean { + const _r = call('text_eq_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_stboxes(temp: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_stboxes_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(count)]); +export function text_ge(txt1: string, txt2: string): boolean { + const _r = call('text_ge_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_split_n_stboxes(temp: Ptr, box_count: number, count: Ptr): Ptr { - const _r = callPtr('trgeometry_split_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), box_count, ptrArgVal(count)]); +export function text_gt(txt1: string, txt2: string): boolean { + const _r = call('text_gt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_split_each_n_stboxes(temp: Ptr, elem_count: number, count: Ptr): Ptr { - const _r = callPtr('trgeometry_split_each_n_stboxes_w', [ptrArgType(), 'number', ptrArgType()], [ptrArgVal(temp), elem_count, ptrArgVal(count)]); +export function text_hash(txt: string, collid: number): number { + const _r = call('text_hash_w', 'number', ['string', 'number'], [txt, collid]); checkMeosError(); return _r; } -export function trgeometry_hausdorff_distance(temp1: Ptr, temp2: Ptr): number { - const _r = call('trgeometry_hausdorff_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function text_hash_extended(txt: string, seed: number, collid: number): number { + const _r = Number(call('text_hash_extended_w', 'bigint', ['string', 'bigint', 'number'], [txt, BigInt(seed), collid])); checkMeosError(); return _r; } -export function trgeometry_frechet_distance(temp1: Ptr, temp2: Ptr): number { - const _r = call('trgeometry_frechet_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function text_le(txt1: string, txt2: string): boolean { + const _r = call('text_le_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_dyntimewarp_distance(temp1: Ptr, temp2: Ptr): number { - const _r = call('trgeometry_dyntimewarp_distance_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function text_lt(txt1: string, txt2: string): boolean { + const _r = call('text_lt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_frechet_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_frechet_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]); +export function text_ne(txt1: string, txt2: string): boolean { + const _r = call('text_ne_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_dyntimewarp_path(temp1: Ptr, temp2: Ptr, count: Ptr): Ptr { - const _r = callPtr('trgeometry_dyntimewarp_path_w', [ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2), ptrArgVal(count)]); +export function text_pattern_ge(txt1: string, txt2: string): boolean { + const _r = call('text_pattern_ge_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_length(temp: Ptr): number { - const _r = call('trgeometry_length_w', 'number', [ptrArgType()], [ptrArgVal(temp)]); +export function text_pattern_gt(txt1: string, txt2: string): boolean { + const _r = call('text_pattern_gt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_cumulative_length(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_cumulative_length_w', [ptrArgType()], [ptrArgVal(temp)]); +export function text_pattern_le(txt1: string, txt2: string): boolean { + const _r = call('text_pattern_le_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_angular_speed(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_angular_speed_w', [ptrArgType()], [ptrArgVal(temp)]); +export function text_pattern_lt(txt1: string, txt2: string): boolean { + const _r = call('text_pattern_lt_w', 'number', ['string', 'string'], [txt1, txt2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_speed(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_speed_w', [ptrArgType()], [ptrArgVal(temp)]); + +// === pg_time.h === + +export function date_timetz_to_timestamptz(date: DateADT, timetz: Ptr): TimestampTz { + const _r = call('date_timetz_to_timestamptz_w', 'number', ['number', ptrArgType()], [date, ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function trgeometry_twcentroid(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_twcentroid_w', [ptrArgType()], [ptrArgVal(temp)]); +export function interval_to_time(interv: Ptr): number { + const _r = call('interval_to_time_w', 'number', [ptrArgType()], [ptrArgVal(interv)]); checkMeosError(); return _r; } -export function trgeometry_append_tinstant(temp: Ptr, inst: Ptr, interp: number, maxdist: number, maxt: Ptr, expand: boolean): Ptr { - const _r = callPtr('trgeometry_append_tinstant_w', [ptrArgType(), ptrArgType(), 'number', 'number', ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(inst), interp, maxdist, ptrArgVal(maxt), expand ? 1 : 0]); +export function minus_time_interval(time: number, interv: Ptr): number { + const _r = call('minus_time_interval_w', 'number', ['number', ptrArgType()], [time, ptrArgVal(interv)]); checkMeosError(); return _r; } -export function trgeometry_append_tsequence(temp: Ptr, seq: Ptr, expand: boolean): Ptr { - const _r = callPtr('trgeometry_append_tsequence_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(seq), expand ? 1 : 0]); +export function minus_time_time(time1: number, time2: number): Ptr { + const _r = callPtr('minus_time_time_w', ['number', 'number'], [time1, time2]); checkMeosError(); return _r; } -export function trgeometry_delete_timestamptz(temp: Ptr, t: TimestampTz, connect: boolean): Ptr { - const _r = callPtr('trgeometry_delete_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), connect ? 1 : 0]); +export function minus_timetz_interval(timetz: Ptr, interv: Ptr): Ptr { + const _r = callPtr('minus_timetz_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function trgeometry_delete_tstzset(temp: Ptr, s: Ptr, connect: boolean): Ptr { - const _r = callPtr('trgeometry_delete_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]); +export function plus_time_interval(time: number, interv: Ptr): number { + const _r = call('plus_time_interval_w', 'number', ['number', ptrArgType()], [time, ptrArgVal(interv)]); checkMeosError(); return _r; } -export function trgeometry_delete_tstzspan(temp: Ptr, s: Ptr, connect: boolean): Ptr { - const _r = callPtr('trgeometry_delete_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), connect ? 1 : 0]); +export function plus_timetz_interval(timetz: Ptr, interv: Ptr): Ptr { + const _r = callPtr('plus_timetz_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function trgeometry_delete_tstzspanset(temp: Ptr, ss: Ptr, connect: boolean): Ptr { - const _r = callPtr('trgeometry_delete_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), connect ? 1 : 0]); +export function time_cmp(time1: number, time2: number): number { + const _r = call('time_cmp_w', 'number', ['number', 'number'], [time1, time2]); checkMeosError(); return _r; } -export function trgeometry_merge(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('trgeometry_merge_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function time_eq(time1: number, time2: number): boolean { + const _r = call('time_eq_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_merge_array(temparr: Ptr, count: number): Ptr { - const _r = callPtr('trgeometry_merge_array_w', [ptrArgType(), 'number'], [ptrArgVal(temparr), count]); +export function time_extract(time: number, units: string): number { + const _r = call('time_extract_w', 'number', ['number', 'string'], [time, units]); checkMeosError(); return _r; } -export function trgeometry_round(temp: Ptr, maxdd: number): Ptr { - const _r = callPtr('trgeometry_round_w', [ptrArgType(), 'number'], [ptrArgVal(temp), maxdd]); +export function time_ge(time1: number, time2: number): boolean { + const _r = call('time_ge_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_set_interp(temp: Ptr, interp: number): Ptr { - const _r = callPtr('trgeometry_set_interp_w', [ptrArgType(), 'number'], [ptrArgVal(temp), interp]); +export function time_gt(time1: number, time2: number): boolean { + const _r = call('time_gt_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_as_tinstant(temp: Ptr): Ptr { - const _r = callPtr('trgeometry_as_tinstant_w', [ptrArgType()], [ptrArgVal(temp)]); +export function time_hash(time: number): number { + const _r = call('time_hash_w', 'number', ['number'], [time]); checkMeosError(); return _r; } -export function trgeometry_as_tsequence(temp: Ptr, interp_str: string): Ptr { - const _r = callPtr('trgeometry_as_tsequence_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]); +export function time_hash_extended(time: number, seed: number): number { + const _r = Number(call('time_hash_extended_w', 'bigint', ['number', 'number'], [time, seed])); checkMeosError(); return _r; } -export function trgeometry_as_tsequenceset(temp: Ptr, interp_str: string): Ptr { - const _r = callPtr('trgeometry_as_tsequenceset_w', [ptrArgType(), 'string'], [ptrArgVal(temp), interp_str]); +export function time_larger(time1: number, time2: number): number { + const _r = call('time_larger_w', 'number', ['number', 'number'], [time1, time2]); checkMeosError(); return _r; } -export function trgeometry_after_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { - const _r = callPtr('trgeometry_after_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); +export function time_le(time1: number, time2: number): boolean { + const _r = call('time_le_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_before_timestamptz(temp: Ptr, t: TimestampTz, strict: boolean): Ptr { - const _r = callPtr('trgeometry_before_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), strict ? 1 : 0]); +export function time_lt(time1: number, time2: number): boolean { + const _r = call('time_lt_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_restrict_values(temp: Ptr, s: Ptr, atfunc: boolean): Ptr { - const _r = callPtr('trgeometry_restrict_values_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]); +export function time_make(tm_hour: number, tm_min: number, sec: number): number { + const _r = call('time_make_w', 'number', ['number', 'number', 'number'], [tm_hour, tm_min, sec]); checkMeosError(); return _r; } -export function trgeometry_restrict_timestamptz(temp: Ptr, t: TimestampTz, atfunc: boolean): Ptr { - const _r = callPtr('trgeometry_restrict_timestamptz_w', [ptrArgType(), 'bigint', 'number'], [ptrArgVal(temp), BigInt(t), atfunc ? 1 : 0]); +export function time_ne(time1: number, time2: number): boolean { + const _r = call('time_ne_w', 'number', ['number', 'number'], [time1, time2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_restrict_tstzset(temp: Ptr, s: Ptr, atfunc: boolean): Ptr { - const _r = callPtr('trgeometry_restrict_tstzset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]); +export function time_overlaps(ts1: number, te1: number, ts2: number, te2: number): boolean { + const _r = call('time_overlaps_w', 'number', ['number', 'number', 'number', 'number'], [ts1, te1, ts2, te2]) !== 0; checkMeosError(); return _r; } -export function trgeometry_restrict_tstzspan(temp: Ptr, s: Ptr, atfunc: boolean): Ptr { - const _r = callPtr('trgeometry_restrict_tstzspan_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(s), atfunc ? 1 : 0]); +export function time_part(time: number, units: string): number { + const _r = call('time_part_w', 'number', ['number', 'string'], [time, units]); checkMeosError(); return _r; } -export function trgeometry_restrict_tstzspanset(temp: Ptr, ss: Ptr, atfunc: boolean): Ptr { - const _r = callPtr('trgeometry_restrict_tstzspanset_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(ss), atfunc ? 1 : 0]); +export function time_scale(date: number, typmod: number): number { + const _r = call('time_scale_w', 'number', ['number', 'number'], [date, typmod]); checkMeosError(); return _r; } -export function trgeometry_at_geom(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('trgeometry_at_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function time_smaller(time1: number, time2: number): number { + const _r = call('time_smaller_w', 'number', ['number', 'number'], [time1, time2]); checkMeosError(); return _r; } -export function trgeometry_minus_geom(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_geom_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function time_to_interval(time: number): Ptr { + const _r = callPtr('time_to_interval_w', ['number'], [time]); checkMeosError(); return _r; } -export function trgeometry_at_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { - const _r = callPtr('trgeometry_at_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); +export function time_to_timetz(time: number): Ptr { + const _r = callPtr('time_to_timetz_w', ['number'], [time]); checkMeosError(); return _r; } -export function trgeometry_minus_stbox(temp: Ptr, box: Ptr, border_inc: boolean): Ptr { - const _r = callPtr('trgeometry_minus_stbox_w', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(box), border_inc ? 1 : 0]); +export function timestamp_to_time(ts: number): number { + const _r = call('timestamp_to_time_w', 'number', ['bigint'], [BigInt(ts)]); checkMeosError(); return _r; } -export function trgeometry_at_value(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('trgeometry_at_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function timestamptz_to_time(tztz: TimestampTz): number { + const _r = call('timestamptz_to_time_w', 'number', ['bigint'], [BigInt(tztz)]); checkMeosError(); return _r; } -export function trgeometry_minus_value(temp: Ptr, pose: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_value_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(pose)]); +export function timestamptz_to_timetz(tztz: TimestampTz): Ptr { + const _r = callPtr('timestamptz_to_timetz_w', ['bigint'], [BigInt(tztz)]); checkMeosError(); return _r; } -export function trgeometry_at_values(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_at_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_at_local(timetz: Ptr): Ptr { + const _r = callPtr('timetz_at_local_w', [ptrArgType()], [ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function trgeometry_minus_values(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_values_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_cmp(timetz1: Ptr, timetz2: Ptr): number { + const _r = call('timetz_cmp_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]); checkMeosError(); return _r; } -export function trgeometry_at_timestamptz(temp: Ptr, t: TimestampTz): Ptr { - const _r = callPtr('trgeometry_at_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]); +export function timetz_eq(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_minus_timestamptz(temp: Ptr, t: TimestampTz): Ptr { - const _r = callPtr('trgeometry_minus_timestamptz_w', [ptrArgType(), 'bigint'], [ptrArgVal(temp), BigInt(t)]); +export function timetz_extract(timetz: Ptr, units: string): number { + const _r = call('timetz_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(timetz), units]); checkMeosError(); return _r; } -export function trgeometry_at_tstzset(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_at_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_ge(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_minus_tstzset(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_tstzset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_gt(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function trgeometry_at_tstzspan(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_at_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_hash(timetz: Ptr): number { + const _r = call('timetz_hash_w', 'number', [ptrArgType()], [ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function trgeometry_minus_tstzspan(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_tstzspan_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_hash_extended(timetz: Ptr, seed: number): number { + const _r = Number(call('timetz_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(timetz), BigInt(seed)])); checkMeosError(); return _r; } -export function trgeometry_at_tstzspanset(temp: Ptr, ss: Ptr): Ptr { - const _r = callPtr('trgeometry_at_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]); +export function timetz_in(str: string, typmod: number): Ptr { + const _r = callPtr('timetz_in_w', ['string', 'number'], [str, typmod]); checkMeosError(); return _r; } -export function trgeometry_minus_tstzspanset(temp: Ptr, ss: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_tstzspanset_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(ss)]); +export function timetz_izone(timetz: Ptr, zone: Ptr): Ptr { + const _r = callPtr('timetz_izone_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz), ptrArgVal(zone)]); checkMeosError(); return _r; } -export function trgeometry_at_elevation(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_at_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_larger(timetz1: Ptr, timetz2: Ptr): Ptr { + const _r = callPtr('timetz_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]); checkMeosError(); return _r; } -export function trgeometry_minus_elevation(temp: Ptr, s: Ptr): Ptr { - const _r = callPtr('trgeometry_minus_elevation_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(s)]); +export function timetz_le(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function tdistance_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('tdistance_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function timetz_lt(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function tdistance_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('tdistance_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timetz_ne(timetz1: Ptr, timetz2: Ptr): boolean { + const _r = call('timetz_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]) !== 0; checkMeosError(); return _r; } -export function tdistance_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('tdistance_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timetz_copy(timetz: Ptr): Ptr { + const _r = callPtr('timetz_copy_w', [ptrArgType()], [ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function nad_stbox_trgeometry(box: Ptr, temp: Ptr): number { - const _r = call('nad_stbox_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(box), ptrArgVal(temp)]); +export function timetz_out(timetz: Ptr): string { + const _r = call('timetz_out_w', 'string', [ptrArgType()], [ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function nad_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('nad_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function timetz_overlaps(ts1: Ptr, te1: Ptr, ts2: Ptr, te2: Ptr): boolean { + const _r = call('timetz_overlaps_w', 'number', [ptrArgType(), ptrArgType(), ptrArgType(), ptrArgType()], [ptrArgVal(ts1), ptrArgVal(te1), ptrArgVal(ts2), ptrArgVal(te2)]) !== 0; checkMeosError(); return _r; } -export function nad_trgeometry_stbox(temp: Ptr, box: Ptr): number { - const _r = call('nad_trgeometry_stbox_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(box)]); +export function timetz_part(timetz: Ptr, units: string): number { + const _r = call('timetz_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(timetz), units]); checkMeosError(); return _r; } -export function nad_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): number { - const _r = call('nad_trgeometry_tpoint_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timetz_scale(timetz: Ptr, typmod: number): Ptr { + const _r = callPtr('timetz_scale_w', [ptrArgType(), 'number'], [ptrArgVal(timetz), typmod]); checkMeosError(); return _r; } -export function nad_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('nad_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timetz_smaller(timetz1: Ptr, timetz2: Ptr): Ptr { + const _r = callPtr('timetz_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(timetz1), ptrArgVal(timetz2)]); checkMeosError(); return _r; } -export function nai_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('nai_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function timetz_to_time(timetz: Ptr): number { + const _r = call('timetz_to_time_w', 'number', [ptrArgType()], [ptrArgVal(timetz)]); checkMeosError(); return _r; } -export function nai_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('nai_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timetz_zone(timetz: Ptr, zone: string): Ptr { + const _r = callPtr('timetz_zone_w', [ptrArgType(), 'string'], [ptrArgVal(timetz), zone]); checkMeosError(); return _r; } -export function nai_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('nai_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); + +// === pg_timestamp.h === + +export function add_timestamp_interval(ts: number, interv: Ptr): number { + const _r = call('add_timestamp_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function shortestline_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('shortestline_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function add_timestamptz_interval(tstz: TimestampTz, interv: Ptr): number { + const _r = call('add_timestamptz_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function shortestline_trgeometry_tpoint(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('shortestline_trgeometry_tpoint_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function add_timestamptz_interval_at_zone(tstz: TimestampTz, interv: Ptr, zone: string): number { + const _r = call('add_timestamptz_interval_at_zone_w', 'number', ['bigint', ptrArgType(), 'string'], [BigInt(tstz), ptrArgVal(interv), zone]); checkMeosError(); return _r; } -export function shortestline_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): Ptr { - const _r = callPtr('shortestline_trgeometry_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function cmp_timestamp_timestamp(ts1: number, ts2: number): number { + const _r = call('cmp_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]); checkMeosError(); return _r; } -export function always_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('always_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function cmp_timestamp_timestamptz(ts: number, tstz: TimestampTz): number { + const _r = call('cmp_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]); checkMeosError(); return _r; } -export function always_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('always_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function cmp_timestamptz_timestamp(tstz: TimestampTz, ts: number): number { + const _r = call('cmp_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]); checkMeosError(); return _r; } -export function always_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function eq_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('eq_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function always_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('always_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function eq_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('eq_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function always_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('always_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function eq_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('eq_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function always_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('always_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function eq_timestamptz_timestamptz(tstz1: TimestampTz, tstz2: TimestampTz): boolean { + const _r = call('eq_timestamptz_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]) !== 0; checkMeosError(); return _r; } -export function ever_eq_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('ever_eq_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function float8_to_timestamptz(seconds: number): TimestampTz { + const _r = call('float8_to_timestamptz_w', 'number', ['number'], [seconds]); checkMeosError(); return _r; } -export function ever_eq_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('ever_eq_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function gt_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('gt_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function ever_eq_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_eq_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function gt_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('gt_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('ever_ne_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function gt_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('gt_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('ever_ne_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function ge_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('ge_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function ever_ne_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('ever_ne_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function ge_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('ge_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function teq_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr { - const _r = callPtr('teq_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function ge_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('ge_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function teq_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('teq_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function le_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('le_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function tne_geo_trgeometry(gs: Ptr, temp: Ptr): Ptr { - const _r = callPtr('tne_geo_trgeometry_w', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function le_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('le_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function tne_trgeometry_geo(temp: Ptr, gs: Ptr): Ptr { - const _r = callPtr('tne_trgeometry_geo_w', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function le_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('le_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function econtains_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('econtains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function lt_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('lt_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function acontains_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('acontains_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function lt_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('lt_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function ecovers_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('ecovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function lt_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('lt_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function acovers_geo_trgeometry(gs: Ptr, temp: Ptr): number { - const _r = call('acovers_geo_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(gs), ptrArgVal(temp)]); +export function minus_timestamp_interval(ts: number, interv: Ptr): number { + const _r = call('minus_timestamp_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function ecovers_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('ecovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function minus_timestamp_timestamp(ts1: number, ts2: number): Ptr { + const _r = callPtr('minus_timestamp_timestamp_w', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]); checkMeosError(); return _r; } -export function acovers_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('acovers_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function minus_timestamptz_interval(tstz: TimestampTz, interv: Ptr): TimestampTz { + const _r = call('minus_timestamptz_interval_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function edisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('edisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function minus_timestamptz_interval_at_zone(tstz: TimestampTz, interv: Ptr, zone: string): TimestampTz { + const _r = call('minus_timestamptz_interval_at_zone_w', 'number', ['bigint', ptrArgType(), 'string'], [BigInt(tstz), ptrArgVal(interv), zone]); checkMeosError(); return _r; } -export function adisjoint_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('adisjoint_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function minus_timestamptz_timestamptz(tstz1: TimestampTz, tstz2: TimestampTz): Ptr { + const _r = callPtr('minus_timestamptz_timestamptz_w', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]); checkMeosError(); return _r; } -export function eintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('eintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function ne_timestamp_timestamp(ts1: number, ts2: number): boolean { + const _r = call('ne_timestamp_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]) !== 0; checkMeosError(); return _r; } -export function aintersects_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('aintersects_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function ne_timestamp_timestamptz(ts: number, tstz: TimestampTz): boolean { + const _r = call('ne_timestamp_timestamptz_w', 'number', ['bigint', 'bigint'], [BigInt(ts), BigInt(tstz)]) !== 0; checkMeosError(); return _r; } -export function etouches_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('etouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function ne_timestamptz_timestamp(tstz: TimestampTz, ts: number): boolean { + const _r = call('ne_timestamptz_timestamp_w', 'number', ['bigint', 'bigint'], [BigInt(tstz), BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function atouches_trgeometry_geo(temp: Ptr, gs: Ptr): number { - const _r = call('atouches_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp), ptrArgVal(gs)]); +export function timestamp_age(ts1: number, ts2: number): Ptr { + const _r = callPtr('timestamp_age_w', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]); checkMeosError(); return _r; } -export function edwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number { - const _r = call('edwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]); +export function timestamp_at_local(ts: number): TimestampTz { + const _r = call('timestamp_at_local_w', 'number', ['bigint'], [BigInt(ts)]); checkMeosError(); return _r; } -export function adwithin_trgeometry_geo(temp: Ptr, gs: Ptr, dist: number): number { - const _r = call('adwithin_trgeometry_geo_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp), ptrArgVal(gs), dist]); +export function timestamp_bin(ts: number, stride: Ptr, origin: number): number { + const _r = call('timestamp_bin_w', 'number', ['bigint', ptrArgType(), 'bigint'], [BigInt(ts), ptrArgVal(stride), BigInt(origin)]); checkMeosError(); return _r; } -export function edisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('edisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timestamp_extract(ts: number, units: string): number { + const _r = call('timestamp_extract_w', 'number', ['bigint', 'string'], [BigInt(ts), units]); checkMeosError(); return _r; } -export function adisjoint_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('adisjoint_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timestamp_hash(ts: number): number { + const _r = call('timestamp_hash_w', 'number', ['bigint'], [BigInt(ts)]); checkMeosError(); return _r; } -export function eintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('eintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timestamp_hash_extended(tstz: TimestampTz, seed: number): number { + const _r = Number(call('timestamp_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(tstz), BigInt(seed)])); checkMeosError(); return _r; } -export function aintersects_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr): number { - const _r = call('aintersects_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(temp1), ptrArgVal(temp2)]); +export function timestamp_is_finite(ts: number): boolean { + const _r = call('timestamp_is_finite_w', 'number', ['bigint'], [BigInt(ts)]) !== 0; checkMeosError(); return _r; } -export function edwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number { - const _r = call('edwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]); +export function timestamp_izone(ts: number, zone: Ptr): TimestampTz { + const _r = call('timestamp_izone_w', 'number', ['bigint', ptrArgType()], [BigInt(ts), ptrArgVal(zone)]); checkMeosError(); return _r; } -export function adwithin_trgeometry_trgeometry(temp1: Ptr, temp2: Ptr, dist: number): number { - const _r = call('adwithin_trgeometry_trgeometry_w', 'number', [ptrArgType(), ptrArgType(), 'number'], [ptrArgVal(temp1), ptrArgVal(temp2), dist]); +export function time_of_day(): string { + const _r = call('time_of_day_w', 'string', [], []); checkMeosError(); return _r; } - -// === pg_interval.h === - -export function add_interval_interval(interv1: Ptr, interv2: Ptr): Ptr { - const _r = callPtr('add_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); +export function timestamp_larger(ts1: number, ts2: number): number { + const _r = call('timestamp_larger_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]); checkMeosError(); return _r; } -export function div_interval_float8(interv: Ptr, factor: number): Ptr { - const _r = callPtr('div_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]); +export function timestamp_make(year: number, month: number, mday: number, hour: number, min: number, sec: number): number { + const _r = call('timestamp_make_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number'], [year, month, mday, hour, min, sec]); checkMeosError(); return _r; } -export function interval_copy(interv: Ptr): Ptr { - const _r = callPtr('interval_copy_w', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamp_overlaps(ts1: number, te1: number, ts2: number, te2: number): boolean { + const _r = call('timestamp_overlaps_w', 'number', ['bigint', 'bigint', 'bigint', 'bigint'], [BigInt(ts1), BigInt(te1), BigInt(ts2), BigInt(te2)]) !== 0; checkMeosError(); return _r; } -export function interval_eq(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_eq_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamp_part(ts: number, units: string): number { + const _r = call('timestamp_part_w', 'number', ['bigint', 'string'], [BigInt(ts), units]); checkMeosError(); return _r; } -export function interval_extract(interv: Ptr, units: string): number { - const _r = call('interval_extract_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); +export function timestamp_scale(ts: number, typmod: number): number { + const _r = call('timestamp_scale_w', 'number', ['bigint', 'number'], [BigInt(ts), typmod]); checkMeosError(); return _r; } -export function interval_ge(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_ge_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamp_smaller(ts1: number, ts2: number): number { + const _r = call('timestamp_smaller_w', 'number', ['bigint', 'bigint'], [BigInt(ts1), BigInt(ts2)]); checkMeosError(); return _r; } -export function interval_gt(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_gt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamp_to_timestamptz(ts: number): TimestampTz { + const _r = call('timestamp_to_timestamptz_w', 'number', ['bigint'], [BigInt(ts)]); checkMeosError(); return _r; } -export function interval_hash(interv: Ptr): number { - const _r = call('interval_hash_w', 'number', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamp_trunc(ts: number, units: string): number { + const _r = call('timestamp_trunc_w', 'number', ['bigint', 'string'], [BigInt(ts), units]); checkMeosError(); return _r; } -export function interval_hash_extended(interv: Ptr, seed: number): number { - const _r = Number(call('interval_hash_extended_w', 'bigint', [ptrArgType(), 'bigint'], [ptrArgVal(interv), BigInt(seed)])); +export function timestamp_zone(ts: number, zone: string): TimestampTz { + const _r = call('timestamp_zone_w', 'number', ['bigint', 'string'], [BigInt(ts), zone]); checkMeosError(); return _r; } -export function interval_is_finite(interv: Ptr): boolean { - const _r = call('interval_is_finite_w', 'number', [ptrArgType()], [ptrArgVal(interv)]) !== 0; +export function timestamptz_age(tstz1: TimestampTz, tstz2: TimestampTz): Ptr { + const _r = callPtr('timestamptz_age_w', ['bigint', 'bigint'], [BigInt(tstz1), BigInt(tstz2)]); checkMeosError(); return _r; } -export function interval_justify_days(interv: Ptr): Ptr { - const _r = callPtr('interval_justify_days_w', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamptz_at_local(tstz: TimestampTz): TimestampTz { + const _r = call('timestamptz_at_local_w', 'number', ['bigint'], [BigInt(tstz)]); checkMeosError(); return _r; } -export function interval_justify_hours(interv: Ptr): Ptr { - const _r = callPtr('interval_justify_hours_w', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamptz_bin(tstz: TimestampTz, stride: Ptr, origin: TimestampTz): TimestampTz { + const _r = call('timestamptz_bin_w', 'number', ['bigint', ptrArgType(), 'bigint'], [BigInt(tstz), ptrArgVal(stride), BigInt(origin)]); checkMeosError(); return _r; } -export function interval_justify_interval(interv: Ptr): Ptr { - const _r = callPtr('interval_justify_interval_w', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamptz_extract(tstz: TimestampTz, units: string): number { + const _r = call('timestamptz_extract_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]); checkMeosError(); return _r; } -export function interval_larger(interv1: Ptr, interv2: Ptr): Ptr { - const _r = callPtr('interval_larger_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); +export function timestamptz_hash(tstz: TimestampTz): number { + const _r = call('timestamptz_hash_w', 'number', ['bigint'], [BigInt(tstz)]); checkMeosError(); return _r; } -export function interval_le(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_le_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamptz_hash_extended(tstz: TimestampTz, seed: number): number { + const _r = Number(call('timestamptz_hash_extended_w', 'bigint', ['bigint', 'bigint'], [BigInt(tstz), BigInt(seed)])); checkMeosError(); return _r; } -export function interval_lt(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_lt_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamptz_izone(tstz: TimestampTz, zone: Ptr): number { + const _r = call('timestamptz_izone_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(zone)]); checkMeosError(); return _r; } -export function interval_make(years: number, months: number, weeks: number, days: number, hours: number, mins: number, secs: number): Ptr { - const _r = callPtr('interval_make_w', ['number', 'number', 'number', 'number', 'number', 'number', 'number'], [years, months, weeks, days, hours, mins, secs]); +export function timestamptz_make(year: number, month: number, day: number, hour: number, min: number, sec: number): TimestampTz { + const _r = call('timestamptz_make_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number'], [year, month, day, hour, min, sec]); checkMeosError(); return _r; } -export function interval_ne(interv1: Ptr, interv2: Ptr): boolean { - const _r = call('interval_ne_w', 'number', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]) !== 0; +export function timestamptz_make_at_timezone(year: number, month: number, day: number, hour: number, min: number, sec: number, zone: string): TimestampTz { + const _r = call('timestamptz_make_at_timezone_w', 'number', ['number', 'number', 'number', 'number', 'number', 'number', 'string'], [year, month, day, hour, min, sec, zone]); checkMeosError(); return _r; } -export function interval_negate(interv: Ptr): Ptr { - const _r = callPtr('interval_negate_w', [ptrArgType()], [ptrArgVal(interv)]); +export function timestamptz_overlaps(ts1: TimestampTz, te1: TimestampTz, ts2: TimestampTz, te2: TimestampTz): boolean { + const _r = call('timestamptz_overlaps_w', 'number', ['bigint', 'bigint', 'bigint', 'bigint'], [BigInt(ts1), BigInt(te1), BigInt(ts2), BigInt(te2)]) !== 0; checkMeosError(); return _r; } -export function interval_part(interv: Ptr, units: string): number { - const _r = call('interval_part_w', 'number', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); +export function timestamptz_part(tstz: TimestampTz, units: string): number { + const _r = call('timestamptz_part_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]); checkMeosError(); return _r; } -export function interval_scale(interv: Ptr, typmod: number): Ptr { - const _r = callPtr('interval_scale_w', [ptrArgType(), 'number'], [ptrArgVal(interv), typmod]); +export function timestamptz_scale(tstz: TimestampTz, typmod: number): TimestampTz { + const _r = call('timestamptz_scale_w', 'number', ['bigint', 'number'], [BigInt(tstz), typmod]); checkMeosError(); return _r; } -export function interval_smaller(interv1: Ptr, interv2: Ptr): Ptr { - const _r = callPtr('interval_smaller_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); +export function timestamptz_shift(tstz: TimestampTz, interv: Ptr): TimestampTz { + const _r = call('timestamptz_shift_w', 'number', ['bigint', ptrArgType()], [BigInt(tstz), ptrArgVal(interv)]); checkMeosError(); return _r; } -export function interval_trunc(interv: Ptr, units: string): Ptr { - const _r = callPtr('interval_trunc_w', [ptrArgType(), 'string'], [ptrArgVal(interv), units]); +export function timestamptz_to_timestamp(tstz: TimestampTz): number { + const _r = call('timestamptz_to_timestamp_w', 'number', ['bigint'], [BigInt(tstz)]); checkMeosError(); return _r; } -export function minus_interval_interval(interv1: Ptr, interv2: Ptr): Ptr { - const _r = callPtr('minus_interval_interval_w', [ptrArgType(), ptrArgType()], [ptrArgVal(interv1), ptrArgVal(interv2)]); +export function timestamptz_trunc(tstz: TimestampTz, units: string): TimestampTz { + const _r = call('timestamptz_trunc_w', 'number', ['bigint', 'string'], [BigInt(tstz), units]); checkMeosError(); return _r; } -export function mul_float8_interval(factor: number, interv: Ptr): Ptr { - const _r = callPtr('mul_float8_interval_w', ['number', ptrArgType()], [factor, ptrArgVal(interv)]); +export function timestamptz_trunc_zone(tstz: TimestampTz, units: string, zone: string): TimestampTz { + const _r = call('timestamptz_trunc_zone_w', 'number', ['bigint', 'string', 'string'], [BigInt(tstz), units, zone]); checkMeosError(); return _r; } -export function mul_interval_float8(interv: Ptr, factor: number): Ptr { - const _r = callPtr('mul_interval_float8_w', [ptrArgType(), 'number'], [ptrArgVal(interv), factor]); +export function timestamptz_zone(tstz: TimestampTz, zone: string): number { + const _r = call('timestamptz_zone_w', 'number', ['bigint', 'string'], [BigInt(tstz), zone]); checkMeosError(); return _r; } diff --git a/core/types/basic/tnumber/TNumber.ts b/core/types/basic/tnumber/TNumber.ts index 60a8754..e06bf27 100644 --- a/core/types/basic/tnumber/TNumber.ts +++ b/core/types/basic/tnumber/TNumber.ts @@ -2,7 +2,6 @@ import { Temporal } from '../../temporal/Temporal.js'; import type { Ptr } from '../../../functions/functions.generated.js'; import { tnumber_integral, - tnumber_avg_value, tnumber_twavg, tnumber_abs, tnumber_delta_value, @@ -64,8 +63,6 @@ export abstract class TNumber extends Temporal { /** Returns the time-weighted average. MEOS: tnumber_twavg */ timeWeightedAverage(): number { return tnumber_twavg(this._inner); } - /** Returns the plain average of all instant values. MEOS: tnumber_avg_value */ - avgValue(): number { return tnumber_avg_value(this._inner); } // ------------------------------------------------------------------------- // VALUE TRANSFORMATIONS