diff --git a/src/geo/tgeography.cpp b/src/geo/tgeography.cpp
index 0122d254..b5691ac1 100644
--- a/src/geo/tgeography.cpp
+++ b/src/geo/tgeography.cpp
@@ -1180,21 +1180,7 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     loader.RegisterFunction( merge_function);
 
-    auto tempSubtype_function = ScalarFunction(
-        "tempSubtype",
-        {TGeographyTypes::tgeography()},
-        LogicalType::VARCHAR,
-        Temporal_subtype
-    );
-    loader.RegisterFunction( tempSubtype_function);
 
-    auto interp_function = ScalarFunction(
-        "interp",
-        {TGeographyTypes::tgeography()},
-        LogicalType::VARCHAR,
-        Temporal_interp
-    );
-    loader.RegisterFunction( interp_function);
 
     auto memSize_function = ScalarFunction(
         "memSize",
@@ -1229,29 +1215,8 @@ void TGeographyTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     loader.RegisterFunction( tgeography_end_value_function);
 
-    auto startInstant_function = ScalarFunction(
-        "startInstant",
-        {TGeographyTypes::tgeography()},
-        TGeographyTypes::tgeography(), 
-        Temporal_start_instant
-    );
-    loader.RegisterFunction( startInstant_function);
 
-    auto endInstant_function = ScalarFunction(
-        "endInstant",
-        {TGeographyTypes::tgeography()},
-        TGeographyTypes::tgeography(), 
-        Temporal_end_instant
-    );
-    loader.RegisterFunction( endInstant_function);
 
-    auto instantN_function = ScalarFunction(
-        "instantN",
-        {TGeographyTypes::tgeography(), LogicalType::INTEGER},
-        TGeographyTypes::tgeography(),  
-        Temporal_instant_n
-    );
-    loader.RegisterFunction( instantN_function);
 
 
     auto tgeography_gettimestamptz_function = ScalarFunction(
diff --git a/src/geo/tgeography_in_out.cpp b/src/geo/tgeography_in_out.cpp
index 046534d1..6577edd1 100644
--- a/src/geo/tgeography_in_out.cpp
+++ b/src/geo/tgeography_in_out.cpp
@@ -248,22 +248,6 @@ inline void TgeographyFromStringExec(DataChunk &args, ExpressionState &, Vector
 }
 
 void TGeographyTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
-    auto TgeographyAsText = ScalarFunction(
-            "asText",
-            {TGeographyTypes::tgeography()},
-            LogicalType::VARCHAR,
-            Tspatial_as_text
-        );
-        loader.RegisterFunction( TgeographyAsText);
-
-    auto TgeographyAsEWKT = ScalarFunction(
-        "asEWKT",
-        {TGeographyTypes::tgeography()},
-        LogicalType::VARCHAR,
-        Tspatial_as_ewkt
-    );
-    loader.RegisterFunction( TgeographyAsEWKT);
-
     const auto B = LogicalType::BLOB;
     const auto V = LogicalType::VARCHAR;
     const auto T = TGeographyTypes::tgeography();
diff --git a/src/geo/tgeometry.cpp b/src/geo/tgeometry.cpp
index 2d30e8df..8c0c48c4 100644
--- a/src/geo/tgeometry.cpp
+++ b/src/geo/tgeometry.cpp
@@ -1181,21 +1181,7 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  merge_function);
 
-    auto tempSubtype_function = ScalarFunction(
-        "tempSubtype",
-        {TGeometryTypes::tgeometry()},
-        LogicalType::VARCHAR,
-        Temporal_subtype
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tempSubtype_function);
 
-    auto interp_function = ScalarFunction(
-        "interp",
-        {TGeometryTypes::tgeometry()},
-        LogicalType::VARCHAR,
-        Temporal_interp
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  interp_function);
 
     auto memSize_function = ScalarFunction(
         "memSize",
@@ -1230,29 +1216,8 @@ void TGeometryTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tgeometry_end_value_function);
 
-    auto startInstant_function = ScalarFunction(
-        "startInstant",
-        {TGeometryTypes::tgeometry()},
-        TGeometryTypes::tgeometry(), 
-        Temporal_start_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  startInstant_function);
 
-    auto endInstant_function = ScalarFunction(
-        "endInstant",
-        {TGeometryTypes::tgeometry()},
-        TGeometryTypes::tgeometry(), 
-        Temporal_end_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  endInstant_function);
 
-    auto instantN_function = ScalarFunction(
-        "instantN",
-        {TGeometryTypes::tgeometry(), LogicalType::INTEGER},
-        TGeometryTypes::tgeometry(),  
-        Temporal_instant_n
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  instantN_function);
 
 
     auto tgeometry_gettimestamptz_function = ScalarFunction(
diff --git a/src/geo/tgeometry_in_out.cpp b/src/geo/tgeometry_in_out.cpp
index 35d6c47c..1c36c891 100644
--- a/src/geo/tgeometry_in_out.cpp
+++ b/src/geo/tgeometry_in_out.cpp
@@ -251,22 +251,6 @@ inline void TspatialFromStringExec(DataChunk &args, ExpressionState &, Vector &r
 }
 
 void TGeometryTypes::RegisterScalarInOutFunctions(ExtensionLoader &loader){
-    auto TgeometryAsText = ScalarFunction(
-            "asText",
-            {TGeometryTypes::tgeometry()},
-            LogicalType::VARCHAR,
-            Tspatial_as_text
-        );
-        duckdb::RegisterSerializedScalarFunction(loader,  TgeometryAsText);
-
-    auto TgeometryAsEWKT = ScalarFunction(
-        "asEWKT",
-        {TGeometryTypes::tgeometry()},
-        LogicalType::VARCHAR,
-        Tspatial_as_ewkt
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  TgeometryAsEWKT);
-
     // ---- tgeometryFromBinary / FromEWKB (auto-detects format) ----
     const auto B = LogicalType::BLOB;
     const auto V = LogicalType::VARCHAR;
diff --git a/src/pointcloud/tpcpatch.cpp b/src/pointcloud/tpcpatch.cpp
index 114d1683..54733cd3 100644
--- a/src/pointcloud/tpcpatch.cpp
+++ b/src/pointcloud/tpcpatch.cpp
@@ -1170,12 +1170,6 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatchseqarr_4params);
 
-    auto tpcpatch_to_timespan_function = ScalarFunction(
-        "timeSpan",
-        {TPcpatchTypes::tpcpatch()},
-        SpanTypes::tstzspan(),
-        Temporal_to_tstzspan);
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_to_timespan_function);
 
     auto tpcpatch_to_tinstant_function = ScalarFunction(
         "tpcpatchInst",
@@ -1202,21 +1196,7 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  merge_function);
 
-    auto tempSubtype_function = ScalarFunction(
-        "tempSubtype",
-        {TPcpatchTypes::tpcpatch()},
-        LogicalType::VARCHAR,
-        Temporal_subtype
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tempSubtype_function);
 
-    auto interp_function = ScalarFunction(
-        "interp",
-        {TPcpatchTypes::tpcpatch()},
-        LogicalType::VARCHAR,
-        Temporal_interp
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  interp_function);
 
     auto memSize_function = ScalarFunction(
         "memSize",
@@ -1255,29 +1235,8 @@ void TPcpatchTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpatch_numpoints_function);
 
-    auto startInstant_function = ScalarFunction(
-        "startInstant",
-        {TPcpatchTypes::tpcpatch()},
-        TPcpatchTypes::tpcpatch(),
-        Temporal_start_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  startInstant_function);
 
-    auto endInstant_function = ScalarFunction(
-        "endInstant",
-        {TPcpatchTypes::tpcpatch()},
-        TPcpatchTypes::tpcpatch(),
-        Temporal_end_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  endInstant_function);
 
-    auto instantN_function = ScalarFunction(
-        "instantN",
-        {TPcpatchTypes::tpcpatch(), LogicalType::INTEGER},
-        TPcpatchTypes::tpcpatch(),
-        Temporal_instant_n
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  instantN_function);
 
 
     auto tpcpatch_gettimestamptz_function = ScalarFunction(
diff --git a/src/pointcloud/tpcpoint.cpp b/src/pointcloud/tpcpoint.cpp
index 42e16ab0..7dbd0ab3 100644
--- a/src/pointcloud/tpcpoint.cpp
+++ b/src/pointcloud/tpcpoint.cpp
@@ -1132,12 +1132,6 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpointseqarr_4params);
 
-    auto tpcpoint_to_timespan_function = ScalarFunction(
-        "timeSpan",
-        {TPcpointTypes::tpcpoint()},
-        SpanTypes::tstzspan(),
-        Temporal_to_tstzspan);
-    duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_to_timespan_function);
 
     auto tpcpoint_to_tinstant_function = ScalarFunction(
         "tpcpointInst",
@@ -1164,21 +1158,7 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  merge_function);
 
-    auto tempSubtype_function = ScalarFunction(
-        "tempSubtype",
-        {TPcpointTypes::tpcpoint()},
-        LogicalType::VARCHAR,
-        Temporal_subtype
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  tempSubtype_function);
 
-    auto interp_function = ScalarFunction(
-        "interp",
-        {TPcpointTypes::tpcpoint()},
-        LogicalType::VARCHAR,
-        Temporal_interp
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  interp_function);
 
     auto memSize_function = ScalarFunction(
         "memSize",
@@ -1209,29 +1189,8 @@ void TPcpointTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     );
     duckdb::RegisterSerializedScalarFunction(loader,  tpcpoint_pcid_function);
 
-    auto startInstant_function = ScalarFunction(
-        "startInstant",
-        {TPcpointTypes::tpcpoint()},
-        TPcpointTypes::tpcpoint(),
-        Temporal_start_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  startInstant_function);
 
-    auto endInstant_function = ScalarFunction(
-        "endInstant",
-        {TPcpointTypes::tpcpoint()},
-        TPcpointTypes::tpcpoint(),
-        Temporal_end_instant
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  endInstant_function);
 
-    auto instantN_function = ScalarFunction(
-        "instantN",
-        {TPcpointTypes::tpcpoint(), LogicalType::INTEGER},
-        TPcpointTypes::tpcpoint(),
-        Temporal_instant_n
-    );
-    duckdb::RegisterSerializedScalarFunction(loader,  instantN_function);
 
 
     auto tpcpoint_gettimestamptz_function = ScalarFunction(
diff --git a/src/temporal/set.cpp b/src/temporal/set.cpp
index a1200a80..1d9963d3 100644
--- a/src/temporal/set.cpp
+++ b/src/temporal/set.cpp
@@ -101,21 +101,9 @@ void SetTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
             ScalarFunction("set", {base_type}, set_type, SetFunctions::Value_to_set)                 
         );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("intset", {SetTypes::floatset()}, SetTypes::intset(), SetFunctions::Floatset_to_intset)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("floatset", {SetTypes::intset()}, SetTypes::floatset(), SetFunctions::Intset_to_floatset)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("dateset", {SetTypes::tstzset()}, SetTypes::dateset(), SetFunctions::Tstzset_to_dateset)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("tstzset", {SetTypes::dateset()}, SetTypes::tstzset(), SetFunctions::Dateset_to_tstzset)                 
-        );
 
         duckdb::RegisterSerializedScalarFunction(loader, 
             ScalarFunction("memSize",{set_type}, LogicalType::INTEGER, SetFunctions::Set_mem_size)
diff --git a/src/temporal/span.cpp b/src/temporal/span.cpp
index 1b805b4a..48986e37 100644
--- a/src/temporal/span.cpp
+++ b/src/temporal/span.cpp
@@ -148,21 +148,9 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
             ScalarFunction("span", {base_type}, span_type, SpanFunctions::Value_to_span)                 
         );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("intspan", {SpanTypes::floatspan()}, SpanTypes::intspan(), SpanFunctions::Floatspan_to_intspan)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("floatspan", {SpanTypes::intspan()}, SpanTypes::floatspan(), SpanFunctions::Intspan_to_floatspan)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("datespan", {SpanTypes::tstzspan()}, SpanTypes::datespan(), SpanFunctions::Tstzspan_to_datespan)                 
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("tstzspan", {SpanTypes::datespan()}, SpanTypes::tstzspan(), SpanFunctions::Datespan_to_tstzspan)                 
-        );
 
         duckdb::RegisterSerializedScalarFunction(loader, 
             ScalarFunction("span", {SetTypes::intset()},SpanTypes::intspan(), SpanFunctions::Set_to_span)
@@ -259,70 +247,7 @@ void SpanTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
 
     // spans(<set_type>) is generated from the catalog (set_spans) in generated_temporal_udfs.cpp.
 
-    duckdb::RegisterSerializedScalarFunction(loader,
-        ScalarFunction("splitNSpans", {SetTypes::intset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNSpans", {SetTypes::bigintset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNSpans", {SetTypes::floatset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNSpans", {SetTypes::dateset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNSpans", {SetTypes::tstzset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNSpans", {SetTypes::intset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNSpans", {SetTypes::bigintset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNSpans", {SetTypes::floatset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNSpans", {SetTypes::dateset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNSpans", {SetTypes::tstzset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_each_n_spans));
 
-    // Lowercase-"spans" aliases matching MobilityDB's SQL surface
-    // (`splitNspans` / `splitEachNspans`). The camelCase forms above
-    // stay registered for back-compat with existing MobilityDuck callers.
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNspans", {SetTypes::intset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNspans", {SetTypes::bigintset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNspans", {SetTypes::floatset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNspans", {SetTypes::dateset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitNspans", {SetTypes::tstzset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNspans", {SetTypes::intset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::intspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNspans", {SetTypes::bigintset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::bigintspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNspans", {SetTypes::floatset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::floatspan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNspans", {SetTypes::dateset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::datespan()), SpanFunctions::Set_split_each_n_spans));
-    duckdb::RegisterSerializedScalarFunction(loader, 
-        ScalarFunction("splitEachNspans", {SetTypes::tstzset(), LogicalType::INTEGER},
-                       LogicalType::LIST(SpanTypes::tstzspan()), SpanFunctions::Set_split_each_n_spans));
 
     // floor/ceil/round/degrees/radians on floatspan are float-base scalar transforms
     // generated from the catalog (generated_temporal_udfs.cpp), full arity plus the
diff --git a/src/temporal/spanset.cpp b/src/temporal/spanset.cpp
index 7ffc434c..f9983c98 100644
--- a/src/temporal/spanset.cpp
+++ b/src/temporal/spanset.cpp
@@ -143,21 +143,9 @@ void SpansetTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
             ScalarFunction("span", {spanset_type}, child_type, SpansetFunctions::Spanset_to_span)
         );
         
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("intspanset", {SpansetTypes::floatspanset()}, SpansetTypes::intspanset(), SpansetFunctions::Floatspanset_to_intspanset)
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("floatspanset", {SpansetTypes::intspanset()}, SpansetTypes::floatspanset(), SpansetFunctions::Intspanset_to_floatspanset)
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("datespanset", {SpansetTypes::tstzspanset()}, SpansetTypes::datespanset(), SpansetFunctions::Tstzspanset_to_datespanset)
-        );
 
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("tstzspanset", {SpansetTypes::datespanset()}, SpansetTypes::tstzspanset(), SpansetFunctions::Datespanset_to_tstzspanset)
-        );
 
         duckdb::RegisterSerializedScalarFunction(loader, 
             ScalarFunction("memSize", {spanset_type}, LogicalType::INTEGER, SpansetFunctions::Spanset_mem_size)
@@ -255,12 +243,6 @@ void SpansetTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
         );
 
         // Lowercase aliases matching MobilityDB's SQL surface
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("splitNspans", {spanset_type, LogicalType::INTEGER}, LogicalType::LIST(child_type), SpansetFunctions::Spanset_split_n_spans)
-        );
-        duckdb::RegisterSerializedScalarFunction(loader, 
-            ScalarFunction("splitEachNspans", {spanset_type, LogicalType::INTEGER}, LogicalType::LIST(child_type), SpansetFunctions::Spanset_split_each_n_spans)
-        );
 
         // hash(spanset_type) / hashExtended(spanset_type, UBIGINT) are generated from
         // the catalog (meos_setspan_accessor) in generated_temporal_udfs.cpp.
diff --git a/src/temporal/temporal.cpp b/src/temporal/temporal.cpp
index cb9bdc36..4bd3d6a7 100644
--- a/src/temporal/temporal.cpp
+++ b/src/temporal/temporal.cpp
@@ -1163,10 +1163,6 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint));
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float));
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nad", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), LogicalType::INTEGER}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_int));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tint(), TemporalTypes::tint()}, LogicalType::INTEGER, TemporalFunctions::Nad_tint_tint));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), LogicalType::DOUBLE}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_float));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("nearestApproachDistance", {TemporalTypes::tfloat(), TemporalTypes::tfloat()}, LogicalType::DOUBLE, TemporalFunctions::Nad_tfloat_tfloat));
 
     // Temporal topological predicates (contains/contained/overlaps/same/adjacent +
     // @>/<@/&&/~=/-|-) for temporal × temporal (same base family) and temporal ×
@@ -1248,9 +1244,6 @@ void TemporalTypes::RegisterScalarFunctions(ExtensionLoader &loader) {
     // temporal_* aliases are dropped (bare names supersede them).
 
     // ttext text functions
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("lower", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_lower));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("upper", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_upper));
-    duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("initcap", {TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Ttext_initcap));
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {LogicalType::VARCHAR, TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_text_ttext));
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), LogicalType::VARCHAR}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_text));
     duckdb::RegisterSerializedScalarFunction(loader, ScalarFunction("||", {TemporalTypes::ttext(), TemporalTypes::ttext()}, TemporalTypes::ttext(), TemporalFunctions::Textcat_ttext_ttext));