@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBLogicalType.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUnionLogicalType = exports.DuckDBArrayLogicalType = exports.DuckDBMapLogicalType = exports.DuckDBStructLogicalType = exports.DuckDBListLogicalType = exports.DuckDBEnumLogicalType = exports.DuckDBDecimalLogicalType = exports.DuckDBLogicalType = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBType_1 = require("./DuckDBType");
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+class DuckDBLogicalType {
+    logical_type;
+    constructor(logical_type) {
+        this.logical_type = logical_type;
+    }
+    static create(logical_type) {
+        switch (node_bindings_1.default.get_type_id(logical_type)) {
+            case node_bindings_1.default.Type.DECIMAL:
+                return new DuckDBDecimalLogicalType(logical_type);
+            case node_bindings_1.default.Type.ENUM:
+                return new DuckDBEnumLogicalType(logical_type);
+            case node_bindings_1.default.Type.LIST:
+                return new DuckDBListLogicalType(logical_type);
+            case node_bindings_1.default.Type.STRUCT:
+                return new DuckDBStructLogicalType(logical_type);
+            case node_bindings_1.default.Type.MAP:
+                return new DuckDBMapLogicalType(logical_type);
+            case node_bindings_1.default.Type.ARRAY:
+                return new DuckDBArrayLogicalType(logical_type);
+            case node_bindings_1.default.Type.UNION:
+                return new DuckDBUnionLogicalType(logical_type);
+            default:
+                return new DuckDBLogicalType(logical_type);
+        }
+    }
+    static createDecimal(width, scale) {
+        return new DuckDBDecimalLogicalType(node_bindings_1.default.create_decimal_type(width, scale));
+    }
+    static createEnum(member_names) {
+        return new DuckDBEnumLogicalType(node_bindings_1.default.create_enum_type(member_names));
+    }
+    static createList(valueType) {
+        return new DuckDBListLogicalType(node_bindings_1.default.create_list_type(valueType.logical_type));
+    }
+    static createStruct(entryNames, entryLogicalTypes) {
+        const length = entryNames.length;
+        if (length !== entryLogicalTypes.length) {
+            throw new Error(`Could not create struct: \
+        entryNames length (${entryNames.length}) does not match entryLogicalTypes length (${entryLogicalTypes.length})`);
+        }
+        const member_types = [];
+        const member_names = [];
+        for (let i = 0; i < length; i++) {
+            member_types.push(entryLogicalTypes[i].logical_type);
+            member_names.push(entryNames[i]);
+        }
+        return new DuckDBStructLogicalType(node_bindings_1.default.create_struct_type(member_types, member_names));
+    }
+    static createMap(keyType, valueType) {
+        return new DuckDBMapLogicalType(node_bindings_1.default.create_map_type(keyType.logical_type, valueType.logical_type));
+    }
+    static createArray(valueType, length) {
+        return new DuckDBArrayLogicalType(node_bindings_1.default.create_array_type(valueType.logical_type, length));
+    }
+    static createUnion(memberTags, memberLogicalTypes) {
+        const length = memberTags.length;
+        if (length !== memberLogicalTypes.length) {
+            throw new Error(`Could not create union: \
+        memberTags length (${memberTags.length}) does not match memberLogicalTypes length (${memberLogicalTypes.length})`);
+        }
+        const member_types = [];
+        const member_names = [];
+        for (let i = 0; i < length; i++) {
+            member_types.push(memberLogicalTypes[i].logical_type);
+            member_names.push(memberTags[i]);
+        }
+        return new DuckDBUnionLogicalType(node_bindings_1.default.create_union_type(member_types, member_names));
+    }
+    get typeId() {
+        return node_bindings_1.default.get_type_id(this.logical_type);
+    }
+    get alias() {
+        return node_bindings_1.default.logical_type_get_alias(this.logical_type) || undefined;
+    }
+    set alias(newAlias) {
+        node_bindings_1.default.logical_type_set_alias(this.logical_type, newAlias || '');
+    }
+    asType() {
+        const alias = this.alias;
+        switch (this.typeId) {
+            case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+                return DuckDBType_1.DuckDBBooleanType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+                return DuckDBType_1.DuckDBTinyIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+                return DuckDBType_1.DuckDBSmallIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+                return DuckDBType_1.DuckDBIntegerType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+                return DuckDBType_1.DuckDBBigIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+                return DuckDBType_1.DuckDBUTinyIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+                return DuckDBType_1.DuckDBUSmallIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+                return DuckDBType_1.DuckDBUIntegerType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+                return DuckDBType_1.DuckDBUBigIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+                return DuckDBType_1.DuckDBFloatType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+                return DuckDBType_1.DuckDBDoubleType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+                return DuckDBType_1.DuckDBTimestampType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.DATE:
+                return DuckDBType_1.DuckDBDateType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIME:
+                return DuckDBType_1.DuckDBTimeType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+                return DuckDBType_1.DuckDBIntervalType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+                return DuckDBType_1.DuckDBHugeIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+                return DuckDBType_1.DuckDBUHugeIntType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+                return DuckDBType_1.DuckDBVarCharType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+                return DuckDBType_1.DuckDBBlobType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+                return DuckDBType_1.DuckDBTimestampSecondsType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+                return DuckDBType_1.DuckDBTimestampMillisecondsType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+                return DuckDBType_1.DuckDBTimestampNanosecondsType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.LIST:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.MAP:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.UUID:
+                return DuckDBType_1.DuckDBUUIDType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.UNION:
+                throw new Error('Expected override');
+            case DuckDBTypeId_1.DuckDBTypeId.BIT:
+                return DuckDBType_1.DuckDBBitType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+                return DuckDBType_1.DuckDBTimeTZType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+                return DuckDBType_1.DuckDBTimestampTZType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.ANY:
+                return DuckDBType_1.DuckDBAnyType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.BIGNUM:
+                return DuckDBType_1.DuckDBBigNumType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+                return DuckDBType_1.DuckDBSQLNullType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL:
+                return DuckDBType_1.DuckDBStringLiteralType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL:
+                return DuckDBType_1.DuckDBIntegerLiteralType.create(alias);
+            case DuckDBTypeId_1.DuckDBTypeId.TIME_NS:
+                return DuckDBType_1.DuckDBTimeNSType.create(alias);
+            default:
+                throw new Error(`Unexpected type id: ${this.typeId}`);
+        }
+    }
+}
+exports.DuckDBLogicalType = DuckDBLogicalType;
+class DuckDBDecimalLogicalType extends DuckDBLogicalType {
+    get width() {
+        return node_bindings_1.default.decimal_width(this.logical_type);
+    }
+    get scale() {
+        return node_bindings_1.default.decimal_scale(this.logical_type);
+    }
+    get internalTypeId() {
+        return node_bindings_1.default.decimal_internal_type(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBDecimalType(this.width, this.scale, this.alias);
+    }
+}
+exports.DuckDBDecimalLogicalType = DuckDBDecimalLogicalType;
+class DuckDBEnumLogicalType extends DuckDBLogicalType {
+    get valueCount() {
+        return node_bindings_1.default.enum_dictionary_size(this.logical_type);
+    }
+    value(index) {
+        return node_bindings_1.default.enum_dictionary_value(this.logical_type, index);
+    }
+    values() {
+        const values = [];
+        const count = this.valueCount;
+        for (let i = 0; i < count; i++) {
+            values.push(this.value(i));
+        }
+        return values;
+    }
+    get internalTypeId() {
+        return node_bindings_1.default.enum_internal_type(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBEnumType(this.values(), this.internalTypeId, this.alias);
+    }
+}
+exports.DuckDBEnumLogicalType = DuckDBEnumLogicalType;
+class DuckDBListLogicalType extends DuckDBLogicalType {
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.list_type_child_type(this.logical_type));
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBListType(this.valueType.asType(), this.alias);
+    }
+}
+exports.DuckDBListLogicalType = DuckDBListLogicalType;
+class DuckDBStructLogicalType extends DuckDBLogicalType {
+    get entryCount() {
+        return node_bindings_1.default.struct_type_child_count(this.logical_type);
+    }
+    entryName(index) {
+        return node_bindings_1.default.struct_type_child_name(this.logical_type, index);
+    }
+    entryLogicalType(index) {
+        return DuckDBLogicalType.create(node_bindings_1.default.struct_type_child_type(this.logical_type, index));
+    }
+    entryType(index) {
+        return this.entryLogicalType(index).asType();
+    }
+    entryNames() {
+        const names = [];
+        const count = this.entryCount;
+        for (let i = 0; i < count; i++) {
+            names.push(this.entryName(i));
+        }
+        return names;
+    }
+    entryLogicalTypes() {
+        const valueTypes = [];
+        const count = this.entryCount;
+        for (let i = 0; i < count; i++) {
+            valueTypes.push(this.entryLogicalType(i));
+        }
+        return valueTypes;
+    }
+    entryTypes() {
+        const valueTypes = [];
+        const count = this.entryCount;
+        for (let i = 0; i < count; i++) {
+            valueTypes.push(this.entryType(i));
+        }
+        return valueTypes;
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBStructType(this.entryNames(), this.entryTypes(), this.alias);
+    }
+}
+exports.DuckDBStructLogicalType = DuckDBStructLogicalType;
+class DuckDBMapLogicalType extends DuckDBLogicalType {
+    get keyType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.map_type_key_type(this.logical_type));
+    }
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.map_type_value_type(this.logical_type));
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBMapType(this.keyType.asType(), this.valueType.asType(), this.alias);
+    }
+}
+exports.DuckDBMapLogicalType = DuckDBMapLogicalType;
+class DuckDBArrayLogicalType extends DuckDBLogicalType {
+    get valueType() {
+        return DuckDBLogicalType.create(node_bindings_1.default.array_type_child_type(this.logical_type));
+    }
+    get length() {
+        return node_bindings_1.default.array_type_array_size(this.logical_type);
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBArrayType(this.valueType.asType(), this.length, this.alias);
+    }
+}
+exports.DuckDBArrayLogicalType = DuckDBArrayLogicalType;
+class DuckDBUnionLogicalType extends DuckDBLogicalType {
+    get memberCount() {
+        return node_bindings_1.default.union_type_member_count(this.logical_type);
+    }
+    memberTag(index) {
+        return node_bindings_1.default.union_type_member_name(this.logical_type, index);
+    }
+    memberLogicalType(index) {
+        return DuckDBLogicalType.create(node_bindings_1.default.union_type_member_type(this.logical_type, index));
+    }
+    memberType(index) {
+        return this.memberLogicalType(index).asType();
+    }
+    memberTags() {
+        const tags = [];
+        const count = this.memberCount;
+        for (let i = 0; i < count; i++) {
+            tags.push(this.memberTag(i));
+        }
+        return tags;
+    }
+    memberLogicalTypes() {
+        const valueTypes = [];
+        const count = this.memberCount;
+        for (let i = 0; i < count; i++) {
+            valueTypes.push(this.memberLogicalType(i));
+        }
+        return valueTypes;
+    }
+    memberTypes() {
+        const valueTypes = [];
+        const count = this.memberCount;
+        for (let i = 0; i < count; i++) {
+            valueTypes.push(this.memberType(i));
+        }
+        return valueTypes;
+    }
+    asType() {
+        return new DuckDBType_1.DuckDBUnionType(this.memberTags(), this.memberTypes(), this.alias);
+    }
+}
+exports.DuckDBUnionLogicalType = DuckDBUnionLogicalType;

package/lib/DuckDBMaterializedResult.d.ts

@@ -0,0 +1,9 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBResult } from './DuckDBResult';
+export declare class DuckDBMaterializedResult extends DuckDBResult {
+    constructor(result: duckdb.Result);
+    get rowCount(): number;
+    get chunkCount(): number;
+    getChunk(chunkIndex: number): DuckDBDataChunk;
+}

package/lib/DuckDBMaterializedResult.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBMaterializedResult = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBResult_1 = require("./DuckDBResult");
+class DuckDBMaterializedResult extends DuckDBResult_1.DuckDBResult {
+    constructor(result) {
+        super(result);
+    }
+    get rowCount() {
+        return node_bindings_1.default.row_count(this.result);
+    }
+    get chunkCount() {
+        return node_bindings_1.default.result_chunk_count(this.result);
+    }
+    getChunk(chunkIndex) {
+        return new DuckDBDataChunk_1.DuckDBDataChunk(node_bindings_1.default.result_get_chunk(this.result, chunkIndex));
+    }
+}
+exports.DuckDBMaterializedResult = DuckDBMaterializedResult;

package/lib/DuckDBPendingResult.d.ts

@@ -0,0 +1,18 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBResultReader } from './DuckDBResultReader';
+export declare enum DuckDBPendingResultState {
+    RESULT_READY = 0,
+    RESULT_NOT_READY = 1,
+    NO_TASKS_AVAILABLE = 3
+}
+export declare class DuckDBPendingResult {
+    private readonly pending_result;
+    constructor(pending_result: duckdb.PendingResult);
+    runTask(): DuckDBPendingResultState;
+    runAllTasks(): Promise<void>;
+    getResult(): Promise<DuckDBResult>;
+    read(): Promise<DuckDBResultReader>;
+    readAll(): Promise<DuckDBResultReader>;
+    readUntil(targetRowCount: number): Promise<DuckDBResultReader>;
+}

package/lib/DuckDBPendingResult.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBPendingResult = exports.DuckDBPendingResultState = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const createResult_1 = require("./createResult");
+const DuckDBResultReader_1 = require("./DuckDBResultReader");
+const sleep_1 = require("./sleep");
+// Values match similar enum in C API.
+var DuckDBPendingResultState;
+(function (DuckDBPendingResultState) {
+    DuckDBPendingResultState[DuckDBPendingResultState["RESULT_READY"] = 0] = "RESULT_READY";
+    DuckDBPendingResultState[DuckDBPendingResultState["RESULT_NOT_READY"] = 1] = "RESULT_NOT_READY";
+    DuckDBPendingResultState[DuckDBPendingResultState["NO_TASKS_AVAILABLE"] = 3] = "NO_TASKS_AVAILABLE";
+})(DuckDBPendingResultState || (exports.DuckDBPendingResultState = DuckDBPendingResultState = {}));
+class DuckDBPendingResult {
+    pending_result;
+    constructor(pending_result) {
+        this.pending_result = pending_result;
+    }
+    runTask() {
+        const pending_state = node_bindings_1.default.pending_execute_task(this.pending_result);
+        switch (pending_state) {
+            case node_bindings_1.default.PendingState.RESULT_READY:
+                return DuckDBPendingResultState.RESULT_READY;
+            case node_bindings_1.default.PendingState.RESULT_NOT_READY:
+                return DuckDBPendingResultState.RESULT_NOT_READY;
+            case node_bindings_1.default.PendingState.ERROR:
+                throw new Error(`Failure running pending result task: ${node_bindings_1.default.pending_error(this.pending_result)}`);
+            case node_bindings_1.default.PendingState.NO_TASKS_AVAILABLE:
+                return DuckDBPendingResultState.NO_TASKS_AVAILABLE;
+            default:
+                throw new Error(`Unexpected pending state: ${pending_state}`);
+        }
+    }
+    async runAllTasks() {
+        while (this.runTask() !== DuckDBPendingResultState.RESULT_READY) {
+            await (0, sleep_1.sleep)(1);
+        }
+    }
+    async getResult() {
+        return (0, createResult_1.createResult)(await node_bindings_1.default.execute_pending(this.pending_result));
+    }
+    async read() {
+        return new DuckDBResultReader_1.DuckDBResultReader(await this.getResult());
+    }
+    async readAll() {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.getResult());
+        await reader.readAll();
+        return reader;
+    }
+    async readUntil(targetRowCount) {
+        const reader = new DuckDBResultReader_1.DuckDBResultReader(await this.getResult());
+        await reader.readUntil(targetRowCount);
+        return reader;
+    }
+}
+exports.DuckDBPendingResult = DuckDBPendingResult;

package/lib/DuckDBPreparedStatement.d.ts

@@ -0,0 +1,72 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBMaterializedResult } from './DuckDBMaterializedResult';
+import { DuckDBPendingResult } from './DuckDBPendingResult';
+import { DuckDBResult } from './DuckDBResult';
+import { DuckDBResultReader } from './DuckDBResultReader';
+import { DuckDBArrayType, DuckDBEnumType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { StatementType } from './enums';
+import { DuckDBArrayValue, DuckDBBitValue, DuckDBDateValue, DuckDBDecimalValue, DuckDBIntervalValue, DuckDBListValue, DuckDBMapValue, DuckDBStructValue, DuckDBTimestampMillisecondsValue, DuckDBTimestampNanosecondsValue, DuckDBTimestampSecondsValue, DuckDBTimestampTZValue, DuckDBTimestampValue, DuckDBTimeTZValue, DuckDBTimeValue, DuckDBUnionValue, DuckDBUUIDValue, DuckDBValue } from './values';
+export declare class DuckDBPreparedStatement {
+    private readonly prepared_statement;
+    constructor(prepared_statement: duckdb.PreparedStatement);
+    destroySync(): void;
+    get statementType(): StatementType;
+    get parameterCount(): number;
+    parameterName(parameterIndex: number): string;
+    parameterTypeId(parameterIndex: number): DuckDBTypeId;
+    parameterType(parameterIndex: number): DuckDBType;
+    get columnCount(): number;
+    columnName(columnIndex: number): string;
+    columnTypeId(columnIndex: number): DuckDBTypeId;
+    columnType(columnIndex: number): DuckDBType;
+    clearBindings(): void;
+    parameterIndex(parameterName: string): number;
+    bindBoolean(parameterIndex: number, value: boolean): void;
+    bindTinyInt(parameterIndex: number, value: number): void;
+    bindSmallInt(parameterIndex: number, value: number): void;
+    bindInteger(parameterIndex: number, value: number): void;
+    bindBigInt(parameterIndex: number, value: bigint): void;
+    bindHugeInt(parameterIndex: number, value: bigint): void;
+    bindUTinyInt(parameterIndex: number, value: number): void;
+    bindUSmallInt(parameterIndex: number, value: number): void;
+    bindUInteger(parameterIndex: number, value: number): void;
+    bindUBigInt(parameterIndex: number, value: bigint): void;
+    bindUHugeInt(parameterIndex: number, value: bigint): void;
+    bindBigNum(parameterIndex: number, value: bigint): void;
+    bindDecimal(parameterIndex: number, value: DuckDBDecimalValue): void;
+    bindFloat(parameterIndex: number, value: number): void;
+    bindDouble(parameterIndex: number, value: number): void;
+    bindDate(parameterIndex: number, value: DuckDBDateValue): void;
+    bindTime(parameterIndex: number, value: DuckDBTimeValue): void;
+    bindTimeTZ(parameterIndex: number, value: DuckDBTimeTZValue): void;
+    bindTimestamp(parameterIndex: number, value: DuckDBTimestampValue): void;
+    bindTimestampTZ(parameterIndex: number, value: DuckDBTimestampTZValue): void;
+    bindTimestampSeconds(parameterIndex: number, value: DuckDBTimestampSecondsValue): void;
+    bindTimestampMilliseconds(parameterIndex: number, value: DuckDBTimestampMillisecondsValue): void;
+    bindTimestampNanoseconds(parameterIndex: number, value: DuckDBTimestampNanosecondsValue): void;
+    bindInterval(parameterIndex: number, value: DuckDBIntervalValue): void;
+    bindVarchar(parameterIndex: number, value: string): void;
+    bindBlob(parameterIndex: number, value: Uint8Array): void;
+    bindEnum(parameterIndex: number, value: string, type: DuckDBEnumType): void;
+    bindArray(parameterIndex: number, value: DuckDBArrayValue | readonly DuckDBValue[], type?: DuckDBArrayType): void;
+    bindList(parameterIndex: number, value: DuckDBListValue | readonly DuckDBValue[], type?: DuckDBListType): void;
+    bindStruct(parameterIndex: number, value: DuckDBStructValue | Readonly<Record<string, DuckDBValue>>, type?: DuckDBStructType): void;
+    bindMap(parameterIndex: number, value: DuckDBMapValue, type?: DuckDBMapType): void;
+    bindUnion(parameterIndex: number, value: DuckDBUnionValue, type?: DuckDBUnionType): void;
+    bindUUID(parameterIndex: number, value: DuckDBUUIDValue): void;
+    bindBit(parameterIndex: number, value: DuckDBBitValue): void;
+    bindNull(parameterIndex: number): void;
+    bindValue(parameterIndex: number, value: DuckDBValue, type?: DuckDBType): void;
+    bind(values: DuckDBValue[] | Record<string, DuckDBValue>, types?: DuckDBType[] | Record<string, DuckDBType | undefined>): void;
+    run(): Promise<DuckDBMaterializedResult>;
+    runAndRead(): Promise<DuckDBResultReader>;
+    runAndReadAll(): Promise<DuckDBResultReader>;
+    runAndReadUntil(targetRowCount: number): Promise<DuckDBResultReader>;
+    stream(): Promise<DuckDBResult>;
+    streamAndRead(): Promise<DuckDBResultReader>;
+    streamAndReadAll(): Promise<DuckDBResultReader>;
+    streamAndReadUntil(targetRowCount: number): Promise<DuckDBResultReader>;
+    start(): DuckDBPendingResult;
+    startStream(): DuckDBPendingResult;
+}