@motherduck/wasm-client 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motherduck/wasm-client",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Client library for MotherDuck-enabled DuckDB powered by WebAssembly (WASM)",
   "browser": "index.js",
   "types": "types/index.d.ts",
@@ -15,7 +15,7 @@
     }
   },
   "peerDependencies": {
-    "apache-arrow": "^15.0.0"
+    "apache-arrow": "^16.0.0"
   },
   "scripts": {}
 }

package/types/DuckDBInstance.d.ts

@@ -0,0 +1,3 @@
+import { AsyncDuckDB } from '@duckdb/duckdb-wasm';
+export declare function getDuckDBInstance(): Promise<AsyncDuckDB> | AsyncDuckDB | null;
+export declare function setDuckDBInstance(instance: Promise<AsyncDuckDB> | AsyncDuckDB): void;

package/types/{api.d.ts → MDConnection.d.ts}

@@ -1,7 +1,7 @@
-import { ScriptTokens, /*StreamToTableOptions,*/ TokenType } from '@duckdb/duckdb-wasm';
-import { MaterializedQueryResult, SafeQueryResult, StreamingQueryResult } from './QueryTypes';
-import { MDConnectionParams } from './duckdb/worker_factory';
-export { ScriptTokens, /*StreamToTableOptions,*/ TokenType };
+import { AsyncPreparedStatement, ScriptTokens, TokenType } from '@duckdb/duckdb-wasm';
+import { MDConnectionParams } from './MDConnectionParams';
+import { MaterializedQueryResult, SafePrepareResult, SafeQueryResult, StreamingQueryResult } from './QueryTypes';
+export { ScriptTokens, TokenType };
 export declare class MDConnection {
     readonly params: MDConnectionParams;
     private deferredDdbConnection;
@@ -17,11 +17,13 @@ export declare class MDConnection {
     tokenize(text: string): Promise<ScriptTokens>;
     incompleteQueryCount(): number;
     enqueueQuery(query: string, args?: any[]): string;
+    safePrepareQuery(query: string): Promise<SafePrepareResult>;
     safeEvaluateQuery(query: string): Promise<SafeQueryResult<MaterializedQueryResult>>;
     safeEvaluatePreparedStatement(query: string, ...args: any[]): Promise<SafeQueryResult<MaterializedQueryResult>>;
     safeEvaluateStreamingQuery(query: string): Promise<SafeQueryResult<StreamingQueryResult>>;
     safeEvaluateStreamingPreparedStatement(query: string, args: any[]): Promise<SafeQueryResult<StreamingQueryResult>>;
     safeEvaluateQueuedQuery(queryId: string): Promise<SafeQueryResult<MaterializedQueryResult>>;
+    prepareQuery(query: string): Promise<AsyncPreparedStatement>;
     evaluateQuery(query: string): Promise<MaterializedQueryResult>;
     evaluatePreparedStatement(query: string, args: any[]): Promise<MaterializedQueryResult>;
     evaluateStreamingQuery(query: string): Promise<StreamingQueryResult>;

package/types/MDConnectionParams.d.ts

@@ -0,0 +1,11 @@
+import { LogSink } from './LogSink';
+export interface MDConnectionParams {
+    mdToken: string;
+    mdServerURL?: string;
+    duckDBAssetsURLPrefix?: string;
+    useDuckDBWasmCOI?: boolean;
+    logSink?: LogSink;
+    skipWelcomePack?: boolean;
+    version?: string;
+    enableDebugLogging?: boolean;
+}

package/types/QueryTypes.d.ts

@@ -1,8 +1,7 @@
-import { AsyncRecordBatchStreamReader } from 'apache-arrow';
-import { TypedTypeMap } from './arrow/TypedTypeMap';
-import { AsyncDuckDBDataBatchIterator } from './duckdb/AsyncDuckDBDataBatchIterator';
-import { DuckDBData } from './duckdb/DuckDBData';
-import { DuckDBDataReader } from './duckdb/DuckDBDataReader';
+import { AsyncPreparedStatement } from '@duckdb/duckdb-wasm';
+import { TypedTypeMap } from './motherduck/duckdb-arrow';
+import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataReader } from './motherduck/duckdb-data';
+import { AsyncRecordBatchStreamReader, DataType } from 'apache-arrow';
 export interface MaterializedQueryResult {
     type: 'materialized';
     startTimeMs: number;
@@ -45,3 +44,16 @@ export interface QueryError {
     err: Error;
 }
 export type SafeQueryResult<T extends QueryResult> = QuerySuccess<T> | QueryError;
+export type PrepareSuccess<T extends {
+    [key: string]: DataType;
+} = any> = {
+    status: 'success';
+    preparedStatement: AsyncPreparedStatement<T>;
+};
+export type PrepareError = {
+    status: 'error';
+    err: Error;
+};
+export type SafePrepareResult<T extends {
+    [key: string]: DataType;
+} = any> = PrepareSuccess<T> | PrepareError;

package/types/TaskSequencer.d.ts

@@ -1,3 +1,4 @@
+import 'core-js/actual/promise/with-resolvers';
 import { LogSink } from './LogSink';
 /**
  * Represents a task that can be sequenced by TaskSequencer.

package/types/createDuckDbConnection.d.ts

@@ -0,0 +1,3 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { MDConnectionParams } from './MDConnectionParams';
+export declare function createDuckDbConnection(params: MDConnectionParams): Promise<AsyncDuckDBConnection>;

package/types/fetchDuckDBAssets.d.ts

@@ -0,0 +1,17 @@
+export declare function fetchDuckDBAssets(duckDBAssetsURLPrefix: string, version?: string): Promise<{
+    coi?: {
+        mainModule: string;
+        mainWorker: string;
+        pthreadWorker: string;
+    };
+    mvp?: {
+        mainModule: string;
+        mainWorker: string;
+        pthreadWorker: undefined;
+    };
+    eh?: {
+        mainModule: string;
+        mainWorker: string;
+        pthreadWorker: undefined;
+    };
+}>;

package/types/fetchVersion.d.ts

@@ -0,0 +1 @@
+export declare function fetchVersion(duckDBAssetsURLPrefix: string): Promise<string | undefined>;

package/types/genConnectionId.d.ts

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

package/types/getAsyncDuckDb.d.ts

@@ -0,0 +1,3 @@
+import { AsyncDuckDB } from '@duckdb/duckdb-wasm';
+import { MDConnectionParams } from './MDConnectionParams';
+export declare function getAsyncDuckDb(params: MDConnectionParams): Promise<AsyncDuckDB>;

package/types/getDuckDBBundlesFromDuckDBAssets.d.ts

@@ -0,0 +1,2 @@
+import { DuckDBBundles } from '@duckdb/duckdb-wasm';
+export declare function getDuckDBBundlesFromDuckDBAssets(duckDBAssetsURLPrefix: string, version: string | undefined, includeCOI: boolean | undefined): Promise<DuckDBBundles>;

package/types/getVersionSuffix.d.ts

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

package/types/index.d.ts

@@ -1,11 +1,11 @@
-export * from '@motherduck/duckdb-types';
+export { TypedTypeMap } from './motherduck/duckdb-arrow';
+export * from './motherduck/duckdb-data';
+export * from './motherduck/duckdb-types';
+export * from './motherduck/duckdb-values';
+export { MotherDuckCatalogChangeEvent, MotherDuckCatalogChangeEventDetail, MotherDuckEvent, MotherDuckEventBase, MotherDuckEventType } from './motherduck/wasm-extension';
+export * from './getAsyncDuckDb';
+export * from './MDConnection';
+export * from './MDConnectionParams';
 export * from './QueryTypes';
-export * from './api';
-export * from './arrow/TypedTypeMap';
-export * from './duckdb/AsyncDuckDBDataBatchIterator';
-export * from './duckdb/DuckDBData';
-export * from './duckdb/DuckDBDataReader';
-export * from './duckdb/DuckDBRow';
-export * from './duckdb/files';
-export * from './duckdb/values';
-export { CATALOG_CHANGE_EVENT, MDConnectionParams, getAsyncDuckDb } from './duckdb/worker_factory';
+export * from './readLocalFS';
+export * from './registerFiles';

package/types/instantiateDB.d.ts

@@ -0,0 +1,2 @@
+import { MDConnectionParams } from './MDConnectionParams';
+export declare function instantiateDB(params: MDConnectionParams): Promise<import("@duckdb/duckdb-wasm").AsyncDuckDB>;

package/types/{arrow → motherduck/duckdb-arrow}/AsyncDuckDBRecordBatchIterator.d.ts

@@ -1,7 +1,6 @@
 import { RecordBatch } from 'apache-arrow';
-import { AsyncDuckDBDataBatchIterator, DuckDBDataBatchIteratorResult } from '../duckdb/AsyncDuckDBDataBatchIterator';
-import { DuckDBData } from '../duckdb/DuckDBData';
-import { TypedTypeMap } from './TypedTypeMap';
+import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataBatchIteratorResult } from '@motherduck/duckdb-data';
+import { TypedTypeMap } from './TypedTypeMap.js';
 export type AsyncRecordBatchIterator = AsyncIterator<RecordBatch<TypedTypeMap>, RecordBatch<TypedTypeMap> | undefined>;
 export declare class AsyncDuckDBRecordBatchIterator implements AsyncDuckDBDataBatchIterator {
     private recordBatchIterator;

package/types/{arrow → motherduck/duckdb-arrow}/DuckDBRecordBatch.d.ts

@@ -1,8 +1,8 @@
+import { DuckDBData } from '@motherduck/duckdb-data';
 import { DuckDBType } from '@motherduck/duckdb-types';
+import { DuckDBValue } from '@motherduck/duckdb-values';
 import { RecordBatch } from 'apache-arrow';
-import { DuckDBData } from '../duckdb/DuckDBData';
-import { DuckDBValue } from '../duckdb/values';
-import { TypedTypeMap } from './TypedTypeMap';
+import { TypedTypeMap } from './TypedTypeMap.js';
 export declare class DuckDBRecordBatch extends DuckDBData {
     private recordBatch;
     constructor(recordBatch: RecordBatch<TypedTypeMap>);

package/types/{arrow → motherduck/duckdb-arrow}/duckDBTypeFromArrowType.d.ts

@@ -1,4 +1,4 @@
 import { DuckDBType } from '@motherduck/duckdb-types';
 import { DataType, Type } from 'apache-arrow';
-import { TypedTypeMap } from './TypedTypeMap';
+import { TypedTypeMap } from './TypedTypeMap.js';
 export declare function duckDBTypeFromArrowType(type: DataType<Type, TypedTypeMap>): DuckDBType;

package/types/{arrow → motherduck/duckdb-arrow}/duckDBValueFromArrowData.d.ts

@@ -1,6 +1,6 @@
+import { DuckDBValue } from '@motherduck/duckdb-values';
 import { Data, DataType, Type } from 'apache-arrow';
-import { DuckDBValue } from '../duckdb/values';
-import { TypedTypeMap } from './TypedTypeMap';
+import { TypedTypeMap } from './TypedTypeMap.js';
 type ArrowDataType = DataType<Type, TypedTypeMap>;
 type ArrowData = Data<ArrowDataType>;
 export declare function duckDBValueFromArrowData(data: ArrowData, rowIndex: number): DuckDBValue;

package/types/motherduck/duckdb-arrow/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AsyncDuckDBRecordBatchIterator.js';
+export * from './TypedTypeMap.js';

package/types/{duckdb → motherduck/duckdb-data}/AsyncDuckDBDataBatchIterator.d.ts

@@ -1,3 +1,3 @@
-import { DuckDBData } from './DuckDBData';
+import { DuckDBData } from './DuckDBData.js';
 export type DuckDBDataBatchIteratorResult = IteratorResult<DuckDBData, DuckDBData | undefined>;
 export type AsyncDuckDBDataBatchIterator = AsyncIterator<DuckDBData, DuckDBData | undefined>;

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

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

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

@@ -1,7 +1,7 @@
 import { DuckDBType } from '@motherduck/duckdb-types';
-import { AsyncDuckDBDataBatchIterator } from './AsyncDuckDBDataBatchIterator';
-import { DuckDBData } from './DuckDBData';
-import { DuckDBValue } from './values';
+import { DuckDBValue } from '@motherduck/duckdb-values';
+import { AsyncDuckDBDataBatchIterator } from './AsyncDuckDBDataBatchIterator.js';
+import { DuckDBData } from './DuckDBData.js';
 /**
  * A result set that can be read incrementally.
  *

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

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

package/types/motherduck/duckdb-data/MemoryDuckDBData.d.ts

@@ -0,0 +1,16 @@
+import { DuckDBType } from '@motherduck/duckdb-types';
+import { DuckDBValue } from '@motherduck/duckdb-values';
+import { DuckDBData } from './DuckDBData.js';
+export declare class MemoryDuckDBData extends DuckDBData {
+    private columns;
+    private values;
+    constructor(columns: {
+        name: string;
+        type: DuckDBType;
+    }[], values: DuckDBValue[][]);
+    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/index.d.ts

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

package/types/motherduck/duckdb-types/DuckDBType.d.ts

@@ -0,0 +1,124 @@
+export type StructEntry = {
+    readonly key: string;
+    readonly valueType: DuckDBType;
+};
+export type UnionAlternative = {
+    readonly tag: string;
+    readonly valueType: DuckDBType;
+};
+export type ArrayDuckDBType = {
+    readonly name: 'ARRAY';
+    readonly valueType: DuckDBType;
+    readonly length: number;
+};
+export type BigIntDuckDBType = {
+    readonly name: 'BIGINT';
+};
+export type BitDuckDBType = {
+    readonly name: 'BIT';
+};
+export type BooleanDuckDBType = {
+    readonly name: 'BOOLEAN';
+};
+export type BlobDuckDBType = {
+    readonly name: 'BLOB';
+};
+export type DateDuckDBType = {
+    readonly name: 'DATE';
+};
+export type DoubleDuckDBType = {
+    readonly name: 'DOUBLE';
+};
+export type DecimalDuckDBType = {
+    readonly name: 'DECIMAL';
+    readonly width?: number;
+    readonly scale?: number;
+};
+export type EnumDuckDBType = {
+    readonly name: 'ENUM';
+};
+export type HugeIntDuckDBType = {
+    readonly name: 'HUGEINT';
+};
+export type IntegerDuckDBType = {
+    readonly name: 'INTEGER';
+};
+export type IntervalDuckDBType = {
+    readonly name: 'INTERVAL';
+};
+export type ListDuckDBType = {
+    readonly name: 'LIST';
+    readonly valueType: DuckDBType;
+};
+export type MapDuckDBType = {
+    readonly name: 'MAP';
+    readonly keyType: DuckDBType;
+    readonly valueType: DuckDBType;
+};
+export type RealDuckDBType = {
+    readonly name: 'REAL';
+};
+export type SmallIntDuckDBType = {
+    readonly name: 'SMALLINT';
+};
+export type SQLNullDuckDBType = {
+    readonly name: 'SQLNULL';
+};
+export type StructDuckDBType = {
+    readonly name: 'STRUCT';
+    readonly entries: readonly StructEntry[];
+};
+export type TimeDuckDBType = {
+    readonly name: 'TIME';
+};
+export type TimeWithTimeZoneDuckDBType = {
+    readonly name: 'TIME_TZ';
+};
+export type TimestampDuckDBType = {
+    readonly name: 'TIMESTAMP';
+};
+export type TimestampSecondsDuckDBType = {
+    readonly name: 'TIMESTAMP_S';
+};
+export type TimestampMillisecondsDuckDBType = {
+    readonly name: 'TIMESTAMP_MS';
+};
+export type TimestampNanosecondsDuckDBType = {
+    readonly name: 'TIMESTAMP_NS';
+};
+export type TimestampWithTimeZoneDuckDBType = {
+    readonly name: 'TIMESTAMP_TZ';
+};
+export type TinyIntDuckDBType = {
+    readonly name: 'TINYINT';
+};
+export type UBigIntDuckDBType = {
+    readonly name: 'UBIGINT';
+};
+export type UIntegerDuckDBType = {
+    readonly name: 'UINTEGER';
+};
+export type USmallIntDuckDBType = {
+    readonly name: 'USMALLINT';
+};
+export type UTinyIntDuckDBType = {
+    readonly name: 'UTINYINT';
+};
+export type UUIDDuckDBType = {
+    readonly name: 'UUID';
+};
+export type UnionDuckDBType = {
+    readonly name: 'UNION';
+    readonly alternatives: readonly UnionAlternative[];
+};
+export type VarCharDuckDBType = {
+    readonly name: 'VARCHAR';
+    readonly length?: number;
+};
+export type GeometryDuckDBType = {
+    readonly name: 'GEOMETRY';
+};
+export type WKBBlobDuckDBType = {
+    readonly name: 'WKB_BLOB';
+};
+export type DuckDBType = ArrayDuckDBType | BigIntDuckDBType | BitDuckDBType | BooleanDuckDBType | BlobDuckDBType | DateDuckDBType | DoubleDuckDBType | DecimalDuckDBType | EnumDuckDBType | HugeIntDuckDBType | IntegerDuckDBType | IntervalDuckDBType | ListDuckDBType | MapDuckDBType | RealDuckDBType | SmallIntDuckDBType | SQLNullDuckDBType | StructDuckDBType | TimeDuckDBType | TimeWithTimeZoneDuckDBType | TimestampDuckDBType | TimestampSecondsDuckDBType | TimestampMillisecondsDuckDBType | TimestampNanosecondsDuckDBType | TimestampWithTimeZoneDuckDBType | TinyIntDuckDBType | UBigIntDuckDBType | UIntegerDuckDBType | USmallIntDuckDBType | UTinyIntDuckDBType | UUIDDuckDBType | UnionDuckDBType | VarCharDuckDBType | GeometryDuckDBType | WKBBlobDuckDBType;

package/types/motherduck/duckdb-types/DuckDBTypes.d.ts

@@ -0,0 +1,43 @@
+import { ArrayDuckDBType, BigIntDuckDBType, BitDuckDBType, BlobDuckDBType, BooleanDuckDBType, DateDuckDBType, DecimalDuckDBType, DoubleDuckDBType, DuckDBType, EnumDuckDBType, GeometryDuckDBType, HugeIntDuckDBType, IntegerDuckDBType, IntervalDuckDBType, ListDuckDBType, MapDuckDBType, RealDuckDBType, SQLNullDuckDBType, SmallIntDuckDBType, StructDuckDBType, StructEntry, TimeDuckDBType, TimeWithTimeZoneDuckDBType, TimestampDuckDBType, TimestampMillisecondsDuckDBType, TimestampNanosecondsDuckDBType, TimestampSecondsDuckDBType, TimestampWithTimeZoneDuckDBType, TinyIntDuckDBType, UBigIntDuckDBType, UIntegerDuckDBType, USmallIntDuckDBType, UTinyIntDuckDBType, UUIDDuckDBType, UnionAlternative, UnionDuckDBType, VarCharDuckDBType, WKBBlobDuckDBType } from './DuckDBType.js';
+export declare class DuckDBTypes {
+    private constructor();
+    static ARRAY(valueType: DuckDBType, length: number): ArrayDuckDBType;
+    static BIGINT: BigIntDuckDBType;
+    static BIT: BitDuckDBType;
+    static BOOLEAN: BooleanDuckDBType;
+    static BLOB: BlobDuckDBType;
+    static DATE: DateDuckDBType;
+    static DOUBLE: DoubleDuckDBType;
+    private static default_DECIMAL;
+    static DECIMAL(width?: number, scale?: number): DecimalDuckDBType;
+    static ENUM: EnumDuckDBType;
+    static GEOMETRY: GeometryDuckDBType;
+    static HUGEINT: HugeIntDuckDBType;
+    static INTEGER: IntegerDuckDBType;
+    static INTERVAL: IntervalDuckDBType;
+    static LIST(valueType: DuckDBType): ListDuckDBType;
+    static MAP(keyType: DuckDBType, valueType: DuckDBType): MapDuckDBType;
+    static REAL: RealDuckDBType;
+    static SMALLINT: SmallIntDuckDBType;
+    static SQLNULL: SQLNullDuckDBType;
+    static STRUCT(entries: readonly StructEntry[]): StructDuckDBType;
+    static STRUCT_entry(key: string, valueType: DuckDBType): StructEntry;
+    static TIME: TimeDuckDBType;
+    static TIME_TZ: TimeWithTimeZoneDuckDBType;
+    static TIMESTAMP: TimestampDuckDBType;
+    static TIMESTAMP_S: TimestampSecondsDuckDBType;
+    static TIMESTAMP_MS: TimestampMillisecondsDuckDBType;
+    static TIMESTAMP_NS: TimestampNanosecondsDuckDBType;
+    static TIMESTAMP_TZ: TimestampWithTimeZoneDuckDBType;
+    static TINYINT: TinyIntDuckDBType;
+    static UBIGINT: UBigIntDuckDBType;
+    static UINTEGER: UIntegerDuckDBType;
+    static USMALLINT: USmallIntDuckDBType;
+    static UTINYINT: UTinyIntDuckDBType;
+    static UUID: UUIDDuckDBType;
+    static UNION(alternatives: readonly UnionAlternative[]): UnionDuckDBType;
+    static UNION_alternative(tag: string, valueType: DuckDBType): UnionAlternative;
+    static VARCHAR: VarCharDuckDBType;
+    static VARCHAR_withLength(length: number): VarCharDuckDBType;
+    static WKB_BLOB: WKBBlobDuckDBType;
+}

package/types/motherduck/duckdb-types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DuckDBType.js';
+export { DuckDBTypes } from './DuckDBTypes.js';
+export { parseLogicalTypeString } from './parseLogicalTypeString.js';

package/types/motherduck/duckdb-types/parseLogicalTypeString.d.ts

@@ -0,0 +1,2 @@
+import { DuckDBType } from './DuckDBType.js';
+export declare function parseLogicalTypeString(typeString: string): DuckDBType;

package/types/motherduck/duckdb-values/DuckDBArray.d.ts

@@ -0,0 +1,7 @@
+import { DuckDBValue } from './DuckDBValue.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBArray extends SpecialDuckDBValue {
+    readonly values: readonly DuckDBValue[];
+    constructor(values: readonly DuckDBValue[]);
+    toDuckDBString(): string;
+}

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBBlob extends SpecialDuckDBValue {
     readonly bytes: Uint8Array;
     constructor(bytes: Uint8Array);

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBDate extends SpecialDuckDBValue {
     readonly days: number;
     constructor(days: number);

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

@@ -1,5 +1,5 @@
-import { DuckDBDecimalFormatOptions } from '../conversion/stringFromDecimal';
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { DuckDBDecimalFormatOptions } from './conversion/stringFromDecimal.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBDecimal extends SpecialDuckDBValue {
     readonly scaledValue: bigint;
     readonly scale: number;

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBInterval extends SpecialDuckDBValue {
     readonly months: number;
     readonly days: number;

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

@@ -1,5 +1,5 @@
-import { DuckDBValue } from './DuckDBValue';
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { DuckDBValue } from './DuckDBValue.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBList extends SpecialDuckDBValue {
     readonly values: readonly DuckDBValue[];
     constructor(values: readonly DuckDBValue[]);

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

@@ -1,5 +1,5 @@
-import { DuckDBMapEntry } from './DuckDBMapEntry';
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { DuckDBMapEntry } from './DuckDBMapEntry.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBMap extends SpecialDuckDBValue {
     readonly entries: readonly DuckDBMapEntry[];
     constructor(entries: readonly DuckDBMapEntry[]);

package/types/{duckdb/values → motherduck/duckdb-values}/DuckDBMapEntry.d.ts

@@ -1,4 +1,4 @@
-import { DuckDBValue } from './DuckDBValue';
+import { DuckDBValue } from './DuckDBValue.js';
 export interface DuckDBMapEntry {
     readonly key: DuckDBValue;
     readonly value: DuckDBValue;

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

@@ -1,5 +1,5 @@
-import { DuckDBStructEntry } from './DuckDBStructEntry';
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { DuckDBStructEntry } from './DuckDBStructEntry.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBStruct extends SpecialDuckDBValue {
     readonly entries: readonly DuckDBStructEntry[];
     constructor(entries: readonly DuckDBStructEntry[]);

package/types/{duckdb/values → motherduck/duckdb-values}/DuckDBStructEntry.d.ts

@@ -1,4 +1,4 @@
-import { DuckDBValue } from './DuckDBValue';
+import { DuckDBValue } from './DuckDBValue.js';
 export interface DuckDBStructEntry {
     readonly key: string;
     readonly value: DuckDBValue;

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBTime extends SpecialDuckDBValue {
     readonly microseconds: bigint;
     constructor(microseconds: bigint);

package/types/{duckdb/values → motherduck/duckdb-values}/DuckDBTimestampMicroseconds.d.ts

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBTimestampMicroseconds extends SpecialDuckDBValue {
     readonly microseconds: bigint;
     readonly timezone: string | null | undefined;

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBTimestampMilliseconds extends SpecialDuckDBValue {
     readonly milliseconds: bigint;
     constructor(milliseconds: bigint);

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

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBTimestampNanoseconds extends SpecialDuckDBValue {
     readonly nanoseconds: bigint;
     constructor(nanoseconds: bigint);

package/types/{duckdb/values → motherduck/duckdb-values}/DuckDBTimestampSeconds.d.ts

@@ -1,4 +1,4 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export declare class DuckDBTimestampSeconds extends SpecialDuckDBValue {
     readonly seconds: bigint;
     constructor(seconds: bigint);

package/types/{duckdb/values → motherduck/duckdb-values}/DuckDBValue.d.ts

@@ -1,2 +1,2 @@
-import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
 export type DuckDBValue = null | boolean | number | string | bigint | SpecialDuckDBValue;

package/types/{duckdb → motherduck/duckdb-values}/conversion/displayStringForDuckDBValue.d.ts

@@ -1,2 +1,2 @@
-import { DuckDBValue } from '../values/DuckDBValue';
+import { DuckDBValue } from '../DuckDBValue.js';
 export declare function displayStringForDuckDBValue(value: DuckDBValue): string;

package/types/motherduck/duckdb-values/index.d.ts

@@ -0,0 +1,17 @@
+export { DuckDBArray } from './DuckDBArray.js';
+export { DuckDBBlob } from './DuckDBBlob.js';
+export { DuckDBDate } from './DuckDBDate.js';
+export { DuckDBDecimal } from './DuckDBDecimal.js';
+export { DuckDBInterval } from './DuckDBInterval.js';
+export { DuckDBList } from './DuckDBList.js';
+export { DuckDBMap } from './DuckDBMap.js';
+export { DuckDBMapEntry } from './DuckDBMapEntry.js';
+export { DuckDBStruct } from './DuckDBStruct.js';
+export { DuckDBStructEntry } from './DuckDBStructEntry.js';
+export { DuckDBTime } from './DuckDBTime.js';
+export { DuckDBTimestampMicroseconds } from './DuckDBTimestampMicroseconds.js';
+export { DuckDBTimestampMilliseconds } from './DuckDBTimestampMilliseconds.js';
+export { DuckDBTimestampNanoseconds } from './DuckDBTimestampNanoseconds.js';
+export { DuckDBTimestampSeconds } from './DuckDBTimestampSeconds.js';
+export { DuckDBValue } from './DuckDBValue.js';
+export { SpecialDuckDBValue } from './SpecialDuckDBValue.js';