@haybarn/node-api 1.5.3-rc2

package/lib/typeForValue.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeForValue = typeForValue;
+const DuckDBType_1 = require("./DuckDBType");
+const values_1 = require("./values");
+function typeForValue(value) {
+    if (value === null) {
+        return DuckDBType_1.SQLNULL;
+    }
+    else {
+        switch (typeof value) {
+            case 'boolean':
+                return DuckDBType_1.BOOLEAN;
+            case 'number':
+                if (Math.round(value) === value) {
+                    return DuckDBType_1.INTEGER;
+                }
+                else {
+                    return DuckDBType_1.DOUBLE;
+                }
+            case 'bigint':
+                return DuckDBType_1.HUGEINT;
+            case 'string':
+                return DuckDBType_1.VARCHAR;
+            case 'object':
+                if (value instanceof values_1.DuckDBArrayValue) {
+                    return (0, DuckDBType_1.ARRAY)(typeForValue(value.items[0]), value.items.length);
+                }
+                else if (value instanceof values_1.DuckDBBitValue) {
+                    return DuckDBType_1.BIT;
+                }
+                else if (value instanceof values_1.DuckDBBlobValue) {
+                    return DuckDBType_1.BLOB;
+                }
+                else if (value instanceof values_1.DuckDBDateValue) {
+                    return DuckDBType_1.DATE;
+                }
+                else if (value instanceof values_1.DuckDBDecimalValue) {
+                    return (0, DuckDBType_1.DECIMAL)(value.width, value.scale);
+                }
+                else if (value instanceof values_1.DuckDBIntervalValue) {
+                    return DuckDBType_1.INTERVAL;
+                }
+                else if (value instanceof values_1.DuckDBListValue) {
+                    return (0, DuckDBType_1.LIST)(typeForValue(value.items[0]));
+                }
+                else if (value instanceof values_1.DuckDBMapValue) {
+                    return (0, DuckDBType_1.MAP)(typeForValue(value.entries[0].key), typeForValue(value.entries[0].value));
+                }
+                else if (value instanceof values_1.DuckDBStructValue) {
+                    const entryTypes = {};
+                    for (const key in value.entries) {
+                        entryTypes[key] = typeForValue(value.entries[key]);
+                    }
+                    return (0, DuckDBType_1.STRUCT)(entryTypes);
+                }
+                else if (value instanceof values_1.DuckDBTimestampMillisecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_MS;
+                }
+                else if (value instanceof values_1.DuckDBTimestampNanosecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_NS;
+                }
+                else if (value instanceof values_1.DuckDBTimestampSecondsValue) {
+                    return DuckDBType_1.TIMESTAMP_S;
+                }
+                else if (value instanceof values_1.DuckDBTimestampTZValue) {
+                    return DuckDBType_1.TIMESTAMPTZ;
+                }
+                else if (value instanceof values_1.DuckDBTimestampValue) {
+                    return DuckDBType_1.TIMESTAMP;
+                }
+                else if (value instanceof values_1.DuckDBTimeTZValue) {
+                    return DuckDBType_1.TIMETZ;
+                }
+                else if (value instanceof values_1.DuckDBTimeValue) {
+                    return DuckDBType_1.TIME;
+                }
+                else if (value instanceof values_1.DuckDBTimeNSValue) {
+                    return DuckDBType_1.TIME_NS;
+                }
+                else if (value instanceof values_1.DuckDBUnionValue) {
+                    return (0, DuckDBType_1.UNION)({ [value.tag]: typeForValue(value.value) });
+                }
+                else if (value instanceof values_1.DuckDBUUIDValue) {
+                    return DuckDBType_1.UUID;
+                }
+                break;
+        }
+    }
+    return DuckDBType_1.ANY;
+}

package/lib/values/DuckDBArrayValue.d.ts

@@ -0,0 +1,7 @@
+import { DuckDBValue } from './DuckDBValue';
+export declare class DuckDBArrayValue {
+    readonly items: readonly DuckDBValue[];
+    constructor(items: readonly DuckDBValue[]);
+    toString(): string;
+}
+export declare function arrayValue(items: readonly DuckDBValue[]): DuckDBArrayValue;

package/lib/values/DuckDBArrayValue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBArrayValue = void 0;
+exports.arrayValue = arrayValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+class DuckDBArrayValue {
+    items;
+    constructor(items) {
+        this.items = items;
+    }
+    toString() {
+        return `[${this.items.map(displayStringForDuckDBValue_1.displayStringForDuckDBValue).join(', ')}]`;
+    }
+}
+exports.DuckDBArrayValue = DuckDBArrayValue;
+function arrayValue(items) {
+    return new DuckDBArrayValue(items);
+}

package/lib/values/DuckDBBitValue.d.ts

@@ -0,0 +1,16 @@
+export declare class DuckDBBitValue {
+    readonly data: Uint8Array;
+    constructor(data: Uint8Array);
+    padding(): number;
+    get length(): number;
+    getBool(index: number): boolean;
+    toBools(): boolean[];
+    getBit(index: number): 0 | 1;
+    toBits(): number[];
+    toString(): string;
+    static fromString(str: string, on?: string): DuckDBBitValue;
+    static fromBits(bits: readonly number[], on?: number): DuckDBBitValue;
+    static fromBools(bools: readonly boolean[]): DuckDBBitValue;
+    static fromLengthAndPredicate(length: number, predicate: (index: number) => boolean): DuckDBBitValue;
+}
+export declare function bitValue(input: string | readonly boolean[] | readonly number[]): DuckDBBitValue;

package/lib/values/DuckDBBitValue.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBitValue = void 0;
+exports.bitValue = bitValue;
+class DuckDBBitValue {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    padding() {
+        return this.data[0];
+    }
+    get length() {
+        return (this.data.length - 1) * 8 - this.padding();
+    }
+    getBool(index) {
+        const offset = index + this.padding();
+        const dataIndex = Math.floor(offset / 8) + 1;
+        const byte = this.data[dataIndex] >> (7 - (offset % 8));
+        return (byte & 1) !== 0;
+    }
+    toBools() {
+        const bools = [];
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            bools.push(this.getBool(i));
+        }
+        return bools;
+    }
+    getBit(index) {
+        return this.getBool(index) ? 1 : 0;
+    }
+    toBits() {
+        const bits = [];
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            bits.push(this.getBit(i));
+        }
+        return bits;
+    }
+    toString() {
+        const length = this.length;
+        const chars = Array.from({ length });
+        for (let i = 0; i < length; i++) {
+            chars[i] = this.getBool(i) ? '1' : '0';
+        }
+        return chars.join('');
+    }
+    static fromString(str, on = '1') {
+        return DuckDBBitValue.fromLengthAndPredicate(str.length, i => str[i] === on);
+    }
+    static fromBits(bits, on = 1) {
+        return DuckDBBitValue.fromLengthAndPredicate(bits.length, i => bits[i] === on);
+    }
+    static fromBools(bools) {
+        return DuckDBBitValue.fromLengthAndPredicate(bools.length, i => bools[i]);
+    }
+    static fromLengthAndPredicate(length, predicate) {
+        const byteCount = Math.ceil(length / 8) + 1;
+        const paddingBitCount = (8 - (length % 8)) % 8;
+        const data = new Uint8Array(byteCount);
+        let byteIndex = 0;
+        // first byte contains count of padding bits
+        data[byteIndex++] = paddingBitCount;
+        let byte = 0;
+        let byteBit = 0;
+        // padding consists of 1s in MSB of second byte
+        while (byteBit < paddingBitCount) {
+            byte <<= 1;
+            byte |= 1;
+            byteBit++;
+        }
+        let bitIndex = 0;
+        while (byteIndex < byteCount) {
+            while (byteBit < 8) {
+                byte <<= 1;
+                if (predicate(bitIndex++)) {
+                    byte |= 1;
+                }
+                byteBit++;
+            }
+            data[byteIndex++] = byte;
+            byte = 0;
+            byteBit = 0;
+        }
+        return new DuckDBBitValue(data);
+    }
+}
+exports.DuckDBBitValue = DuckDBBitValue;
+function bitValue(input) {
+    if (typeof input === 'string') {
+        return DuckDBBitValue.fromString(input);
+    }
+    if (input.length > 0) {
+        if (typeof input[0] === 'boolean') {
+            return DuckDBBitValue.fromBools(input);
+        }
+        else if (typeof input[0] === 'number') {
+            return DuckDBBitValue.fromBits(input);
+        }
+    }
+    return DuckDBBitValue.fromLengthAndPredicate(0, _ => false);
+}

package/lib/values/DuckDBBlobValue.d.ts

@@ -0,0 +1,8 @@
+export declare class DuckDBBlobValue {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    /** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
+    toString(): string;
+    static fromString(str: string): DuckDBBlobValue;
+}
+export declare function blobValue(input: Uint8Array | string): DuckDBBlobValue;

package/lib/values/DuckDBBlobValue.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBBlobValue = void 0;
+exports.blobValue = blobValue;
+const bytesFromString_1 = require("../conversion/bytesFromString");
+const stringFromBlob_1 = require("../conversion/stringFromBlob");
+class DuckDBBlobValue {
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    /** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
+    toString() {
+        return (0, stringFromBlob_1.stringFromBlob)(this.bytes);
+    }
+    static fromString(str) {
+        return new DuckDBBlobValue(Buffer.from((0, bytesFromString_1.bytesFromString)(str)));
+    }
+}
+exports.DuckDBBlobValue = DuckDBBlobValue;
+function blobValue(input) {
+    if (typeof input === 'string') {
+        return DuckDBBlobValue.fromString(input);
+    }
+    return new DuckDBBlobValue(input);
+}

package/lib/values/DuckDBDateValue.d.ts

@@ -0,0 +1,16 @@
+import { Date_, DateParts } from '@haybarn/node-bindings';
+export type { DateParts };
+export declare class DuckDBDateValue implements Date_ {
+    readonly days: number;
+    constructor(days: number);
+    get isFinite(): boolean;
+    toString(): string;
+    toParts(): DateParts;
+    static fromParts(parts: DateParts): DuckDBDateValue;
+    static readonly Epoch: DuckDBDateValue;
+    static readonly Max: DuckDBDateValue;
+    static readonly Min: DuckDBDateValue;
+    static readonly PosInf: DuckDBDateValue;
+    static readonly NegInf: DuckDBDateValue;
+}
+export declare function dateValue(daysOrParts: number | DateParts): DuckDBDateValue;

package/lib/values/DuckDBDateValue.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDateValue = void 0;
+exports.dateValue = dateValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBDateValue {
+    days;
+    constructor(days) {
+        this.days = days;
+    }
+    get isFinite() {
+        return node_bindings_1.default.is_finite_date(this);
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBDateStringFromDays)(this.days);
+    }
+    toParts() {
+        return node_bindings_1.default.from_date(this);
+    }
+    static fromParts(parts) {
+        return new DuckDBDateValue(node_bindings_1.default.to_date(parts).days);
+    }
+    static Epoch = new DuckDBDateValue(0);
+    static Max = new DuckDBDateValue(2 ** 31 - 2);
+    static Min = new DuckDBDateValue(-(2 ** 31 - 2));
+    static PosInf = new DuckDBDateValue(2 ** 31 - 1);
+    static NegInf = new DuckDBDateValue(-(2 ** 31 - 1));
+}
+exports.DuckDBDateValue = DuckDBDateValue;
+function dateValue(daysOrParts) {
+    if (typeof daysOrParts === 'number') {
+        return new DuckDBDateValue(daysOrParts);
+    }
+    return DuckDBDateValue.fromParts(daysOrParts);
+}

package/lib/values/DuckDBDecimalValue.d.ts

@@ -0,0 +1,19 @@
+import { Decimal } from '@haybarn/node-bindings';
+export declare class DuckDBDecimalValue implements Decimal {
+    /** Total number of decimal digits (including fractional digits) in represented number. */
+    readonly width: number;
+    /** Number of fractional digits in represented number. */
+    readonly scale: number;
+    /** Scaled-up value. Represented number is value/(10^scale). */
+    readonly value: bigint;
+    /**
+     * @param value Scaled-up value. Represented number is value/(10^scale).
+     * @param width Total number of decimal digits (including fractional digits) in represented number.
+     * @param scale Number of fractional digits in represented number.
+     */
+    constructor(value: bigint, width: number, scale: number);
+    toString(): string;
+    toDouble(): number;
+    static fromDouble(double: number, width: number, scale: number): DuckDBDecimalValue;
+}
+export declare function decimalValue(value: bigint | number, width: number, scale: number): DuckDBDecimalValue;

package/lib/values/DuckDBDecimalValue.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDecimalValue = void 0;
+exports.decimalValue = decimalValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const stringFromDecimal_1 = require("../conversion/stringFromDecimal");
+class DuckDBDecimalValue {
+    /** Total number of decimal digits (including fractional digits) in represented number. */
+    width;
+    /** Number of fractional digits in represented number. */
+    scale;
+    /** Scaled-up value. Represented number is value/(10^scale). */
+    value;
+    /**
+     * @param value Scaled-up value. Represented number is value/(10^scale).
+     * @param width Total number of decimal digits (including fractional digits) in represented number.
+     * @param scale Number of fractional digits in represented number.
+     */
+    constructor(value, width, scale) {
+        this.width = width;
+        this.scale = scale;
+        this.value = value;
+    }
+    toString() {
+        return (0, stringFromDecimal_1.stringFromDecimal)(this.value, this.scale);
+    }
+    toDouble() {
+        return node_bindings_1.default.decimal_to_double(this);
+    }
+    static fromDouble(double, width, scale) {
+        const decimal = node_bindings_1.default.double_to_decimal(double, width, scale);
+        return new DuckDBDecimalValue(decimal.value, decimal.width, decimal.scale);
+    }
+}
+exports.DuckDBDecimalValue = DuckDBDecimalValue;
+function decimalValue(value, width, scale) {
+    if (typeof value === 'number') {
+        return DuckDBDecimalValue.fromDouble(value, width, scale);
+    }
+    return new DuckDBDecimalValue(value, width, scale);
+}

package/lib/values/DuckDBIntervalValue.d.ts

@@ -0,0 +1,9 @@
+import { Interval } from '@haybarn/node-bindings';
+export declare class DuckDBIntervalValue implements Interval {
+    readonly months: number;
+    readonly days: number;
+    readonly micros: bigint;
+    constructor(months: number, days: number, micros: bigint);
+    toString(): string;
+}
+export declare function intervalValue(months: number, days: number, micros: bigint): DuckDBIntervalValue;

package/lib/values/DuckDBIntervalValue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBIntervalValue = void 0;
+exports.intervalValue = intervalValue;
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBIntervalValue {
+    months;
+    days;
+    micros;
+    constructor(months, days, micros) {
+        this.months = months;
+        this.days = days;
+        this.micros = micros;
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBIntervalString)(this.months, this.days, this.micros);
+    }
+}
+exports.DuckDBIntervalValue = DuckDBIntervalValue;
+function intervalValue(months, days, micros) {
+    return new DuckDBIntervalValue(months, days, micros);
+}

package/lib/values/DuckDBListValue.d.ts

@@ -0,0 +1,7 @@
+import { DuckDBValue } from './DuckDBValue';
+export declare class DuckDBListValue {
+    readonly items: readonly DuckDBValue[];
+    constructor(items: readonly DuckDBValue[]);
+    toString(): string;
+}
+export declare function listValue(items: readonly DuckDBValue[]): DuckDBListValue;

package/lib/values/DuckDBListValue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBListValue = void 0;
+exports.listValue = listValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+class DuckDBListValue {
+    items;
+    constructor(items) {
+        this.items = items;
+    }
+    toString() {
+        return `[${this.items.map(displayStringForDuckDBValue_1.displayStringForDuckDBValue).join(', ')}]`;
+    }
+}
+exports.DuckDBListValue = DuckDBListValue;
+function listValue(items) {
+    return new DuckDBListValue(items);
+}

package/lib/values/DuckDBMapValue.d.ts

@@ -0,0 +1,11 @@
+import { DuckDBValue } from './DuckDBValue';
+export interface DuckDBMapEntry {
+    key: DuckDBValue;
+    value: DuckDBValue;
+}
+export declare class DuckDBMapValue {
+    readonly entries: DuckDBMapEntry[];
+    constructor(entries: DuckDBMapEntry[]);
+    toString(): string;
+}
+export declare function mapValue(entries: DuckDBMapEntry[]): DuckDBMapValue;

package/lib/values/DuckDBMapValue.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBMapValue = void 0;
+exports.mapValue = mapValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+class DuckDBMapValue {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+    toString() {
+        return `{${this.entries.map(({ key, value }) => `${(0, displayStringForDuckDBValue_1.displayStringForDuckDBValue)(key)}: ${(0, displayStringForDuckDBValue_1.displayStringForDuckDBValue)(value)}`).join(', ')}}`;
+    }
+}
+exports.DuckDBMapValue = DuckDBMapValue;
+function mapValue(entries) {
+    return new DuckDBMapValue(entries);
+}

package/lib/values/DuckDBStructValue.d.ts

@@ -0,0 +1,7 @@
+import { DuckDBValue } from './DuckDBValue';
+export declare class DuckDBStructValue {
+    readonly entries: Readonly<Record<string, DuckDBValue>>;
+    constructor(entries: Readonly<Record<string, DuckDBValue>>);
+    toString(): string;
+}
+export declare function structValue(entries: Readonly<Record<string, DuckDBValue>>): DuckDBStructValue;

package/lib/values/DuckDBStructValue.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBStructValue = void 0;
+exports.structValue = structValue;
+const displayStringForDuckDBValue_1 = require("../conversion/displayStringForDuckDBValue");
+class DuckDBStructValue {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+    toString() {
+        const parts = [];
+        for (const name in this.entries) {
+            parts.push(`${(0, displayStringForDuckDBValue_1.displayStringForDuckDBValue)(name)}: ${(0, displayStringForDuckDBValue_1.displayStringForDuckDBValue)(this.entries[name])}`);
+        }
+        return `{${parts.join(', ')}}`;
+    }
+}
+exports.DuckDBStructValue = DuckDBStructValue;
+function structValue(entries) {
+    return new DuckDBStructValue(entries);
+}

package/lib/values/DuckDBTimeNSValue.d.ts

@@ -0,0 +1,9 @@
+import { TimeNS } from '@haybarn/node-bindings';
+export declare class DuckDBTimeNSValue implements TimeNS {
+    readonly nanos: bigint;
+    constructor(nanos: bigint);
+    toString(): string;
+    static readonly Max: DuckDBTimeNSValue;
+    static readonly Min: DuckDBTimeNSValue;
+}
+export declare function timeNSValue(nanos: bigint): DuckDBTimeNSValue;

package/lib/values/DuckDBTimeNSValue.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeNSValue = void 0;
+exports.timeNSValue = timeNSValue;
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBTimeNSValue {
+    nanos;
+    constructor(nanos) {
+        this.nanos = nanos;
+    }
+    toString() {
+        return (0, dateTimeStringConversion_1.getDuckDBTimeStringFromNanosecondsInDay)(this.nanos);
+    }
+    static Max = new DuckDBTimeNSValue(24n * 60n * 60n * 1000n * 1000n * 1000n);
+    static Min = new DuckDBTimeNSValue(0n);
+}
+exports.DuckDBTimeNSValue = DuckDBTimeNSValue;
+function timeNSValue(nanos) {
+    return new DuckDBTimeNSValue(nanos);
+}

package/lib/values/DuckDBTimeTZValue.d.ts

@@ -0,0 +1,35 @@
+import { TimeTZ, TimeTZParts } from '@haybarn/node-bindings';
+export type { TimeTZParts };
+export declare class DuckDBTimeTZValue implements TimeTZ {
+    /**
+     * 40 bits for micros, then 24 bits for encoded offset in seconds.
+     *
+     * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
+     *
+     * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
+     *
+     * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
+     *
+     * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
+     */
+    readonly bits: bigint;
+    /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
+    readonly micros: bigint;
+    /** In seconds, ranges from -57599 to 57599 (= 16 * 60 * 60 - 1) */
+    readonly offset: number;
+    constructor(bits: bigint, micros: bigint, offset: number);
+    toString(): string;
+    toParts(): TimeTZParts;
+    static TimeBits: number;
+    static OffsetBits: number;
+    static MaxOffset: number;
+    static MinOffset: number;
+    static MaxMicros: bigint;
+    static MinMicros: bigint;
+    static fromBits(bits: bigint): DuckDBTimeTZValue;
+    static fromMicrosAndOffset(micros: bigint, offset: number): DuckDBTimeTZValue;
+    static fromParts(parts: TimeTZParts): DuckDBTimeTZValue;
+    static readonly Max: DuckDBTimeTZValue;
+    static readonly Min: DuckDBTimeTZValue;
+}
+export declare function timeTZValue(micros: bigint, offset: number): DuckDBTimeTZValue;

package/lib/values/DuckDBTimeTZValue.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimeTZValue = void 0;
+exports.timeTZValue = timeTZValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const dateTimeStringConversion_1 = require("../conversion/dateTimeStringConversion");
+class DuckDBTimeTZValue {
+    /**
+     * 40 bits for micros, then 24 bits for encoded offset in seconds.
+     *
+     * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
+     *
+     * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
+     *
+     * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
+     *
+     * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
+     */
+    bits;
+    /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
+    micros;
+    /** In seconds, ranges from -57599 to 57599 (= 16 * 60 * 60 - 1) */
+    offset;
+    constructor(bits, micros, offset) {
+        this.bits = bits;
+        this.micros = micros;
+        this.offset = offset;
+    }
+    toString() {
+        return `${(0, dateTimeStringConversion_1.getDuckDBTimeStringFromMicrosecondsInDay)(this.micros)}${(0, dateTimeStringConversion_1.getOffsetStringFromSeconds)(this.offset)}`;
+    }
+    toParts() {
+        return node_bindings_1.default.from_time_tz(this);
+    }
+    static TimeBits = 40;
+    static OffsetBits = 24;
+    static MaxOffset = 16 * 60 * 60 - 1; // ±15:59:59 = 57599 seconds
+    static MinOffset = -DuckDBTimeTZValue.MaxOffset;
+    static MaxMicros = 24n * 60n * 60n * 1000n * 1000n; // 86400000000
+    static MinMicros = 0n;
+    static fromBits(bits) {
+        const micros = BigInt.asUintN(DuckDBTimeTZValue.TimeBits, bits >> BigInt(DuckDBTimeTZValue.OffsetBits));
+        const offset = DuckDBTimeTZValue.MaxOffset -
+            Number(BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, bits));
+        return new DuckDBTimeTZValue(bits, micros, offset);
+    }
+    static fromMicrosAndOffset(micros, offset) {
+        const bits = (BigInt.asUintN(DuckDBTimeTZValue.TimeBits, micros) <<
+            BigInt(DuckDBTimeTZValue.OffsetBits)) |
+            BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, BigInt(DuckDBTimeTZValue.MaxOffset - offset));
+        return new DuckDBTimeTZValue(bits, micros, offset);
+    }
+    static fromParts(parts) {
+        return DuckDBTimeTZValue.fromMicrosAndOffset(node_bindings_1.default.to_time(parts.time).micros, parts.offset);
+    }
+    static Max = DuckDBTimeTZValue.fromMicrosAndOffset(DuckDBTimeTZValue.MaxMicros, DuckDBTimeTZValue.MinOffset);
+    static Min = DuckDBTimeTZValue.fromMicrosAndOffset(DuckDBTimeTZValue.MinMicros, DuckDBTimeTZValue.MaxOffset);
+}
+exports.DuckDBTimeTZValue = DuckDBTimeTZValue;
+function timeTZValue(micros, offset) {
+    return DuckDBTimeTZValue.fromMicrosAndOffset(micros, offset);
+}