@haybarn/node-api 1.5.5-rc1 → 2.0.0-rc3

package/lib/types/DuckDBTimeType.js

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

package/lib/types/DuckDBTimestampMillisecondsType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampMillisecondsValue } from '../values';
+export declare class DuckDBTimestampMillisecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_MS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampMillisecondsType;
+    static create(alias?: string): DuckDBTimestampMillisecondsType;
+    get epoch(): DuckDBTimestampMillisecondsValue;
+    get max(): DuckDBTimestampMillisecondsValue;
+    get min(): DuckDBTimestampMillisecondsValue;
+    get posInf(): DuckDBTimestampMillisecondsValue;
+    get negInf(): DuckDBTimestampMillisecondsValue;
+}
+export declare const TIMESTAMP_MS: DuckDBTimestampMillisecondsType;

package/lib/types/DuckDBTimestampMillisecondsType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_MS = exports.DuckDBTimestampMillisecondsType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampMillisecondsType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS, alias);
+    }
+    static instance = new DuckDBTimestampMillisecondsType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampMillisecondsType(alias) : DuckDBTimestampMillisecondsType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampMillisecondsValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampMillisecondsValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampMillisecondsValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampMillisecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampMillisecondsValue.NegInf;
+    }
+}
+exports.DuckDBTimestampMillisecondsType = DuckDBTimestampMillisecondsType;
+exports.TIMESTAMP_MS = DuckDBTimestampMillisecondsType.instance;

package/lib/types/DuckDBTimestampNanosecondsType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampNanosecondsValue } from '../values';
+export declare class DuckDBTimestampNanosecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_NS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampNanosecondsType;
+    static create(alias?: string): DuckDBTimestampNanosecondsType;
+    get epoch(): DuckDBTimestampNanosecondsValue;
+    get max(): DuckDBTimestampNanosecondsValue;
+    get min(): DuckDBTimestampNanosecondsValue;
+    get posInf(): DuckDBTimestampNanosecondsValue;
+    get negInf(): DuckDBTimestampNanosecondsValue;
+}
+export declare const TIMESTAMP_NS: DuckDBTimestampNanosecondsType;

package/lib/types/DuckDBTimestampNanosecondsType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_NS = exports.DuckDBTimestampNanosecondsType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampNanosecondsType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS, alias);
+    }
+    static instance = new DuckDBTimestampNanosecondsType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampNanosecondsType(alias) : DuckDBTimestampNanosecondsType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampNanosecondsValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampNanosecondsValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampNanosecondsValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampNanosecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampNanosecondsValue.NegInf;
+    }
+}
+exports.DuckDBTimestampNanosecondsType = DuckDBTimestampNanosecondsType;
+exports.TIMESTAMP_NS = DuckDBTimestampNanosecondsType.instance;

package/lib/types/DuckDBTimestampSecondsType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampSecondsValue } from '../values';
+export declare class DuckDBTimestampSecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_S> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampSecondsType;
+    static create(alias?: string): DuckDBTimestampSecondsType;
+    get epoch(): DuckDBTimestampSecondsValue;
+    get max(): DuckDBTimestampSecondsValue;
+    get min(): DuckDBTimestampSecondsValue;
+    get posInf(): DuckDBTimestampSecondsValue;
+    get negInf(): DuckDBTimestampSecondsValue;
+}
+export declare const TIMESTAMP_S: DuckDBTimestampSecondsType;

package/lib/types/DuckDBTimestampSecondsType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_S = exports.DuckDBTimestampSecondsType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampSecondsType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S, alias);
+    }
+    static instance = new DuckDBTimestampSecondsType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampSecondsType(alias) : DuckDBTimestampSecondsType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampSecondsValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampSecondsValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampSecondsValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampSecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampSecondsValue.NegInf;
+    }
+}
+exports.DuckDBTimestampSecondsType = DuckDBTimestampSecondsType;
+exports.TIMESTAMP_S = DuckDBTimestampSecondsType.instance;

package/lib/types/DuckDBTimestampTZNanosecondsType.d.ts

@@ -0,0 +1,15 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampTZNanosecondsValue } from '../values';
+export declare class DuckDBTimestampTZNanosecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_TZ_NS> {
+    constructor(alias?: string);
+    toString(): string;
+    static readonly instance: DuckDBTimestampTZNanosecondsType;
+    static create(alias?: string): DuckDBTimestampTZNanosecondsType;
+    get epoch(): DuckDBTimestampTZNanosecondsValue;
+    get max(): DuckDBTimestampTZNanosecondsValue;
+    get min(): DuckDBTimestampTZNanosecondsValue;
+    get posInf(): DuckDBTimestampTZNanosecondsValue;
+    get negInf(): DuckDBTimestampTZNanosecondsValue;
+}
+export declare const TIMESTAMPTZ_NS: DuckDBTimestampTZNanosecondsType;

package/lib/types/DuckDBTimestampTZNanosecondsType.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMPTZ_NS = exports.DuckDBTimestampTZNanosecondsType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampTZNanosecondsType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ_NS, alias);
+    }
+    toString() {
+        return 'TIMESTAMPTZ_NS';
+    }
+    static instance = new DuckDBTimestampTZNanosecondsType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampTZNanosecondsType(alias) : DuckDBTimestampTZNanosecondsType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampTZNanosecondsValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampTZNanosecondsValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampTZNanosecondsValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampTZNanosecondsValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampTZNanosecondsValue.NegInf;
+    }
+}
+exports.DuckDBTimestampTZNanosecondsType = DuckDBTimestampTZNanosecondsType;
+exports.TIMESTAMPTZ_NS = DuckDBTimestampTZNanosecondsType.instance;

package/lib/types/DuckDBTimestampTZType.d.ts

@@ -0,0 +1,15 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampTZValue } from '../values';
+export declare class DuckDBTimestampTZType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_TZ> {
+    constructor(alias?: string);
+    toString(): string;
+    static readonly instance: DuckDBTimestampTZType;
+    static create(alias?: string): DuckDBTimestampTZType;
+    get epoch(): DuckDBTimestampTZValue;
+    get max(): DuckDBTimestampTZValue;
+    get min(): DuckDBTimestampTZValue;
+    get posInf(): DuckDBTimestampTZValue;
+    get negInf(): DuckDBTimestampTZValue;
+}
+export declare const TIMESTAMPTZ: DuckDBTimestampTZType;

package/lib/types/DuckDBTimestampTZType.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMPTZ = exports.DuckDBTimestampTZType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampTZType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ, alias);
+    }
+    toString() {
+        return 'TIMESTAMP WITH TIME ZONE';
+    }
+    static instance = new DuckDBTimestampTZType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampTZType(alias) : DuckDBTimestampTZType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampTZValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampTZValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampTZValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampTZValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampTZValue.NegInf;
+    }
+}
+exports.DuckDBTimestampTZType = DuckDBTimestampTZType;
+exports.TIMESTAMPTZ = DuckDBTimestampTZType.instance;

package/lib/types/DuckDBTimestampType.d.ts

@@ -0,0 +1,16 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampValue } from '../values';
+export declare class DuckDBTimestampType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampType;
+    static create(alias?: string): DuckDBTimestampType;
+    get epoch(): DuckDBTimestampValue;
+    get max(): DuckDBTimestampValue;
+    get min(): DuckDBTimestampValue;
+    get posInf(): DuckDBTimestampValue;
+    get negInf(): DuckDBTimestampValue;
+}
+export declare const TIMESTAMP: DuckDBTimestampType;
+export type DuckDBTimestampMicrosecondsType = DuckDBTimestampType;
+export declare const DuckDBTimestampMicrosecondsType: typeof DuckDBTimestampType;

package/lib/types/DuckDBTimestampType.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBTimestampMicrosecondsType = exports.TIMESTAMP = exports.DuckDBTimestampType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBTimestampType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP, alias);
+    }
+    static instance = new DuckDBTimestampType();
+    static create(alias) {
+        return alias ? new DuckDBTimestampType(alias) : DuckDBTimestampType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBTimestampValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBTimestampValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBTimestampValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBTimestampValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBTimestampValue.NegInf;
+    }
+}
+exports.DuckDBTimestampType = DuckDBTimestampType;
+exports.TIMESTAMP = DuckDBTimestampType.instance;
+exports.DuckDBTimestampMicrosecondsType = DuckDBTimestampType;

package/lib/types/DuckDBTinyIntType.d.ts

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

package/lib/types/DuckDBTinyIntType.js

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

package/lib/types/DuckDBType.d.ts

@@ -0,0 +1,43 @@
+import type { DuckDBAnyType } from './DuckDBAnyType';
+import type { DuckDBArrayType } from './DuckDBArrayType';
+import type { DuckDBBigIntType } from './DuckDBBigIntType';
+import type { DuckDBBigNumType } from './DuckDBBigNumType';
+import type { DuckDBBitType } from './DuckDBBitType';
+import type { DuckDBBlobType } from './DuckDBBlobType';
+import type { DuckDBBooleanType } from './DuckDBBooleanType';
+import type { DuckDBDateType } from './DuckDBDateType';
+import type { DuckDBDecimalType } from './DuckDBDecimalType';
+import type { DuckDBDoubleType } from './DuckDBDoubleType';
+import type { DuckDBEnumType } from './DuckDBEnumType';
+import type { DuckDBFloatType } from './DuckDBFloatType';
+import type { DuckDBGeometryType } from './DuckDBGeometryType';
+import type { DuckDBHugeIntType } from './DuckDBHugeIntType';
+import type { DuckDBIntegerLiteralType } from './DuckDBIntegerLiteralType';
+import type { DuckDBIntegerType } from './DuckDBIntegerType';
+import type { DuckDBIntervalType } from './DuckDBIntervalType';
+import type { DuckDBListType } from './DuckDBListType';
+import type { DuckDBMapType } from './DuckDBMapType';
+import type { DuckDBSQLNullType } from './DuckDBSQLNullType';
+import type { DuckDBSmallIntType } from './DuckDBSmallIntType';
+import type { DuckDBStringLiteralType } from './DuckDBStringLiteralType';
+import type { DuckDBStructType } from './DuckDBStructType';
+import type { DuckDBTimeNSType } from './DuckDBTimeNSType';
+import type { DuckDBTimeTZType } from './DuckDBTimeTZType';
+import type { DuckDBTimeType } from './DuckDBTimeType';
+import type { DuckDBTimestampMillisecondsType } from './DuckDBTimestampMillisecondsType';
+import type { DuckDBTimestampNanosecondsType } from './DuckDBTimestampNanosecondsType';
+import type { DuckDBTimestampSecondsType } from './DuckDBTimestampSecondsType';
+import type { DuckDBTimestampTZType } from './DuckDBTimestampTZType';
+import type { DuckDBTimestampTZNanosecondsType } from './DuckDBTimestampTZNanosecondsType';
+import type { DuckDBTimestampType } from './DuckDBTimestampType';
+import type { DuckDBTinyIntType } from './DuckDBTinyIntType';
+import type { DuckDBUnionType } from './DuckDBUnionType';
+import type { DuckDBUBigIntType } from './DuckDBUBigIntType';
+import type { DuckDBUHugeIntType } from './DuckDBUHugeIntType';
+import type { DuckDBUIntegerType } from './DuckDBUIntegerType';
+import type { DuckDBUSmallIntType } from './DuckDBUSmallIntType';
+import type { DuckDBUTinyIntType } from './DuckDBUTinyIntType';
+import type { DuckDBUUIDType } from './DuckDBUUIDType';
+import type { DuckDBVarCharType } from './DuckDBVarCharType';
+import type { DuckDBVariantType } from './DuckDBVariantType';
+export type DuckDBType = DuckDBBooleanType | DuckDBTinyIntType | DuckDBSmallIntType | DuckDBIntegerType | DuckDBBigIntType | DuckDBUTinyIntType | DuckDBUSmallIntType | DuckDBUIntegerType | DuckDBUBigIntType | DuckDBFloatType | DuckDBDoubleType | DuckDBTimestampType | DuckDBDateType | DuckDBTimeType | DuckDBIntervalType | DuckDBHugeIntType | DuckDBUHugeIntType | DuckDBVarCharType | DuckDBBlobType | DuckDBDecimalType | DuckDBTimestampSecondsType | DuckDBTimestampMillisecondsType | DuckDBTimestampNanosecondsType | DuckDBEnumType | DuckDBListType | DuckDBStructType | DuckDBMapType | DuckDBArrayType | DuckDBUUIDType | DuckDBUnionType | DuckDBBitType | DuckDBTimeTZType | DuckDBTimestampTZType | DuckDBAnyType | DuckDBBigNumType | DuckDBSQLNullType | DuckDBStringLiteralType | DuckDBIntegerLiteralType | DuckDBTimeNSType | DuckDBGeometryType | DuckDBVariantType | DuckDBTimestampTZNanosecondsType;

package/lib/types/DuckDBType.js

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

package/lib/types/DuckDBUBigIntType.d.ts

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

package/lib/types/DuckDBUBigIntType.js

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

package/lib/types/DuckDBUHugeIntType.d.ts

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

package/lib/types/DuckDBUHugeIntType.js

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

package/lib/types/DuckDBUIntegerType.d.ts

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

package/lib/types/DuckDBUIntegerType.js

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

package/lib/types/DuckDBUSmallIntType.d.ts

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

package/lib/types/DuckDBUSmallIntType.js

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

package/lib/types/DuckDBUTinyIntType.d.ts

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

package/lib/types/DuckDBUTinyIntType.js

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

package/lib/types/DuckDBUUIDType.d.ts

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

package/lib/types/DuckDBUUIDType.js

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