@motherduck/wasm-client 0.4.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@motherduck/wasm-client",
+  "version": "0.4.0",
+  "description": "Client library for MotherDuck-enabled DuckDB powered by WebAssembly (WASM)",
+  "browser": "index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./index.js"
+    },
+    "./with-arrow": {
+      "types": "./types/index.d.ts",
+      "default": "./index_with_arrow.js"
+    }
+  },
+  "peerDependencies": {
+    "apache-arrow": "^14.0.x"
+  },
+  "scripts": {}
+}

package/types/LogSink.d.ts

@@ -0,0 +1,6 @@
+export interface LogSink {
+    debug(message?: any, ...optionalParams: any[]): void;
+    log(message?: any, ...optionalParams: any[]): void;
+    warn(message?: any, ...optionalParams: any[]): void;
+    error(message?: any, ...optionalParams: any[]): void;
+}

package/types/MaterializedQueryTask.d.ts

@@ -0,0 +1,15 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { MaterializedQueryResult } from './QueryTypes';
+import { Task } from './TaskSequencer';
+export declare class MaterializedQueryTask implements Task<MaterializedQueryResult> {
+    private connection;
+    private deferredConnection;
+    private query;
+    private args?;
+    private creationTime;
+    constructor(connection: Promise<AsyncDuckDBConnection>, query: string, args?: any[]);
+    run(initialQueuePosition?: number): Promise<MaterializedQueryResult>;
+    cancel(): Promise<boolean>;
+    private getConnection;
+    private sendQuery;
+}

package/types/QueryTypes.d.ts

@@ -0,0 +1,48 @@
+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';
+export interface MaterializedQueryResult {
+    type: 'materialized';
+    initialQueuePosition?: number;
+    queueTime?: [number, number];
+    executionTime: [number, number];
+    /**
+     * Full result set.
+     *
+     * Includes column metadata, such as types. Supports duplicate column names without renaming.
+     *
+     * See the `DuckDBData` interface for details.
+     */
+    data: DuckDBData;
+}
+export interface StreamingQueryResult {
+    type: 'streaming';
+    /**
+     * Stream of underlying Arrow RecordBatches. Useful if you need results in Arrow format, but note that the conversion
+     * of some value types, especially dates, times, and decimals, to JavaScript types is lossy in some cases, and also
+     * the conversion of several types to string does not match DuckDB's format.
+     */
+    arrowStream: AsyncRecordBatchStreamReader<TypedTypeMap>;
+    /**
+     * Async iterator of DuckDB data batches. DuckDB data batches are similar to Arrow RecordBatches, but expose DuckDB
+     * types and values, preserving full range and precision, and matching DuckDB's format when converted to strings.
+     */
+    dataStream: AsyncDuckDBDataBatchIterator;
+    /**
+     * Convenience wrapper around dataStream. Enables reading DuckDB data up to some row count, and exposes the DuckDBData
+     * interface for accessing all rows read so far (not just one batch).
+     */
+    dataReader: DuckDBDataReader;
+}
+export type QueryResult = MaterializedQueryResult | StreamingQueryResult;
+export interface QuerySuccess<T extends QueryResult> {
+    status: 'success';
+    result: T;
+}
+export interface QueryError {
+    status: 'error';
+    err: Error;
+}
+export type SafeQueryResult<T extends QueryResult> = QuerySuccess<T> | QueryError;

package/types/StreamingQueryTask.d.ts

@@ -0,0 +1,14 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { StreamingQueryResult } from './QueryTypes';
+import { Task } from './TaskSequencer';
+export declare class StreamingQueryTask implements Task<StreamingQueryResult> {
+    private connection;
+    private deferredConnection;
+    private query;
+    private args?;
+    constructor(connection: Promise<AsyncDuckDBConnection>, query: string, args?: any[]);
+    run(): Promise<StreamingQueryResult>;
+    cancel(): Promise<boolean>;
+    private getConnection;
+    private sendQuery;
+}

package/types/TaskSequencer.d.ts

@@ -0,0 +1,56 @@
+import { LogSink } from './LogSink';
+/**
+ * Represents a task that can be sequenced by TaskSequencer.
+ *
+ * Implemented by users of TaskSequencer.
+ */
+export interface Task<T> {
+    /**
+     * Run the task and return a promise for the results.
+     *
+     * The argument `initialQueuePosition` indicates the initial index of this task on the queue when it was first enqueued.
+     * This can be useful for determining whether a task was pending for a significant amount of time.
+     */
+    run: (initialQueuePosition?: number) => Promise<T>;
+    /**
+     * Attempt to cancel a running task, and return a boolean promise indicating whether the attempt was successful.
+     */
+    cancel: () => Promise<boolean>;
+}
+/**
+ * Sequences user-defined Tasks, ensuring only one is running at a given time.
+ * Supports cancellation.
+ */
+export declare class TaskSequencer<T> {
+    private nextTaskId;
+    private queuedTaskIds;
+    private queuedTasksById;
+    private processingQueue;
+    private logSink?;
+    constructor(logSink?: LogSink);
+    /**
+     * Append a task to the queue, and return its unique id.
+     *
+     * The id can be used to get the result (using `taskResult`) or cancel (using `cancelTask`).
+     */
+    enqueueTask(task: Task<T>): string;
+    /**
+     * Attempt to cancel a previously enqueued task.
+     * Returns a boolean promise indicating whether the attempt succeeded.
+     *
+     * In addition to the `taskId` to cancel, takes an optional `errorMessage` to supply to the rejected task promise, if a pending task is cancelled.
+     * If a running task is cancelled, then the task implementation controls the error message in the rejected task promise.
+     */
+    cancelTask(taskId: string, errorMessage?: string): Promise<boolean>;
+    /**
+     * Returns a promise for the result of previously-enqueue task.
+     */
+    taskResult(taskId: string): Promise<T>;
+    private logDebug;
+    private logWarn;
+    private createTaskId;
+    private addQueuedTask;
+    private scheduleProcessQueueIfNeeded;
+    private processQueue;
+    private processFirstQueuedTask;
+}

package/types/api.d.ts

@@ -0,0 +1,32 @@
+import { ScriptTokens, /*StreamToTableOptions,*/ TokenType } from '@duckdb/duckdb-wasm';
+import { MaterializedQueryResult, SafeQueryResult, StreamingQueryResult } from './QueryTypes';
+import { MDConnectionParams } from './duckdb/worker_factory';
+export { ScriptTokens, /*StreamToTableOptions,*/ TokenType };
+export declare class MDConnection {
+    readonly params: MDConnectionParams;
+    private deferredDdbConnection;
+    private sequencer;
+    readonly id: string;
+    static idMap: {
+        [id: string]: MDConnection;
+    };
+    private constructor();
+    static create(params: MDConnectionParams): MDConnection;
+    isInitialized(): Promise<boolean>;
+    static getById(id: string): MDConnection | undefined;
+    tokenize(text: string): Promise<ScriptTokens>;
+    enqueueQuery(query: string, args?: any[]): string;
+    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>>;
+    evaluateQuery(query: string): Promise<MaterializedQueryResult>;
+    evaluatePreparedStatement(query: string, args: any[]): Promise<MaterializedQueryResult>;
+    evaluateStreamingQuery(query: string): Promise<StreamingQueryResult>;
+    evaluateStreamingPreparedStatement(query: string, args: any[]): Promise<StreamingQueryResult>;
+    private evaluateExclusive;
+    evaluateQueuedQuery(queryId: string): Promise<MaterializedQueryResult>;
+    cancelQuery(queryId: string, errorMessage?: string): Promise<boolean>;
+    close(): Promise<void>;
+}

package/types/arrow/AsyncDuckDBRecordBatchIterator.d.ts

@@ -0,0 +1,13 @@
+import { RecordBatch } from 'apache-arrow';
+import { AsyncDuckDBDataBatchIterator, DuckDBDataBatchIteratorResult } from '../duckdb/AsyncDuckDBDataBatchIterator';
+import { DuckDBData } from '../duckdb/DuckDBData';
+import { TypedTypeMap } from './TypedTypeMap';
+export type AsyncRecordBatchIterator = AsyncIterator<RecordBatch<TypedTypeMap>, RecordBatch<TypedTypeMap> | undefined>;
+export declare class AsyncDuckDBRecordBatchIterator implements AsyncDuckDBDataBatchIterator {
+    private recordBatchIterator;
+    constructor(recordBatchIterator: AsyncRecordBatchIterator);
+    next(): Promise<DuckDBDataBatchIteratorResult>;
+    return(value?: DuckDBData): Promise<DuckDBDataBatchIteratorResult>;
+    throw(e?: any): Promise<DuckDBDataBatchIteratorResult>;
+    [Symbol.asyncIterator](): AsyncDuckDBDataBatchIterator;
+}

package/types/arrow/DuckDBRecordBatch.d.ts

@@ -0,0 +1,14 @@
+import { RecordBatch } from 'apache-arrow';
+import { DuckDBData } from '../duckdb/DuckDBData';
+import { DuckDBType } from '../duckdb/types';
+import { DuckDBValue } from '../duckdb/values';
+import { TypedTypeMap } from './TypedTypeMap';
+export declare class DuckDBRecordBatch extends DuckDBData {
+    private recordBatch;
+    constructor(recordBatch: RecordBatch<TypedTypeMap>);
+    get columnCount(): number;
+    get rowCount(): number;
+    columnName(columnIndex: number): string;
+    columnType(columnIndex: number): DuckDBType;
+    value(columnIndex: number, rowIndex: number): DuckDBValue;
+}

package/types/arrow/TypedTypeMap.d.ts

@@ -0,0 +1,2 @@
+import { DataType, Type } from 'apache-arrow';
+export type TypedTypeMap = Record<string | number | symbol, DataType<Type, TypedTypeMap>>;

package/types/arrow/duckDBTypeFromArrowType.d.ts

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

package/types/arrow/duckDBValueFromArrowData.d.ts

@@ -0,0 +1,8 @@
+import { Data, DataType, Type } from 'apache-arrow';
+import { DuckDBValue } from '../duckdb/values';
+import { TypedTypeMap } from './TypedTypeMap';
+type ArrowDataType = DataType<Type, TypedTypeMap>;
+type ArrowData = Data<ArrowDataType>;
+export declare function duckDBValueFromArrowData(data: ArrowData, rowIndex: number): DuckDBValue;
+export declare function duckDBValuesFromArrowData(data: ArrowData, begin: number, end: number): readonly DuckDBValue[];
+export {};

package/types/createDeferred.d.ts

@@ -0,0 +1,6 @@
+export interface Deferred<T> {
+    readonly promise: Promise<T>;
+    readonly resolve: (value: T | PromiseLike<T>) => void;
+    readonly reject: (reason?: any) => void;
+}
+export declare function createDeferred<T = unknown>(): Deferred<T>;

package/types/createHRTime.d.ts

@@ -0,0 +1 @@
+export declare function createHRTime(startMicroSec: number, endMicroSec: number): [number, number];

package/types/duckdb/AsyncDuckDBDataBatchIterator.d.ts

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

package/types/duckdb/DuckDBData.d.ts

@@ -0,0 +1,56 @@
+import { DuckDBRow } from './DuckDBRow';
+import { DuckDBType } from './types/DuckDBType';
+import { DuckDBValue } from './values';
+/**
+ * A two-dimensional table of data along with column metadata.
+ *
+ * May represent either a partial or full result set, or a batch of rows read from a result stream.
+ * */
+export declare abstract class DuckDBData {
+    /**
+     * Number of columns.
+     *
+     * May be zero until the first part of the result is read. Will not change after the initial read.
+     */
+    abstract get columnCount(): number;
+    /**
+     * Current number of rows.
+     *
+     * For a partial result set, this may change as more rows are read.
+     * For a full result, or a batch, this will not change.
+     */
+    abstract get rowCount(): number;
+    /**
+     * Returns the name of column at the given index (starting at zero).
+     *
+     * Note that duplicate column names are possible.
+     */
+    abstract columnName(columnIndex: number): string;
+    /**
+     * Returns the type of the column at the given index (starting at zero).
+     */
+    abstract columnType(columnIndex: number): DuckDBType;
+    /**
+     * Returns the value for the given column and row. Both are zero-indexed.
+     */
+    abstract value(columnIndex: number, rowIndex: number): DuckDBValue;
+    /**
+     * Returns the single value, assuming exactly one column and row. Throws otherwise.
+     */
+    singleValue(): DuckDBValue;
+    /**
+     * Returns the column names as an array.
+     */
+    columnNames(): readonly string[];
+    /**
+     * Returns the column names as an array, deduplicated following DuckDB's "Auto-Increment Duplicate Column Names"
+     * behavior.
+     */
+    deduplicatedColumnNames(): readonly string[];
+    /**
+     * Returns the data as an array of row objects, keyed by column names.
+     *
+     * The column names are deduplicated following DuckDB's "Auto-Increment Duplicate Column Names" behavior.
+     */
+    toRows(): readonly DuckDBRow[];
+}

package/types/duckdb/DuckDBDataReader.d.ts

@@ -0,0 +1,68 @@
+import { AsyncDuckDBDataBatchIterator } from './AsyncDuckDBDataBatchIterator';
+import { DuckDBData } from './DuckDBData';
+import { DuckDBType } from './types';
+import { DuckDBValue } from './values';
+/**
+ * A result set that can be read incrementally.
+ *
+ * Represents either a partial or full result.
+ * For full results, the `done` property will be true.
+ * To read more rows into a partial result, use the `readUntil` or `readAll` methods.
+ */
+export declare class DuckDBDataReader extends DuckDBData {
+    private readonly iterator;
+    private iteratorDone;
+    private totalRowsRead;
+    private readonly batches;
+    private readonly batchSizeRuns;
+    constructor(iterator: AsyncDuckDBDataBatchIterator);
+    /**
+     * Number of columns.
+     *
+     * Will be zero until the first part of the result is read. Will not change after the initial read.
+     */
+    get columnCount(): number;
+    /**
+     * Current number of rows.
+     *
+     * For a partial result set, with `done` false, this may change as more rows are read.
+     * For a full result, with `done` true, this will not change.
+     */
+    get rowCount(): number;
+    /**
+     * Returns the name of column at the given index (starting at zero).
+     *
+     * Note that duplicate column names are possible.
+     *
+     * Will return an error if no part of the result has been read yet.
+     */
+    columnName(columnIndex: number): string;
+    /**
+     * Returns the type of the column at the given index (starting at zero).
+     *
+     * Will return an error if no part of the result has been read yet.
+     */
+    columnType(columnIndex: number): DuckDBType;
+    /**
+     * Returns the value for the given column and row. Both are zero-indexed.
+     *
+     * Will return an error if `rowIndex` is not less than the current `rowCount`.
+     */
+    value(columnIndex: number, rowIndex: number): DuckDBValue;
+    /**
+     * Returns true if all rows have been read.
+     */
+    get done(): boolean;
+    /**
+     * Read all rows.
+     */
+    readAll(): Promise<void>;
+    /**
+     * Read rows until at least the given target row count has been met.
+     *
+     * Note that the resulting row count could be greater than the target, since rows are read in batches, typically of 2048 rows each.
+     */
+    readUntil(targetRowCount: number): Promise<void>;
+    private read;
+    private updateBatchSizeRuns;
+}

package/types/duckdb/DuckDBRow.d.ts

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

package/types/duckdb/conversion/dateTimeStringConversion.d.ts

@@ -0,0 +1,12 @@
+export declare function getDuckDBDateStringFromYearMonthDay(year: number, month: number, dayOfMonth: number): string;
+export declare function getDuckDBDateStringFromDays(days: number): string;
+export declare function getDuckDBTimeStringFromParts(hoursPart: bigint, minutesPart: bigint, secondsPart: bigint, microsecondsPart: bigint): string;
+export declare function getDuckDBTimeStringFromPositiveMicroseconds(positiveMicroseconds: bigint): string;
+export declare function getDuckDBTimeStringFromMicrosecondsInDay(microsecondsInDay: bigint): string;
+export declare function getDuckDBTimeStringFromMicroseconds(microseconds: bigint): string;
+export declare function getDuckDBTimestampStringFromDaysAndMicroseconds(days: bigint, microsecondsInDay: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromMicroseconds(microseconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromSeconds(seconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromMilliseconds(milliseconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBTimestampStringFromNanoseconds(nanoseconds: bigint, timezone?: string | null): string;
+export declare function getDuckDBIntervalString(months: number, days: number, microseconds: bigint): string;

package/types/duckdb/conversion/displayStringForDuckDBValue.d.ts

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

package/types/duckdb/conversion/stringFromBlob.d.ts

@@ -0,0 +1,2 @@
+/** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
+export declare function stringFromBlob(bytes: Uint8Array): string;

package/types/duckdb/conversion/stringFromDecimal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Decimal string formatting.
+ *
+ * Supports a subset of the functionality of `BigInt.prototype.toLocaleString` for locale-specific formatting.
+ */
+export interface DuckDBDecimalFormatOptions {
+    useGrouping?: boolean;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+export interface LocaleOptions {
+    locales?: string | string[];
+    options?: DuckDBDecimalFormatOptions;
+}
+/**
+ * Convert a scaled decimal value to a string, possibly using locale-specific formatting.
+ */
+export declare function stringFromDecimal(scaledValue: bigint, scale: number, localeOptions?: LocaleOptions): string;

package/types/duckdb/files.d.ts

@@ -0,0 +1,13 @@
+import { WebFile } from '@duckdb/duckdb-wasm';
+import { MDConnectionParams } from './worker_factory';
+/**
+ * Register the files within DuckDB WASM
+ */
+export declare function registerFiles(params: MDConnectionParams, files: FileList): Promise<void>;
+/**
+ * Read local data files from wasm db
+ *
+ * @returns Local data files list.
+ */
+export declare function readLocalFS(params: MDConnectionParams): Promise<WebFile[]>;
+export { WebFile };

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

@@ -0,0 +1,110 @@
+export type StructEntry = {
+    readonly key: string;
+    readonly valueType: DuckDBType;
+};
+export type UnionAlternative = {
+    readonly tag: string;
+    readonly valueType: DuckDBType;
+};
+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 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 DuckDBType = BigIntDuckDBType | BitDuckDBType | BooleanDuckDBType | BlobDuckDBType | DateDuckDBType | DoubleDuckDBType | DecimalDuckDBType | EnumDuckDBType | HugeIntDuckDBType | IntegerDuckDBType | IntervalDuckDBType | ListDuckDBType | MapDuckDBType | RealDuckDBType | SmallIntDuckDBType | SQLNullDuckDBType | StructDuckDBType | TimeDuckDBType | TimestampDuckDBType | TimestampSecondsDuckDBType | TimestampMillisecondsDuckDBType | TimestampNanosecondsDuckDBType | TimestampWithTimeZoneDuckDBType | TinyIntDuckDBType | UBigIntDuckDBType | UIntegerDuckDBType | USmallIntDuckDBType | UTinyIntDuckDBType | UUIDDuckDBType | UnionDuckDBType | VarCharDuckDBType;

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

@@ -0,0 +1,39 @@
+import { BigIntDuckDBType, BitDuckDBType, BlobDuckDBType, BooleanDuckDBType, DateDuckDBType, DecimalDuckDBType, DoubleDuckDBType, DuckDBType, EnumDuckDBType, HugeIntDuckDBType, IntegerDuckDBType, IntervalDuckDBType, ListDuckDBType, MapDuckDBType, RealDuckDBType, SQLNullDuckDBType, SmallIntDuckDBType, StructDuckDBType, StructEntry, TimeDuckDBType, TimestampDuckDBType, TimestampMillisecondsDuckDBType, TimestampNanosecondsDuckDBType, TimestampSecondsDuckDBType, TimestampWithTimeZoneDuckDBType, TinyIntDuckDBType, UBigIntDuckDBType, UIntegerDuckDBType, USmallIntDuckDBType, UTinyIntDuckDBType, UUIDDuckDBType, UnionAlternative, UnionDuckDBType, VarCharDuckDBType } from './DuckDBType';
+export declare class DuckDBTypes {
+    private constructor();
+    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 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 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;
+}

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

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

package/types/duckdb/values/DuckDBBlob.d.ts

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

package/types/duckdb/values/DuckDBDate.d.ts

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

package/types/duckdb/values/DuckDBDecimal.d.ts

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

package/types/duckdb/values/DuckDBInterval.d.ts

@@ -0,0 +1,8 @@
+import { SpecialDuckDBValue } from './SpecialDuckDBValue';
+export declare class DuckDBInterval extends SpecialDuckDBValue {
+    readonly months: number;
+    readonly days: number;
+    readonly microseconds: bigint;
+    constructor(months: number, days: number, microseconds: bigint);
+    toDuckDBString(): string;
+}

package/types/duckdb/values/DuckDBList.d.ts

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