@motherduck/wasm-client 0.6.5 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motherduck/wasm-client",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "Client library for MotherDuck-enabled DuckDB powered by WebAssembly (WASM)",
   "browser": "index.js",
   "types": "types/index.d.ts",

package/types/@duckdb/data-reader/ColumnFilteredDuckDBData.d.ts

@@ -0,0 +1,13 @@
+import { DuckDBType } from '../../@duckdb/data-types';
+import { DuckDBValue } from '../../@duckdb/data-values';
+import { DuckDBData } from './DuckDBData.js';
+export declare class ColumnFilteredDuckDBData extends DuckDBData {
+    private data;
+    private readonly inputColumnIndexForOutputColumnIndex;
+    constructor(data: DuckDBData, columnVisibility: readonly boolean[]);
+    get columnCount(): number;
+    get rowCount(): number;
+    columnName(columnIndex: number): string;
+    columnType(columnIndex: number): DuckDBType;
+    value(columnIndex: number, rowIndex: number): DuckDBValue;
+}

package/types/{motherduck/duckdb-data → @duckdb/data-reader}/DuckDBData.d.ts

@@ -1,5 +1,5 @@
-import { DuckDBType } from '../../motherduck/duckdb-types';
-import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { DuckDBType } from '../../@duckdb/data-types';
+import { DuckDBValue } from '../../@duckdb/data-values';
 import { DuckDBRow } from './DuckDBRow.js';
 /**
  * A two-dimensional table of data along with column metadata.

package/types/{motherduck/duckdb-data → @duckdb/data-reader}/DuckDBDataReader.d.ts

@@ -1,5 +1,5 @@
-import { DuckDBType } from '../../motherduck/duckdb-types';
-import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { DuckDBType } from '../../@duckdb/data-types';
+import { DuckDBValue } from '../../@duckdb/data-values';
 import { AsyncDuckDBDataBatchIterator } from './AsyncDuckDBDataBatchIterator.js';
 import { DuckDBData } from './DuckDBData.js';
 /**

package/types/{motherduck/duckdb-data → @duckdb/data-reader}/DuckDBRow.d.ts

@@ -1,4 +1,4 @@
-import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { DuckDBValue } from '../../@duckdb/data-values';
 export interface DuckDBRow {
     readonly [columnName: string]: DuckDBValue;
 }

package/types/{motherduck/duckdb-data → @duckdb/data-reader}/MemoryDuckDBData.d.ts

@@ -1,5 +1,5 @@
-import { DuckDBType } from '../../motherduck/duckdb-types';
-import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { DuckDBType } from '../../@duckdb/data-types';
+import { DuckDBValue } from '../../@duckdb/data-values';
 import { DuckDBData } from './DuckDBData.js';
 export declare class MemoryDuckDBData extends DuckDBData {
     private columns;

package/types/{motherduck/duckdb-data → @duckdb/data-reader}/index.d.ts

@@ -1,4 +1,5 @@
 export * from './AsyncDuckDBDataBatchIterator.js';
+export * from './ColumnFilteredDuckDBData.js';
 export * from './DuckDBData.js';
 export * from './DuckDBDataReader.js';
 export * from './DuckDBRow.js';

package/types/@duckdb/data-types/DuckDBType.d.ts

@@ -0,0 +1,324 @@
+import { Json } from '../../@duckdb/data-values';
+import { DuckDBTypeId } from './DuckDBTypeId.js';
+export interface DuckDBTypeToStringOptions {
+    short?: boolean;
+}
+export declare abstract class BaseDuckDBType<T extends DuckDBTypeId> {
+    readonly typeId: T;
+    readonly alias?: string;
+    protected constructor(typeId: T, alias?: string);
+    toString(_options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare class DuckDBBooleanType extends BaseDuckDBType<DuckDBTypeId.BOOLEAN> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBooleanType;
+    static create(alias?: string): DuckDBBooleanType;
+}
+export declare const BOOLEAN: DuckDBBooleanType;
+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;
+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;
+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;
+export declare class DuckDBBigIntType extends BaseDuckDBType<DuckDBTypeId.BIGINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBigIntType;
+    static create(alias?: string): DuckDBBigIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const BIGINT: DuckDBBigIntType;
+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;
+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;
+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;
+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;
+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;
+export declare class DuckDBDoubleType extends BaseDuckDBType<DuckDBTypeId.DOUBLE> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBDoubleType;
+    static create(alias?: string): DuckDBDoubleType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const DOUBLE: DuckDBDoubleType;
+export declare class DuckDBTimestampType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampType;
+    static create(alias?: string): DuckDBTimestampType;
+}
+export declare const TIMESTAMP: DuckDBTimestampType;
+export type DuckDBTimestampMicrosecondsType = DuckDBTimestampType;
+export declare const DuckDBTimestampMicrosecondsType: typeof DuckDBTimestampType;
+export declare class DuckDBDateType extends BaseDuckDBType<DuckDBTypeId.DATE> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBDateType;
+    static create(alias?: string): DuckDBDateType;
+}
+export declare const DATE: DuckDBDateType;
+export declare class DuckDBTimeType extends BaseDuckDBType<DuckDBTypeId.TIME> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimeType;
+    static create(alias?: string): DuckDBTimeType;
+}
+export declare const TIME: DuckDBTimeType;
+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;
+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;
+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;
+export declare class DuckDBVarCharType extends BaseDuckDBType<DuckDBTypeId.VARCHAR> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBVarCharType;
+    static create(alias?: string): DuckDBVarCharType;
+}
+export declare const VARCHAR: DuckDBVarCharType;
+export declare class DuckDBBlobType extends BaseDuckDBType<DuckDBTypeId.BLOB> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBlobType;
+    static create(alias?: string): DuckDBBlobType;
+}
+export declare const BLOB: DuckDBBlobType;
+export declare class DuckDBDecimalType extends BaseDuckDBType<DuckDBTypeId.DECIMAL> {
+    readonly width: number;
+    readonly scale: number;
+    constructor(width: number, scale: number, alias?: string);
+    toString(_options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+    static readonly default: DuckDBDecimalType;
+}
+export declare function DECIMAL(width?: number, scale?: number, alias?: string): DuckDBDecimalType;
+export declare class DuckDBTimestampSecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_S> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampSecondsType;
+    static create(alias?: string): DuckDBTimestampSecondsType;
+}
+export declare const TIMESTAMP_S: DuckDBTimestampSecondsType;
+export declare class DuckDBTimestampMillisecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_MS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampMillisecondsType;
+    static create(alias?: string): DuckDBTimestampMillisecondsType;
+}
+export declare const TIMESTAMP_MS: DuckDBTimestampMillisecondsType;
+export declare class DuckDBTimestampNanosecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_NS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampNanosecondsType;
+    static create(alias?: string): DuckDBTimestampNanosecondsType;
+}
+export declare const TIMESTAMP_NS: DuckDBTimestampNanosecondsType;
+export declare class DuckDBEnumType extends BaseDuckDBType<DuckDBTypeId.ENUM> {
+    readonly values: readonly string[];
+    readonly valueIndexes: Readonly<Record<string, number>>;
+    readonly internalTypeId: DuckDBTypeId;
+    constructor(values: readonly string[], internalTypeId: DuckDBTypeId, alias?: string);
+    indexForValue(value: string): number;
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function ENUM8(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM16(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM32(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare class DuckDBListType extends BaseDuckDBType<DuckDBTypeId.LIST> {
+    readonly valueType: DuckDBType;
+    constructor(valueType: DuckDBType, alias?: string);
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function LIST(valueType: DuckDBType, alias?: string): DuckDBListType;
+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;
+    indexForEntry(entryName: string): number;
+    typeForEntry(entryName: string): DuckDBType;
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function STRUCT(entries: Record<string, DuckDBType>, alias?: string): DuckDBStructType;
+export declare class DuckDBMapType extends BaseDuckDBType<DuckDBTypeId.MAP> {
+    readonly keyType: DuckDBType;
+    readonly valueType: DuckDBType;
+    constructor(keyType: DuckDBType, valueType: DuckDBType, alias?: string);
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function MAP(keyType: DuckDBType, valueType: DuckDBType, alias?: string): DuckDBMapType;
+export declare class DuckDBArrayType extends BaseDuckDBType<DuckDBTypeId.ARRAY> {
+    readonly valueType: DuckDBType;
+    readonly length: number;
+    constructor(valueType: DuckDBType, length: number, alias?: string);
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function ARRAY(valueType: DuckDBType, length: number, alias?: string): DuckDBArrayType;
+export declare class DuckDBUUIDType extends BaseDuckDBType<DuckDBTypeId.UUID> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUUIDType;
+    static create(alias?: string): DuckDBUUIDType;
+}
+export declare const UUID: DuckDBUUIDType;
+export declare class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION> {
+    readonly memberTags: readonly string[];
+    readonly tagMemberIndexes: Readonly<Record<string, number>>;
+    readonly memberTypes: readonly DuckDBType[];
+    constructor(memberTags: readonly string[], memberTypes: readonly DuckDBType[], alias?: string);
+    memberIndexForTag(tag: string): number;
+    memberTypeForTag(tag: string): DuckDBType;
+    get memberCount(): number;
+    toString(options?: DuckDBTypeToStringOptions): string;
+    toJson(): Json;
+}
+export declare function UNION(members: Record<string, DuckDBType>, alias?: string): DuckDBUnionType;
+export declare class DuckDBBitType extends BaseDuckDBType<DuckDBTypeId.BIT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBitType;
+    static create(alias?: string): DuckDBBitType;
+}
+export declare const BIT: DuckDBBitType;
+export declare class DuckDBTimeTZType extends BaseDuckDBType<DuckDBTypeId.TIME_TZ> {
+    constructor(alias?: string);
+    toString(options?: DuckDBTypeToStringOptions): string;
+    static readonly instance: DuckDBTimeTZType;
+    static create(alias?: string): DuckDBTimeTZType;
+}
+export declare const TIMETZ: DuckDBTimeTZType;
+export declare class DuckDBTimestampTZType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_TZ> {
+    constructor(alias?: string);
+    toString(options?: DuckDBTypeToStringOptions): string;
+    static readonly instance: DuckDBTimestampTZType;
+    static create(alias?: string): DuckDBTimestampTZType;
+}
+export declare const TIMESTAMPTZ: DuckDBTimestampTZType;
+export declare class DuckDBAnyType extends BaseDuckDBType<DuckDBTypeId.ANY> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBAnyType;
+    static create(alias?: string): DuckDBAnyType;
+}
+export declare const ANY: DuckDBAnyType;
+export declare class DuckDBVarIntType extends BaseDuckDBType<DuckDBTypeId.VARINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBVarIntType;
+    static create(alias?: string): DuckDBVarIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const VARINT: DuckDBVarIntType;
+export declare class DuckDBSQLNullType extends BaseDuckDBType<DuckDBTypeId.SQLNULL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBSQLNullType;
+    static create(alias?: string): DuckDBSQLNullType;
+}
+export declare const SQLNULL: DuckDBSQLNullType;
+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;
+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;
+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 | DuckDBVarIntType | DuckDBSQLNullType | DuckDBStringLiteralType | DuckDBIntegerLiteralType;

package/types/@duckdb/data-types/DuckDBTypeId.d.ts

@@ -0,0 +1,41 @@
+export declare enum DuckDBTypeId {
+    INVALID = 0,
+    BOOLEAN = 1,
+    TINYINT = 2,
+    SMALLINT = 3,
+    INTEGER = 4,
+    BIGINT = 5,
+    UTINYINT = 6,
+    USMALLINT = 7,
+    UINTEGER = 8,
+    UBIGINT = 9,
+    FLOAT = 10,
+    DOUBLE = 11,
+    TIMESTAMP = 12,
+    DATE = 13,
+    TIME = 14,
+    INTERVAL = 15,
+    HUGEINT = 16,
+    UHUGEINT = 32,
+    VARCHAR = 17,
+    BLOB = 18,
+    DECIMAL = 19,
+    TIMESTAMP_S = 20,
+    TIMESTAMP_MS = 21,
+    TIMESTAMP_NS = 22,
+    ENUM = 23,
+    LIST = 24,
+    STRUCT = 25,
+    MAP = 26,
+    ARRAY = 33,
+    UUID = 27,
+    UNION = 28,
+    BIT = 29,
+    TIME_TZ = 30,
+    TIMESTAMP_TZ = 31,
+    ANY = 34,
+    VARINT = 35,
+    SQLNULL = 36,
+    STRING_LITERAL = 37,
+    INTEGER_LITERAL = 38
+}

package/types/@duckdb/data-types/extensionTypes.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBBlobType, DuckDBVarCharType } from './DuckDBType.js';
+export declare const INET: import("./DuckDBType.js").DuckDBStructType;
+export declare const JSONType: DuckDBVarCharType;
+export declare const BOX_2D: import("./DuckDBType.js").DuckDBStructType;
+export declare const BOX_2DF: import("./DuckDBType.js").DuckDBStructType;
+export declare const GEOMETRY: DuckDBBlobType;
+export declare const LINESTRING_2D: import("./DuckDBType.js").DuckDBListType;
+export declare const POINT_2D: import("./DuckDBType.js").DuckDBStructType;
+export declare const POINT_3D: import("./DuckDBType.js").DuckDBStructType;
+export declare const POINT_4D: import("./DuckDBType.js").DuckDBStructType;
+export declare const POLYGON_2D: import("./DuckDBType.js").DuckDBListType;
+export declare const WKB_BLOB: DuckDBBlobType;

package/types/@duckdb/data-types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DuckDBType.js';
+export * from './DuckDBTypeId.js';
+export * from './extensionTypes.js';
+export * from './parseLogicalTypeString.js';

package/types/@duckdb/data-types/sql.d.ts

@@ -0,0 +1,2 @@
+export declare function quotedString(input: string): string;
+export declare function quotedIdentifier(input: string): string;

package/types/{motherduck/duckdb-values/DuckDBList.d.ts → @duckdb/data-values/DuckDBArrayValue.d.ts}

@@ -1,8 +1,10 @@
 import { DuckDBValue } from './DuckDBValue.js';
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBList extends SpecialDuckDBValue {
+export declare class DuckDBArrayValue extends SpecialDuckDBValue {
     readonly values: readonly DuckDBValue[];
     constructor(values: readonly DuckDBValue[]);
     toDuckDBString(): string;
-    toJS(): any[];
+    toSql(): string;
+    toJson(): Json;
 }

package/types/@duckdb/data-values/DuckDBBitValue.d.ts

@@ -0,0 +1,19 @@
+import { Json } from './Json.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBBitValue extends SpecialDuckDBValue {
+    readonly data: Uint8Array;
+    constructor(data: Uint8Array);
+    padding(): number;
+    get length(): number;
+    getBool(index: number): boolean;
+    toBools(): boolean[];
+    getBit(index: number): 0 | 1;
+    toBits(): number[];
+    toDuckDBString(): string;
+    toSql(): string;
+    toJson(): Json;
+    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;
+}

package/types/{motherduck/duckdb-values/DuckDBBlob.d.ts → @duckdb/data-values/DuckDBBlobValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBBlob extends SpecialDuckDBValue {
+export declare class DuckDBBlobValue extends SpecialDuckDBValue {
     readonly bytes: Uint8Array;
     constructor(bytes: Uint8Array);
     toDuckDBString(): string;
-    toJS(): Uint8Array;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBDate.d.ts → @duckdb/data-values/DuckDBDateValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBDate extends SpecialDuckDBValue {
+export declare class DuckDBDateValue extends SpecialDuckDBValue {
     readonly days: number;
     constructor(days: number);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBDecimal.d.ts → @duckdb/data-values/DuckDBDecimalValue.d.ts}

@@ -1,11 +1,13 @@
 import { DuckDBDecimalFormatOptions } from './conversion/stringFromDecimal.js';
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBDecimal extends SpecialDuckDBValue {
+export declare class DuckDBDecimalValue extends SpecialDuckDBValue {
     readonly scaledValue: bigint;
     readonly scale: number;
     constructor(scaledValue: bigint, scale: number);
     toDuckDBString(): string;
+    toSql(): string;
     /** Returns a string representation appropriate to the host environment's current locale. */
     toLocaleString(locales?: string | string[], options?: DuckDBDecimalFormatOptions): string;
-    toJS(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBInterval.d.ts → @duckdb/data-values/DuckDBIntervalValue.d.ts}

@@ -1,9 +1,11 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBInterval extends SpecialDuckDBValue {
+export declare class DuckDBIntervalValue extends SpecialDuckDBValue {
     readonly months: number;
     readonly days: number;
     readonly microseconds: bigint;
     constructor(months: number, days: number, microseconds: bigint);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBArray.d.ts → @duckdb/data-values/DuckDBListValue.d.ts}

@@ -1,8 +1,10 @@
 import { DuckDBValue } from './DuckDBValue.js';
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBArray extends SpecialDuckDBValue {
+export declare class DuckDBListValue extends SpecialDuckDBValue {
     readonly values: readonly DuckDBValue[];
     constructor(values: readonly DuckDBValue[]);
     toDuckDBString(): string;
-    toJS(): any[];
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBMap.d.ts → @duckdb/data-values/DuckDBMapValue.d.ts}

@@ -1,8 +1,10 @@
 import { DuckDBMapEntry } from './DuckDBMapEntry.js';
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBMap extends SpecialDuckDBValue {
+export declare class DuckDBMapValue extends SpecialDuckDBValue {
     readonly entries: readonly DuckDBMapEntry[];
     constructor(entries: readonly DuckDBMapEntry[]);
     toDuckDBString(): string;
-    toJS(): Record<string, any>;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBStruct.d.ts → @duckdb/data-values/DuckDBStructValue.d.ts}

@@ -1,8 +1,10 @@
 import { DuckDBStructEntry } from './DuckDBStructEntry.js';
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBStruct extends SpecialDuckDBValue {
+export declare class DuckDBStructValue extends SpecialDuckDBValue {
     readonly entries: readonly DuckDBStructEntry[];
     constructor(entries: readonly DuckDBStructEntry[]);
     toDuckDBString(): string;
-    toJS(): Record<string, any>;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/@duckdb/data-values/DuckDBTimeTZValue.d.ts

@@ -0,0 +1,14 @@
+import { Json } from './Json.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBTimeTZValue extends SpecialDuckDBValue {
+    readonly micros: bigint;
+    readonly offset: number;
+    constructor(micros: bigint, offset: number);
+    toDuckDBString(): string;
+    toSql(): string;
+    toJson(): Json;
+    private static TimeBits;
+    private static OffsetBits;
+    private static MaxOffset;
+    static fromBits(bits: bigint): DuckDBTimeTZValue;
+}

package/types/{motherduck/duckdb-values/DuckDBTime.d.ts → @duckdb/data-values/DuckDBTimeValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBTime extends SpecialDuckDBValue {
+export declare class DuckDBTimeValue extends SpecialDuckDBValue {
     readonly microseconds: bigint;
     constructor(microseconds: bigint);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/@duckdb/data-values/DuckDBTimestampMicrosecondsValue.d.ts

@@ -0,0 +1,10 @@
+import { Json } from './Json.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBTimestampMicrosecondsValue extends SpecialDuckDBValue {
+    readonly microseconds: bigint;
+    constructor(microseconds: bigint);
+    toDuckDBString(): string;
+    toSql(): string;
+    toJson(): Json;
+}
+export type DuckDBTimestamp = DuckDBTimestampMicrosecondsValue;

package/types/{motherduck/duckdb-values/DuckDBTimestampMilliseconds.d.ts → @duckdb/data-values/DuckDBTimestampMillisecondsValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBTimestampMilliseconds extends SpecialDuckDBValue {
+export declare class DuckDBTimestampMillisecondsValue extends SpecialDuckDBValue {
     readonly milliseconds: bigint;
     constructor(milliseconds: bigint);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }

package/types/{motherduck/duckdb-values/DuckDBTimestampNanoseconds.d.ts → @duckdb/data-values/DuckDBTimestampNanosecondsValue.d.ts}

@@ -1,7 +1,9 @@
+import { Json } from './Json.js';
 import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
-export declare class DuckDBTimestampNanoseconds extends SpecialDuckDBValue {
+export declare class DuckDBTimestampNanosecondsValue extends SpecialDuckDBValue {
     readonly nanoseconds: bigint;
     constructor(nanoseconds: bigint);
     toDuckDBString(): string;
-    toJS(): string;
+    toSql(): string;
+    toJson(): Json;
 }