@haybarn/node-api 1.5.3-rc2

package/lib/values/DuckDBTimeValue.d.ts

@@ -0,0 +1,12 @@
+import { Time, TimeParts } from '@haybarn/node-bindings';
+export type { TimeParts };
+export declare class DuckDBTimeValue implements Time {
+    readonly micros: bigint;
+    constructor(micros: bigint);
+    toString(): string;
+    toParts(): TimeParts;
+    static fromParts(parts: TimeParts): DuckDBTimeValue;
+    static readonly Max: DuckDBTimeValue;
+    static readonly Min: DuckDBTimeValue;
+}
+export declare function timeValue(microsOrParts: bigint | TimeParts): DuckDBTimeValue;

package/lib/values/DuckDBTimeValue.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeValue = void 0;
+exports.timeValue = timeValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBTimeValue {
+    micros;
+    constructor(micros) {
+        this.micros = micros;
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimeStringFromMicrosecondsInDay)(this.micros);
+    }
+    toParts() {
+        return node_bindings_1.default.from_time(this);
+    }
+    static fromParts(parts) {
+        return new DuckDBTimeValue(node_bindings_1.default.to_time(parts).micros);
+    }
+    static Max = new DuckDBTimeValue(24n * 60n * 60n * 1000n * 1000n);
+    static Min = new DuckDBTimeValue(0n);
+}
+exports.DuckDBTimeValue = DuckDBTimeValue;
+function timeValue(microsOrParts) {
+    if (typeof microsOrParts === 'bigint') {
+        return new DuckDBTimeValue(microsOrParts);
+    }
+    return DuckDBTimeValue.fromParts(microsOrParts);
+}

package/lib/values/DuckDBTimestampMillisecondsValue.d.ts

@@ -0,0 +1,13 @@
+import { TimestampMilliseconds } from '@haybarn/node-bindings';
+export declare class DuckDBTimestampMillisecondsValue implements TimestampMilliseconds {
+    readonly millis: bigint;
+    constructor(millis: bigint);
+    get isFinite(): boolean;
+    toString(): string;
+    static readonly Epoch: DuckDBTimestampMillisecondsValue;
+    static readonly Max: DuckDBTimestampMillisecondsValue;
+    static readonly Min: DuckDBTimestampMillisecondsValue;
+    static readonly PosInf: DuckDBTimestampMillisecondsValue;
+    static readonly NegInf: DuckDBTimestampMillisecondsValue;
+}
+export declare function timestampMillisValue(millis: bigint): DuckDBTimestampMillisecondsValue;

package/lib/values/DuckDBTimestampMillisecondsValue.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampMillisecondsValue = void 0;
+exports.timestampMillisValue = timestampMillisValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+const DuckDBTimestampSecondsValue_1 = require("./DuckDBTimestampSecondsValue");
+class DuckDBTimestampMillisecondsValue {
+    millis;
+    constructor(millis) {
+        this.millis = millis;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp_ms(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromMilliseconds)(this.millis);
+    }
+    static Epoch = new DuckDBTimestampMillisecondsValue(0n);
+    static Max = new DuckDBTimestampMillisecondsValue((2n ** 63n - 2n) / 1000n);
+    static Min = new DuckDBTimestampMillisecondsValue(DuckDBTimestampSecondsValue_1.DuckDBTimestampSecondsValue.Min.seconds * 1000n);
+    static PosInf = new DuckDBTimestampMillisecondsValue(2n ** 63n - 1n);
+    static NegInf = new DuckDBTimestampMillisecondsValue(-(2n ** 63n - 1n));
+}
+exports.DuckDBTimestampMillisecondsValue = DuckDBTimestampMillisecondsValue;
+function timestampMillisValue(millis) {
+    return new DuckDBTimestampMillisecondsValue(millis);
+}

package/lib/values/DuckDBTimestampNanosecondsValue.d.ts

@@ -0,0 +1,13 @@
+import { TimestampNanoseconds } from '@haybarn/node-bindings';
+export declare class DuckDBTimestampNanosecondsValue implements TimestampNanoseconds {
+    readonly nanos: bigint;
+    constructor(nanos: bigint);
+    get isFinite(): boolean;
+    toString(): string;
+    static readonly Epoch: DuckDBTimestampNanosecondsValue;
+    static readonly Max: DuckDBTimestampNanosecondsValue;
+    static readonly Min: DuckDBTimestampNanosecondsValue;
+    static readonly PosInf: DuckDBTimestampNanosecondsValue;
+    static readonly NegInf: DuckDBTimestampNanosecondsValue;
+}
+export declare function timestampNanosValue(nanos: bigint): DuckDBTimestampNanosecondsValue;

package/lib/values/DuckDBTimestampNanosecondsValue.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampNanosecondsValue = void 0;
+exports.timestampNanosValue = timestampNanosValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBTimestampNanosecondsValue {
+    nanos;
+    constructor(nanos) {
+        this.nanos = nanos;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp_ns(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromNanoseconds)(this.nanos);
+    }
+    static Epoch = new DuckDBTimestampNanosecondsValue(0n);
+    static Max = new DuckDBTimestampNanosecondsValue(2n ** 63n - 2n);
+    static Min = new DuckDBTimestampNanosecondsValue(-9223286400000000000n);
+    static PosInf = new DuckDBTimestampNanosecondsValue(2n ** 63n - 1n);
+    static NegInf = new DuckDBTimestampNanosecondsValue(-(2n ** 63n - 1n));
+}
+exports.DuckDBTimestampNanosecondsValue = DuckDBTimestampNanosecondsValue;
+function timestampNanosValue(nanos) {
+    return new DuckDBTimestampNanosecondsValue(nanos);
+}

package/lib/values/DuckDBTimestampSecondsValue.d.ts

@@ -0,0 +1,13 @@
+import { TimestampSeconds } from '@haybarn/node-bindings';
+export declare class DuckDBTimestampSecondsValue implements TimestampSeconds {
+    readonly seconds: bigint;
+    constructor(seconds: bigint);
+    get isFinite(): boolean;
+    toString(): string;
+    static readonly Epoch: DuckDBTimestampSecondsValue;
+    static readonly Max: DuckDBTimestampSecondsValue;
+    static readonly Min: DuckDBTimestampSecondsValue;
+    static readonly PosInf: DuckDBTimestampSecondsValue;
+    static readonly NegInf: DuckDBTimestampSecondsValue;
+}
+export declare function timestampSecondsValue(seconds: bigint): DuckDBTimestampSecondsValue;

package/lib/values/DuckDBTimestampSecondsValue.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampSecondsValue = void 0;
+exports.timestampSecondsValue = timestampSecondsValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBTimestampSecondsValue {
+    seconds;
+    constructor(seconds) {
+        this.seconds = seconds;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp_s(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromSeconds)(this.seconds);
+    }
+    static Epoch = new DuckDBTimestampSecondsValue(0n);
+    static Max = new DuckDBTimestampSecondsValue(9223372036854n);
+    static Min = new DuckDBTimestampSecondsValue(-9223372022400n); // from test_all_types() select epoch(timestamp_s)::bigint;
+    static PosInf = new DuckDBTimestampSecondsValue(2n ** 63n - 1n);
+    static NegInf = new DuckDBTimestampSecondsValue(-(2n ** 63n - 1n));
+}
+exports.DuckDBTimestampSecondsValue = DuckDBTimestampSecondsValue;
+function timestampSecondsValue(seconds) {
+    return new DuckDBTimestampSecondsValue(seconds);
+}

package/lib/values/DuckDBTimestampTZValue.d.ts

@@ -0,0 +1,16 @@
+import { Timestamp, TimestampParts } from '@haybarn/node-bindings';
+export declare class DuckDBTimestampTZValue implements Timestamp {
+    static timezoneOffsetInMinutes: number;
+    readonly micros: bigint;
+    constructor(micros: bigint);
+    get isFinite(): boolean;
+    toString(): string;
+    toParts(): TimestampParts;
+    static fromParts(parts: TimestampParts): DuckDBTimestampTZValue;
+    static readonly Epoch: DuckDBTimestampTZValue;
+    static readonly Max: DuckDBTimestampTZValue;
+    static readonly Min: DuckDBTimestampTZValue;
+    static readonly PosInf: DuckDBTimestampTZValue;
+    static readonly NegInf: DuckDBTimestampTZValue;
+}
+export declare function timestampTZValue(microsOrParts: bigint | TimestampParts): DuckDBTimestampTZValue;

package/lib/values/DuckDBTimestampTZValue.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampTZValue = void 0;
+exports.timestampTZValue = timestampTZValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+const DuckDBTimestampValue_1 = require("./DuckDBTimestampValue");
+class DuckDBTimestampTZValue {
+    static timezoneOffsetInMinutes = -new Date().getTimezoneOffset();
+    micros;
+    constructor(micros) {
+        this.micros = micros;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromMicroseconds)(this.micros, DuckDBTimestampTZValue.timezoneOffsetInMinutes);
+    }
+    toParts() {
+        return node_bindings_1.default.from_timestamp(this);
+    }
+    static fromParts(parts) {
+        return new DuckDBTimestampTZValue(node_bindings_1.default.to_timestamp(parts).micros);
+    }
+    static Epoch = new DuckDBTimestampTZValue(0n);
+    static Max = new DuckDBTimestampTZValue(DuckDBTimestampValue_1.DuckDBTimestampValue.Max.micros);
+    static Min = new DuckDBTimestampTZValue(DuckDBTimestampValue_1.DuckDBTimestampValue.Min.micros);
+    static PosInf = new DuckDBTimestampTZValue(DuckDBTimestampValue_1.DuckDBTimestampValue.PosInf.micros);
+    static NegInf = new DuckDBTimestampTZValue(DuckDBTimestampValue_1.DuckDBTimestampValue.NegInf.micros);
+}
+exports.DuckDBTimestampTZValue = DuckDBTimestampTZValue;
+function timestampTZValue(microsOrParts) {
+    if (typeof microsOrParts === 'bigint') {
+        return new DuckDBTimestampTZValue(microsOrParts);
+    }
+    return DuckDBTimestampTZValue.fromParts(microsOrParts);
+}

package/lib/values/DuckDBTimestampValue.d.ts

@@ -0,0 +1,18 @@
+import { Timestamp, TimestampParts } from '@haybarn/node-bindings';
+export type { TimestampParts };
+export declare class DuckDBTimestampValue implements Timestamp {
+    readonly micros: bigint;
+    constructor(micros: bigint);
+    get isFinite(): boolean;
+    toString(): string;
+    toParts(): TimestampParts;
+    static fromParts(parts: TimestampParts): DuckDBTimestampValue;
+    static readonly Epoch: DuckDBTimestampValue;
+    static readonly Max: DuckDBTimestampValue;
+    static readonly Min: DuckDBTimestampValue;
+    static readonly PosInf: DuckDBTimestampValue;
+    static readonly NegInf: DuckDBTimestampValue;
+}
+export type DuckDBTimestampMicrosecondsValue = DuckDBTimestampValue;
+export declare const DuckDBTimestampMicrosecondsValue: typeof DuckDBTimestampValue;
+export declare function timestampValue(microsOrParts: bigint | TimestampParts): DuckDBTimestampValue;

package/lib/values/DuckDBTimestampValue.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampMicrosecondsValue = exports.DuckDBTimestampValue = void 0;
+exports.timestampValue = timestampValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+const DuckDBTimestampMillisecondsValue_1 = require("./DuckDBTimestampMillisecondsValue");
+class DuckDBTimestampValue {
+    micros;
+    constructor(micros) {
+        this.micros = micros;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_timestamp(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimestampStringFromMicroseconds)(this.micros);
+    }
+    toParts() {
+        return node_bindings_1.default.from_timestamp(this);
+    }
+    static fromParts(parts) {
+        return new DuckDBTimestampValue(node_bindings_1.default.to_timestamp(parts).micros);
+    }
+    static Epoch = new DuckDBTimestampValue(0n);
+    static Max = new DuckDBTimestampValue(2n ** 63n - 2n);
+    static Min = new DuckDBTimestampValue(DuckDBTimestampMillisecondsValue_1.DuckDBTimestampMillisecondsValue.Min.millis * 1000n);
+    static PosInf = new DuckDBTimestampValue(2n ** 63n - 1n);
+    static NegInf = new DuckDBTimestampValue(-(2n ** 63n - 1n));
+}
+exports.DuckDBTimestampValue = DuckDBTimestampValue;
+exports.DuckDBTimestampMicrosecondsValue = DuckDBTimestampValue;
+function timestampValue(microsOrParts) {
+    if (typeof microsOrParts === 'bigint') {
+        return new DuckDBTimestampValue(microsOrParts);
+    }
+    return DuckDBTimestampValue.fromParts(microsOrParts);
+}

package/lib/values/DuckDBUUIDValue.d.ts

@@ -0,0 +1,19 @@
+export declare class DuckDBUUIDValue {
+    readonly hugeint: bigint;
+    private constructor();
+    /** Return the UUID as an unsigned 128-bit integer in a JS BigInt. */
+    toUint128(): bigint;
+    toString(): string;
+    /** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+    static fromUint128(uint128: bigint): DuckDBUUIDValue;
+    /**
+     * Create a DuckDBUUIDValue from a HUGEINT as stored by DuckDB.
+     *
+     * UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+     */
+    static fromStoredHugeInt(hugeint: bigint): DuckDBUUIDValue;
+    static readonly Max: DuckDBUUIDValue;
+    static readonly Min: DuckDBUUIDValue;
+}
+/** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+export declare function uuidValue(uint128: bigint): DuckDBUUIDValue;

package/lib/values/DuckDBUUIDValue.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUUIDValue = void 0;
+exports.uuidValue = uuidValue;
+class DuckDBUUIDValue {
+    hugeint;
+    constructor(hugeint) {
+        this.hugeint = hugeint;
+    }
+    /** Return the UUID as an unsigned 128-bit integer in a JS BigInt. */
+    toUint128() {
+        // UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+        return (this.hugeint ^ 0x80000000000000000000000000000000n) & 0xffffffffffffffffffffffffffffffffn;
+    }
+    toString() {
+        // Prepend with a (hex) 1 before converting to a hex string.
+        // This ensures the trailing 32 characters are the hex digits we want, left padded with zeros as needed.
+        const hex = (this.toUint128() | 0x100000000000000000000000000000000n).toString(16);
+        return `${hex.substring(1, 9)}-${hex.substring(9, 13)}-${hex.substring(13, 17)}-${hex.substring(17, 21)}-${hex.substring(21, 33)}`;
+    }
+    /** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+    static fromUint128(uint128) {
+        return new DuckDBUUIDValue((uint128 ^ 0x80000000000000000000000000000000n) & 0xffffffffffffffffffffffffffffffffn);
+    }
+    /**
+     * Create a DuckDBUUIDValue from a HUGEINT as stored by DuckDB.
+     *
+     * UUID values are stored with their MSB flipped so their numeric ordering matches their string ordering.
+     */
+    static fromStoredHugeInt(hugeint) {
+        return new DuckDBUUIDValue(hugeint);
+    }
+    static Max = new DuckDBUUIDValue(2n ** 127n - 1n); //  7fffffffffffffffffffffffffffffff
+    static Min = new DuckDBUUIDValue(-(2n ** 127n)); //  80000000000000000000000000000000
+}
+exports.DuckDBUUIDValue = DuckDBUUIDValue;
+/** Create a DuckDBUUIDValue from an unsigned 128-bit integer in a JS BigInt. */
+function uuidValue(uint128) {
+    return DuckDBUUIDValue.fromUint128(uint128);
+}

package/lib/values/DuckDBUnionValue.d.ts

@@ -0,0 +1,8 @@
+import { DuckDBValue } from './DuckDBValue';
+export declare class DuckDBUnionValue {
+    readonly tag: string;
+    readonly value: DuckDBValue;
+    constructor(tag: string, value: DuckDBValue);
+    toString(): string;
+}
+export declare function unionValue(tag: string, value: DuckDBValue): DuckDBUnionValue;

package/lib/values/DuckDBUnionValue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBUnionValue = void 0;
+exports.unionValue = unionValue;
+class DuckDBUnionValue {
+    tag;
+    value;
+    constructor(tag, value) {
+        this.tag = tag;
+        this.value = value;
+    }
+    toString() {
+        if (this.value == null) {
+            return 'NULL';
+        }
+        return this.value.toString();
+    }
+}
+exports.DuckDBUnionValue = DuckDBUnionValue;
+function unionValue(tag, value) {
+    return new DuckDBUnionValue(tag, value);
+}

package/lib/values/DuckDBValue.d.ts

@@ -0,0 +1,20 @@
+import { DuckDBArrayValue } from './DuckDBArrayValue';
+import { DuckDBBitValue } from './DuckDBBitValue';
+import { DuckDBBlobValue } from './DuckDBBlobValue';
+import { DuckDBDateValue } from './DuckDBDateValue';
+import { DuckDBDecimalValue } from './DuckDBDecimalValue';
+import { DuckDBIntervalValue } from './DuckDBIntervalValue';
+import { DuckDBListValue } from './DuckDBListValue';
+import { DuckDBMapValue } from './DuckDBMapValue';
+import { DuckDBStructValue } from './DuckDBStructValue';
+import { DuckDBTimeNSValue } from './DuckDBTimeNSValue';
+import { DuckDBTimestampMillisecondsValue } from './DuckDBTimestampMillisecondsValue';
+import { DuckDBTimestampNanosecondsValue } from './DuckDBTimestampNanosecondsValue';
+import { DuckDBTimestampSecondsValue } from './DuckDBTimestampSecondsValue';
+import { DuckDBTimestampTZValue } from './DuckDBTimestampTZValue';
+import { DuckDBTimestampValue } from './DuckDBTimestampValue';
+import { DuckDBTimeTZValue } from './DuckDBTimeTZValue';
+import { DuckDBTimeValue } from './DuckDBTimeValue';
+import { DuckDBUnionValue } from './DuckDBUnionValue';
+import { DuckDBUUIDValue } from './DuckDBUUIDValue';
+export type DuckDBValue = null | boolean | number | bigint | string | DuckDBArrayValue | DuckDBBitValue | DuckDBBlobValue | DuckDBDateValue | DuckDBDecimalValue | DuckDBIntervalValue | DuckDBListValue | DuckDBMapValue | DuckDBStructValue | DuckDBTimestampMillisecondsValue | DuckDBTimestampNanosecondsValue | DuckDBTimestampSecondsValue | DuckDBTimestampTZValue | DuckDBTimestampValue | DuckDBTimeTZValue | DuckDBTimeValue | DuckDBTimeNSValue | DuckDBUnionValue | DuckDBUUIDValue;

package/lib/values/DuckDBValue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/values/index.d.ts

@@ -0,0 +1,20 @@
+export * from './DuckDBArrayValue';
+export * from './DuckDBBitValue';
+export * from './DuckDBBlobValue';
+export * from './DuckDBDateValue';
+export * from './DuckDBDecimalValue';
+export * from './DuckDBIntervalValue';
+export * from './DuckDBListValue';
+export * from './DuckDBMapValue';
+export * from './DuckDBStructValue';
+export * from './DuckDBTimeNSValue';
+export * from './DuckDBTimestampMillisecondsValue';
+export * from './DuckDBTimestampNanosecondsValue';
+export * from './DuckDBTimestampSecondsValue';
+export * from './DuckDBTimestampTZValue';
+export * from './DuckDBTimestampValue';
+export * from './DuckDBTimeTZValue';
+export * from './DuckDBTimeValue';
+export * from './DuckDBUnionValue';
+export * from './DuckDBUUIDValue';
+export * from './DuckDBValue';

package/lib/values/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DuckDBArrayValue"), exports);
+__exportStar(require("./DuckDBBitValue"), exports);
+__exportStar(require("./DuckDBBlobValue"), exports);
+__exportStar(require("./DuckDBDateValue"), exports);
+__exportStar(require("./DuckDBDecimalValue"), exports);
+__exportStar(require("./DuckDBIntervalValue"), exports);
+__exportStar(require("./DuckDBListValue"), exports);
+__exportStar(require("./DuckDBMapValue"), exports);
+__exportStar(require("./DuckDBStructValue"), exports);
+__exportStar(require("./DuckDBTimeNSValue"), exports);
+__exportStar(require("./DuckDBTimestampMillisecondsValue"), exports);
+__exportStar(require("./DuckDBTimestampNanosecondsValue"), exports);
+__exportStar(require("./DuckDBTimestampSecondsValue"), exports);
+__exportStar(require("./DuckDBTimestampTZValue"), exports);
+__exportStar(require("./DuckDBTimestampValue"), exports);
+__exportStar(require("./DuckDBTimeTZValue"), exports);
+__exportStar(require("./DuckDBTimeValue"), exports);
+__exportStar(require("./DuckDBUnionValue"), exports);
+__exportStar(require("./DuckDBUUIDValue"), exports);
+__exportStar(require("./DuckDBValue"), exports);

package/lib/version.d.ts

@@ -0,0 +1 @@
+export declare function version(): string;

package/lib/version.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = version;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+function version() {
+    return node_bindings_1.default.library_version();
+}

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@haybarn/node-api",
+  "version": "1.5.3-rc2",
+  "license": "MIT",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "@haybarn/node-bindings": "1.5.3-rc2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Query-farm-haybarn/haybarn-node-neo.git"
+  },
+  "description": "High-level Node API for Haybarn — a derived distribution of DuckDB, powered by DuckDB."
+}