@haybarn/node-api 1.5.6-rc1 → 2.0.0-rc5

package/lib/types/DuckDBFloatType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBFloatType extends BaseDuckDBType<DuckDBTypeId.FLOAT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBFloatType;
+    static create(alias?: string): DuckDBFloatType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const FLOAT: DuckDBFloatType;

package/lib/types/DuckDBFloatType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLOAT = exports.DuckDBFloatType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBFloatType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.FLOAT, alias);
+    }
+    static instance = new DuckDBFloatType();
+    static create(alias) {
+        return alias ? new DuckDBFloatType(alias) : DuckDBFloatType.instance;
+    }
+    static Max = Math.fround(3.4028235e38);
+    static Min = Math.fround(-3.4028235e38);
+    get max() {
+        return DuckDBFloatType.Max;
+    }
+    get min() {
+        return DuckDBFloatType.Min;
+    }
+}
+exports.DuckDBFloatType = DuckDBFloatType;
+exports.FLOAT = DuckDBFloatType.instance;

package/lib/types/DuckDBGeometryType.d.ts

@@ -0,0 +1,19 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+export declare class DuckDBGeometryType extends BaseDuckDBType<DuckDBTypeId.GEOMETRY> {
+    /**
+     * Coordinate Reference System (e.g. a WKT2 string) attached to the type.
+     *
+     * Read-only: setting `crs` on a `DuckDBGeometryType` is not propagated by
+     * `toLogicalType()`. To produce a GEOMETRY logical type carrying a CRS,
+     * construct it via SQL (e.g. `'POINT(1 2)'::GEOMETRY('<crs>')`).
+     */
+    readonly crs?: string;
+    constructor(alias?: string, crs?: string);
+    toString(): string;
+    toJson(): Json;
+    static readonly instance: DuckDBGeometryType;
+    static create(alias?: string, crs?: string): DuckDBGeometryType;
+}
+export declare const GEOMETRY: DuckDBGeometryType;

package/lib/types/DuckDBGeometryType.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRY = exports.DuckDBGeometryType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const sql_1 = require("../sql");
+class DuckDBGeometryType extends BaseDuckDBType_1.BaseDuckDBType {
+    /**
+     * Coordinate Reference System (e.g. a WKT2 string) attached to the type.
+     *
+     * Read-only: setting `crs` on a `DuckDBGeometryType` is not propagated by
+     * `toLogicalType()`. To produce a GEOMETRY logical type carrying a CRS,
+     * construct it via SQL (e.g. `'POINT(1 2)'::GEOMETRY('<crs>')`).
+     */
+    crs;
+    constructor(alias, crs) {
+        super(DuckDBTypeId_1.DuckDBTypeId.GEOMETRY, alias);
+        this.crs = crs;
+    }
+    toString() {
+        return this.crs ? `GEOMETRY(${(0, sql_1.quotedString)(this.crs)})` : 'GEOMETRY';
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            ...(this.crs ? { crs: this.crs } : {}),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+    static instance = new DuckDBGeometryType();
+    static create(alias, crs) {
+        return alias || crs
+            ? new DuckDBGeometryType(alias, crs)
+            : DuckDBGeometryType.instance;
+    }
+}
+exports.DuckDBGeometryType = DuckDBGeometryType;
+exports.GEOMETRY = DuckDBGeometryType.instance;

package/lib/types/DuckDBHugeIntType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBHugeIntType extends BaseDuckDBType<DuckDBTypeId.HUGEINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBHugeIntType;
+    static create(alias?: string): DuckDBHugeIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const HUGEINT: DuckDBHugeIntType;

package/lib/types/DuckDBHugeIntType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUGEINT = exports.DuckDBHugeIntType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBHugeIntType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.HUGEINT, alias);
+    }
+    static instance = new DuckDBHugeIntType();
+    static create(alias) {
+        return alias ? new DuckDBHugeIntType(alias) : DuckDBHugeIntType.instance;
+    }
+    static Max = 2n ** 127n - 1n;
+    static Min = -(2n ** 127n);
+    get max() {
+        return DuckDBHugeIntType.Max;
+    }
+    get min() {
+        return DuckDBHugeIntType.Min;
+    }
+}
+exports.DuckDBHugeIntType = DuckDBHugeIntType;
+exports.HUGEINT = DuckDBHugeIntType.instance;

package/lib/types/DuckDBIntegerLiteralType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBIntegerLiteralType extends BaseDuckDBType<DuckDBTypeId.INTEGER_LITERAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntegerLiteralType;
+    static create(alias?: string): DuckDBIntegerLiteralType;
+}
+export declare const INTEGER_LITERAL: DuckDBIntegerLiteralType;

package/lib/types/DuckDBIntegerLiteralType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTEGER_LITERAL = exports.DuckDBIntegerLiteralType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBIntegerLiteralType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL, alias);
+    }
+    static instance = new DuckDBIntegerLiteralType();
+    static create(alias) {
+        return alias ? new DuckDBIntegerLiteralType(alias) : DuckDBIntegerLiteralType.instance;
+    }
+}
+exports.DuckDBIntegerLiteralType = DuckDBIntegerLiteralType;
+exports.INTEGER_LITERAL = DuckDBIntegerLiteralType.instance;

package/lib/types/DuckDBIntegerType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBIntegerType extends BaseDuckDBType<DuckDBTypeId.INTEGER> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntegerType;
+    static create(alias?: string): DuckDBIntegerType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const INTEGER: DuckDBIntegerType;

package/lib/types/DuckDBIntegerType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTEGER = exports.DuckDBIntegerType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBIntegerType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.INTEGER, alias);
+    }
+    static instance = new DuckDBIntegerType();
+    static create(alias) {
+        return alias ? new DuckDBIntegerType(alias) : DuckDBIntegerType.instance;
+    }
+    static Max = 2 ** 31 - 1;
+    static Min = -(2 ** 31);
+    get max() {
+        return DuckDBIntegerType.Max;
+    }
+    get min() {
+        return DuckDBIntegerType.Min;
+    }
+}
+exports.DuckDBIntegerType = DuckDBIntegerType;
+exports.INTEGER = DuckDBIntegerType.instance;

package/lib/types/DuckDBIntervalType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBIntervalType extends BaseDuckDBType<DuckDBTypeId.INTERVAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntervalType;
+    static create(alias?: string): DuckDBIntervalType;
+}
+export declare const INTERVAL: DuckDBIntervalType;

package/lib/types/DuckDBIntervalType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERVAL = exports.DuckDBIntervalType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBIntervalType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.INTERVAL, alias);
+    }
+    static instance = new DuckDBIntervalType();
+    static create(alias) {
+        return alias ? new DuckDBIntervalType(alias) : DuckDBIntervalType.instance;
+    }
+}
+exports.DuckDBIntervalType = DuckDBIntervalType;
+exports.INTERVAL = DuckDBIntervalType.instance;

package/lib/types/DuckDBListType.d.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+export declare class DuckDBListType extends BaseDuckDBType<DuckDBTypeId.LIST> {
+    readonly valueType: DuckDBType;
+    constructor(valueType: DuckDBType, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function LIST(valueType: DuckDBType, alias?: string): DuckDBListType;

package/lib/types/DuckDBListType.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBListType = void 0;
+exports.LIST = LIST;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBListType extends BaseDuckDBType_1.BaseDuckDBType {
+    valueType;
+    constructor(valueType, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.LIST, alias);
+        this.valueType = valueType;
+    }
+    toString() {
+        return `${this.valueType}[]`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createList(this.valueType.toLogicalType());
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        return logicalType;
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            valueType: this.valueType.toJson(),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+}
+exports.DuckDBListType = DuckDBListType;
+function LIST(valueType, alias) {
+    return new DuckDBListType(valueType, alias);
+}

package/lib/types/DuckDBMapType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+export declare class DuckDBMapType extends BaseDuckDBType<DuckDBTypeId.MAP> {
+    readonly keyType: DuckDBType;
+    readonly valueType: DuckDBType;
+    constructor(keyType: DuckDBType, valueType: DuckDBType, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function MAP(keyType: DuckDBType, valueType: DuckDBType, alias?: string): DuckDBMapType;

package/lib/types/DuckDBMapType.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBMapType = void 0;
+exports.MAP = MAP;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBMapType extends BaseDuckDBType_1.BaseDuckDBType {
+    keyType;
+    valueType;
+    constructor(keyType, valueType, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.MAP, alias);
+        this.keyType = keyType;
+        this.valueType = valueType;
+    }
+    toString() {
+        return `MAP(${this.keyType}, ${this.valueType})`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createMap(this.keyType.toLogicalType(), this.valueType.toLogicalType());
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        return logicalType;
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            keyType: this.keyType.toJson(),
+            valueType: this.valueType.toJson(),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+}
+exports.DuckDBMapType = DuckDBMapType;
+function MAP(keyType, valueType, alias) {
+    return new DuckDBMapType(keyType, valueType, alias);
+}

package/lib/types/DuckDBSQLNullType.d.ts

@@ -0,0 +1,10 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBSQLNullType extends BaseDuckDBType<DuckDBTypeId.SQLNULL> {
+    constructor(alias?: string);
+    /** DuckDB's name for the type, quoted because NULL is a keyword. */
+    toString(): string;
+    static readonly instance: DuckDBSQLNullType;
+    static create(alias?: string): DuckDBSQLNullType;
+}
+export declare const SQLNULL: DuckDBSQLNullType;

package/lib/types/DuckDBSQLNullType.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLNULL = exports.DuckDBSQLNullType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBSQLNullType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.SQLNULL, alias);
+    }
+    /** DuckDB's name for the type, quoted because NULL is a keyword. */
+    toString() {
+        return '"NULL"';
+    }
+    static instance = new DuckDBSQLNullType();
+    static create(alias) {
+        return alias ? new DuckDBSQLNullType(alias) : DuckDBSQLNullType.instance;
+    }
+}
+exports.DuckDBSQLNullType = DuckDBSQLNullType;
+exports.SQLNULL = DuckDBSQLNullType.instance;

package/lib/types/DuckDBSmallIntType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBSmallIntType extends BaseDuckDBType<DuckDBTypeId.SMALLINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBSmallIntType;
+    static create(alias?: string): DuckDBSmallIntType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const SMALLINT: DuckDBSmallIntType;

package/lib/types/DuckDBSmallIntType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMALLINT = exports.DuckDBSmallIntType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBSmallIntType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.SMALLINT, alias);
+    }
+    static instance = new DuckDBSmallIntType();
+    static create(alias) {
+        return alias ? new DuckDBSmallIntType(alias) : DuckDBSmallIntType.instance;
+    }
+    static Max = 2 ** 15 - 1;
+    static Min = -(2 ** 15);
+    get max() {
+        return DuckDBSmallIntType.Max;
+    }
+    get min() {
+        return DuckDBSmallIntType.Min;
+    }
+}
+exports.DuckDBSmallIntType = DuckDBSmallIntType;
+exports.SMALLINT = DuckDBSmallIntType.instance;

package/lib/types/DuckDBStringLiteralType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+export declare class DuckDBStringLiteralType extends BaseDuckDBType<DuckDBTypeId.STRING_LITERAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBStringLiteralType;
+    static create(alias?: string): DuckDBStringLiteralType;
+}
+export declare const STRING_LITERAL: DuckDBStringLiteralType;

package/lib/types/DuckDBStringLiteralType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRING_LITERAL = exports.DuckDBStringLiteralType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBStringLiteralType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL, alias);
+    }
+    static instance = new DuckDBStringLiteralType();
+    static create(alias) {
+        return alias ? new DuckDBStringLiteralType(alias) : DuckDBStringLiteralType.instance;
+    }
+}
+exports.DuckDBStringLiteralType = DuckDBStringLiteralType;
+exports.STRING_LITERAL = DuckDBStringLiteralType.instance;

package/lib/types/DuckDBStructType.d.ts

@@ -0,0 +1,29 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+export declare class DuckDBStructType extends BaseDuckDBType<DuckDBTypeId.STRUCT> {
+    readonly entryNames: readonly string[];
+    readonly entryTypes: readonly DuckDBType[];
+    readonly entryIndexes: Readonly<Record<string, number>>;
+    constructor(entryNames: readonly string[], entryTypes: readonly DuckDBType[], alias?: string);
+    get entryCount(): number;
+    /**
+     * Whether this is an unnamed struct, i.e. a tuple, such as the type of
+     * `(1, 'a')` or `row(1, 'a')`. DuckDB reports these as STRUCTs whose entry
+     * names are all empty. A STRUCT with no entries is not a tuple.
+     *
+     * Values of a tuple type are `DuckDBTupleValue`s, whose items are
+     * positional, rather than `DuckDBStructValue`s.
+     */
+    get isTuple(): boolean;
+    indexForEntry(entryName: string): number;
+    typeForEntry(entryName: string): DuckDBType;
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function STRUCT(entries: Record<string, DuckDBType>, alias?: string): DuckDBStructType;
+/** Creates a tuple type: an unnamed STRUCT with the given entry types. */
+export declare function TUPLE(entryTypes: readonly DuckDBType[], alias?: string): DuckDBStructType;

package/lib/types/DuckDBStructType.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBStructType = void 0;
+exports.STRUCT = STRUCT;
+exports.TUPLE = TUPLE;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const sql_1 = require("../sql");
+class DuckDBStructType extends BaseDuckDBType_1.BaseDuckDBType {
+    entryNames;
+    entryTypes;
+    entryIndexes;
+    constructor(entryNames, entryTypes, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.STRUCT, alias);
+        if (entryNames.length !== entryTypes.length) {
+            throw new Error(`Could not create DuckDBStructType: \
+        entryNames length (${entryNames.length}) does not match entryTypes length (${entryTypes.length})`);
+        }
+        this.entryNames = entryNames;
+        this.entryTypes = entryTypes;
+        const entryIndexes = {};
+        for (let i = 0; i < entryNames.length; i++) {
+            entryIndexes[entryNames[i]] = i;
+        }
+        this.entryIndexes = entryIndexes;
+    }
+    get entryCount() {
+        return this.entryNames.length;
+    }
+    /**
+     * Whether this is an unnamed struct, i.e. a tuple, such as the type of
+     * `(1, 'a')` or `row(1, 'a')`. DuckDB reports these as STRUCTs whose entry
+     * names are all empty. A STRUCT with no entries is not a tuple.
+     *
+     * Values of a tuple type are `DuckDBTupleValue`s, whose items are
+     * positional, rather than `DuckDBStructValue`s.
+     */
+    get isTuple() {
+        return (this.entryNames.length > 0 && this.entryNames.every((name) => name === ''));
+    }
+    indexForEntry(entryName) {
+        return this.entryIndexes[entryName];
+    }
+    typeForEntry(entryName) {
+        return this.entryTypes[this.entryIndexes[entryName]];
+    }
+    toString() {
+        if (this.entryNames.length === 0) {
+            return 'STRUCT';
+        }
+        if (this.isTuple) {
+            return `TUPLE(${this.entryTypes.join(', ')})`;
+        }
+        const parts = [];
+        for (let i = 0; i < this.entryNames.length; i++) {
+            parts.push(`${(0, sql_1.quotedIdentifier)(this.entryNames[i])} ${this.entryTypes[i]}`);
+        }
+        return `STRUCT(${parts.join(', ')})`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createStruct(this.entryNames, this.entryTypes.map((t) => t.toLogicalType()));
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        return logicalType;
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            entryNames: [...this.entryNames],
+            entryTypes: this.entryTypes.map(t => t.toJson()),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+}
+exports.DuckDBStructType = DuckDBStructType;
+function STRUCT(entries, alias) {
+    const entryNames = Object.keys(entries);
+    const entryTypes = Object.values(entries);
+    return new DuckDBStructType(entryNames, entryTypes, alias);
+}
+/** Creates a tuple type: an unnamed STRUCT with the given entry types. */
+function TUPLE(entryTypes, alias) {
+    return new DuckDBStructType(entryTypes.map(() => ''), entryTypes, alias);
+}

package/lib/types/DuckDBTimeNSType.d.ts

@@ -0,0 +1,11 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimeNSValue } from '../values';
+export declare class DuckDBTimeNSType extends BaseDuckDBType<DuckDBTypeId.TIME_NS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimeNSType;
+    static create(alias?: string): DuckDBTimeNSType;
+    get max(): DuckDBTimeNSValue;
+    get min(): DuckDBTimeNSValue;
+}
+export declare const TIME_NS: DuckDBTimeNSType;

package/lib/types/DuckDBTimeNSType.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_NS = exports.DuckDBTimeNSType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimeNSType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIME_NS, alias);
+    }
+    static instance = new DuckDBTimeNSType();
+    static create(alias) {
+        return alias ? new DuckDBTimeNSType(alias) : DuckDBTimeNSType.instance;
+    }
+    get max() {
+        return values_1.DuckDBTimeNSValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimeNSValue.Min;
+    }
+}
+exports.DuckDBTimeNSType = DuckDBTimeNSType;
+exports.TIME_NS = DuckDBTimeNSType.instance;

package/lib/types/DuckDBTimeTZType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimeTZValue } from '../values';
+export declare class DuckDBTimeTZType extends BaseDuckDBType<DuckDBTypeId.TIME_TZ> {
+    constructor(alias?: string);
+    toString(): string;
+    static readonly instance: DuckDBTimeTZType;
+    static create(alias?: string): DuckDBTimeTZType;
+    get max(): DuckDBTimeTZValue;
+    get min(): DuckDBTimeTZValue;
+}
+export declare const TIMETZ: DuckDBTimeTZType;

package/lib/types/DuckDBTimeTZType.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMETZ = exports.DuckDBTimeTZType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimeTZType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIME_TZ, alias);
+    }
+    toString() {
+        return 'TIME WITH TIME ZONE';
+    }
+    static instance = new DuckDBTimeTZType();
+    static create(alias) {
+        return alias ? new DuckDBTimeTZType(alias) : DuckDBTimeTZType.instance;
+    }
+    get max() {
+        return values_1.DuckDBTimeTZValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimeTZValue.Min;
+    }
+}
+exports.DuckDBTimeTZType = DuckDBTimeTZType;
+exports.TIMETZ = DuckDBTimeTZType.instance;

package/lib/types/DuckDBTimeType.d.ts

@@ -0,0 +1,11 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimeValue } from '../values';
+export declare class DuckDBTimeType extends BaseDuckDBType<DuckDBTypeId.TIME> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimeType;
+    static create(alias?: string): DuckDBTimeType;
+    get max(): DuckDBTimeValue;
+    get min(): DuckDBTimeValue;
+}
+export declare const TIME: DuckDBTimeType;