duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/include/duckdb.h

@@ -6,17 +6,25 @@
 //
 //
 //===----------------------------------------------------------------------===//
+//
+// !!!!!!!
+// WARNING: this file is autogenerated by scripts/generate_c_api.py, manual changes will be overwritten
+// !!!!!!!
 
 #pragma once
 
 //! duplicate of duckdb/main/winapi.hpp
 #ifndef DUCKDB_API
 #ifdef _WIN32
+#ifdef DUCKDB_STATIC_BUILD
+#define DUCKDB_API
+#else
 #if defined(DUCKDB_BUILD_LIBRARY) && !defined(DUCKDB_BUILD_LOADABLE_EXTENSION)
 #define DUCKDB_API __declspec(dllexport)
 #else
 #define DUCKDB_API __declspec(dllimport)
 #endif
+#endif
 #else
 #define DUCKDB_API
 #endif
@@ -25,41 +33,20 @@
 //! duplicate of duckdb/main/winapi.hpp
 #ifndef DUCKDB_EXTENSION_API
 #ifdef _WIN32
+#ifdef DUCKDB_STATIC_BUILD
+#define DUCKDB_EXTENSION_API
+#else
 #ifdef DUCKDB_BUILD_LOADABLE_EXTENSION
 #define DUCKDB_EXTENSION_API __declspec(dllexport)
 #else
 #define DUCKDB_EXTENSION_API
 #endif
+#endif
 #else
 #define DUCKDB_EXTENSION_API __attribute__((visibility("default")))
 #endif
 #endif
 
-//! In the future, we are planning to move extension functions to a separate header. For now you can set the define
-//! below to remove the functions that are planned to be moved out of this header.
-// #define DUCKDB_NO_EXTENSION_FUNCTIONS
-
-//! Set the define below to remove all functions that are deprecated or planned to be deprecated
-// #define DUCKDB_API_NO_DEPRECATED
-
-//! API versions
-//! If no explicit API version is defined, the latest API version is used.
-//! Note that using older API versions (i.e. not using DUCKDB_API_LATEST) is deprecated.
-//! These will not be supported long-term, and will be removed in future versions.
-#ifndef DUCKDB_API_0_3_1
-#define DUCKDB_API_0_3_1 1
-#endif
-#ifndef DUCKDB_API_0_3_2
-#define DUCKDB_API_0_3_2 2
-#endif
-#ifndef DUCKDB_API_LATEST
-#define DUCKDB_API_LATEST DUCKDB_API_0_3_2
-#endif
-
-#ifndef DUCKDB_API_VERSION
-#define DUCKDB_API_VERSION DUCKDB_API_LATEST
-#endif
-
 #include <stdbool.h>
 #include <stdint.h>
 #include <stddef.h>
@@ -142,25 +129,29 @@ typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_TIME_TZ = 30,
 	// duckdb_timestamp
 	DUCKDB_TYPE_TIMESTAMP_TZ = 31,
+	// ANY type
+	DUCKDB_TYPE_ANY = 34,
+	// duckdb_varint
+	DUCKDB_TYPE_VARINT = 35,
 } duckdb_type;
 //! An enum over the returned state of different functions.
-typedef enum { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
+typedef enum duckdb_state { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
 //! An enum over the pending state of a pending query result.
-typedef enum {
+typedef enum duckdb_pending_state {
 	DUCKDB_PENDING_RESULT_READY = 0,
 	DUCKDB_PENDING_RESULT_NOT_READY = 1,
 	DUCKDB_PENDING_ERROR = 2,
 	DUCKDB_PENDING_NO_TASKS_AVAILABLE = 3
 } duckdb_pending_state;
 //! An enum over DuckDB's different result types.
-typedef enum {
+typedef enum duckdb_result_type {
 	DUCKDB_RESULT_TYPE_INVALID = 0,
 	DUCKDB_RESULT_TYPE_CHANGED_ROWS = 1,
 	DUCKDB_RESULT_TYPE_NOTHING = 2,
 	DUCKDB_RESULT_TYPE_QUERY_RESULT = 3,
 } duckdb_result_type;
 //! An enum over DuckDB's different statement types.
-typedef enum {
+typedef enum duckdb_statement_type {
 	DUCKDB_STATEMENT_TYPE_INVALID = 0,
 	DUCKDB_STATEMENT_TYPE_SELECT = 1,
 	DUCKDB_STATEMENT_TYPE_INSERT = 2,
@@ -190,6 +181,54 @@ typedef enum {
 	DUCKDB_STATEMENT_TYPE_DETACH = 26,
 	DUCKDB_STATEMENT_TYPE_MULTI = 27,
 } duckdb_statement_type;
+//! An enum over DuckDB's different result types.
+typedef enum duckdb_error_type {
+	DUCKDB_ERROR_INVALID = 0,
+	DUCKDB_ERROR_OUT_OF_RANGE = 1,
+	DUCKDB_ERROR_CONVERSION = 2,
+	DUCKDB_ERROR_UNKNOWN_TYPE = 3,
+	DUCKDB_ERROR_DECIMAL = 4,
+	DUCKDB_ERROR_MISMATCH_TYPE = 5,
+	DUCKDB_ERROR_DIVIDE_BY_ZERO = 6,
+	DUCKDB_ERROR_OBJECT_SIZE = 7,
+	DUCKDB_ERROR_INVALID_TYPE = 8,
+	DUCKDB_ERROR_SERIALIZATION = 9,
+	DUCKDB_ERROR_TRANSACTION = 10,
+	DUCKDB_ERROR_NOT_IMPLEMENTED = 11,
+	DUCKDB_ERROR_EXPRESSION = 12,
+	DUCKDB_ERROR_CATALOG = 13,
+	DUCKDB_ERROR_PARSER = 14,
+	DUCKDB_ERROR_PLANNER = 15,
+	DUCKDB_ERROR_SCHEDULER = 16,
+	DUCKDB_ERROR_EXECUTOR = 17,
+	DUCKDB_ERROR_CONSTRAINT = 18,
+	DUCKDB_ERROR_INDEX = 19,
+	DUCKDB_ERROR_STAT = 20,
+	DUCKDB_ERROR_CONNECTION = 21,
+	DUCKDB_ERROR_SYNTAX = 22,
+	DUCKDB_ERROR_SETTINGS = 23,
+	DUCKDB_ERROR_BINDER = 24,
+	DUCKDB_ERROR_NETWORK = 25,
+	DUCKDB_ERROR_OPTIMIZER = 26,
+	DUCKDB_ERROR_NULL_POINTER = 27,
+	DUCKDB_ERROR_IO = 28,
+	DUCKDB_ERROR_INTERRUPT = 29,
+	DUCKDB_ERROR_FATAL = 30,
+	DUCKDB_ERROR_INTERNAL = 31,
+	DUCKDB_ERROR_INVALID_INPUT = 32,
+	DUCKDB_ERROR_OUT_OF_MEMORY = 33,
+	DUCKDB_ERROR_PERMISSION = 34,
+	DUCKDB_ERROR_PARAMETER_NOT_RESOLVED = 35,
+	DUCKDB_ERROR_PARAMETER_NOT_ALLOWED = 36,
+	DUCKDB_ERROR_DEPENDENCY = 37,
+	DUCKDB_ERROR_HTTP = 38,
+	DUCKDB_ERROR_MISSING_EXTENSION = 39,
+	DUCKDB_ERROR_AUTOLOAD = 40,
+	DUCKDB_ERROR_SEQUENCE = 41,
+	DUCKDB_INVALID_CONFIGURATION = 42
+} duckdb_error_type;
+//! An enum over DuckDB's different cast modes.
+typedef enum duckdb_cast_mode { DUCKDB_CAST_NORMAL = 0, DUCKDB_CAST_TRY = 1 } duckdb_cast_mode;
 
 //===--------------------------------------------------------------------===//
 // General type definitions
@@ -313,28 +352,21 @@ typedef struct {
 //! duckdb_column_type, and duckdb_column_name, which take the result and the column index
 //! as their parameters
 typedef struct {
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-	void *data;
-	bool *nullmask;
-	duckdb_type type;
-	char *name;
-#else
 	// deprecated, use duckdb_column_data
-	void *__deprecated_data;
+	void *deprecated_data;
 	// deprecated, use duckdb_nullmask_data
-	bool *__deprecated_nullmask;
+	bool *deprecated_nullmask;
 	// deprecated, use duckdb_column_type
-	duckdb_type __deprecated_type;
+	duckdb_type deprecated_type;
 	// deprecated, use duckdb_column_name
-	char *__deprecated_name;
-#endif
+	char *deprecated_name;
 	void *internal_data;
 } duckdb_column;
 
 //! A vector to a specified column in a data chunk. Lives as long as the
 //! data chunk lives, i.e., must not be destroyed.
 typedef struct _duckdb_vector {
-	void *__vctr;
+	void *internal_ptr;
 } * duckdb_vector;
 
 //===--------------------------------------------------------------------===//
@@ -358,100 +390,177 @@ typedef struct {
 //! A query result consists of a pointer to its internal data.
 //! Must be freed with 'duckdb_destroy_result'.
 typedef struct {
-#if DUCKDB_API_VERSION < DUCKDB_API_0_3_2
-	idx_t column_count;
-	idx_t row_count;
-	idx_t rows_changed;
-	duckdb_column *columns;
-	char *error_message;
-#else
 	// deprecated, use duckdb_column_count
-	idx_t __deprecated_column_count;
+	idx_t deprecated_column_count;
 	// deprecated, use duckdb_row_count
-	idx_t __deprecated_row_count;
+	idx_t deprecated_row_count;
 	// deprecated, use duckdb_rows_changed
-	idx_t __deprecated_rows_changed;
+	idx_t deprecated_rows_changed;
 	// deprecated, use duckdb_column_*-family of functions
-	duckdb_column *__deprecated_columns;
+	duckdb_column *deprecated_columns;
 	// deprecated, use duckdb_result_error
-	char *__deprecated_error_message;
-#endif
+	char *deprecated_error_message;
 	void *internal_data;
 } duckdb_result;
 
 //! A database object. Should be closed with `duckdb_close`.
 typedef struct _duckdb_database {
-	void *__db;
+	void *internal_ptr;
 } * duckdb_database;
 
 //! A connection to a duckdb database. Must be closed with `duckdb_disconnect`.
 typedef struct _duckdb_connection {
-	void *__conn;
+	void *internal_ptr;
 } * duckdb_connection;
 
 //! A prepared statement is a parameterized query that allows you to bind parameters to it.
 //! Must be destroyed with `duckdb_destroy_prepare`.
 typedef struct _duckdb_prepared_statement {
-	void *__prep;
+	void *internal_ptr;
 } * duckdb_prepared_statement;
 
 //! Extracted statements. Must be destroyed with `duckdb_destroy_extracted`.
 typedef struct _duckdb_extracted_statements {
-	void *__extrac;
+	void *internal_ptr;
 } * duckdb_extracted_statements;
 
 //! The pending result represents an intermediate structure for a query that is not yet fully executed.
 //! Must be destroyed with `duckdb_destroy_pending`.
 typedef struct _duckdb_pending_result {
-	void *__pend;
+	void *internal_ptr;
 } * duckdb_pending_result;
 
 //! The appender enables fast data loading into DuckDB.
 //! Must be destroyed with `duckdb_appender_destroy`.
 typedef struct _duckdb_appender {
-	void *__appn;
+	void *internal_ptr;
 } * duckdb_appender;
 
+//! The table description allows querying info about the table.
+//! Must be destroyed with `duckdb_table_description_destroy`.
+typedef struct _duckdb_table_description {
+	void *internal_ptr;
+} * duckdb_table_description;
+
 //! Can be used to provide start-up options for the DuckDB instance.
 //! Must be destroyed with `duckdb_destroy_config`.
 typedef struct _duckdb_config {
-	void *__cnfg;
+	void *internal_ptr;
 } * duckdb_config;
 
 //! Holds an internal logical type.
 //! Must be destroyed with `duckdb_destroy_logical_type`.
 typedef struct _duckdb_logical_type {
-	void *__lglt;
+	void *internal_ptr;
 } * duckdb_logical_type;
 
+//! Holds extra information used when registering a custom logical type.
+//! Reserved for future use.
+typedef struct _duckdb_create_type_info {
+	void *internal_ptr;
+} * duckdb_create_type_info;
+
 //! Contains a data chunk from a duckdb_result.
 //! Must be destroyed with `duckdb_destroy_data_chunk`.
 typedef struct _duckdb_data_chunk {
-	void *__dtck;
+	void *internal_ptr;
 } * duckdb_data_chunk;
 
 //! Holds a DuckDB value, which wraps a type.
 //! Must be destroyed with `duckdb_destroy_value`.
 typedef struct _duckdb_value {
-	void *__val;
+	void *internal_ptr;
 } * duckdb_value;
 
+//! Holds a recursive tree that matches the query plan.
+typedef struct _duckdb_profiling_info {
+	void *internal_ptr;
+} * duckdb_profiling_info;
+
+//===--------------------------------------------------------------------===//
+// C API Extension info
+//===--------------------------------------------------------------------===//
+//! Holds state during the C API extension intialization process
+typedef struct _duckdb_extension_info {
+	void *internal_ptr;
+} * duckdb_extension_info;
+
+//===--------------------------------------------------------------------===//
+// Function types
+//===--------------------------------------------------------------------===//
+//! Additional function info. When setting this info, it is necessary to pass a destroy-callback function.
+typedef struct _duckdb_function_info {
+	void *internal_ptr;
+} * duckdb_function_info;
+
+//===--------------------------------------------------------------------===//
+// Scalar function types
+//===--------------------------------------------------------------------===//
+//! A scalar function. Must be destroyed with `duckdb_destroy_scalar_function`.
+typedef struct _duckdb_scalar_function {
+	void *internal_ptr;
+} * duckdb_scalar_function;
+
+//! A scalar function set. Must be destroyed with `duckdb_destroy_scalar_function_set`.
+typedef struct _duckdb_scalar_function_set {
+	void *internal_ptr;
+} * duckdb_scalar_function_set;
+
+//! The main function of the scalar function.
+typedef void (*duckdb_scalar_function_t)(duckdb_function_info info, duckdb_data_chunk input, duckdb_vector output);
+
+//===--------------------------------------------------------------------===//
+// Aggregate function types
+//===--------------------------------------------------------------------===//
+//! An aggregate function. Must be destroyed with `duckdb_destroy_aggregate_function`.
+typedef struct _duckdb_aggregate_function {
+	void *internal_ptr;
+} * duckdb_aggregate_function;
+
+//! A aggregate function set. Must be destroyed with `duckdb_destroy_aggregate_function_set`.
+typedef struct _duckdb_aggregate_function_set {
+	void *internal_ptr;
+} * duckdb_aggregate_function_set;
+
+//! Aggregate state
+typedef struct _duckdb_aggregate_state {
+	void *internal_ptr;
+} * duckdb_aggregate_state;
+
+//! Returns the aggregate state size
+typedef idx_t (*duckdb_aggregate_state_size)(duckdb_function_info info);
+//! Initialize the aggregate state
+typedef void (*duckdb_aggregate_init_t)(duckdb_function_info info, duckdb_aggregate_state state);
+//! Destroy aggregate state (optional)
+typedef void (*duckdb_aggregate_destroy_t)(duckdb_aggregate_state *states, idx_t count);
+//! Update a set of aggregate states with new values
+typedef void (*duckdb_aggregate_update_t)(duckdb_function_info info, duckdb_data_chunk input,
+                                          duckdb_aggregate_state *states);
+//! Combine aggregate states
+typedef void (*duckdb_aggregate_combine_t)(duckdb_function_info info, duckdb_aggregate_state *source,
+                                           duckdb_aggregate_state *target, idx_t count);
+//! Finalize aggregate states into a result vector
+typedef void (*duckdb_aggregate_finalize_t)(duckdb_function_info info, duckdb_aggregate_state *source,
+                                            duckdb_vector result, idx_t count, idx_t offset);
+
 //===--------------------------------------------------------------------===//
 // Table function types
 //===--------------------------------------------------------------------===//
 
-#ifndef DUCKDB_NO_EXTENSION_FUNCTIONS
 //! A table function. Must be destroyed with `duckdb_destroy_table_function`.
-typedef void *duckdb_table_function;
+typedef struct _duckdb_table_function {
+	void *internal_ptr;
+} * duckdb_table_function;
 
 //! The bind info of the function. When setting this info, it is necessary to pass a destroy-callback function.
-typedef void *duckdb_bind_info;
+typedef struct _duckdb_bind_info {
+	void *internal_ptr;
+} * duckdb_bind_info;
 
 //! Additional function init info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef void *duckdb_init_info;
-
-//! Additional function info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef void *duckdb_function_info;
+typedef struct _duckdb_init_info {
+	void *internal_ptr;
+} * duckdb_init_info;
 
 //! The bind function of the table function.
 typedef void (*duckdb_table_function_bind_t)(duckdb_bind_info info);
@@ -462,16 +571,29 @@ typedef void (*duckdb_table_function_init_t)(duckdb_init_info info);
 //! The main function of the table function.
 typedef void (*duckdb_table_function_t)(duckdb_function_info info, duckdb_data_chunk output);
 
+//===--------------------------------------------------------------------===//
+// Cast types
+//===--------------------------------------------------------------------===//
+
+//! A cast function. Must be destroyed with `duckdb_destroy_cast_function`.
+typedef struct _duckdb_cast_function {
+	void *internal_ptr;
+} * duckdb_cast_function;
+
+typedef bool (*duckdb_cast_function_t)(duckdb_function_info info, idx_t count, duckdb_vector input,
+                                       duckdb_vector output);
+
 //===--------------------------------------------------------------------===//
 // Replacement scan types
 //===--------------------------------------------------------------------===//
 
 //! Additional replacement scan info. When setting this info, it is necessary to pass a destroy-callback function.
-typedef void *duckdb_replacement_scan_info;
+typedef struct _duckdb_replacement_scan_info {
+	void *internal_ptr;
+} * duckdb_replacement_scan_info;
 
 //! A replacement scan function that can be added to a database.
 typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info, const char *table_name, void *data);
-#endif
 
 //===--------------------------------------------------------------------===//
 // Arrow-related types
@@ -479,30 +601,43 @@ typedef void (*duckdb_replacement_callback_t)(duckdb_replacement_scan_info info,
 
 //! Holds an arrow query result. Must be destroyed with `duckdb_destroy_arrow`.
 typedef struct _duckdb_arrow {
-	void *__arrw;
+	void *internal_ptr;
 } * duckdb_arrow;
 
 //! Holds an arrow array stream. Must be destroyed with `duckdb_destroy_arrow_stream`.
 typedef struct _duckdb_arrow_stream {
-	void *__arrwstr;
+	void *internal_ptr;
 } * duckdb_arrow_stream;
 
 //! Holds an arrow schema. Remember to release the respective ArrowSchema object.
 typedef struct _duckdb_arrow_schema {
-	void *__arrs;
+	void *internal_ptr;
 } * duckdb_arrow_schema;
 
 //! Holds an arrow array. Remember to release the respective ArrowArray object.
 typedef struct _duckdb_arrow_array {
-	void *__arra;
+	void *internal_ptr;
 } * duckdb_arrow_array;
 
+//===--------------------------------------------------------------------===//
+// DuckDB extension access
+//===--------------------------------------------------------------------===//
+//! Passed to C API extension as parameter to the entrypoint
+struct duckdb_extension_access {
+	//! Indicate that an error has occured
+	void (*set_error)(duckdb_extension_info info, const char *error);
+	//! Fetch the database from duckdb to register extensions to
+	duckdb_database *(*get_database)(duckdb_extension_info info);
+	//! Fetch the API
+	void *(*get_api)(duckdb_extension_info info, const char *version);
+};
+
 //===--------------------------------------------------------------------===//
 // Functions
 //===--------------------------------------------------------------------===//
 
 //===--------------------------------------------------------------------===//
-// Open/Connect
+// Open Connect
 //===--------------------------------------------------------------------===//
 
 /*!
@@ -510,9 +645,9 @@ Creates a new database or opens an existing database file stored at the given pa
 If no path is given a new in-memory database is created instead.
 The instantiated database should be closed with 'duckdb_close'.
 
-* path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
-* out_database: The result database object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param path Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
+* @param out_database The result database object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_database);
 
@@ -520,12 +655,12 @@ DUCKDB_API duckdb_state duckdb_open(const char *path, duckdb_database *out_datab
 Extended version of duckdb_open. Creates a new database or opens an existing database file stored at the given path.
 The instantiated database should be closed with 'duckdb_close'.
 
-* path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
-* out_database: The result database object.
-* config: (Optional) configuration used to start up the database system.
-* out_error: If set and the function returns DuckDBError, this will contain the reason why the start-up failed.
+* @param path Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
+* @param out_database The result database object.
+* @param config (Optional) configuration used to start up the database system.
+* @param out_error If set and the function returns DuckDBError, this will contain the reason why the start-up failed.
 Note that the error must be freed using `duckdb_free`.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_open_ext(const char *path, duckdb_database *out_database, duckdb_config config,
                                         char **out_error);
@@ -536,7 +671,7 @@ This should be called after you are done with any database allocated through `du
 Note that failing to call `duckdb_close` (in case of e.g. a program crash) will not cause data corruption.
 Still, it is recommended to always correctly close a database object after you are done with it.
 
-* database: The database object to shut down.
+* @param database The database object to shut down.
 */
 DUCKDB_API void duckdb_close(duckdb_database *database);
 
@@ -545,31 +680,31 @@ Opens a connection to a database. Connections are required to query the database
 associated with the connection.
 The instantiated connection should be closed using 'duckdb_disconnect'.
 
-* database: The database file to connect to.
-* out_connection: The result connection object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param database The database file to connect to.
+* @param out_connection The result connection object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_connect(duckdb_database database, duckdb_connection *out_connection);
 
 /*!
 Interrupt running query
 
-* connection: The connection to interrupt
+* @param connection The connection to interrupt
 */
 DUCKDB_API void duckdb_interrupt(duckdb_connection connection);
 
 /*!
 Get progress of the running query
 
-* connection: The working connection
-* returns: -1 if no progress or a percentage of the progress
+* @param connection The working connection
+* @return -1 if no progress or a percentage of the progress
 */
 DUCKDB_API duckdb_query_progress_type duckdb_query_progress(duckdb_connection connection);
 
 /*!
 Closes the specified connection and de-allocates all memory allocated for that connection.
 
-* connection: The connection to close.
+* @param connection The connection to close.
 */
 DUCKDB_API void duckdb_disconnect(duckdb_connection *connection);
 
@@ -591,8 +726,11 @@ The duckdb_config must be destroyed using 'duckdb_destroy_config'
 
 This will always succeed unless there is a malloc failure.
 
-* out_config: The result configuration object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+Note that `duckdb_destroy_config` should always be called on the resulting config, even if the function returns
+`DuckDBError`.
+
+* @param out_config The result configuration object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_create_config(duckdb_config *out_config);
 
@@ -601,7 +739,7 @@ This returns the total amount of configuration options available for usage with
 
 This should not be called in a loop as it internally loops over all the options.
 
-* returns: The amount of config options available.
+* @return The amount of config options available.
 */
 DUCKDB_API size_t duckdb_config_count();
 
@@ -611,10 +749,10 @@ display configuration options. This will succeed unless `index` is out of range
 
 The result name or description MUST NOT be freed.
 
-* index: The index of the configuration option (between 0 and `duckdb_config_count`)
-* out_name: A name of the configuration flag.
-* out_description: A description of the configuration flag.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param index The index of the configuration option (between 0 and `duckdb_config_count`)
+* @param out_name A name of the configuration flag.
+* @param out_description A description of the configuration flag.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_get_config_flag(size_t index, const char **out_name, const char **out_description);
 
@@ -626,17 +764,17 @@ In the source code, configuration options are defined in `config.cpp`.
 
 This can fail if either the name is invalid, or if the value provided for the option is invalid.
 
-* duckdb_config: The configuration object to set the option on.
-* name: The name of the configuration flag to set.
-* option: The value to set the configuration flag to.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param config The configuration object to set the option on.
+* @param name The name of the configuration flag to set.
+* @param option The value to set the configuration flag to.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_set_config(duckdb_config config, const char *name, const char *option);
 
 /*!
 Destroys the specified configuration object and de-allocates all memory allocated for the object.
 
-* config: The configuration object to destroy.
+* @param config The configuration object to destroy.
 */
 DUCKDB_API void duckdb_destroy_config(duckdb_config *config);
 
@@ -652,17 +790,17 @@ If the query fails to execute, DuckDBError is returned and the error message can
 Note that after running `duckdb_query`, `duckdb_destroy_result` must be called on the result object even if the
 query fails, otherwise the error stored within the result will not be freed correctly.
 
-* connection: The connection to perform the query in.
-* query: The SQL query to run.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection to perform the query in.
+* @param query The SQL query to run.
+* @param out_result The query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_query(duckdb_connection connection, const char *query, duckdb_result *out_result);
 
 /*!
 Closes the result and de-allocates all memory allocated for that connection.
 
-* result: The result to destroy.
+* @param result The result to destroy.
 */
 DUCKDB_API void duckdb_destroy_result(duckdb_result *result);
 
@@ -672,9 +810,9 @@ automatically be destroyed when the result is destroyed.
 
 Returns `NULL` if the column is out of range.
 
-* result: The result object to fetch the column name from.
-* col: The column index.
-* returns: The column name of the specified column.
+* @param result The result object to fetch the column name from.
+* @param col The column index.
+* @return The column name of the specified column.
 */
 DUCKDB_API const char *duckdb_column_name(duckdb_result *result, idx_t col);
 
@@ -683,18 +821,18 @@ Returns the column type of the specified column.
 
 Returns `DUCKDB_TYPE_INVALID` if the column is out of range.
 
-* result: The result object to fetch the column type from.
-* col: The column index.
-* returns: The column type of the specified column.
+* @param result The result object to fetch the column type from.
+* @param col The column index.
+* @return The column type of the specified column.
 */
 DUCKDB_API duckdb_type duckdb_column_type(duckdb_result *result, idx_t col);
 
 /*!
 Returns the statement type of the statement that was executed
 
-* result: The result object to fetch the statement type from.
- * returns: duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
- */
+* @param result The result object to fetch the statement type from.
+* @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
+*/
 DUCKDB_API duckdb_statement_type duckdb_result_statement_type(duckdb_result result);
 
 /*!
@@ -704,17 +842,17 @@ The return type of this call should be destroyed with `duckdb_destroy_logical_ty
 
 Returns `NULL` if the column is out of range.
 
-* result: The result object to fetch the column type from.
-* col: The column index.
-* returns: The logical column type of the specified column.
+* @param result The result object to fetch the column type from.
+* @param col The column index.
+* @return The logical column type of the specified column.
 */
 DUCKDB_API duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col);
 
 /*!
 Returns the number of columns present in a the result object.
 
-* result: The result object.
-* returns: The number of columns present in the result object.
+* @param result The result object.
+* @return The number of columns present in the result object.
 */
 DUCKDB_API idx_t duckdb_column_count(duckdb_result *result);
 
@@ -724,8 +862,8 @@ DUCKDB_API idx_t duckdb_column_count(duckdb_result *result);
 
 Returns the number of rows present in the result object.
 
-* result: The result object.
-* returns: The number of rows present in the result object.
+* @param result The result object.
+* @return The number of rows present in the result object.
 */
 DUCKDB_API idx_t duckdb_row_count(duckdb_result *result);
 #endif
@@ -734,8 +872,8 @@ DUCKDB_API idx_t duckdb_row_count(duckdb_result *result);
 Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE
 queries. For other queries the rows_changed will be 0.
 
-* result: The result object.
-* returns: The number of rows changed.
+* @param result The result object.
+* @return The number of rows changed.
 */
 DUCKDB_API idx_t duckdb_rows_changed(duckdb_result *result);
 
@@ -755,12 +893,14 @@ int32_t *data = (int32_t *) duckdb_column_data(&result, 0);
 printf("Data for row %d: %d\n", row, data[row]);
 ```
 
-* result: The result object to fetch the column data from.
-* col: The column index.
-* returns: The column data of the specified column.
+* @param result The result object to fetch the column data from.
+* @param col The column index.
+* @return The column data of the specified column.
 */
 DUCKDB_API void *duckdb_column_data(duckdb_result *result, idx_t col);
+#endif
 
+#ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
 
@@ -778,9 +918,9 @@ if (nullmask[row]) {
 }
 ```
 
-* result: The result object to fetch the nullmask from.
-* col: The column index.
-* returns: The nullmask of the specified column.
+* @param result The result object to fetch the nullmask from.
+* @param col The column index.
+* @return The nullmask of the specified column.
 */
 DUCKDB_API bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);
 #endif
@@ -790,14 +930,24 @@ Returns the error message contained within the result. The error is only set if
 
 The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_result` is called.
 
-* result: The result object to fetch the error from.
-* returns: The error of the result.
+* @param result The result object to fetch the error from.
+* @return The error of the result.
 */
 DUCKDB_API const char *duckdb_result_error(duckdb_result *result);
 
+/*!
+Returns the result error type contained within the result. The error is only set if `duckdb_query` returns
+`DuckDBError`.
+
+* @param result The result object to fetch the error from.
+* @return The error type of the result.
+*/
+DUCKDB_API duckdb_error_type duckdb_result_error_type(duckdb_result *result);
+
 //===--------------------------------------------------------------------===//
 // Result Functions
 //===--------------------------------------------------------------------===//
+
 #ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
@@ -814,9 +964,9 @@ mixed with the legacy result functions).
 
 Use `duckdb_result_chunk_count` to figure out how many chunks there are in the result.
 
-* result: The result object to fetch the data chunk from.
-* chunk_index: The chunk index to fetch from.
-* returns: The resulting data chunk. Returns `NULL` if the chunk index is out of bounds.
+* @param result The result object to fetch the data chunk from.
+* @param chunk_index The chunk index to fetch from.
+* @return The resulting data chunk. Returns `NULL` if the chunk index is out of bounds.
 */
 DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_index);
 
@@ -825,8 +975,8 @@ DUCKDB_API duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t
 
 Checks if the type of the internal result is StreamQueryResult.
 
-* result: The result object to check.
-* returns: Whether or not the result object is of the type StreamQueryResult
+* @param result The result object to check.
+* @return Whether or not the result object is of the type StreamQueryResult
 */
 DUCKDB_API bool duckdb_result_is_streaming(duckdb_result result);
 
@@ -835,159 +985,160 @@ DUCKDB_API bool duckdb_result_is_streaming(duckdb_result result);
 
 Returns the number of data chunks present in the result.
 
-* result: The result object
-* returns: Number of data chunks present in the result.
+* @param result The result object
+* @return Number of data chunks present in the result.
 */
 DUCKDB_API idx_t duckdb_result_chunk_count(duckdb_result result);
-#endif
 
 /*!
 Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error
 
-* result: The result object
-* returns: The return_type
- */
+* @param result The result object
+* @return The return_type
+*/
 DUCKDB_API duckdb_result_type duckdb_result_return_type(duckdb_result result);
 
-#ifndef DUCKDB_API_NO_DEPRECATED
+#endif
 //===--------------------------------------------------------------------===//
-// Safe fetch functions
+// Safe Fetch Functions
 //===--------------------------------------------------------------------===//
 
 // These functions will perform conversions if necessary.
 // On failure (e.g. if conversion cannot be performed or if the value is NULL) a default value is returned.
 // Note that these functions are slow since they perform bounds checking and conversion
 // For fast access of values prefer using `duckdb_result_get_chunk`
-
+#ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The boolean value at the specified location, or false if the value cannot be converted.
- */
+* @return The boolean value at the specified location, or false if the value cannot be converted.
+*/
 DUCKDB_API bool duckdb_value_boolean(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The int8_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The int8_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API int8_t duckdb_value_int8(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The int16_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The int16_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API int16_t duckdb_value_int16(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The int32_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The int32_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API int32_t duckdb_value_int32(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The int64_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The int64_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_hugeint value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_hugeint value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_uhugeint value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_uhugeint value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_uhugeint duckdb_value_uhugeint(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The uint8_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The uint8_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API uint8_t duckdb_value_uint8(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The uint16_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The uint16_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API uint16_t duckdb_value_uint16(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The uint32_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The uint32_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API uint32_t duckdb_value_uint32(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The uint64_t value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The uint64_t value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API uint64_t duckdb_value_uint64(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The float value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The float value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API float duckdb_value_float(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The double value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The double value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API double duckdb_value_double(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_date value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_date value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_date duckdb_value_date(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_time value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_time value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_time duckdb_value_time(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_timestamp value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_timestamp value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_timestamp duckdb_value_timestamp(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The duckdb_interval value at the specified location, or 0 if the value cannot be converted.
- */
+* @return The duckdb_interval value at the specified location, or 0 if the value cannot be converted.
+*/
 DUCKDB_API duckdb_interval duckdb_value_interval(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
-* DEPRECATED: use duckdb_value_string instead. This function does not work correctly if the string contains null bytes.
-* returns: The text value at the specified location as a null-terminated string, or nullptr if the value cannot be
+**DEPRECATED**: Use duckdb_value_string instead. This function does not work correctly if the string contains null
+bytes.
+
+* @return The text value at the specified location as a null-terminated string, or nullptr if the value cannot be
 converted. The result must be freed with `duckdb_free`.
 */
 DUCKDB_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t row);
@@ -995,16 +1146,18 @@ DUCKDB_API char *duckdb_value_varchar(duckdb_result *result, idx_t col, idx_t ro
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: The string value at the specified location. Attempts to cast the result value to string.
- * No support for nested types, and for other complex types.
- * The resulting field "string.data" must be freed with `duckdb_free.`
- */
+No support for nested types, and for other complex types.
+The resulting field "string.data" must be freed with `duckdb_free.`
+
+* @return The string value at the specified location. Attempts to cast the result value to string.
+*/
 DUCKDB_API duckdb_string duckdb_value_string(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
-* DEPRECATED: use duckdb_value_string_internal instead. This function does not work correctly if the string contains
+**DEPRECATED**: Use duckdb_value_string_internal instead. This function does not work correctly if the string contains
 null bytes.
-* returns: The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
+
+* @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
 If the column is NOT a VARCHAR column this function will return NULL.
 
 The result must NOT be freed.
@@ -1012,9 +1165,9 @@ The result must NOT be freed.
 DUCKDB_API char *duckdb_value_varchar_internal(duckdb_result *result, idx_t col, idx_t row);
 
 /*!
-* DEPRECATED: use duckdb_value_string_internal instead. This function does not work correctly if the string contains
+**DEPRECATED**: Use duckdb_value_string_internal instead. This function does not work correctly if the string contains
 null bytes.
-* returns: The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
+* @return The char* value at the specified location. ONLY works on VARCHAR columns and does not auto-cast.
 If the column is NOT a VARCHAR column this function will return NULL.
 
 The result must NOT be freed.
@@ -1024,7 +1177,7 @@ DUCKDB_API duckdb_string duckdb_value_string_internal(duckdb_result *result, idx
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
-* returns: The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the
+* @return The duckdb_blob value at the specified location. Returns a blob with blob.data set to nullptr if the
 value cannot be converted. The resulting field "blob.data" must be freed with `duckdb_free.`
 */
 DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t row);
@@ -1032,11 +1185,11 @@ DUCKDB_API duckdb_blob duckdb_value_blob(duckdb_result *result, idx_t col, idx_t
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
- * returns: Returns true if the value at the specified index is NULL, and false otherwise.
- */
+* @return Returns true if the value at the specified index is NULL, and false otherwise.
+*/
 DUCKDB_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row);
-#endif
 
+#endif
 //===--------------------------------------------------------------------===//
 // Helpers
 //===--------------------------------------------------------------------===//
@@ -1045,8 +1198,8 @@ DUCKDB_API bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row
 Allocate `size` bytes of memory using the duckdb internal malloc function. Any memory allocated in this manner
 should be freed using `duckdb_free`.
 
-* size: The number of bytes to allocate.
-* returns: A pointer to the allocated memory region.
+* @param size The number of bytes to allocate.
+* @return A pointer to the allocated memory region.
 */
 DUCKDB_API void *duckdb_malloc(size_t size);
 
@@ -1054,7 +1207,7 @@ DUCKDB_API void *duckdb_malloc(size_t size);
 Free a value returned from `duckdb_malloc`, `duckdb_value_varchar`, `duckdb_value_blob`, or
 `duckdb_value_string`.
 
-* ptr: The memory region to de-allocate.
+* @param ptr The memory region to de-allocate.
 */
 DUCKDB_API void duckdb_free(void *ptr);
 
@@ -1062,7 +1215,7 @@ DUCKDB_API void duckdb_free(void *ptr);
 The internal vector size used by DuckDB.
 This is the amount of tuples that will fit into a data chunk created by `duckdb_create_data_chunk`.
 
-* returns: The vector size.
+* @return The vector size.
 */
 DUCKDB_API idx_t duckdb_vector_size();
 
@@ -1073,48 +1226,64 @@ This means that the data of the string does not have a separate allocation.
 */
 DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);
 
+/*!
+Get the string length of a string_t
+
+* @param string The string to get the length of.
+* @return The length.
+*/
+DUCKDB_API uint32_t duckdb_string_t_length(duckdb_string_t string);
+
+/*!
+Get a pointer to the string data of a string_t
+
+* @param string The string to get the pointer to.
+* @return The pointer.
+*/
+DUCKDB_API const char *duckdb_string_t_data(duckdb_string_t *string);
+
 //===--------------------------------------------------------------------===//
-// Date/Time/Timestamp Helpers
+// Date Time Timestamp Helpers
 //===--------------------------------------------------------------------===//
 
 /*!
 Decompose a `duckdb_date` object into year, month and date (stored as `duckdb_date_struct`).
 
-* date: The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
-* returns: The `duckdb_date_struct` with the decomposed elements.
+* @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
+* @return The `duckdb_date_struct` with the decomposed elements.
 */
 DUCKDB_API duckdb_date_struct duckdb_from_date(duckdb_date date);
 
 /*!
 Re-compose a `duckdb_date` from year, month and date (`duckdb_date_struct`).
 
-* date: The year, month and date stored in a `duckdb_date_struct`.
-* returns: The `duckdb_date` element.
+* @param date The year, month and date stored in a `duckdb_date_struct`.
+* @return The `duckdb_date` element.
 */
 DUCKDB_API duckdb_date duckdb_to_date(duckdb_date_struct date);
 
 /*!
 Test a `duckdb_date` to see if it is a finite value.
 
-* date: The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
-* returns: True if the date is finite, false if it is ±infinity.
+* @param date The date object, as obtained from a `DUCKDB_TYPE_DATE` column.
+* @return True if the date is finite, false if it is ±infinity.
 */
 DUCKDB_API bool duckdb_is_finite_date(duckdb_date date);
 
 /*!
 Decompose a `duckdb_time` object into hour, minute, second and microsecond (stored as `duckdb_time_struct`).
 
-* time: The time object, as obtained from a `DUCKDB_TYPE_TIME` column.
-* returns: The `duckdb_time_struct` with the decomposed elements.
+* @param time The time object, as obtained from a `DUCKDB_TYPE_TIME` column.
+* @return The `duckdb_time_struct` with the decomposed elements.
 */
 DUCKDB_API duckdb_time_struct duckdb_from_time(duckdb_time time);
 
 /*!
 Create a `duckdb_time_tz` object from micros and a timezone offset.
 
-* micros: The microsecond component of the time.
-* offset: The timezone offset component of the time.
-* returns: The `duckdb_time_tz` element.
+* @param micros The microsecond component of the time.
+* @param offset The timezone offset component of the time.
+* @return The `duckdb_time_tz` element.
 */
 DUCKDB_API duckdb_time_tz duckdb_create_time_tz(int64_t micros, int32_t offset);
 
@@ -1123,41 +1292,39 @@ Decompose a TIME_TZ objects into micros and a timezone offset.
 
 Use `duckdb_from_time` to further decompose the micros into hour, minute, second and microsecond.
 
-* micros: The time object, as obtained from a `DUCKDB_TYPE_TIME_TZ` column.
-* out_micros: The microsecond component of the time.
-* out_offset: The timezone offset component of the time.
+* @param micros The time object, as obtained from a `DUCKDB_TYPE_TIME_TZ` column.
 */
 DUCKDB_API duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz micros);
 
 /*!
 Re-compose a `duckdb_time` from hour, minute, second and microsecond (`duckdb_time_struct`).
 
-* time: The hour, minute, second and microsecond in a `duckdb_time_struct`.
-* returns: The `duckdb_time` element.
+* @param time The hour, minute, second and microsecond in a `duckdb_time_struct`.
+* @return The `duckdb_time` element.
 */
 DUCKDB_API duckdb_time duckdb_to_time(duckdb_time_struct time);
 
 /*!
 Decompose a `duckdb_timestamp` object into a `duckdb_timestamp_struct`.
 
-* ts: The ts object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
-* returns: The `duckdb_timestamp_struct` with the decomposed elements.
+* @param ts The ts object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
+* @return The `duckdb_timestamp_struct` with the decomposed elements.
 */
 DUCKDB_API duckdb_timestamp_struct duckdb_from_timestamp(duckdb_timestamp ts);
 
 /*!
 Re-compose a `duckdb_timestamp` from a duckdb_timestamp_struct.
 
-* ts: The de-composed elements in a `duckdb_timestamp_struct`.
-* returns: The `duckdb_timestamp` element.
+* @param ts The de-composed elements in a `duckdb_timestamp_struct`.
+* @return The `duckdb_timestamp` element.
 */
 DUCKDB_API duckdb_timestamp duckdb_to_timestamp(duckdb_timestamp_struct ts);
 
 /*!
 Test a `duckdb_timestamp` to see if it is a finite value.
 
-* ts: The timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
-* returns: True if the timestamp is finite, false if it is ±infinity.
+* @param ts The timestamp object, as obtained from a `DUCKDB_TYPE_TIMESTAMP` column.
+* @return True if the timestamp is finite, false if it is ±infinity.
 */
 DUCKDB_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
 
@@ -1168,8 +1335,8 @@ DUCKDB_API bool duckdb_is_finite_timestamp(duckdb_timestamp ts);
 /*!
 Converts a duckdb_hugeint object (as obtained from a `DUCKDB_TYPE_HUGEINT` column) into a double.
 
-* val: The hugeint value.
-* returns: The converted `double` element.
+* @param val The hugeint value.
+* @return The converted `double` element.
 */
 DUCKDB_API double duckdb_hugeint_to_double(duckdb_hugeint val);
 
@@ -1178,8 +1345,8 @@ Converts a double value to a duckdb_hugeint object.
 
 If the conversion fails because the double value is too big the result will be 0.
 
-* val: The double value.
-* returns: The converted `duckdb_hugeint` element.
+* @param val The double value.
+* @return The converted `duckdb_hugeint` element.
 */
 DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 
@@ -1190,8 +1357,8 @@ DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 /*!
 Converts a duckdb_uhugeint object (as obtained from a `DUCKDB_TYPE_UHUGEINT` column) into a double.
 
-* val: The uhugeint value.
-* returns: The converted `double` element.
+* @param val The uhugeint value.
+* @return The converted `double` element.
 */
 DUCKDB_API double duckdb_uhugeint_to_double(duckdb_uhugeint val);
 
@@ -1200,8 +1367,8 @@ Converts a double value to a duckdb_uhugeint object.
 
 If the conversion fails because the double value is too big the result will be 0.
 
-* val: The double value.
-* returns: The converted `duckdb_uhugeint` element.
+* @param val The double value.
+* @return The converted `duckdb_uhugeint` element.
 */
 DUCKDB_API duckdb_uhugeint duckdb_double_to_uhugeint(double val);
 
@@ -1214,16 +1381,16 @@ Converts a double value to a duckdb_decimal object.
 
 If the conversion fails because the double value is too big, or the width/scale are invalid the result will be 0.
 
-* val: The double value.
-* returns: The converted `duckdb_decimal` element.
+* @param val The double value.
+* @return The converted `duckdb_decimal` element.
 */
 DUCKDB_API duckdb_decimal duckdb_double_to_decimal(double val, uint8_t width, uint8_t scale);
 
 /*!
 Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
 
-* val: The decimal value.
-* returns: The converted `double` element.
+* @param val The decimal value.
+* @return The converted `double` element.
 */
 DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
 
@@ -1240,7 +1407,6 @@ DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
 //   SELECT * FROM tbl WHERE id=?
 // Or a query with multiple parameters:
 //   SELECT * FROM tbl WHERE id=$1 OR name=$2
-
 /*!
 Create a prepared statement object from a query.
 
@@ -1249,10 +1415,10 @@ Note that after calling `duckdb_prepare`, the prepared statement should always b
 
 If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
 
-* connection: The connection object
-* query: The SQL query to prepare
-* out_prepared_statement: The resulting prepared statement object
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection object
+* @param query The SQL query to prepare
+* @param out_prepared_statement The resulting prepared statement object
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
                                        duckdb_prepared_statement *out_prepared_statement);
@@ -1260,7 +1426,7 @@ DUCKDB_API duckdb_state duckdb_prepare(duckdb_connection connection, const char
 /*!
 Closes the prepared statement and de-allocates all memory allocated for the statement.
 
-* prepared_statement: The prepared statement to destroy.
+* @param prepared_statement The prepared statement to destroy.
 */
 DUCKDB_API void duckdb_destroy_prepare(duckdb_prepared_statement *prepared_statement);
 
@@ -1270,8 +1436,8 @@ If the prepared statement has no error message, this returns `nullptr` instead.
 
 The error message should not be freed. It will be de-allocated when `duckdb_destroy_prepare` is called.
 
-* prepared_statement: The prepared statement to obtain the error from.
-* returns: The error message, or `nullptr` if there is none.
+* @param prepared_statement The prepared statement to obtain the error from.
+* @return The error message, or `nullptr` if there is none.
 */
 DUCKDB_API const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement);
 
@@ -1280,7 +1446,7 @@ Returns the number of parameters that can be provided to the given prepared stat
 
 Returns 0 if the query was not successfully prepared.
 
-* prepared_statement: The prepared statement to obtain the number of parameters for.
+* @param prepared_statement The prepared statement to obtain the number of parameters for.
 */
 DUCKDB_API idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement);
 
@@ -1290,7 +1456,7 @@ The returned string should be freed using `duckdb_free`.
 
 Returns NULL if the index is out of range for the provided prepared statement.
 
-* prepared_statement: The prepared statement for which to get the parameter name from.
+* @param prepared_statement The prepared statement for which to get the parameter name from.
 */
 DUCKDB_API const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index);
 
@@ -1299,9 +1465,9 @@ Returns the parameter type for the parameter at the given index.
 
 Returns `DUCKDB_TYPE_INVALID` if the parameter index is out of range or the statement was not successfully prepared.
 
-* prepared_statement: The prepared statement.
-* param_idx: The parameter index.
-* returns: The parameter type
+* @param prepared_statement The prepared statement.
+* @param param_idx The parameter index.
+* @return The parameter type
 */
 DUCKDB_API duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx);
 
@@ -1313,13 +1479,13 @@ DUCKDB_API duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared
 /*!
 Returns the statement type of the statement to be executed
 
- * statement: The prepared statement.
- * returns: duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
- */
+* @param statement The prepared statement.
+* @return duckdb_statement_type value or DUCKDB_STATEMENT_TYPE_INVALID
+*/
 DUCKDB_API duckdb_statement_type duckdb_prepared_statement_type(duckdb_prepared_statement statement);
 
 //===--------------------------------------------------------------------===//
-// Bind Values to Prepared Statements
+// Bind Values To Prepared Statements
 //===--------------------------------------------------------------------===//
 
 /*!
@@ -1364,11 +1530,13 @@ Binds a duckdb_hugeint value to the prepared statement at the specified index.
 */
 DUCKDB_API duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                             duckdb_hugeint val);
+
 /*!
 Binds an duckdb_uhugeint value to the prepared statement at the specified index.
 */
 DUCKDB_API duckdb_state duckdb_bind_uhugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                              duckdb_uhugeint val);
+
 /*!
 Binds a duckdb_decimal value to the prepared statement at the specified index.
 */
@@ -1423,6 +1591,12 @@ Binds a duckdb_timestamp value to the prepared statement at the specified index.
 DUCKDB_API duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                               duckdb_timestamp val);
 
+/*!
+Binds a duckdb_timestamp value to the prepared statement at the specified index.
+*/
+DUCKDB_API duckdb_state duckdb_bind_timestamp_tz(duckdb_prepared_statement prepared_statement, idx_t param_idx,
+                                                 duckdb_timestamp val);
+
 /*!
 Binds a duckdb_interval value to the prepared statement at the specified index.
 */
@@ -1464,9 +1638,9 @@ between calls to this function.
 
 Note that the result must be freed with `duckdb_destroy_result`.
 
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared_statement The prepared statement to execute.
+* @param out_result The query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement,
                                                 duckdb_result *out_result);
@@ -1483,9 +1657,9 @@ between calls to this function.
 
 Note that the result must be freed with `duckdb_destroy_result`.
 
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared_statement The prepared statement to execute.
+* @param out_result The query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
                                                           duckdb_result *out_result);
@@ -1496,7 +1670,6 @@ DUCKDB_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statem
 //===--------------------------------------------------------------------===//
 
 // A query string can be extracted into multiple SQL statements. Each statement can be prepared and executed separately.
-
 /*!
 Extract all statements from a query.
 Note that after calling `duckdb_extract_statements`, the extracted statements should always be destroyed using
@@ -1504,10 +1677,10 @@ Note that after calling `duckdb_extract_statements`, the extracted statements sh
 
 If the extract fails, `duckdb_extract_statements_error` can be called to obtain the reason why the extract failed.
 
-* connection: The connection object
-* query: The SQL query to extract
-* out_extracted_statements: The resulting extracted statements object
-* returns: The number of extracted statements or 0 on failure.
+* @param connection The connection object
+* @param query The SQL query to extract
+* @param out_extracted_statements The resulting extracted statements object
+* @return The number of extracted statements or 0 on failure.
 */
 DUCKDB_API idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
                                            duckdb_extracted_statements *out_extracted_statements);
@@ -1519,28 +1692,29 @@ Note that after calling `duckdb_prepare_extracted_statement`, the prepared state
 
 If the prepare fails, `duckdb_prepare_error` can be called to obtain the reason why the prepare failed.
 
-* connection: The connection object
-* extracted_statements: The extracted statements object
-* index: The index of the extracted statement to prepare
-* out_prepared_statement: The resulting prepared statement object
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection object
+* @param extracted_statements The extracted statements object
+* @param index The index of the extracted statement to prepare
+* @param out_prepared_statement The resulting prepared statement object
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,
                                                            duckdb_extracted_statements extracted_statements,
                                                            idx_t index,
                                                            duckdb_prepared_statement *out_prepared_statement);
+
 /*!
 Returns the error message contained within the extracted statements.
 The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_extracted` is called.
 
-* result: The extracted statements to fetch the error from.
-* returns: The error of the extracted statements.
+* @param extracted_statements The extracted statements to fetch the error from.
+* @return The error of the extracted statements.
 */
 DUCKDB_API const char *duckdb_extract_statements_error(duckdb_extracted_statements extracted_statements);
 
 /*!
 De-allocates all memory allocated for the extracted statements.
-* extracted_statements: The extracted statements to destroy.
+* @param extracted_statements The extracted statements to destroy.
 */
 DUCKDB_API void duckdb_destroy_extracted(duckdb_extracted_statements *extracted_statements);
 
@@ -1556,12 +1730,13 @@ The pending result can be used to incrementally execute a query, returning contr
 Note that after calling `duckdb_pending_prepared`, the pending result should always be destroyed using
 `duckdb_destroy_pending`, even if this function returns DuckDBError.
 
-* prepared_statement: The prepared statement to execute.
-* out_result: The pending query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared_statement The prepared statement to execute.
+* @param out_result The pending query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_pending_prepared(duckdb_prepared_statement prepared_statement,
                                                 duckdb_pending_result *out_result);
+
 #ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
@@ -1573,9 +1748,9 @@ The pending result represents an intermediate structure for a query that is not
 Note that after calling `duckdb_pending_prepared_streaming`, the pending result should always be destroyed using
 `duckdb_destroy_pending`, even if this function returns DuckDBError.
 
-* prepared_statement: The prepared statement to execute.
-* out_result: The pending query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared_statement The prepared statement to execute.
+* @param out_result The pending query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
                                                           duckdb_pending_result *out_result);
@@ -1584,7 +1759,7 @@ DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statem
 /*!
 Closes the pending result and de-allocates all memory allocated for the result.
 
-* pending_result: The pending result to destroy.
+* @param pending_result The pending result to destroy.
 */
 DUCKDB_API void duckdb_destroy_pending(duckdb_pending_result *pending_result);
 
@@ -1593,8 +1768,8 @@ Returns the error message contained within the pending result.
 
 The result of this function must not be freed. It will be cleaned up when `duckdb_destroy_pending` is called.
 
-* result: The pending result to fetch the error from.
-* returns: The error of the pending result.
+* @param pending_result The pending result to fetch the error from.
+* @return The error of the pending result.
 */
 DUCKDB_API const char *duckdb_pending_error(duckdb_pending_result pending_result);
 
@@ -1607,8 +1782,8 @@ If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
 
 The error message can be obtained by calling duckdb_pending_error on the pending_result.
 
-* pending_result: The pending result to execute a task within.
-* returns: The state of the pending result after the execution.
+* @param pending_result The pending result to execute a task within.
+* @return The state of the pending result after the execution.
 */
 DUCKDB_API duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_result);
 
@@ -1619,8 +1794,8 @@ If this returns DUCKDB_PENDING_ERROR, an error occurred during execution.
 
 The error message can be obtained by calling duckdb_pending_error on the pending_result.
 
-* pending_result: The pending result.
-* returns: The state of the pending result.
+* @param pending_result The pending result.
+* @return The state of the pending result.
 */
 DUCKDB_API duckdb_pending_state duckdb_pending_execute_check_state(duckdb_pending_result pending_result);
 
@@ -1632,9 +1807,9 @@ Otherwise, all remaining tasks must be executed first.
 
 Note that the result must be freed with `duckdb_destroy_result`.
 
-* pending_result: The pending result to execute.
-* out_result: The result object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param pending_result The pending result to execute.
+* @param out_result The result object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb_result *out_result);
 
@@ -1642,8 +1817,8 @@ DUCKDB_API duckdb_state duckdb_execute_pending(duckdb_pending_result pending_res
 Returns whether a duckdb_pending_state is finished executing. For example if `pending_state` is
 DUCKDB_PENDING_RESULT_READY, this function will return true.
 
-* pending_state: The pending state on which to decide whether to finish execution.
-* returns: Boolean indicating pending execution should be considered finished.
+* @param pending_state The pending state on which to decide whether to finish execution.
+* @return Boolean indicating pending execution should be considered finished.
 */
 DUCKDB_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pending_state);
 
@@ -1654,447 +1829,794 @@ DUCKDB_API bool duckdb_pending_execution_is_finished(duckdb_pending_state pendin
 /*!
 Destroys the value and de-allocates all memory allocated for that type.
 
-* value: The value to destroy.
+* @param value The value to destroy.
 */
 DUCKDB_API void duckdb_destroy_value(duckdb_value *value);
 
 /*!
 Creates a value from a null-terminated string
 
-* value: The null-terminated string
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param text The null-terminated string
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
 DUCKDB_API duckdb_value duckdb_create_varchar(const char *text);
 
 /*!
 Creates a value from a string
 
-* value: The text
-* length: The length of the text
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param text The text
+* @param length The length of the text
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
 DUCKDB_API duckdb_value duckdb_create_varchar_length(const char *text, idx_t length);
 
 /*!
-Creates a value from an int64
+Creates a value from a boolean
 
-* value: The bigint value
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param input The boolean value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_value duckdb_create_int64(int64_t val);
+DUCKDB_API duckdb_value duckdb_create_bool(bool input);
 
 /*!
-Creates a struct value from a type and an array of values
+Creates a value from a int8_t (a tinyint)
 
-* type: The type of the struct
-* values: The values for the struct fields
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param input The tinyint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
+DUCKDB_API duckdb_value duckdb_create_int8(int8_t input);
 
 /*!
-Creates a list value from a type and an array of values of length `value_count`
+Creates a value from a uint8_t (a utinyint)
 
-* type: The type of the list
-* values: The values for the list
-* value_count: The number of values in the list
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param input The utinyint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
+DUCKDB_API duckdb_value duckdb_create_uint8(uint8_t input);
 
 /*!
-Creates a array value from a type and an array of values of length `value_count`
+Creates a value from a int16_t (a smallint)
 
-* type: The type of the array
-* values: The values for the array
-* value_count: The number of values in the array
-* returns: The value. This must be destroyed with `duckdb_destroy_value`.
+* @param input The smallint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
+DUCKDB_API duckdb_value duckdb_create_int16(int16_t input);
 
 /*!
-Obtains a string representation of the given value.
-The result must be destroyed with `duckdb_free`.
+Creates a value from a uint16_t (a usmallint)
 
-* value: The value
-* returns: The string value. This must be destroyed with `duckdb_free`.
+* @param input The usmallint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API char *duckdb_get_varchar(duckdb_value value);
+DUCKDB_API duckdb_value duckdb_create_uint16(uint16_t input);
 
 /*!
-Obtains an int64 of the given value.
+Creates a value from a int32_t (an integer)
 
-* value: The value
-* returns: The int64 value, or 0 if no conversion is possible
+* @param input The integer value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API int64_t duckdb_get_int64(duckdb_value value);
-
-//===--------------------------------------------------------------------===//
-// Logical Type Interface
-//===--------------------------------------------------------------------===//
+DUCKDB_API duckdb_value duckdb_create_int32(int32_t input);
 
 /*!
-Creates a `duckdb_logical_type` from a standard primitive type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a uint32_t (a uinteger)
 
-This should not be used with `DUCKDB_TYPE_DECIMAL`.
-
-* type: The primitive type to create.
-* returns: The logical type.
+* @param input The uinteger value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
+DUCKDB_API duckdb_value duckdb_create_uint32(uint32_t input);
 
 /*!
-Returns the alias of a duckdb_logical_type, if one is set, else `NULL`.
-The result must be destroyed with `duckdb_free`.
+Creates a value from a uint64_t (a ubigint)
 
-* type: The logical type to return the alias of
-* returns: The alias or `NULL`
- */
-DUCKDB_API char *duckdb_logical_type_get_alias(duckdb_logical_type type);
+* @param input The ubigint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
+*/
+DUCKDB_API duckdb_value duckdb_create_uint64(uint64_t input);
 
 /*!
-Creates a list type from its child type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from an int64
 
-* type: The child type of list type to create.
-* returns: The logical type.
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
+DUCKDB_API duckdb_value duckdb_create_int64(int64_t val);
 
 /*!
-Creates a array type from its child type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a hugeint
 
-* type: The child type of array type to create.
-* array_size: The number of elements in the array.
-* returns: The logical type.
+* @param input The hugeint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size);
+DUCKDB_API duckdb_value duckdb_create_hugeint(duckdb_hugeint input);
 
 /*!
-Creates a map type from its key type and value type.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a uhugeint
 
-* type: The key type and value type of map type to create.
-* returns: The logical type.
+* @param input The uhugeint value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
+DUCKDB_API duckdb_value duckdb_create_uhugeint(duckdb_uhugeint input);
 
 /*!
-Creates a UNION type from the passed types array.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a float
 
-* types: The array of types that the union should consist of.
-* type_amount: The size of the types array.
-* returns: The logical type.
+* @param input The float value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types, const char **member_names,
-                                                        idx_t member_count);
+DUCKDB_API duckdb_value duckdb_create_float(float input);
 
 /*!
-Creates a STRUCT type from the passed member name and type arrays.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a double
 
-* member_types: The array of types that the struct should consist of.
-* member_names: The array of names that the struct should consist of.
-* member_count: The number of members that were specified for both arrays.
-* returns: The logical type.
+* @param input The double value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, const char **member_names,
-                                                         idx_t member_count);
+DUCKDB_API duckdb_value duckdb_create_double(double input);
 
 /*!
-Creates an ENUM type from the passed member name array.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a date
 
-* enum_name: The name of the enum.
-* member_names: The array of names that the enum should consist of.
-* member_count: The number of elements that were specified in the array.
-* returns: The logical type.
+* @param input The date value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count);
+DUCKDB_API duckdb_value duckdb_create_date(duckdb_date input);
 
 /*!
-Creates a `duckdb_logical_type` of type decimal with the specified width and scale.
-The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+Creates a value from a time
 
-* width: The width of the decimal type
-* scale: The scale of the decimal type
-* returns: The logical type.
+* @param input The time value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
+DUCKDB_API duckdb_value duckdb_create_time(duckdb_time input);
 
 /*!
-Retrieves the enum type class of a `duckdb_logical_type`.
+Creates a value from a time_tz.
+Not to be confused with `duckdb_create_time_tz`, which creates a duckdb_time_tz_t.
 
-* type: The logical type object
-* returns: The type id
+* @param value The time_tz value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_type duckdb_get_type_id(duckdb_logical_type type);
+DUCKDB_API duckdb_value duckdb_create_time_tz_value(duckdb_time_tz value);
 
 /*!
-Retrieves the width of a decimal type.
+Creates a value from a timestamp
 
-* type: The logical type object
-* returns: The width of the decimal type
+* @param input The timestamp value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API uint8_t duckdb_decimal_width(duckdb_logical_type type);
+DUCKDB_API duckdb_value duckdb_create_timestamp(duckdb_timestamp input);
 
 /*!
-Retrieves the scale of a decimal type.
+Creates a value from an interval
 
-* type: The logical type object
-* returns: The scale of the decimal type
+* @param input The interval value
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API uint8_t duckdb_decimal_scale(duckdb_logical_type type);
+DUCKDB_API duckdb_value duckdb_create_interval(duckdb_interval input);
 
 /*!
-Retrieves the internal storage type of a decimal type.
+Creates a value from a blob
 
-* type: The logical type object
-* returns: The internal type of the decimal type
+* @param data The blob data
+* @param length The length of the blob data
+* @return The value. This must be destroyed with `duckdb_destroy_value`.
 */
-DUCKDB_API duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type);
+DUCKDB_API duckdb_value duckdb_create_blob(const uint8_t *data, idx_t length);
 
 /*!
-Retrieves the internal storage type of an enum type.
+Returns the boolean value of the given value.
 
-* type: The logical type object
-* returns: The internal type of the enum type
+* @param val A duckdb_value containing a boolean
+* @return A boolean, or false if the value cannot be converted
 */
-DUCKDB_API duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
+DUCKDB_API bool duckdb_get_bool(duckdb_value val);
 
 /*!
-Retrieves the dictionary size of the enum type.
+Returns the int8_t value of the given value.
 
-* type: The logical type object
-* returns: The dictionary size of the enum type
+* @param val A duckdb_value containing a tinyint
+* @return A int8_t, or MinValue<int8> if the value cannot be converted
 */
-DUCKDB_API uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
+DUCKDB_API int8_t duckdb_get_int8(duckdb_value val);
 
 /*!
-Retrieves the dictionary value at the specified position from the enum.
+Returns the uint8_t value of the given value.
 
-The result must be freed with `duckdb_free`.
-
-* type: The logical type object
-* index: The index in the dictionary
-* returns: The string value of the enum type. Must be freed with `duckdb_free`.
+* @param val A duckdb_value containing a utinyint
+* @return A uint8_t, or MinValue<uint8> if the value cannot be converted
 */
-DUCKDB_API char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index);
+DUCKDB_API uint8_t duckdb_get_uint8(duckdb_value val);
 
 /*!
-Retrieves the child type of the given list type.
-
-The result must be freed with `duckdb_destroy_logical_type`.
+Returns the int16_t value of the given value.
 
-* type: The logical type object
-* returns: The child type of the list type. Must be destroyed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a smallint
+* @return A int16_t, or MinValue<int16> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
+DUCKDB_API int16_t duckdb_get_int16(duckdb_value val);
 
 /*!
-Retrieves the child type of the given array type.
-
-The result must be freed with `duckdb_destroy_logical_type`.
+Returns the uint16_t value of the given value.
 
-* type: The logical type object
-* returns: The child type of the array type. Must be destroyed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a usmallint
+* @return A uint16_t, or MinValue<uint16> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type);
+DUCKDB_API uint16_t duckdb_get_uint16(duckdb_value val);
 
 /*!
-Retrieves the array size of the given array type.
+Returns the int32_t value of the given value.
 
-* type: The logical type object
-* returns: The fixed number of elements the values of this array type can store.
+* @param val A duckdb_value containing a integer
+* @return A int32_t, or MinValue<int32> if the value cannot be converted
 */
-DUCKDB_API idx_t duckdb_array_type_array_size(duckdb_logical_type type);
+DUCKDB_API int32_t duckdb_get_int32(duckdb_value val);
 
 /*!
-Retrieves the key type of the given map type.
+Returns the uint32_t value of the given value.
 
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* type: The logical type object
-* returns: The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a uinteger
+* @return A uint32_t, or MinValue<uint32> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
+DUCKDB_API uint32_t duckdb_get_uint32(duckdb_value val);
 
 /*!
-Retrieves the value type of the given map type.
+Returns the int64_t value of the given value.
 
-The result must be freed with `duckdb_destroy_logical_type`.
-
-* type: The logical type object
-* returns: The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a bigint
+* @return A int64_t, or MinValue<int64> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
+DUCKDB_API int64_t duckdb_get_int64(duckdb_value val);
 
 /*!
-Returns the number of children of a struct type.
+Returns the uint64_t value of the given value.
 
-* type: The logical type object
-* returns: The number of children of a struct type.
+* @param val A duckdb_value containing a ubigint
+* @return A uint64_t, or MinValue<uint64> if the value cannot be converted
 */
-DUCKDB_API idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
+DUCKDB_API uint64_t duckdb_get_uint64(duckdb_value val);
 
 /*!
-Retrieves the name of the struct child.
-
-The result must be freed with `duckdb_free`.
+Returns the hugeint value of the given value.
 
-* type: The logical type object
-* index: The child index
-* returns: The name of the struct type. Must be freed with `duckdb_free`.
+* @param val A duckdb_value containing a hugeint
+* @return A duckdb_hugeint, or MinValue<hugeint> if the value cannot be converted
 */
-DUCKDB_API char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index);
+DUCKDB_API duckdb_hugeint duckdb_get_hugeint(duckdb_value val);
 
 /*!
-Retrieves the child type of the given struct type at the specified index.
-
-The result must be freed with `duckdb_destroy_logical_type`.
+Returns the uhugeint value of the given value.
 
-* type: The logical type object
-* index: The child index
-* returns: The child type of the struct type. Must be destroyed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a uhugeint
+* @return A duckdb_uhugeint, or MinValue<uhugeint> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index);
+DUCKDB_API duckdb_uhugeint duckdb_get_uhugeint(duckdb_value val);
 
 /*!
-Returns the number of members that the union type has.
+Returns the float value of the given value.
 
-* type: The logical type (union) object
-* returns: The number of members of a union type.
+* @param val A duckdb_value containing a float
+* @return A float, or NAN if the value cannot be converted
 */
-DUCKDB_API idx_t duckdb_union_type_member_count(duckdb_logical_type type);
+DUCKDB_API float duckdb_get_float(duckdb_value val);
 
 /*!
-Retrieves the name of the union member.
+Returns the double value of the given value.
 
-The result must be freed with `duckdb_free`.
+* @param val A duckdb_value containing a double
+* @return A double, or NAN if the value cannot be converted
+*/
+DUCKDB_API double duckdb_get_double(duckdb_value val);
+
+/*!
+Returns the date value of the given value.
 
-* type: The logical type object
-* index: The child index
-* returns: The name of the union member. Must be freed with `duckdb_free`.
+* @param val A duckdb_value containing a date
+* @return A duckdb_date, or MinValue<date> if the value cannot be converted
 */
-DUCKDB_API char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t index);
+DUCKDB_API duckdb_date duckdb_get_date(duckdb_value val);
 
 /*!
-Retrieves the child type of the given union member at the specified index.
+Returns the time value of the given value.
 
-The result must be freed with `duckdb_destroy_logical_type`.
+* @param val A duckdb_value containing a time
+* @return A duckdb_time, or MinValue<time> if the value cannot be converted
+*/
+DUCKDB_API duckdb_time duckdb_get_time(duckdb_value val);
 
-* type: The logical type object
-* index: The child index
-* returns: The child type of the union member. Must be destroyed with `duckdb_destroy_logical_type`.
+/*!
+Returns the time_tz value of the given value.
+
+* @param val A duckdb_value containing a time_tz
+* @return A duckdb_time_tz, or MinValue<time_tz> if the value cannot be converted
 */
-DUCKDB_API duckdb_logical_type duckdb_union_type_member_type(duckdb_logical_type type, idx_t index);
+DUCKDB_API duckdb_time_tz duckdb_get_time_tz(duckdb_value val);
 
 /*!
-Destroys the logical type and de-allocates all memory allocated for that type.
+Returns the timestamp value of the given value.
 
-* type: The logical type to destroy.
+* @param val A duckdb_value containing a timestamp
+* @return A duckdb_timestamp, or MinValue<timestamp> if the value cannot be converted
 */
-DUCKDB_API void duckdb_destroy_logical_type(duckdb_logical_type *type);
+DUCKDB_API duckdb_timestamp duckdb_get_timestamp(duckdb_value val);
 
-//===--------------------------------------------------------------------===//
-// Data Chunk Interface
-//===--------------------------------------------------------------------===//
+/*!
+Returns the interval value of the given value.
+
+* @param val A duckdb_value containing a interval
+* @return A duckdb_interval, or MinValue<interval> if the value cannot be converted
+*/
+DUCKDB_API duckdb_interval duckdb_get_interval(duckdb_value val);
 
 /*!
-Creates an empty DataChunk with the specified set of types.
+Returns the type of the given value. The type is valid as long as the value is not destroyed.
+The type itself must not be destroyed.
+
+* @param val A duckdb_value
+* @return A duckdb_logical_type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_get_value_type(duckdb_value val);
 
-Note that the result must be destroyed with `duckdb_destroy_data_chunk`.
+/*!
+Returns the blob value of the given value.
 
-* types: An array of types of the data chunk.
-* column_count: The number of columns.
-* returns: The data chunk.
+* @param val A duckdb_value containing a blob
+* @return A duckdb_blob
 */
-DUCKDB_API duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *types, idx_t column_count);
+DUCKDB_API duckdb_blob duckdb_get_blob(duckdb_value val);
 
 /*!
-Destroys the data chunk and de-allocates all memory allocated for that chunk.
+Obtains a string representation of the given value.
+The result must be destroyed with `duckdb_free`.
 
-* chunk: The data chunk to destroy.
+* @param value The value
+* @return The string value. This must be destroyed with `duckdb_free`.
 */
-DUCKDB_API void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk);
+DUCKDB_API char *duckdb_get_varchar(duckdb_value value);
 
 /*!
-Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0.
+Creates a struct value from a type and an array of values. Must be destroyed with `duckdb_destroy_value`.
 
-* chunk: The data chunk to reset.
+* @param type The type of the struct
+* @param values The values for the struct fields
+* @return The struct value, or nullptr, if any child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
 */
-DUCKDB_API void duckdb_data_chunk_reset(duckdb_data_chunk chunk);
+DUCKDB_API duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *values);
 
 /*!
-Retrieves the number of columns in a data chunk.
+Creates a list value from a child (element) type and an array of values of length `value_count`.
+Must be destroyed with `duckdb_destroy_value`.
 
-* chunk: The data chunk to get the data from
-* returns: The number of columns in the data chunk
+* @param type The type of the list
+* @param values The values for the list
+* @param value_count The number of values in the list
+* @return The list value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
 */
-DUCKDB_API idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk);
+DUCKDB_API duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
 
 /*!
-Retrieves the vector at the specified column index in the data chunk.
+Creates an array value from a child (element) type and an array of values of length `value_count`.
+Must be destroyed with `duckdb_destroy_value`.
 
-The pointer to the vector is valid for as long as the chunk is alive.
-It does NOT need to be destroyed.
+* @param type The type of the array
+* @param values The values for the array
+* @param value_count The number of values in the array
+* @return The array value, or nullptr, if the child type is `DUCKDB_TYPE_ANY` or `DUCKDB_TYPE_INVALID`.
+*/
+DUCKDB_API duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count);
+
+/*!
+Returns the number of elements in a MAP value.
 
-* chunk: The data chunk to get the data from
-* returns: The vector
+* @param value The MAP value.
+* @return The number of elements in the map.
 */
-DUCKDB_API duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx);
+DUCKDB_API idx_t duckdb_get_map_size(duckdb_value value);
 
 /*!
-Retrieves the current number of tuples in a data chunk.
+Returns the MAP key at index as a duckdb_value.
 
-* chunk: The data chunk to get the data from
-* returns: The number of tuples in the data chunk
+* @param value The MAP value.
+* @param index The index of the key.
+* @return The key as a duckdb_value.
 */
-DUCKDB_API idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk);
+DUCKDB_API duckdb_value duckdb_get_map_key(duckdb_value value, idx_t index);
 
 /*!
-Sets the current number of tuples in a data chunk.
+Returns the MAP value at index as a duckdb_value.
 
-* chunk: The data chunk to set the size in
-* size: The number of tuples in the data chunk
+* @param value The MAP value.
+* @param index The index of the value.
+* @return The value as a duckdb_value.
 */
-DUCKDB_API void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);
+DUCKDB_API duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index);
 
 //===--------------------------------------------------------------------===//
-// Vector Interface
+// Logical Type Interface
 //===--------------------------------------------------------------------===//
 
 /*!
-Retrieves the column type of the specified vector.
+Creates a `duckdb_logical_type` from a primitive type.
+The resulting logical type must be destroyed with `duckdb_destroy_logical_type`.
 
-The result must be destroyed with `duckdb_destroy_logical_type`.
+Returns an invalid logical type, if type is: `DUCKDB_TYPE_INVALID`, `DUCKDB_TYPE_DECIMAL`, `DUCKDB_TYPE_ENUM`,
+`DUCKDB_TYPE_LIST`, `DUCKDB_TYPE_STRUCT`, `DUCKDB_TYPE_MAP`, `DUCKDB_TYPE_ARRAY`, or `DUCKDB_TYPE_UNION`.
 
-* vector: The vector get the data from
-* returns: The type of the vector
+* @param type The primitive type to create.
+* @return The logical type.
 */
-DUCKDB_API duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
+DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
 
 /*!
-Retrieves the data pointer of the vector.
-
-The data pointer can be used to read or write values from the vector.
-How to read or write values depends on the type of the vector.
+Returns the alias of a duckdb_logical_type, if set, else `nullptr`.
+The result must be destroyed with `duckdb_free`.
 
-* vector: The vector to get the data from
-* returns: The data pointer
+* @param type The logical type
+* @return The alias or `nullptr`
 */
-DUCKDB_API void *duckdb_vector_get_data(duckdb_vector vector);
+DUCKDB_API char *duckdb_logical_type_get_alias(duckdb_logical_type type);
 
 /*!
-Retrieves the validity mask pointer of the specified vector.
+Sets the alias of a duckdb_logical_type.
 
-If all values are valid, this function MIGHT return NULL!
+* @param type The logical type
+* @param alias The alias to set
+*/
+DUCKDB_API void duckdb_logical_type_set_alias(duckdb_logical_type type, const char *alias);
 
-The validity mask is a bitset that signifies null-ness within the data chunk.
-It is a series of uint64_t values, where each uint64_t value contains validity for 64 tuples.
+/*!
+Creates a LIST type from its child type.
+The return type must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param type The child type of the list
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
+
+/*!
+Creates an ARRAY type from its child type.
+The return type must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param type The child type of the array.
+* @param array_size The number of elements in the array.
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size);
+
+/*!
+Creates a MAP type from its key type and value type.
+The return type must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param key_type The map's key type.
+* @param value_type The map's value type.
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
+
+/*!
+Creates a UNION type from the passed arrays.
+The return type must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param member_types The array of union member types.
+* @param member_names The union member names.
+* @param member_count The number of union members.
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types, const char **member_names,
+                                                        idx_t member_count);
+
+/*!
+Creates a STRUCT type based on the member types and names.
+The resulting type must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param member_types The array of types of the struct members.
+* @param member_names The array of names of the struct members.
+* @param member_count The number of members of the struct.
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_struct_type(duckdb_logical_type *member_types, const char **member_names,
+                                                         idx_t member_count);
+
+/*!
+Creates an ENUM type from the passed member name array.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* @param member_names The array of names that the enum should consist of.
+* @param member_count The number of elements that were specified in the array.
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_enum_type(const char **member_names, idx_t member_count);
+
+/*!
+Creates a DECIMAL type with the specified width and scale.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* @param width The width of the decimal type
+* @param scale The scale of the decimal type
+* @return The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale);
+
+/*!
+Retrieves the enum `duckdb_type` of a `duckdb_logical_type`.
+
+* @param type The logical type.
+* @return The `duckdb_type` id.
+*/
+DUCKDB_API duckdb_type duckdb_get_type_id(duckdb_logical_type type);
+
+/*!
+Retrieves the width of a decimal type.
+
+* @param type The logical type object
+* @return The width of the decimal type
+*/
+DUCKDB_API uint8_t duckdb_decimal_width(duckdb_logical_type type);
+
+/*!
+Retrieves the scale of a decimal type.
+
+* @param type The logical type object
+* @return The scale of the decimal type
+*/
+DUCKDB_API uint8_t duckdb_decimal_scale(duckdb_logical_type type);
+
+/*!
+Retrieves the internal storage type of a decimal type.
+
+* @param type The logical type object
+* @return The internal type of the decimal type
+*/
+DUCKDB_API duckdb_type duckdb_decimal_internal_type(duckdb_logical_type type);
+
+/*!
+Retrieves the internal storage type of an enum type.
+
+* @param type The logical type object
+* @return The internal type of the enum type
+*/
+DUCKDB_API duckdb_type duckdb_enum_internal_type(duckdb_logical_type type);
+
+/*!
+Retrieves the dictionary size of the enum type.
+
+* @param type The logical type object
+* @return The dictionary size of the enum type
+*/
+DUCKDB_API uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type);
+
+/*!
+Retrieves the dictionary value at the specified position from the enum.
+
+The result must be freed with `duckdb_free`.
+
+* @param type The logical type object
+* @param index The index in the dictionary
+* @return The string value of the enum type. Must be freed with `duckdb_free`.
+*/
+DUCKDB_API char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index);
+
+/*!
+Retrieves the child type of the given LIST type. Also accepts MAP types.
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type, either LIST or MAP.
+* @return The child type of the LIST or MAP type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
+
+/*!
+Retrieves the child type of the given ARRAY type.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type. Must be ARRAY.
+* @return The child type of the ARRAY type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type);
+
+/*!
+Retrieves the array size of the given array type.
+
+* @param type The logical type object
+* @return The fixed number of elements the values of this array type can store.
+*/
+DUCKDB_API idx_t duckdb_array_type_array_size(duckdb_logical_type type);
+
+/*!
+Retrieves the key type of the given map type.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type object
+* @return The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
+
+/*!
+Retrieves the value type of the given map type.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type object
+* @return The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
+
+/*!
+Returns the number of children of a struct type.
+
+* @param type The logical type object
+* @return The number of children of a struct type.
+*/
+DUCKDB_API idx_t duckdb_struct_type_child_count(duckdb_logical_type type);
+
+/*!
+Retrieves the name of the struct child.
+
+The result must be freed with `duckdb_free`.
+
+* @param type The logical type object
+* @param index The child index
+* @return The name of the struct type. Must be freed with `duckdb_free`.
+*/
+DUCKDB_API char *duckdb_struct_type_child_name(duckdb_logical_type type, idx_t index);
+
+/*!
+Retrieves the child type of the given struct type at the specified index.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type object
+* @param index The child index
+* @return The child type of the struct type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_struct_type_child_type(duckdb_logical_type type, idx_t index);
+
+/*!
+Returns the number of members that the union type has.
+
+* @param type The logical type (union) object
+* @return The number of members of a union type.
+*/
+DUCKDB_API idx_t duckdb_union_type_member_count(duckdb_logical_type type);
+
+/*!
+Retrieves the name of the union member.
+
+The result must be freed with `duckdb_free`.
+
+* @param type The logical type object
+* @param index The child index
+* @return The name of the union member. Must be freed with `duckdb_free`.
+*/
+DUCKDB_API char *duckdb_union_type_member_name(duckdb_logical_type type, idx_t index);
+
+/*!
+Retrieves the child type of the given union member at the specified index.
+
+The result must be freed with `duckdb_destroy_logical_type`.
+
+* @param type The logical type object
+* @param index The child index
+* @return The child type of the union member. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_union_type_member_type(duckdb_logical_type type, idx_t index);
+
+/*!
+Destroys the logical type and de-allocates all memory allocated for that type.
+
+* @param type The logical type to destroy.
+*/
+DUCKDB_API void duckdb_destroy_logical_type(duckdb_logical_type *type);
+
+/*!
+Registers a custom type within the given connection.
+The type must have an alias
+
+* @param con The connection to use
+* @param type The custom type to register
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_logical_type(duckdb_connection con, duckdb_logical_type type,
+                                                     duckdb_create_type_info info);
+
+//===--------------------------------------------------------------------===//
+// Data Chunk Interface
+//===--------------------------------------------------------------------===//
+
+/*!
+Creates an empty data chunk with the specified column types.
+The result must be destroyed with `duckdb_destroy_data_chunk`.
+
+* @param types An array of column types. Column types can not contain ANY and INVALID types.
+* @param column_count The number of columns.
+* @return The data chunk.
+*/
+DUCKDB_API duckdb_data_chunk duckdb_create_data_chunk(duckdb_logical_type *types, idx_t column_count);
+
+/*!
+Destroys the data chunk and de-allocates all memory allocated for that chunk.
+
+* @param chunk The data chunk to destroy.
+*/
+DUCKDB_API void duckdb_destroy_data_chunk(duckdb_data_chunk *chunk);
+
+/*!
+Resets a data chunk, clearing the validity masks and setting the cardinality of the data chunk to 0.
+After calling this method, you must call `duckdb_vector_get_validity` and `duckdb_vector_get_data` to obtain current
+data and validity pointers
+
+* @param chunk The data chunk to reset.
+*/
+DUCKDB_API void duckdb_data_chunk_reset(duckdb_data_chunk chunk);
+
+/*!
+Retrieves the number of columns in a data chunk.
+
+* @param chunk The data chunk to get the data from
+* @return The number of columns in the data chunk
+*/
+DUCKDB_API idx_t duckdb_data_chunk_get_column_count(duckdb_data_chunk chunk);
+
+/*!
+Retrieves the vector at the specified column index in the data chunk.
+
+The pointer to the vector is valid for as long as the chunk is alive.
+It does NOT need to be destroyed.
+
+* @param chunk The data chunk to get the data from
+* @return The vector
+*/
+DUCKDB_API duckdb_vector duckdb_data_chunk_get_vector(duckdb_data_chunk chunk, idx_t col_idx);
+
+/*!
+Retrieves the current number of tuples in a data chunk.
+
+* @param chunk The data chunk to get the data from
+* @return The number of tuples in the data chunk
+*/
+DUCKDB_API idx_t duckdb_data_chunk_get_size(duckdb_data_chunk chunk);
+
+/*!
+Sets the current number of tuples in a data chunk.
+
+* @param chunk The data chunk to set the size in
+* @param size The number of tuples in the data chunk
+*/
+DUCKDB_API void duckdb_data_chunk_set_size(duckdb_data_chunk chunk, idx_t size);
+
+//===--------------------------------------------------------------------===//
+// Vector Interface
+//===--------------------------------------------------------------------===//
+
+/*!
+Retrieves the column type of the specified vector.
+
+The result must be destroyed with `duckdb_destroy_logical_type`.
+
+* @param vector The vector get the data from
+* @return The type of the vector
+*/
+DUCKDB_API duckdb_logical_type duckdb_vector_get_column_type(duckdb_vector vector);
+
+/*!
+Retrieves the data pointer of the vector.
+
+The data pointer can be used to read or write values from the vector.
+How to read or write values depends on the type of the vector.
+
+* @param vector The vector to get the data from
+* @return The data pointer
+*/
+DUCKDB_API void *duckdb_vector_get_data(duckdb_vector vector);
+
+/*!
+Retrieves the validity mask pointer of the specified vector.
+
+If all values are valid, this function MIGHT return NULL!
+
+The validity mask is a bitset that signifies null-ness within the data chunk.
+It is a series of uint64_t values, where each uint64_t value contains validity for 64 tuples.
 The bit is set to 1 if the value is valid (i.e. not NULL) or 0 if the value is invalid (i.e. NULL).
 
 Validity of a specific value can be obtained like this:
@@ -2105,8 +2627,8 @@ bool is_valid = validity_mask[entry_idx] & (1 << idx_in_entry);
 
 Alternatively, the (slower) duckdb_validity_row_is_valid function can be used.
 
-* vector: The vector to get the data from
-* returns: The pointer to the validity mask, or NULL if no validity mask is present
+* @param vector The vector to get the data from
+* @return The pointer to the validity mask, or NULL if no validity mask is present
 */
 DUCKDB_API uint64_t *duckdb_vector_get_validity(duckdb_vector vector);
 
@@ -2116,26 +2638,26 @@ Ensures the validity mask is writable by allocating it.
 After this function is called, `duckdb_vector_get_validity` will ALWAYS return non-NULL.
 This allows null values to be written to the vector, regardless of whether a validity mask was present before.
 
-* vector: The vector to alter
+* @param vector The vector to alter
 */
 DUCKDB_API void duckdb_vector_ensure_validity_writable(duckdb_vector vector);
 
 /*!
 Assigns a string element in the vector at the specified location.
 
-* vector: The vector to alter
-* index: The row position in the vector to assign the string to
-* str: The null-terminated string
+* @param vector The vector to alter
+* @param index The row position in the vector to assign the string to
+* @param str The null-terminated string
 */
 DUCKDB_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str);
 
 /*!
 Assigns a string element in the vector at the specified location. You may also use this function to assign BLOBs.
 
-* vector: The vector to alter
-* index: The row position in the vector to assign the string to
-* str: The string
-* str_len: The length of the string (in bytes)
+* @param vector The vector to alter
+* @param index The row position in the vector to assign the string to
+* @param str The string
+* @param str_len The length of the string (in bytes)
 */
 DUCKDB_API void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index, const char *str,
                                                         idx_t str_len);
@@ -2145,34 +2667,37 @@ Retrieves the child vector of a list vector.
 
 The resulting vector is valid as long as the parent vector is valid.
 
-* vector: The vector
-* returns: The child vector
+* @param vector The vector
+* @return The child vector
 */
 DUCKDB_API duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector);
 
 /*!
 Returns the size of the child vector of the list.
 
-* vector: The vector
-* returns: The size of the child list
+* @param vector The vector
+* @return The size of the child list
 */
 DUCKDB_API idx_t duckdb_list_vector_get_size(duckdb_vector vector);
 
 /*!
 Sets the total size of the underlying child-vector of a list vector.
 
-* vector: The list vector.
-* size: The size of the child list.
-* returns: The duckdb state. Returns DuckDBError if the vector is nullptr.
+* @param vector The list vector.
+* @param size The size of the child list.
+* @return The duckdb state. Returns DuckDBError if the vector is nullptr.
 */
 DUCKDB_API duckdb_state duckdb_list_vector_set_size(duckdb_vector vector, idx_t size);
 
 /*!
 Sets the total capacity of the underlying child-vector of a list.
 
-* vector: The list vector.
-* required_capacity: the total capacity to reserve.
-* return: The duckdb state. Returns DuckDBError if the vector is nullptr.
+After calling this method, you must call `duckdb_vector_get_validity` and `duckdb_vector_get_data` to obtain current
+data and validity pointers
+
+* @param vector The list vector.
+* @param required_capacity the total capacity to reserve.
+* @return The duckdb state. Returns DuckDBError if the vector is nullptr.
 */
 DUCKDB_API duckdb_state duckdb_list_vector_reserve(duckdb_vector vector, idx_t required_capacity);
 
@@ -2181,9 +2706,9 @@ Retrieves the child vector of a struct vector.
 
 The resulting vector is valid as long as the parent vector is valid.
 
-* vector: The vector
-* index: The child index
-* returns: The child vector
+* @param vector The vector
+* @param index The child index
+* @return The child vector
 */
 DUCKDB_API duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index);
 
@@ -2193,8 +2718,8 @@ Retrieves the child vector of a array vector.
 The resulting vector is valid as long as the parent vector is valid.
 The resulting vector has the size of the parent vector multiplied by the array size.
 
-* vector: The vector
-* returns: The child vector
+* @param vector The vector
+* @return The child vector
 */
 DUCKDB_API duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
 
@@ -2205,9 +2730,9 @@ DUCKDB_API duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector);
 /*!
 Returns whether or not a row is valid (i.e. not NULL) in the given validity mask.
 
-* validity: The validity mask, as obtained through `duckdb_vector_get_validity`
-* row: The row index
-* returns: true if the row is valid, false otherwise
+* @param validity The validity mask, as obtained through `duckdb_vector_get_validity`
+* @param row The row index
+* @return true if the row is valid, false otherwise
 */
 DUCKDB_API bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row);
 
@@ -2217,9 +2742,9 @@ In a validity mask, sets a specific row to either valid or invalid.
 Note that `duckdb_vector_ensure_validity_writable` should be called before calling `duckdb_vector_get_validity`,
 to ensure that there is a validity mask to write to.
 
-* validity: The validity mask, as obtained through `duckdb_vector_get_validity`.
-* row: The row index
-* valid: Whether or not to set the row to valid, or invalid
+* @param validity The validity mask, as obtained through `duckdb_vector_get_validity`.
+* @param row The row index
+* @param valid Whether or not to set the row to valid, or invalid
 */
 DUCKDB_API void duckdb_validity_set_row_validity(uint64_t *validity, idx_t row, bool valid);
 
@@ -2228,8 +2753,8 @@ In a validity mask, sets a specific row to invalid.
 
 Equivalent to `duckdb_validity_set_row_validity` with valid set to false.
 
-* validity: The validity mask
-* row: The row index
+* @param validity The validity mask
+* @param row The row index
 */
 DUCKDB_API void duckdb_validity_set_row_invalid(uint64_t *validity, idx_t row);
 
@@ -2238,12 +2763,326 @@ In a validity mask, sets a specific row to valid.
 
 Equivalent to `duckdb_validity_set_row_validity` with valid set to true.
 
-* validity: The validity mask
-* row: The row index
+* @param validity The validity mask
+* @param row The row index
 */
 DUCKDB_API void duckdb_validity_set_row_valid(uint64_t *validity, idx_t row);
 
-#ifndef DUCKDB_NO_EXTENSION_FUNCTIONS
+//===--------------------------------------------------------------------===//
+// Scalar Functions
+//===--------------------------------------------------------------------===//
+
+/*!
+Creates a new empty scalar function.
+
+The return value should be destroyed with `duckdb_destroy_scalar_function`.
+
+* @return The scalar function object.
+*/
+DUCKDB_API duckdb_scalar_function duckdb_create_scalar_function();
+
+/*!
+Destroys the given scalar function object.
+
+* @param scalar_function The scalar function to destroy
+*/
+DUCKDB_API void duckdb_destroy_scalar_function(duckdb_scalar_function *scalar_function);
+
+/*!
+Sets the name of the given scalar function.
+
+* @param scalar_function The scalar function
+* @param name The name of the scalar function
+*/
+DUCKDB_API void duckdb_scalar_function_set_name(duckdb_scalar_function scalar_function, const char *name);
+
+/*!
+Sets the parameters of the given scalar function to varargs. Does not require adding parameters with
+duckdb_scalar_function_add_parameter.
+
+* @param scalar_function The scalar function.
+* @param type The type of the arguments.
+* @return The parameter type. Cannot contain INVALID.
+*/
+DUCKDB_API void duckdb_scalar_function_set_varargs(duckdb_scalar_function scalar_function, duckdb_logical_type type);
+
+/*!
+Sets the parameters of the given scalar function to varargs. Does not require adding parameters with
+duckdb_scalar_function_add_parameter.
+
+* @param scalar_function The scalar function.
+*/
+DUCKDB_API void duckdb_scalar_function_set_special_handling(duckdb_scalar_function scalar_function);
+
+/*!
+Sets the Function Stability of the scalar function to VOLATILE, indicating the function should be re-run for every row.
+This limits optimization that can be performed for the function.
+
+* @param scalar_function The scalar function.
+*/
+DUCKDB_API void duckdb_scalar_function_set_volatile(duckdb_scalar_function scalar_function);
+
+/*!
+Adds a parameter to the scalar function.
+
+* @param scalar_function The scalar function.
+* @param type The parameter type. Cannot contain INVALID.
+*/
+DUCKDB_API void duckdb_scalar_function_add_parameter(duckdb_scalar_function scalar_function, duckdb_logical_type type);
+
+/*!
+Sets the return type of the scalar function.
+
+* @param scalar_function The scalar function
+* @param type Cannot contain INVALID or ANY.
+*/
+DUCKDB_API void duckdb_scalar_function_set_return_type(duckdb_scalar_function scalar_function,
+                                                       duckdb_logical_type type);
+
+/*!
+Assigns extra information to the scalar function that can be fetched during binding, etc.
+
+* @param scalar_function The scalar function
+* @param extra_info The extra information
+* @param destroy The callback that will be called to destroy the bind data (if any)
+*/
+DUCKDB_API void duckdb_scalar_function_set_extra_info(duckdb_scalar_function scalar_function, void *extra_info,
+                                                      duckdb_delete_callback_t destroy);
+
+/*!
+Sets the main function of the scalar function.
+
+* @param scalar_function The scalar function
+* @param function The function
+*/
+DUCKDB_API void duckdb_scalar_function_set_function(duckdb_scalar_function scalar_function,
+                                                    duckdb_scalar_function_t function);
+
+/*!
+Register the scalar function object within the given connection.
+
+The function requires at least a name, a function and a return type.
+
+If the function is incomplete or a function with this name already exists DuckDBError is returned.
+
+* @param con The connection to register it in.
+* @param scalar_function The function pointer
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_scalar_function(duckdb_connection con, duckdb_scalar_function scalar_function);
+
+/*!
+Retrieves the extra info of the function as set in `duckdb_scalar_function_set_extra_info`.
+
+* @param info The info object.
+* @return The extra info.
+*/
+DUCKDB_API void *duckdb_scalar_function_get_extra_info(duckdb_function_info info);
+
+/*!
+Report that an error has occurred while executing the scalar function.
+
+* @param info The info object.
+* @param error The error message
+*/
+DUCKDB_API void duckdb_scalar_function_set_error(duckdb_function_info info, const char *error);
+
+/*!
+Creates a new empty scalar function set.
+
+The return value should be destroyed with `duckdb_destroy_scalar_function_set`.
+
+* @return The scalar function set object.
+*/
+DUCKDB_API duckdb_scalar_function_set duckdb_create_scalar_function_set(const char *name);
+
+/*!
+Destroys the given scalar function set object.
+
+*/
+DUCKDB_API void duckdb_destroy_scalar_function_set(duckdb_scalar_function_set *scalar_function_set);
+
+/*!
+Adds the scalar function as a new overload to the scalar function set.
+
+Returns DuckDBError if the function could not be added, for example if the overload already exists.
+
+* @param set The scalar function set
+* @param function The function to add
+*/
+DUCKDB_API duckdb_state duckdb_add_scalar_function_to_set(duckdb_scalar_function_set set,
+                                                          duckdb_scalar_function function);
+
+/*!
+Register the scalar function set within the given connection.
+
+The set requires at least a single valid overload.
+
+If the set is incomplete or a function with this name already exists DuckDBError is returned.
+
+* @param con The connection to register it in.
+* @param set The function set to register
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_scalar_function_set(duckdb_connection con, duckdb_scalar_function_set set);
+
+//===--------------------------------------------------------------------===//
+// Aggregate Functions
+//===--------------------------------------------------------------------===//
+
+/*!
+Creates a new empty aggregate function.
+
+The return value should be destroyed with `duckdb_destroy_aggregate_function`.
+
+* @return The aggregate function object.
+*/
+DUCKDB_API duckdb_aggregate_function duckdb_create_aggregate_function();
+
+/*!
+Destroys the given aggregate function object.
+
+*/
+DUCKDB_API void duckdb_destroy_aggregate_function(duckdb_aggregate_function *aggregate_function);
+
+/*!
+Sets the name of the given aggregate function.
+
+* @param aggregate_function The aggregate function
+* @param name The name of the aggregate function
+*/
+DUCKDB_API void duckdb_aggregate_function_set_name(duckdb_aggregate_function aggregate_function, const char *name);
+
+/*!
+Adds a parameter to the aggregate function.
+
+* @param aggregate_function The aggregate function.
+* @param type The parameter type. Cannot contain INVALID.
+*/
+DUCKDB_API void duckdb_aggregate_function_add_parameter(duckdb_aggregate_function aggregate_function,
+                                                        duckdb_logical_type type);
+
+/*!
+Sets the return type of the aggregate function.
+
+* @param aggregate_function The aggregate function.
+* @param type The return type. Cannot contain INVALID or ANY.
+*/
+DUCKDB_API void duckdb_aggregate_function_set_return_type(duckdb_aggregate_function aggregate_function,
+                                                          duckdb_logical_type type);
+
+/*!
+Sets the main functions of the aggregate function.
+
+* @param aggregate_function The aggregate function
+* @param state_size state size
+* @param state_init state init function
+* @param update update states
+* @param combine combine states
+* @param finalize finalize states
+*/
+DUCKDB_API void duckdb_aggregate_function_set_functions(duckdb_aggregate_function aggregate_function,
+                                                        duckdb_aggregate_state_size state_size,
+                                                        duckdb_aggregate_init_t state_init,
+                                                        duckdb_aggregate_update_t update,
+                                                        duckdb_aggregate_combine_t combine,
+                                                        duckdb_aggregate_finalize_t finalize);
+
+/*!
+Sets the state destructor callback of the aggregate function (optional)
+
+* @param aggregate_function The aggregate function
+* @param destroy state destroy callback
+*/
+DUCKDB_API void duckdb_aggregate_function_set_destructor(duckdb_aggregate_function aggregate_function,
+                                                         duckdb_aggregate_destroy_t destroy);
+
+/*!
+Register the aggregate function object within the given connection.
+
+The function requires at least a name, functions and a return type.
+
+If the function is incomplete or a function with this name already exists DuckDBError is returned.
+
+* @param con The connection to register it in.
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_aggregate_function(duckdb_connection con,
+                                                           duckdb_aggregate_function aggregate_function);
+
+/*!
+Sets the NULL handling of the aggregate function to SPECIAL_HANDLING.
+
+* @param aggregate_function The aggregate function
+*/
+DUCKDB_API void duckdb_aggregate_function_set_special_handling(duckdb_aggregate_function aggregate_function);
+
+/*!
+Assigns extra information to the scalar function that can be fetched during binding, etc.
+
+* @param aggregate_function The aggregate function
+* @param extra_info The extra information
+* @param destroy The callback that will be called to destroy the bind data (if any)
+*/
+DUCKDB_API void duckdb_aggregate_function_set_extra_info(duckdb_aggregate_function aggregate_function, void *extra_info,
+                                                         duckdb_delete_callback_t destroy);
+
+/*!
+Retrieves the extra info of the function as set in `duckdb_aggregate_function_set_extra_info`.
+
+* @param info The info object
+* @return The extra info
+*/
+DUCKDB_API void *duckdb_aggregate_function_get_extra_info(duckdb_function_info info);
+
+/*!
+Report that an error has occurred while executing the aggregate function.
+
+* @param info The info object
+* @param error The error message
+*/
+DUCKDB_API void duckdb_aggregate_function_set_error(duckdb_function_info info, const char *error);
+
+/*!
+Creates a new empty aggregate function set.
+
+The return value should be destroyed with `duckdb_destroy_aggregate_function_set`.
+
+* @return The aggregate function set object.
+*/
+DUCKDB_API duckdb_aggregate_function_set duckdb_create_aggregate_function_set(const char *name);
+
+/*!
+Destroys the given aggregate function set object.
+
+*/
+DUCKDB_API void duckdb_destroy_aggregate_function_set(duckdb_aggregate_function_set *aggregate_function_set);
+
+/*!
+Adds the aggregate function as a new overload to the aggregate function set.
+
+Returns DuckDBError if the function could not be added, for example if the overload already exists.
+
+* @param set The aggregate function set
+* @param function The function to add
+*/
+DUCKDB_API duckdb_state duckdb_add_aggregate_function_to_set(duckdb_aggregate_function_set set,
+                                                             duckdb_aggregate_function function);
+
+/*!
+Register the aggregate function set within the given connection.
+
+The set requires at least a single valid overload.
+
+If the set is incomplete or a function with this name already exists DuckDBError is returned.
+
+* @param con The connection to register it in.
+* @param set The function set to register
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_aggregate_function_set(duckdb_connection con,
+                                                               duckdb_aggregate_function_set set);
+
 //===--------------------------------------------------------------------===//
 // Table Functions
 //===--------------------------------------------------------------------===//
@@ -2253,39 +3092,39 @@ Creates a new empty table function.
 
 The return value should be destroyed with `duckdb_destroy_table_function`.
 
-* returns: The table function object.
+* @return The table function object.
 */
 DUCKDB_API duckdb_table_function duckdb_create_table_function();
 
 /*!
 Destroys the given table function object.
 
-* table_function: The table function to destroy
+* @param table_function The table function to destroy
 */
 DUCKDB_API void duckdb_destroy_table_function(duckdb_table_function *table_function);
 
 /*!
 Sets the name of the given table function.
 
-* table_function: The table function
-* name: The name of the table function
+* @param table_function The table function
+* @param name The name of the table function
 */
 DUCKDB_API void duckdb_table_function_set_name(duckdb_table_function table_function, const char *name);
 
 /*!
 Adds a parameter to the table function.
 
-* table_function: The table function
-* type: The type of the parameter to add.
+* @param table_function The table function.
+* @param type The parameter type. Cannot contain INVALID.
 */
 DUCKDB_API void duckdb_table_function_add_parameter(duckdb_table_function table_function, duckdb_logical_type type);
 
 /*!
 Adds a named parameter to the table function.
 
-* table_function: The table function
-* name: The name of the parameter
-* type: The type of the parameter to add.
+* @param table_function The table function.
+* @param name The parameter name.
+* @param type The parameter type. Cannot contain INVALID.
 */
 DUCKDB_API void duckdb_table_function_add_named_parameter(duckdb_table_function table_function, const char *name,
                                                           duckdb_logical_type type);
@@ -2293,9 +3132,9 @@ DUCKDB_API void duckdb_table_function_add_named_parameter(duckdb_table_function
 /*!
 Assigns extra information to the table function that can be fetched during binding, etc.
 
-* table_function: The table function
-* extra_info: The extra information
-* destroy: The callback that will be called to destroy the bind data (if any)
+* @param table_function The table function
+* @param extra_info The extra information
+* @param destroy The callback that will be called to destroy the bind data (if any)
 */
 DUCKDB_API void duckdb_table_function_set_extra_info(duckdb_table_function table_function, void *extra_info,
                                                      duckdb_delete_callback_t destroy);
@@ -2303,24 +3142,24 @@ DUCKDB_API void duckdb_table_function_set_extra_info(duckdb_table_function table
 /*!
 Sets the bind function of the table function.
 
-* table_function: The table function
-* bind: The bind function
+* @param table_function The table function
+* @param bind The bind function
 */
 DUCKDB_API void duckdb_table_function_set_bind(duckdb_table_function table_function, duckdb_table_function_bind_t bind);
 
 /*!
 Sets the init function of the table function.
 
-* table_function: The table function
-* init: The init function
+* @param table_function The table function
+* @param init The init function
 */
 DUCKDB_API void duckdb_table_function_set_init(duckdb_table_function table_function, duckdb_table_function_init_t init);
 
 /*!
 Sets the thread-local init function of the table function.
 
-* table_function: The table function
-* init: The init function
+* @param table_function The table function
+* @param init The init function
 */
 DUCKDB_API void duckdb_table_function_set_local_init(duckdb_table_function table_function,
                                                      duckdb_table_function_init_t init);
@@ -2328,8 +3167,8 @@ DUCKDB_API void duckdb_table_function_set_local_init(duckdb_table_function table
 /*!
 Sets the main function of the table function.
 
-* table_function: The table function
-* function: The function
+* @param table_function The table function
+* @param function The function
 */
 DUCKDB_API void duckdb_table_function_set_function(duckdb_table_function table_function,
                                                    duckdb_table_function_t function);
@@ -2341,8 +3180,8 @@ If this is set to true, the system will provide a list of all required columns i
 the `duckdb_init_get_column_count` and `duckdb_init_get_column_index` functions.
 If this is set to false (the default), the system will expect all columns to be projected.
 
-* table_function: The table function
-* pushdown: True if the table function supports projection pushdown, false otherwise.
+* @param table_function The table function
+* @param pushdown True if the table function supports projection pushdown, false otherwise.
 */
 DUCKDB_API void duckdb_table_function_supports_projection_pushdown(duckdb_table_function table_function, bool pushdown);
 
@@ -2353,9 +3192,9 @@ The function requires at least a name, a bind function, an init function and a m
 
 If the function is incomplete or a function with this name already exists DuckDBError is returned.
 
-* con: The connection to register it in.
-* function: The function pointer
-* returns: Whether or not the registration was successful.
+* @param con The connection to register it in.
+* @param function The function pointer
+* @return Whether or not the registration was successful.
 */
 DUCKDB_API duckdb_state duckdb_register_table_function(duckdb_connection con, duckdb_table_function function);
 
@@ -2366,25 +3205,25 @@ DUCKDB_API duckdb_state duckdb_register_table_function(duckdb_connection con, du
 /*!
 Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
-* info: The info object
-* returns: The extra info
+* @param info The info object
+* @return The extra info
 */
 DUCKDB_API void *duckdb_bind_get_extra_info(duckdb_bind_info info);
 
 /*!
 Adds a result column to the output of the table function.
 
-* info: The info object
-* name: The name of the column
-* type: The logical type of the column
+* @param info The table function's bind info.
+* @param name The column name.
+* @param type The logical column type.
 */
 DUCKDB_API void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duckdb_logical_type type);
 
 /*!
 Retrieves the number of regular (non-named) parameters to the function.
 
-* info: The info object
-* returns: The number of parameters
+* @param info The info object
+* @return The number of parameters
 */
 DUCKDB_API idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info);
 
@@ -2393,9 +3232,9 @@ Retrieves the parameter at the given index.
 
 The result must be destroyed with `duckdb_destroy_value`.
 
-* info: The info object
-* index: The index of the parameter to get
-* returns: The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
+* @param info The info object
+* @param index The index of the parameter to get
+* @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
 */
 DUCKDB_API duckdb_value duckdb_bind_get_parameter(duckdb_bind_info info, idx_t index);
 
@@ -2404,34 +3243,34 @@ Retrieves a named parameter with the given name.
 
 The result must be destroyed with `duckdb_destroy_value`.
 
-* info: The info object
-* name: The name of the parameter
-* returns: The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
+* @param info The info object
+* @param name The name of the parameter
+* @return The value of the parameter. Must be destroyed with `duckdb_destroy_value`.
 */
 DUCKDB_API duckdb_value duckdb_bind_get_named_parameter(duckdb_bind_info info, const char *name);
 
 /*!
 Sets the user-provided bind data in the bind object. This object can be retrieved again during execution.
 
-* info: The info object
-* extra_data: The bind data object.
-* destroy: The callback that will be called to destroy the bind data (if any)
+* @param info The info object
+* @param bind_data The bind data object.
+* @param destroy The callback that will be called to destroy the bind data (if any)
 */
 DUCKDB_API void duckdb_bind_set_bind_data(duckdb_bind_info info, void *bind_data, duckdb_delete_callback_t destroy);
 
 /*!
 Sets the cardinality estimate for the table function, used for optimization.
 
-* info: The bind data object.
-* is_exact: Whether or not the cardinality estimate is exact, or an approximation
+* @param info The bind data object.
+* @param is_exact Whether or not the cardinality estimate is exact, or an approximation
 */
 DUCKDB_API void duckdb_bind_set_cardinality(duckdb_bind_info info, idx_t cardinality, bool is_exact);
 
 /*!
 Report that an error has occurred while calling bind.
 
-* info: The info object
-* error: The error message
+* @param info The info object
+* @param error The error message
 */
 DUCKDB_API void duckdb_bind_set_error(duckdb_bind_info info, const char *error);
 
@@ -2442,8 +3281,8 @@ DUCKDB_API void duckdb_bind_set_error(duckdb_bind_info info, const char *error);
 /*!
 Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
-* info: The info object
-* returns: The extra info
+* @param info The info object
+* @return The extra info
 */
 DUCKDB_API void *duckdb_init_get_extra_info(duckdb_init_info info);
 
@@ -2453,17 +3292,17 @@ Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
 Note that the bind data should be considered as read-only.
 For tracking state, use the init data instead.
 
-* info: The info object
-* returns: The bind data object
+* @param info The info object
+* @return The bind data object
 */
 DUCKDB_API void *duckdb_init_get_bind_data(duckdb_init_info info);
 
 /*!
 Sets the user-provided init data in the init object. This object can be retrieved again during execution.
 
-* info: The info object
-* extra_data: The init data object.
-* destroy: The callback that will be called to destroy the init data (if any)
+* @param info The info object
+* @param init_data The init data object.
+* @param destroy The callback that will be called to destroy the init data (if any)
 */
 DUCKDB_API void duckdb_init_set_init_data(duckdb_init_info info, void *init_data, duckdb_delete_callback_t destroy);
 
@@ -2472,8 +3311,8 @@ Returns the number of projected columns.
 
 This function must be used if projection pushdown is enabled to figure out which columns to emit.
 
-* info: The info object
-* returns: The number of projected columns.
+* @param info The info object
+* @return The number of projected columns.
 */
 DUCKDB_API idx_t duckdb_init_get_column_count(duckdb_init_info info);
 
@@ -2482,25 +3321,25 @@ Returns the column index of the projected column at the specified position.
 
 This function must be used if projection pushdown is enabled to figure out which columns to emit.
 
-* info: The info object
-* column_index: The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
-* returns: The column index of the projected column.
+* @param info The info object
+* @param column_index The index at which to get the projected column index, from 0..duckdb_init_get_column_count(info)
+* @return The column index of the projected column.
 */
 DUCKDB_API idx_t duckdb_init_get_column_index(duckdb_init_info info, idx_t column_index);
 
 /*!
 Sets how many threads can process this table function in parallel (default: 1)
 
-* info: The info object
-* max_threads: The maximum amount of threads that can process this table function
+* @param info The info object
+* @param max_threads The maximum amount of threads that can process this table function
 */
 DUCKDB_API void duckdb_init_set_max_threads(duckdb_init_info info, idx_t max_threads);
 
 /*!
 Report that an error has occurred while calling init.
 
-* info: The info object
-* error: The error message
+* @param info The info object
+* @param error The error message
 */
 DUCKDB_API void duckdb_init_set_error(duckdb_init_info info, const char *error);
 
@@ -2511,8 +3350,8 @@ DUCKDB_API void duckdb_init_set_error(duckdb_init_info info, const char *error);
 /*!
 Retrieves the extra info of the function as set in `duckdb_table_function_set_extra_info`.
 
-* info: The info object
-* returns: The extra info
+* @param info The info object
+* @return The extra info
 */
 DUCKDB_API void *duckdb_function_get_extra_info(duckdb_function_info info);
 
@@ -2522,32 +3361,32 @@ Gets the bind data set by `duckdb_bind_set_bind_data` during the bind.
 Note that the bind data should be considered as read-only.
 For tracking state, use the init data instead.
 
-* info: The info object
-* returns: The bind data object
+* @param info The info object
+* @return The bind data object
 */
 DUCKDB_API void *duckdb_function_get_bind_data(duckdb_function_info info);
 
 /*!
 Gets the init data set by `duckdb_init_set_init_data` during the init.
 
-* info: The info object
-* returns: The init data object
+* @param info The info object
+* @return The init data object
 */
 DUCKDB_API void *duckdb_function_get_init_data(duckdb_function_info info);
 
 /*!
 Gets the thread-local init data set by `duckdb_init_set_init_data` during the local_init.
 
-* info: The info object
-* returns: The init data object
+* @param info The info object
+* @return The init data object
 */
 DUCKDB_API void *duckdb_function_get_local_init_data(duckdb_function_info info);
 
 /*!
 Report that an error has occurred while executing the function.
 
-* info: The info object
-* error: The error message
+* @param info The info object
+* @param error The error message
 */
 DUCKDB_API void duckdb_function_set_error(duckdb_function_info info, const char *error);
 
@@ -2558,10 +3397,10 @@ DUCKDB_API void duckdb_function_set_error(duckdb_function_info info, const char
 /*!
 Add a replacement scan definition to the specified database.
 
-* db: The database object to add the replacement scan to
-* replacement: The replacement scan callback
-* extra_data: Extra data that is passed back into the specified callback
-* delete_callback: The delete callback to call on the extra data, if any
+* @param db The database object to add the replacement scan to
+* @param replacement The replacement scan callback
+* @param extra_data Extra data that is passed back into the specified callback
+* @param delete_callback The delete callback to call on the extra data, if any
 */
 DUCKDB_API void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback_t replacement,
                                             void *extra_data, duckdb_delete_callback_t delete_callback);
@@ -2570,27 +3409,75 @@ DUCKDB_API void duckdb_add_replacement_scan(duckdb_database db, duckdb_replaceme
 Sets the replacement function name. If this function is called in the replacement callback,
 the replacement scan is performed. If it is not called, the replacement callback is not performed.
 
-* info: The info object
-* function_name: The function name to substitute.
+* @param info The info object
+* @param function_name The function name to substitute.
 */
 DUCKDB_API void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info, const char *function_name);
 
 /*!
 Adds a parameter to the replacement scan function.
 
-* info: The info object
-* parameter: The parameter to add.
+* @param info The info object
+* @param parameter The parameter to add.
 */
 DUCKDB_API void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info, duckdb_value parameter);
 
 /*!
 Report that an error has occurred while executing the replacement scan.
 
-* info: The info object
-* error: The error message
+* @param info The info object
+* @param error The error message
 */
 DUCKDB_API void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info info, const char *error);
-#endif
+
+//===--------------------------------------------------------------------===//
+// Profiling Info
+//===--------------------------------------------------------------------===//
+
+/*!
+Returns the root node of the profiling information. Returns nullptr, if profiling is not enabled.
+
+* @param connection A connection object.
+* @return A profiling information object.
+*/
+DUCKDB_API duckdb_profiling_info duckdb_get_profiling_info(duckdb_connection connection);
+
+/*!
+Returns the value of the metric of the current profiling info node. Returns nullptr, if the metric does
+ not exist or is not enabled. Currently, the value holds a string, and you can retrieve the string
+ by calling the corresponding function: char *duckdb_get_varchar(duckdb_value value).
+
+* @param info A profiling information object.
+* @param key The name of the requested metric.
+* @return The value of the metric. Must be freed with `duckdb_destroy_value`
+*/
+DUCKDB_API duckdb_value duckdb_profiling_info_get_value(duckdb_profiling_info info, const char *key);
+
+/*!
+Returns the key-value metric map of this profiling node as a MAP duckdb_value.
+The individual elements are accessible via the duckdb_value MAP functions.
+
+* @param info A profiling information object.
+* @return The key-value metric map as a MAP duckdb_value.
+*/
+DUCKDB_API duckdb_value duckdb_profiling_info_get_metrics(duckdb_profiling_info info);
+
+/*!
+Returns the number of children in the current profiling info node.
+
+* @param info A profiling information object.
+* @return The number of children in the current node.
+*/
+DUCKDB_API idx_t duckdb_profiling_info_get_child_count(duckdb_profiling_info info);
+
+/*!
+Returns the child node at the specified index.
+
+* @param info A profiling information object.
+* @param index The index of the child node.
+* @return The child node at the specified index.
+*/
+DUCKDB_API duckdb_profiling_info duckdb_profiling_info_get_child(duckdb_profiling_info info, idx_t index);
 
 //===--------------------------------------------------------------------===//
 // Appender
@@ -2608,17 +3495,16 @@ DUCKDB_API void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info i
 
 // Note that `duckdb_appender_destroy` should always be called on the resulting appender, even if the function returns
 // `DuckDBError`.
-
 /*!
 Creates an appender object.
 
 Note that the object must be destroyed with `duckdb_appender_destroy`.
 
-* connection: The connection context to create the appender in.
-* schema: The schema of the table to append to, or `nullptr` for the default schema.
-* table: The table name to append to.
-* out_appender: The resulting appender object.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection context to create the appender in.
+* @param schema The schema of the table to append to, or `nullptr` for the default schema.
+* @param table The table name to append to.
+* @param out_appender The resulting appender object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_appender_create(duckdb_connection connection, const char *schema, const char *table,
                                                duckdb_appender *out_appender);
@@ -2626,8 +3512,8 @@ DUCKDB_API duckdb_state duckdb_appender_create(duckdb_connection connection, con
 /*!
 Returns the number of columns in the table that belongs to the appender.
 
-* appender The appender to get the column count from.
-* returns: The number of columns in the table.
+* @param appender The appender to get the column count from.
+* @return The number of columns in the table.
 */
 DUCKDB_API idx_t duckdb_appender_column_count(duckdb_appender appender);
 
@@ -2636,9 +3522,9 @@ Returns the type of the column at the specified index.
 
 Note: The resulting type should be destroyed with `duckdb_destroy_logical_type`.
 
-* appender The appender to get the column type from.
-* col_idx The index of the column to get the type of.
-* returns: The duckdb_logical_type of the column.
+* @param appender The appender to get the column type from.
+* @param col_idx The index of the column to get the type of.
+* @return The duckdb_logical_type of the column.
 */
 DUCKDB_API duckdb_logical_type duckdb_appender_column_type(duckdb_appender appender, idx_t col_idx);
 
@@ -2648,8 +3534,8 @@ If the appender has no error message, this returns `nullptr` instead.
 
 The error message should not be freed. It will be de-allocated when `duckdb_appender_destroy` is called.
 
-* appender: The appender to get the error from.
-* returns: The error message, or `nullptr` if there is none.
+* @param appender The appender to get the error from.
+* @return The error message, or `nullptr` if there is none.
 */
 DUCKDB_API const char *duckdb_appender_error(duckdb_appender appender);
 
@@ -2659,8 +3545,8 @@ constraint violation or any other error, then all data is invalidated, and this
 It is not possible to append more values. Call duckdb_appender_error to obtain the error message followed by
 duckdb_appender_destroy to destroy the invalidated appender.
 
-* appender: The appender to flush.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param appender The appender to flush.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_appender_flush(duckdb_appender appender);
 
@@ -2670,8 +3556,8 @@ triggers a constraint violation or any other error, then all data is invalidated
 Call duckdb_appender_error to obtain the error message followed by duckdb_appender_destroy to destroy the invalidated
 appender.
 
-* appender: The appender to flush and close.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param appender The appender to flush and close.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_appender_close(duckdb_appender appender);
 
@@ -2682,8 +3568,8 @@ then all data is invalidated, and this function returns DuckDBError. Due to the
 longer possible to obtain the specific error message with duckdb_appender_error. Therefore, call duckdb_appender_close
 before destroying the appender, if you need insights into the specific error.
 
-* appender: The appender to flush, close and destroy.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param appender The appender to flush, close and destroy.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_appender_destroy(duckdb_appender *appender);
 
@@ -2695,11 +3581,16 @@ DUCKDB_API duckdb_state duckdb_appender_begin_row(duckdb_appender appender);
 /*!
 Finish the current row of appends. After end_row is called, the next row can be appended.
 
-* appender: The appender.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param appender The appender.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_appender_end_row(duckdb_appender appender);
 
+/*!
+Append a DEFAULT value (NULL if DEFAULT not available for column) to the appender.
+*/
+DUCKDB_API duckdb_state duckdb_append_default(duckdb_appender appender);
+
 /*!
 Append a bool value to the appender.
 */
@@ -2812,17 +3703,61 @@ The types of the data chunk must exactly match the types of the table, no castin
 If the types do not match or the appender is in an invalid state, DuckDBError is returned.
 If the append is successful, DuckDBSuccess is returned.
 
-* appender: The appender to append to.
-* chunk: The data chunk to append.
-* returns: The return state.
+* @param appender The appender to append to.
+* @param chunk The data chunk to append.
+* @return The return state.
 */
 DUCKDB_API duckdb_state duckdb_append_data_chunk(duckdb_appender appender, duckdb_data_chunk chunk);
 
-#ifndef DUCKDB_API_NO_DEPRECATED
+//===--------------------------------------------------------------------===//
+// Table Description
+//===--------------------------------------------------------------------===//
+
+/*!
+Creates a table description object. Note that `duckdb_table_description_destroy` should always be called on the
+resulting table_description, even if the function returns `DuckDBError`.
+
+* @param connection The connection context.
+* @param schema The schema of the table, or `nullptr` for the default schema.
+* @param table The table name.
+* @param out The resulting table description object.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_table_description_create(duckdb_connection connection, const char *schema,
+                                                        const char *table, duckdb_table_description *out);
+
+/*!
+Destroy the TableDescription object.
+
+* @param table_description The table_description to destroy.
+*/
+DUCKDB_API void duckdb_table_description_destroy(duckdb_table_description *table_description);
+
+/*!
+Returns the error message associated with the given table_description.
+If the table_description has no error message, this returns `nullptr` instead.
+The error message should not be freed. It will be de-allocated when `duckdb_table_description_destroy` is called.
+
+* @param table_description The table_description to get the error from.
+* @return The error message, or `nullptr` if there is none.
+*/
+DUCKDB_API const char *duckdb_table_description_error(duckdb_table_description table_description);
+
+/*!
+Check if the column at 'index' index of the table has a DEFAULT expression.
+
+* @param table_description The table_description to query.
+* @param index The index of the column to query.
+* @param out The out-parameter used to store the result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
+*/
+DUCKDB_API duckdb_state duckdb_column_has_default(duckdb_table_description table_description, idx_t index, bool *out);
+
 //===--------------------------------------------------------------------===//
 // Arrow Interface
 //===--------------------------------------------------------------------===//
 
+#ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
@@ -2833,10 +3768,10 @@ If the query fails to execute, DuckDBError is returned and the error message can
 Note that after running `duckdb_query_arrow`, `duckdb_destroy_arrow` must be called on the result object even if the
 query fails, otherwise the error stored within the result will not be freed correctly.
 
-* connection: The connection to perform the query in.
-* query: The SQL query to run.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection to perform the query in.
+* @param query The SQL query to run.
+* @param out_result The query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_query_arrow(duckdb_connection connection, const char *query, duckdb_arrow *out_result);
 
@@ -2846,9 +3781,9 @@ DUCKDB_API duckdb_state duckdb_query_arrow(duckdb_connection connection, const c
 Fetch the internal arrow schema from the arrow result. Remember to call release on the respective
 ArrowSchema object.
 
-* result: The result to fetch the schema from.
-* out_schema: The output schema.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param result The result to fetch the schema from.
+* @param out_schema The output schema.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_arrow_schema *out_schema);
 
@@ -2858,21 +3793,22 @@ DUCKDB_API duckdb_state duckdb_query_arrow_schema(duckdb_arrow result, duckdb_ar
 Fetch the internal arrow schema from the prepared statement. Remember to call release on the respective
 ArrowSchema object.
 
-* result: The prepared statement to fetch the schema from.
-* out_schema: The output schema.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared The prepared statement to fetch the schema from.
+* @param out_schema The output schema.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_prepared_arrow_schema(duckdb_prepared_statement prepared,
                                                      duckdb_arrow_schema *out_schema);
+
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
 
 Convert a data chunk into an arrow struct array. Remember to call release on the respective
 ArrowArray object.
 
-* result: The result object the data chunk have been fetched from.
-* chunk: The data chunk to convert.
-* out_array: The output array.
+* @param result The result object the data chunk have been fetched from.
+* @param chunk The data chunk to convert.
+* @param out_array The output array.
 */
 DUCKDB_API void duckdb_result_arrow_array(duckdb_result result, duckdb_data_chunk chunk, duckdb_arrow_array *out_array);
 
@@ -2885,9 +3821,9 @@ ArrowArray object.
 This function can be called multiple time to get next chunks, which will free the previous out_array.
 So consume the out_array before calling this function again.
 
-* result: The result to fetch the array from.
-* out_array: The output array.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param result The result to fetch the array from.
+* @param out_array The output array.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arrow_array *out_array);
 
@@ -2896,8 +3832,8 @@ DUCKDB_API duckdb_state duckdb_query_arrow_array(duckdb_arrow result, duckdb_arr
 
 Returns the number of columns present in the arrow result object.
 
-* result: The result object.
-* returns: The number of columns present in the result object.
+* @param result The result object.
+* @return The number of columns present in the result object.
 */
 DUCKDB_API idx_t duckdb_arrow_column_count(duckdb_arrow result);
 
@@ -2906,8 +3842,8 @@ DUCKDB_API idx_t duckdb_arrow_column_count(duckdb_arrow result);
 
 Returns the number of rows present in the arrow result object.
 
-* result: The result object.
-* returns: The number of rows present in the result object.
+* @param result The result object.
+* @return The number of rows present in the result object.
 */
 DUCKDB_API idx_t duckdb_arrow_row_count(duckdb_arrow result);
 
@@ -2917,8 +3853,8 @@ DUCKDB_API idx_t duckdb_arrow_row_count(duckdb_arrow result);
 Returns the number of rows changed by the query stored in the arrow result. This is relevant only for
 INSERT/UPDATE/DELETE queries. For other queries the rows_changed will be 0.
 
-* result: The result object.
-* returns: The number of rows changed.
+* @param result The result object.
+* @return The number of rows changed.
 */
 DUCKDB_API idx_t duckdb_arrow_rows_changed(duckdb_arrow result);
 
@@ -2930,8 +3866,8 @@ DUCKDB_API idx_t duckdb_arrow_rows_changed(duckdb_arrow result);
 
 The error message should not be freed. It will be de-allocated when `duckdb_destroy_arrow` is called.
 
-* result: The result object to fetch the error from.
-* returns: The error of the result.
+* @param result The result object to fetch the error from.
+* @return The error of the result.
 */
 DUCKDB_API const char *duckdb_query_arrow_error(duckdb_arrow result);
 
@@ -2940,7 +3876,7 @@ DUCKDB_API const char *duckdb_query_arrow_error(duckdb_arrow result);
 
 Closes the result and de-allocates all memory allocated for the arrow result.
 
-* result: The result to destroy.
+* @param result The result to destroy.
 */
 DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
 
@@ -2949,7 +3885,7 @@ DUCKDB_API void duckdb_destroy_arrow(duckdb_arrow *result);
 
 Releases the arrow array stream and de-allocates its memory.
 
-* stream: The arrow array stream to destroy.
+* @param stream_p The arrow array stream to destroy.
 */
 DUCKDB_API void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p);
 
@@ -2959,9 +3895,9 @@ DUCKDB_API void duckdb_destroy_arrow_stream(duckdb_arrow_stream *stream_p);
 Executes the prepared statement with the given bound parameters, and returns an arrow query result.
 Note that after running `duckdb_execute_prepared_arrow`, `duckdb_destroy_arrow` must be called on the result object.
 
-* prepared_statement: The prepared statement to execute.
-* out_result: The query result.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param prepared_statement The prepared statement to execute.
+* @param out_result The query result.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement prepared_statement,
                                                       duckdb_arrow *out_result);
@@ -2971,10 +3907,10 @@ DUCKDB_API duckdb_state duckdb_execute_prepared_arrow(duckdb_prepared_statement
 
 Scans the Arrow stream and creates a view with the given name.
 
-* connection: The connection on which to execute the scan.
-* table_name: Name of the temporary view to create.
-* arrow: Arrow stream wrapper.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection on which to execute the scan.
+* @param table_name Name of the temporary view to create.
+* @param arrow Arrow stream wrapper.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_arrow_scan(duckdb_connection connection, const char *table_name,
                                           duckdb_arrow_stream arrow);
@@ -2985,19 +3921,18 @@ DUCKDB_API duckdb_state duckdb_arrow_scan(duckdb_connection connection, const ch
 Scans the Arrow array and creates a view with the given name.
 Note that after running `duckdb_arrow_array_scan`, `duckdb_destroy_arrow_stream` must be called on the out stream.
 
-* connection: The connection on which to execute the scan.
-* table_name: Name of the temporary view to create.
-* arrow_schema: Arrow schema wrapper.
-* arrow_array: Arrow array wrapper.
-* out_stream: Output array stream that wraps around the passed schema, for releasing/deleting once done.
-* returns: `DuckDBSuccess` on success or `DuckDBError` on failure.
+* @param connection The connection on which to execute the scan.
+* @param table_name Name of the temporary view to create.
+* @param arrow_schema Arrow schema wrapper.
+* @param arrow_array Arrow array wrapper.
+* @param out_stream Output array stream that wraps around the passed schema, for releasing/deleting once done.
+* @return `DuckDBSuccess` on success or `DuckDBError` on failure.
 */
 DUCKDB_API duckdb_state duckdb_arrow_array_scan(duckdb_connection connection, const char *table_name,
                                                 duckdb_arrow_schema arrow_schema, duckdb_arrow_array arrow_array,
                                                 duckdb_arrow_stream *out_stream);
-#endif
 
-#ifndef DUCKDB_NO_EXTENSION_FUNCTIONS
+#endif
 //===--------------------------------------------------------------------===//
 // Threading Information
 //===--------------------------------------------------------------------===//
@@ -3007,8 +3942,8 @@ Execute DuckDB tasks on this thread.
 
 Will return after `max_tasks` have been executed, or if there are no more tasks present.
 
-* database: The database object to execute tasks for
-* max_tasks: The maximum amount of tasks to execute
+* @param database The database object to execute tasks for
+* @param max_tasks The maximum amount of tasks to execute
 */
 DUCKDB_API void duckdb_execute_tasks(duckdb_database database, idx_t max_tasks);
 
@@ -3018,8 +3953,8 @@ Creates a task state that can be used with duckdb_execute_tasks_state to execute
 
 `duckdb_destroy_state` must be called on the result.
 
-* database: The database object to create the task state for
-* returns: The task state that can be used with duckdb_execute_tasks_state.
+* @param database The database object to create the task state for
+* @return The task state that can be used with duckdb_execute_tasks_state.
 */
 DUCKDB_API duckdb_task_state duckdb_create_task_state(duckdb_database database);
 
@@ -3029,7 +3964,7 @@ Execute DuckDB tasks on this thread.
 The thread will keep on executing tasks forever, until duckdb_finish_execution is called on the state.
 Multiple threads can share the same duckdb_task_state.
 
-* state: The task state of the executor
+* @param state The task state of the executor
 */
 DUCKDB_API void duckdb_execute_tasks_state(duckdb_task_state state);
 
@@ -3041,24 +3976,24 @@ max_tasks tasks have been executed or there are no more tasks to be executed.
 
 Multiple threads can share the same duckdb_task_state.
 
-* state: The task state of the executor
-* max_tasks: The maximum amount of tasks to execute
-* returns: The amount of tasks that have actually been executed
+* @param state The task state of the executor
+* @param max_tasks The maximum amount of tasks to execute
+* @return The amount of tasks that have actually been executed
 */
 DUCKDB_API idx_t duckdb_execute_n_tasks_state(duckdb_task_state state, idx_t max_tasks);
 
 /*!
 Finish execution on a specific task.
 
-* state: The task state to finish execution
+* @param state The task state to finish execution
 */
 DUCKDB_API void duckdb_finish_execution(duckdb_task_state state);
 
 /*!
 Check if the provided duckdb_task_state has finished execution
 
-* state: The task state to inspect
-* returns: Whether or not duckdb_finish_execution has been called on the task state
+* @param state The task state to inspect
+* @return Whether or not duckdb_finish_execution has been called on the task state
 */
 DUCKDB_API bool duckdb_task_state_is_finished(duckdb_task_state state);
 
@@ -3068,21 +4003,21 @@ Destroys the task state returned from duckdb_create_task_state.
 Note that this should not be called while there is an active duckdb_execute_tasks_state running
 on the task state.
 
-* state: The task state to clean up
+* @param state The task state to clean up
 */
 DUCKDB_API void duckdb_destroy_task_state(duckdb_task_state state);
 
 /*!
 Returns true if the execution of the current query is finished.
 
-* con: The connection on which to check
+* @param con The connection on which to check
 */
 DUCKDB_API bool duckdb_execution_is_finished(duckdb_connection con);
-#endif
 
 //===--------------------------------------------------------------------===//
 // Streaming Result Interface
 //===--------------------------------------------------------------------===//
+
 #ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATION NOTICE**: This method is scheduled for removal in a future release.
@@ -3099,8 +4034,8 @@ mixed with the legacy result functions or the materialized result functions).
 
 It is not known beforehand how many chunks will be returned by this result.
 
-* result: The result object to fetch the data chunk from.
-* returns: The resulting data chunk. Returns `NULL` if the result has an error.
+* @param result The result object to fetch the data chunk from.
+* @return The resulting data chunk. Returns `NULL` if the result has an error.
 */
 DUCKDB_API duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
 #endif
@@ -3112,11 +4047,116 @@ The result must be destroyed with `duckdb_destroy_data_chunk`.
 
 It is not known beforehand how many chunks will be returned by this result.
 
-* result: The result object to fetch the data chunk from.
-* returns: The resulting data chunk. Returns `NULL` if the result has an error.
+* @param result The result object to fetch the data chunk from.
+* @return The resulting data chunk. Returns `NULL` if the result has an error.
 */
 DUCKDB_API duckdb_data_chunk duckdb_fetch_chunk(duckdb_result result);
 
+//===--------------------------------------------------------------------===//
+// Cast Functions
+//===--------------------------------------------------------------------===//
+
+/*!
+Creates a new cast function object.
+
+* @return The cast function object.
+*/
+DUCKDB_API duckdb_cast_function duckdb_create_cast_function();
+
+/*!
+Sets the source type of the cast function.
+
+* @param cast_function The cast function object.
+* @param source_type The source type to set.
+*/
+DUCKDB_API void duckdb_cast_function_set_source_type(duckdb_cast_function cast_function,
+                                                     duckdb_logical_type source_type);
+
+/*!
+Sets the target type of the cast function.
+
+* @param cast_function The cast function object.
+* @param target_type The target type to set.
+*/
+DUCKDB_API void duckdb_cast_function_set_target_type(duckdb_cast_function cast_function,
+                                                     duckdb_logical_type target_type);
+
+/*!
+Sets the "cost" of implicitly casting the source type to the target type using this function.
+
+* @param cast_function The cast function object.
+* @param cost The cost to set.
+*/
+DUCKDB_API void duckdb_cast_function_set_implicit_cast_cost(duckdb_cast_function cast_function, int64_t cost);
+
+/*!
+Sets the actual cast function to use.
+
+* @param cast_function The cast function object.
+* @param function The function to set.
+*/
+DUCKDB_API void duckdb_cast_function_set_function(duckdb_cast_function cast_function, duckdb_cast_function_t function);
+
+/*!
+Assigns extra information to the cast function that can be fetched during execution, etc.
+
+* @param extra_info The extra information
+* @param destroy The callback that will be called to destroy the extra information (if any)
+*/
+DUCKDB_API void duckdb_cast_function_set_extra_info(duckdb_cast_function cast_function, void *extra_info,
+                                                    duckdb_delete_callback_t destroy);
+
+/*!
+Retrieves the extra info of the function as set in `duckdb_cast_function_set_extra_info`.
+
+* @param info The info object.
+* @return The extra info.
+*/
+DUCKDB_API void *duckdb_cast_function_get_extra_info(duckdb_function_info info);
+
+/*!
+Get the cast execution mode from the given function info.
+
+* @param info The info object.
+* @return The cast mode.
+*/
+DUCKDB_API duckdb_cast_mode duckdb_cast_function_get_cast_mode(duckdb_function_info info);
+
+/*!
+Report that an error has occurred while executing the cast function.
+
+* @param info The info object.
+* @param error The error message.
+*/
+DUCKDB_API void duckdb_cast_function_set_error(duckdb_function_info info, const char *error);
+
+/*!
+Report that an error has occurred while executing the cast function, setting the corresponding output row to NULL.
+
+* @param info The info object.
+* @param error The error message.
+* @param row The index of the row within the output vector to set to NULL.
+* @param output The output vector.
+*/
+DUCKDB_API void duckdb_cast_function_set_row_error(duckdb_function_info info, const char *error, idx_t row,
+                                                   duckdb_vector output);
+
+/*!
+Registers a cast function within the given connection.
+
+* @param con The connection to use.
+* @param cast_function The cast function to register.
+* @return Whether or not the registration was successful.
+*/
+DUCKDB_API duckdb_state duckdb_register_cast_function(duckdb_connection con, duckdb_cast_function cast_function);
+
+/*!
+Destroys the cast function object.
+
+* @param cast_function The cast function object.
+*/
+DUCKDB_API void duckdb_destroy_cast_function(duckdb_cast_function *cast_function);
+
 #ifdef __cplusplus
 }
 #endif