@motherduck/wasm-client 0.6.3 → 0.6.4

package/types/duckdb-wasm/bindings/runtime_browser.d.ts

@@ -0,0 +1,9 @@
+import { DuckDBFileInfo, DuckDBGlobalFileInfo, DuckDBRuntime } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare const BROWSER_RUNTIME: DuckDBRuntime & {
+    _fileInfoCache: Map<number, DuckDBFileInfo>;
+    _globalFileInfo: DuckDBGlobalFileInfo | null;
+    getFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
+    getGlobalFileInfo(mod: DuckDBModule): DuckDBGlobalFileInfo | null;
+};
+export default BROWSER_RUNTIME;

package/types/duckdb-wasm/bindings/runtime_node.d.ts

@@ -0,0 +1,8 @@
+import { DuckDBRuntime, DuckDBFileInfo } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare const NODE_RUNTIME: DuckDBRuntime & {
+    _filesById: Map<number, any>;
+    _fileInfoCache: Map<number, DuckDBFileInfo>;
+    resolveFileInfo(mod: DuckDBModule, fileId: number): DuckDBFileInfo | null;
+};
+export default NODE_RUNTIME;

package/types/duckdb-wasm/bindings/tokens.d.ts

@@ -0,0 +1,12 @@
+export declare enum TokenType {
+    IDENTIFIER = 0,
+    NUMERIC_CONSTANT = 1,
+    STRING_CONSTANT = 2,
+    OPERATOR = 3,
+    KEYWORD = 4,
+    COMMENT = 5
+}
+export interface ScriptTokens {
+    offsets: number[];
+    types: TokenType[];
+}

package/types/duckdb-wasm/bindings/udf_function.d.ts

@@ -0,0 +1,14 @@
+import { SQLType } from '../json_typedef';
+import * as arrow from 'apache-arrow';
+export interface UDFFunctionDeclaration {
+    functionId: number;
+    name: string;
+    returnType: SQLType;
+}
+export interface UDFFunction {
+    functionId: number;
+    connectionId: number;
+    name: string;
+    returnType: arrow.DataType;
+    func: (...args: any[]) => any;
+}

package/types/duckdb-wasm/bindings/udf_runtime.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBRuntime } from './runtime';
+import { DuckDBModule } from './duckdb_module';
+export declare function callScalarUDF(runtime: DuckDBRuntime, mod: DuckDBModule, response: number, funcId: number, descPtr: number, descSize: number, ptrsPtr: number, ptrsSize: number): void;

package/types/duckdb-wasm/bindings/web_file.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBDataProtocol } from './runtime';
+export interface WebFile {
+    fileName: string;
+    dataProtocol: DuckDBDataProtocol;
+    fileId?: number;
+    fileSize?: number;
+    dataUrl?: string;
+    dataNativeFd?: number;
+    collectStatistics?: boolean;
+    reliableHeadRequests?: boolean;
+    allowFullHttpReads?: boolean;
+}

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

@@ -0,0 +1,7 @@
+export * from './bindings';
+export * from './log';
+export * from './parallel';
+export * from './status';
+export * from './platform';
+export * from './version';
+export * from './worker';

package/types/duckdb-wasm/index_docs.d.ts

@@ -0,0 +1 @@
+export {};

package/types/duckdb-wasm/json_typedef.d.ts

@@ -0,0 +1,17 @@
+import * as arrow from 'apache-arrow';
+export interface SQLType {
+    sqlType: string;
+    nullable?: boolean;
+    precision?: number;
+    scale?: number;
+    timezone?: string;
+    byteWidth?: number;
+    keyType?: SQLType;
+    valueType?: SQLType;
+    fields?: SQLField[];
+}
+export declare function arrowToSQLType(type: arrow.DataType): SQLType;
+export type SQLField = SQLType & {
+    name: string;
+};
+export declare function arrowToSQLField(name: string, type: arrow.DataType): SQLField;

package/types/duckdb-wasm/log.d.ts

@@ -0,0 +1,54 @@
+export declare enum LogLevel {
+    NONE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARNING = 3,
+    ERROR = 4
+}
+export declare enum LogTopic {
+    NONE = 0,
+    CONNECT = 1,
+    DISCONNECT = 2,
+    OPEN = 3,
+    QUERY = 4,
+    INSTANTIATE = 5
+}
+export declare enum LogEvent {
+    NONE = 0,
+    OK = 1,
+    ERROR = 2,
+    START = 3,
+    RUN = 4,
+    CAPTURE = 5
+}
+export declare enum LogOrigin {
+    NONE = 0,
+    WEB_WORKER = 1,
+    NODE_WORKER = 2,
+    BINDINGS = 3,
+    ASYNC_DUCKDB = 4
+}
+export type LogEntry<O, T, E, V> = {
+    readonly timestamp: Date;
+    readonly level: LogLevel;
+    readonly origin: O;
+    readonly topic: T;
+    readonly event: E;
+    readonly value: V;
+};
+export type LogEntryVariant = LogEntry<LogOrigin.BINDINGS, LogTopic.INSTANTIATE, LogEvent.ERROR, string> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.QUERY, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.CONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.DISCONNECT, LogEvent.ERROR, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.START, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.OK, void> | LogEntry<LogOrigin.BINDINGS, LogTopic.OPEN, LogEvent.ERROR, void> | LogEntry<LogOrigin.ASYNC_DUCKDB, LogTopic.QUERY, LogEvent.RUN, string>;
+export interface Logger {
+    log(entry: LogEntryVariant): void;
+}
+export declare class VoidLogger implements Logger {
+    log(_entry: LogEntryVariant): void;
+}
+export declare class ConsoleLogger implements Logger {
+    protected level: LogLevel;
+    constructor(level?: LogLevel);
+    log(entry: LogEntryVariant): void;
+}
+export declare function getLogLevelLabel(level: LogLevel): string;
+export declare function getLogEventLabel(event: LogEvent): string;
+export declare function getLogTopicLabel(topic: LogTopic): string;
+export declare function getLogOriginLabel(origin: LogOrigin): string;

package/types/duckdb-wasm/parallel/async_bindings.d.ts

@@ -0,0 +1,122 @@
+import { WorkerTaskVariant, ConnectionID, WorkerTaskReturnType } from './worker_request';
+import { AsyncDuckDBBindings } from './async_bindings_interface';
+import { Logger } from '../log';
+import { AsyncDuckDBConnection } from './async_connection';
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bindings/insert_options';
+import { ScriptTokens } from '../bindings/tokens';
+import { FileStatistics } from '../bindings/file_stats';
+import { DuckDBConfig } from '../bindings/config';
+import { InstantiationProgress } from '../bindings/progress';
+import { WebFile } from '../bindings/web_file';
+import { DuckDBDataProtocol } from '../bindings';
+export declare class AsyncDuckDB implements AsyncDuckDBBindings {
+    /** The message handler */
+    protected readonly _onMessageHandler: (event: MessageEvent) => void;
+    /** The error handler */
+    protected readonly _onErrorHandler: (event: ErrorEvent) => void;
+    /** The close handler */
+    protected readonly _onCloseHandler: () => void;
+    /** Instantiate the module */
+    protected _onInstantiationProgress: ((p: InstantiationProgress) => void)[];
+    /** The logger */
+    protected readonly _logger: Logger;
+    /** The worker */
+    protected _worker: Worker | null;
+    /** The promise for the worker shutdown */
+    protected _workerShutdownPromise: Promise<null> | null;
+    /** Make the worker as terminated */
+    protected _workerShutdownResolver: (value: PromiseLike<null> | null) => void;
+    /** The next message id */
+    protected _nextMessageId: number;
+    /** The pending requests */
+    protected _pendingRequests: Map<number, WorkerTaskVariant>;
+    constructor(logger: Logger, worker?: Worker | null);
+    /** Get the logger */
+    get logger(): Logger;
+    /** Attach to worker */
+    protected attach(worker: Worker): void;
+    /** Detach from worker */
+    detach(): void;
+    /** Kill the worker */
+    terminate(): Promise<void>;
+    /** Post a task */
+    protected postTask<W extends WorkerTaskVariant>(task: W, transfer?: ArrayBuffer[]): Promise<WorkerTaskReturnType<W>>;
+    /** Received a message */
+    protected onMessage(event: MessageEvent): void;
+    /** Received an error */
+    protected onError(event: ErrorEvent): void;
+    /** The worker was closed */
+    protected onClose(): void;
+    /** Reset the duckdb */
+    reset(): Promise<null>;
+    /** Ping the worker thread */
+    ping(): Promise<any>;
+    /** Try to drop a file */
+    dropFile(name: string): Promise<null>;
+    /** Try to drop files */
+    dropFiles(): Promise<null>;
+    /** Flush all files */
+    flushFiles(): Promise<null>;
+    /** Open the database */
+    instantiate(mainModuleURL: string, pthreadWorkerURL?: string | null, progress?: (progress: InstantiationProgress) => void): Promise<null>;
+    /** Get the version */
+    getVersion(): Promise<string>;
+    /** Get the feature flags */
+    getFeatureFlags(): Promise<number>;
+    /** Open a new database */
+    open(config: DuckDBConfig): Promise<void>;
+    /** Tokenize a script text */
+    tokenize(text: string): Promise<ScriptTokens>;
+    /** Connect to the database */
+    connectInternal(): Promise<number>;
+    /** Connect to the database */
+    connect(): Promise<AsyncDuckDBConnection>;
+    /** Disconnect from the database */
+    disconnect(conn: ConnectionID): Promise<void>;
+    /** Run a query */
+    runQuery(conn: ConnectionID, text: string): Promise<Uint8Array>;
+    /** Start a pending query */
+    startPendingQuery(conn: ConnectionID, text: string): Promise<Uint8Array | null>;
+    /** Poll a pending query */
+    pollPendingQuery(conn: ConnectionID): Promise<Uint8Array | null>;
+    /** Cancel a pending query */
+    cancelPendingQuery(conn: ConnectionID): Promise<boolean>;
+    /** Fetch query results */
+    fetchQueryResults(conn: ConnectionID): Promise<Uint8Array>;
+    /** Get table names */
+    getTableNames(conn: number, text: string): Promise<string[]>;
+    /** Prepare a statement and return its identifier */
+    createPrepared(conn: number, text: string): Promise<number>;
+    /** Close a prepared statement */
+    closePrepared(conn: number, statement: number): Promise<void>;
+    /** Execute a prepared statement and return the full result */
+    runPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    /** Execute a prepared statement and stream the result */
+    sendPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    /** Glob file infos */
+    globFiles(path: string): Promise<WebFile[]>;
+    /** Register file text */
+    registerFileText(name: string, text: string): Promise<void>;
+    /** Register a file path. */
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    /** Register an empty file buffer. */
+    registerEmptyFileBuffer(name: string): Promise<void>;
+    /** Register a file buffer. */
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    /** Register a file handle. */
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    /** Enable file statistics */
+    collectFileStatistics(name: string, enable: boolean): Promise<void>;
+    /** Export file statistics */
+    exportFileStatistics(name: string): Promise<FileStatistics>;
+    /** Copy a file to a buffer. */
+    copyFileToBuffer(name: string): Promise<Uint8Array>;
+    /** Copy a file to a path. */
+    copyFileToPath(name: string, path: string): Promise<void>;
+    /** Insert arrow from an ipc stream */
+    insertArrowFromIPCStream(conn: ConnectionID, buffer: Uint8Array, options?: ArrowInsertOptions): Promise<void>;
+    /** Insert a csv file */
+    insertCSVFromPath(conn: ConnectionID, path: string, options: CSVInsertOptions): Promise<void>;
+    /** Insert a json file */
+    insertJSONFromPath(conn: ConnectionID, path: string, options: JSONInsertOptions): Promise<void>;
+}

package/types/duckdb-wasm/parallel/async_bindings_interface.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from '../log';
+import { CSVInsertOptions, JSONInsertOptions } from '../bindings/insert_options';
+import { DuckDBDataProtocol } from '../bindings';
+/** An interface for the async DuckDB bindings */
+export interface AsyncDuckDBBindings {
+    logger: Logger;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    registerFileBuffer(name: string, buffer: Uint8Array): Promise<void>;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): Promise<void>;
+    copyFileToPath(name: string, out: string): Promise<void>;
+    copyFileToBuffer(name: string): Promise<Uint8Array>;
+    disconnect(conn: number): Promise<void>;
+    runQuery(conn: number, text: string): Promise<Uint8Array>;
+    startPendingQuery(conn: number, text: string): Promise<Uint8Array | null>;
+    pollPendingQuery(conn: number): Promise<Uint8Array | null>;
+    cancelPendingQuery(conn: number): Promise<boolean>;
+    fetchQueryResults(conn: number): Promise<Uint8Array>;
+    createPrepared(conn: number, text: string): Promise<number>;
+    closePrepared(conn: number, statement: number): Promise<void>;
+    runPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    sendPrepared(conn: number, statement: number, params: any[]): Promise<Uint8Array>;
+    insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: CSVInsertOptions): Promise<void>;
+    insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): Promise<void>;
+    insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): Promise<void>;
+}

package/types/duckdb-wasm/parallel/async_connection.d.ts

@@ -0,0 +1,75 @@
+import * as arrow from 'apache-arrow';
+import { AsyncDuckDB } from './async_bindings';
+import { ArrowInsertOptions, CSVInsertOptions, JSONInsertOptions } from '../bindings/insert_options';
+/** A thin helper to memoize the connection id */
+export declare class AsyncDuckDBConnection {
+    /** The async duckdb */
+    protected readonly _bindings: AsyncDuckDB;
+    /** The conn handle */
+    protected readonly _conn: number;
+    constructor(bindings: AsyncDuckDB, conn: number);
+    /** Access the database bindings */
+    get bindings(): AsyncDuckDB;
+    /** Disconnect from the database */
+    close(): Promise<void>;
+    /** Brave souls may use this function to consume the underlying connection id */
+    useUnsafe<R>(callback: (bindings: AsyncDuckDB, conn: number) => R): R;
+    /** Run a query */
+    query<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): Promise<arrow.Table<T>>;
+    /** Send a query */
+    send<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): Promise<arrow.AsyncRecordBatchStreamReader<T>>;
+    /** Cancel a query that was sent earlier */
+    cancelSent(): Promise<boolean>;
+    /** Get table names */
+    getTableNames(query: string): Promise<string[]>;
+    /** Create a prepared statement */
+    prepare<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): Promise<AsyncPreparedStatement>;
+    /** Insert an arrow table */
+    insertArrowTable(table: arrow.Table, options: ArrowInsertOptions): Promise<void>;
+    /** Insert an arrow table from an ipc stream */
+    insertArrowFromIPCStream(buffer: Uint8Array, options: ArrowInsertOptions): Promise<void>;
+    /** Insert csv file from path */
+    insertCSVFromPath(text: string, options: CSVInsertOptions): Promise<void>;
+    /** Insert json file from path */
+    insertJSONFromPath(text: string, options: JSONInsertOptions): Promise<void>;
+}
+/** An async result stream iterator */
+export declare class AsyncResultStreamIterator implements AsyncIterable<Uint8Array> {
+    protected readonly db: AsyncDuckDB;
+    protected readonly conn: number;
+    protected readonly header: Uint8Array;
+    /** First chunk? */
+    protected _first: boolean;
+    /** Reached end of stream? */
+    protected _depleted: boolean;
+    /** In-flight */
+    protected _inFlight: Promise<Uint8Array> | null;
+    constructor(db: AsyncDuckDB, conn: number, header: Uint8Array);
+    next(): Promise<IteratorResult<Uint8Array>>;
+    [Symbol.asyncIterator](): this;
+}
+/** A thin helper to bind the prepared statement id */
+export declare class AsyncPreparedStatement<T extends {
+    [key: string]: arrow.DataType;
+} = any> {
+    /** The bindings */
+    protected readonly bindings: AsyncDuckDB;
+    /** The connection id */
+    protected readonly connectionId: number;
+    /** The statement id */
+    protected readonly statementId: number;
+    /** Constructor */
+    constructor(bindings: AsyncDuckDB, connectionId: number, statementId: number);
+    /** Close a prepared statement */
+    close(): Promise<void>;
+    /** Run a prepared statement */
+    query(...params: any[]): Promise<arrow.Table<T>>;
+    /** Send a prepared statement */
+    send(...params: any[]): Promise<arrow.AsyncRecordBatchStreamReader<T>>;
+}

package/types/duckdb-wasm/parallel/index.d.ts

@@ -0,0 +1,5 @@
+export * from './async_connection';
+export * from './async_bindings_interface';
+export * from './async_bindings';
+export * from './worker_dispatcher';
+export * from './worker_request';

package/types/duckdb-wasm/parallel/worker_dispatcher.d.ts

@@ -0,0 +1,22 @@
+import { DuckDBBindings } from '../bindings';
+import { WorkerResponseVariant, WorkerRequestVariant } from './worker_request';
+import { Logger, LogEntryVariant } from '../log';
+import { InstantiationProgress } from '../bindings/progress';
+export declare abstract class AsyncDuckDBDispatcher implements Logger {
+    /** The bindings */
+    protected _bindings: DuckDBBindings | null;
+    /** The next message id */
+    protected _nextMessageId: number;
+    /** Instantiate the wasm module */
+    protected abstract instantiate(mainModule: string, pthreadWorker: string | null, progress: (p: InstantiationProgress) => void): Promise<DuckDBBindings>;
+    /** Post a response to the main thread */
+    protected abstract postMessage(response: WorkerResponseVariant, transfer: ArrayBuffer[]): void;
+    /** Send log entry to the main thread */
+    log(entry: LogEntryVariant): void;
+    /** Send plain OK without further data */
+    protected sendOK(request: WorkerRequestVariant): void;
+    /** Fail with an error */
+    protected failWith(request: WorkerRequestVariant, e: Error): void;
+    /** Process a request from the main thread */
+    onMessage(request: WorkerRequestVariant): Promise<void>;
+}

package/types/duckdb-wasm/parallel/worker_request.d.ts

@@ -0,0 +1,99 @@
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from '../bindings/insert_options';
+import { LogEntryVariant } from '../log';
+import { ScriptTokens } from '../bindings/tokens';
+import { FileStatistics } from '../bindings/file_stats';
+import { DuckDBConfig } from '../bindings/config';
+import { WebFile } from '../bindings/web_file';
+import { InstantiationProgress } from '../bindings/progress';
+import { DuckDBDataProtocol } from '../bindings';
+export type ConnectionID = number;
+export type StatementID = number;
+export declare enum WorkerRequestType {
+    CANCEL_PENDING_QUERY = "CANCEL_PENDING_QUERY",
+    CLOSE_PREPARED = "CLOSE_PREPARED",
+    COLLECT_FILE_STATISTICS = "COLLECT_FILE_STATISTICS",
+    CONNECT = "CONNECT",
+    COPY_FILE_TO_BUFFER = "COPY_FILE_TO_BUFFER",
+    COPY_FILE_TO_PATH = "COPY_FILE_TO_PATH",
+    CREATE_PREPARED = "CREATE_PREPARED",
+    DISCONNECT = "DISCONNECT",
+    DROP_FILE = "DROP_FILE",
+    DROP_FILES = "DROP_FILES",
+    EXPORT_FILE_STATISTICS = "EXPORT_FILE_STATISTICS",
+    FETCH_QUERY_RESULTS = "FETCH_QUERY_RESULTS",
+    FLUSH_FILES = "FLUSH_FILES",
+    GET_FEATURE_FLAGS = "GET_FEATURE_FLAGS",
+    GET_TABLE_NAMES = "GET_TABLE_NAMES",
+    GET_VERSION = "GET_VERSION",
+    GLOB_FILE_INFOS = "GLOB_FILE_INFOS",
+    INSERT_ARROW_FROM_IPC_STREAM = "INSERT_ARROW_FROM_IPC_STREAM",
+    INSERT_CSV_FROM_PATH = "IMPORT_CSV_FROM_PATH",
+    INSERT_JSON_FROM_PATH = "IMPORT_JSON_FROM_PATH",
+    INSTANTIATE = "INSTANTIATE",
+    OPEN = "OPEN",
+    PING = "PING",
+    POLL_PENDING_QUERY = "POLL_PENDING_QUERY",
+    REGISTER_FILE_BUFFER = "REGISTER_FILE_BUFFER",
+    REGISTER_FILE_HANDLE = "REGISTER_FILE_HANDLE",
+    REGISTER_FILE_URL = "REGISTER_FILE_URL",
+    RESET = "RESET",
+    RUN_PREPARED = "RUN_PREPARED",
+    RUN_QUERY = "RUN_QUERY",
+    SEND_PREPARED = "SEND_PREPARED",
+    START_PENDING_QUERY = "START_PENDING_QUERY",
+    TOKENIZE = "TOKENIZE"
+}
+export declare enum WorkerResponseType {
+    CONNECTION_INFO = "CONNECTION_INFO",
+    ERROR = "ERROR",
+    FEATURE_FLAGS = "FEATURE_FLAGS",
+    FILE_BUFFER = "FILE_BUFFER",
+    FILE_INFOS = "FILE_INFOS",
+    FILE_SIZE = "FILE_SIZE",
+    FILE_STATISTICS = "FILE_STATISTICS",
+    INSTANTIATE_PROGRESS = "INSTANTIATE_PROGRESS",
+    LOG = "LOG",
+    OK = "OK",
+    PREPARED_STATEMENT_ID = "PREPARED_STATEMENT_ID",
+    QUERY_PLAN = "QUERY_PLAN",
+    QUERY_RESULT = "QUERY_RESULT",
+    QUERY_RESULT_CHUNK = "QUERY_RESULT_CHUNK",
+    QUERY_RESULT_HEADER = "QUERY_RESULT_HEADER",
+    QUERY_RESULT_HEADER_OR_NULL = "QUERY_RESULT_HEADER_OR_NULL",
+    REGISTERED_FILE = "REGISTERED_FILE",
+    SCRIPT_TOKENS = "SCRIPT_TOKENS",
+    SUCCESS = "SUCCESS",
+    TABLE_NAMES = "TABLE_NAMES",
+    VERSION_STRING = "VERSION_STRING"
+}
+export type WorkerRequest<T, P> = {
+    readonly messageId: number;
+    readonly type: T;
+    readonly data: P;
+};
+export type WorkerResponse<T, P> = {
+    readonly messageId: number;
+    readonly requestId: number;
+    readonly type: T;
+    readonly data: P;
+};
+export type WorkerTaskReturnType<T extends WorkerTaskVariant> = T extends WorkerTask<any, any, infer P> ? P : never;
+export declare class WorkerTask<T, D, P> {
+    readonly type: T;
+    readonly data: D;
+    promise: Promise<P>;
+    promiseResolver: (value: P | PromiseLike<P>) => void;
+    promiseRejecter: (value: any) => void;
+    constructor(type: T, data: D);
+}
+export type WorkerRequestVariant = WorkerRequest<WorkerRequestType.CLOSE_PREPARED, [ConnectionID, StatementID]> | WorkerRequest<WorkerRequestType.CANCEL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean]> | WorkerRequest<WorkerRequestType.CONNECT, null> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_BUFFER, string> | WorkerRequest<WorkerRequestType.COPY_FILE_TO_PATH, [string, string]> | WorkerRequest<WorkerRequestType.CREATE_PREPARED, [ConnectionID, string]> | WorkerRequest<WorkerRequestType.DISCONNECT, number> | WorkerRequest<WorkerRequestType.DROP_FILE, string> | WorkerRequest<WorkerRequestType.DROP_FILES, null> | WorkerRequest<WorkerRequestType.EXPORT_FILE_STATISTICS, string> | WorkerRequest<WorkerRequestType.FETCH_QUERY_RESULTS, number> | WorkerRequest<WorkerRequestType.FLUSH_FILES, null> | WorkerRequest<WorkerRequestType.GET_FEATURE_FLAGS, null> | WorkerRequest<WorkerRequestType.GET_TABLE_NAMES, [number, string]> | WorkerRequest<WorkerRequestType.GET_VERSION, null> | WorkerRequest<WorkerRequestType.GLOB_FILE_INFOS, string> | WorkerRequest<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+    number,
+    Uint8Array,
+    ArrowInsertOptions | undefined
+]> | WorkerRequest<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions]> | WorkerRequest<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions]> | WorkerRequest<WorkerRequestType.INSTANTIATE, [string, string | null]> | WorkerRequest<WorkerRequestType.OPEN, DuckDBConfig> | WorkerRequest<WorkerRequestType.PING, null> | WorkerRequest<WorkerRequestType.POLL_PENDING_QUERY, number> | WorkerRequest<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean]> | WorkerRequest<WorkerRequestType.RESET, null> | WorkerRequest<WorkerRequestType.RUN_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.RUN_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.SEND_PREPARED, [number, number, any[]]> | WorkerRequest<WorkerRequestType.START_PENDING_QUERY, [number, string]> | WorkerRequest<WorkerRequestType.TOKENIZE, string>;
+export type WorkerResponseVariant = WorkerResponse<WorkerResponseType.CONNECTION_INFO, number> | WorkerResponse<WorkerResponseType.ERROR, any> | WorkerResponse<WorkerResponseType.FEATURE_FLAGS, number> | WorkerResponse<WorkerResponseType.FILE_BUFFER, Uint8Array> | WorkerResponse<WorkerResponseType.FILE_INFOS, WebFile[]> | WorkerResponse<WorkerResponseType.FILE_SIZE, number> | WorkerResponse<WorkerResponseType.FILE_STATISTICS, FileStatistics> | WorkerResponse<WorkerResponseType.INSTANTIATE_PROGRESS, InstantiationProgress> | WorkerResponse<WorkerResponseType.LOG, LogEntryVariant> | WorkerResponse<WorkerResponseType.OK, null> | WorkerResponse<WorkerResponseType.PREPARED_STATEMENT_ID, number> | WorkerResponse<WorkerResponseType.QUERY_PLAN, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_CHUNK, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER, Uint8Array> | WorkerResponse<WorkerResponseType.QUERY_RESULT_HEADER_OR_NULL, Uint8Array | null> | WorkerResponse<WorkerResponseType.SCRIPT_TOKENS, ScriptTokens> | WorkerResponse<WorkerResponseType.SUCCESS, boolean> | WorkerResponse<WorkerResponseType.TABLE_NAMES, string[]> | WorkerResponse<WorkerResponseType.VERSION_STRING, string>;
+export type WorkerTaskVariant = WorkerTask<WorkerRequestType.COLLECT_FILE_STATISTICS, [string, boolean], null> | WorkerTask<WorkerRequestType.CLOSE_PREPARED, [number, number], null> | WorkerTask<WorkerRequestType.CONNECT, null, ConnectionID> | WorkerTask<WorkerRequestType.COPY_FILE_TO_BUFFER, string, Uint8Array> | WorkerTask<WorkerRequestType.COPY_FILE_TO_PATH, [string, string], null> | WorkerTask<WorkerRequestType.CREATE_PREPARED, [number, string], number> | WorkerTask<WorkerRequestType.DISCONNECT, ConnectionID, null> | WorkerTask<WorkerRequestType.DROP_FILE, string, null> | WorkerTask<WorkerRequestType.DROP_FILES, null, null> | WorkerTask<WorkerRequestType.EXPORT_FILE_STATISTICS, string, FileStatistics> | WorkerTask<WorkerRequestType.FETCH_QUERY_RESULTS, ConnectionID, Uint8Array> | WorkerTask<WorkerRequestType.FLUSH_FILES, null, null> | WorkerTask<WorkerRequestType.GET_FEATURE_FLAGS, null, number> | WorkerTask<WorkerRequestType.GET_TABLE_NAMES, [number, string], string[]> | WorkerTask<WorkerRequestType.GET_VERSION, null, string> | WorkerTask<WorkerRequestType.INSERT_ARROW_FROM_IPC_STREAM, [
+    number,
+    Uint8Array,
+    ArrowInsertOptions | undefined
+], null> | WorkerTask<WorkerRequestType.INSERT_CSV_FROM_PATH, [number, string, CSVInsertOptions], null> | WorkerTask<WorkerRequestType.INSERT_JSON_FROM_PATH, [number, string, JSONInsertOptions], null> | WorkerTask<WorkerRequestType.INSTANTIATE, [string, string | null], null> | WorkerTask<WorkerRequestType.OPEN, DuckDBConfig, null> | WorkerTask<WorkerRequestType.PING, null, null> | WorkerTask<WorkerRequestType.REGISTER_FILE_BUFFER, [string, Uint8Array], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_HANDLE, [string, any, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.REGISTER_FILE_URL, [string, string, DuckDBDataProtocol, boolean], null> | WorkerTask<WorkerRequestType.GLOB_FILE_INFOS, string, WebFile[]> | WorkerTask<WorkerRequestType.RESET, null, null> | WorkerTask<WorkerRequestType.RUN_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.RUN_QUERY, [ConnectionID, string], Uint8Array> | WorkerTask<WorkerRequestType.SEND_PREPARED, [number, number, any[]], Uint8Array> | WorkerTask<WorkerRequestType.START_PENDING_QUERY, [ConnectionID, string], Uint8Array | null> | WorkerTask<WorkerRequestType.POLL_PENDING_QUERY, ConnectionID, Uint8Array | null> | WorkerTask<WorkerRequestType.CANCEL_PENDING_QUERY, ConnectionID, boolean> | WorkerTask<WorkerRequestType.TOKENIZE, string, ScriptTokens>;

package/types/duckdb-wasm/platform.d.ts

@@ -0,0 +1,39 @@
+export declare const isNode: () => boolean;
+export declare const isFirefox: () => boolean;
+export declare const isSafari: () => boolean;
+/** Bundles have different characteristics:
+  * - MVP: minimum viable product (uses features from first stable version of WebAssembly standard)
+  * - EH: exception handling
+  * - COI: cross origin isolation
+  */
+export interface DuckDBBundles {
+    mvp: {
+        mainModule: string;
+        mainWorker: string;
+    };
+    eh?: {
+        mainModule: string;
+        mainWorker: string;
+    };
+    coi?: {
+        mainModule: string;
+        mainWorker: string;
+        pthreadWorker: string;
+    };
+}
+export declare function getJsDelivrBundles(): DuckDBBundles;
+export interface DuckDBBundle {
+    mainModule: string;
+    mainWorker: string | null;
+    pthreadWorker: string | null;
+}
+export interface PlatformFeatures {
+    bigInt64Array: boolean;
+    crossOriginIsolated: boolean;
+    wasmExceptions: boolean;
+    wasmSIMD: boolean;
+    wasmBulkMemory: boolean;
+    wasmThreads: boolean;
+}
+export declare function getPlatformFeatures(): Promise<PlatformFeatures>;
+export declare function selectBundle(bundles: DuckDBBundles): Promise<DuckDBBundle>;

package/types/duckdb-wasm/status.d.ts

@@ -0,0 +1,3 @@
+export declare enum StatusCode {
+    SUCCESS = 0
+}

package/types/duckdb-wasm/targets/duckdb-browser-blocking.d.ts

@@ -0,0 +1,12 @@
+export * from '../bindings';
+export * from '../log';
+export * from '../platform';
+export * from '../status';
+export * from '../version';
+export { DuckDBDataProtocol } from '../bindings/runtime';
+export { DEFAULT_RUNTIME } from '../bindings/runtime';
+export { BROWSER_RUNTIME } from '../bindings/runtime_browser';
+import { Logger } from '../log';
+import { DuckDBRuntime, DuckDBBindings } from '../bindings';
+import { DuckDBBundles } from '../platform';
+export declare function createDuckDB(bundles: DuckDBBundles, logger: Logger, runtime: DuckDBRuntime): Promise<DuckDBBindings>;

package/types/duckdb-wasm/targets/duckdb-browser-coi.pthread.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/types/duckdb-wasm/targets/duckdb-browser-coi.worker.d.ts

@@ -0,0 +1,2 @@
+/** Register the worker */
+export declare function registerWorker(): void;

package/types/duckdb-wasm/targets/duckdb-browser-eh.worker.d.ts

@@ -0,0 +1,2 @@
+/** Register the worker */
+export declare function registerWorker(): void;

package/types/duckdb-wasm/targets/duckdb-browser-mvp.worker.d.ts

@@ -0,0 +1,2 @@
+/** Register the worker */
+export declare function registerWorker(): void;

package/types/duckdb-wasm/targets/duckdb-node-blocking.d.ts

@@ -0,0 +1,13 @@
+export * from '../bindings';
+export * from '../log';
+export * from '../platform';
+export * from '../status';
+export * from '../version';
+export { DuckDBDataProtocol } from '../bindings/runtime';
+export { DEFAULT_RUNTIME } from '../bindings/runtime';
+export { NODE_RUNTIME } from '../bindings/runtime_node';
+import { Logger } from '../log';
+import { DuckDBRuntime } from '../bindings';
+import { DuckDBNodeBindings } from '../bindings/bindings_node_base';
+import { DuckDBBundles } from '../platform';
+export declare function createDuckDB(bundles: DuckDBBundles, logger: Logger, runtime: DuckDBRuntime): Promise<DuckDBNodeBindings>;

package/types/duckdb-wasm/targets/duckdb-node-eh.worker.d.ts

@@ -0,0 +1,2 @@
+/** Register the worker */
+export declare function registerWorker(): void;

package/types/duckdb-wasm/targets/duckdb-node-mvp.worker.d.ts

@@ -0,0 +1,2 @@
+/** Register the worker */
+export declare function registerWorker(): void;

package/types/duckdb-wasm/targets/duckdb.d.ts

@@ -0,0 +1,9 @@
+export * from '../bindings/config';
+export * from '../bindings/tokens';
+export * from '../log';
+export * from '../status';
+export * from '../parallel';
+export * from '../platform';
+export * from '../version';
+export * from '../worker';
+export { InstantiationProgress, InstantiationProgressHandler, DuckDBDataProtocol, WebFile } from '../bindings';

package/types/duckdb-wasm/utils/binary_dump.d.ts

@@ -0,0 +1 @@
+export declare function dumpBuffer(src: Uint8Array): string;

package/types/duckdb-wasm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './binary_dump';
+export * from './s3_helper';