@uwdata/mosaic-core 0.15.0 → 0.16.2

package/dist/types/Coordinator.d.ts

@@ -8,29 +8,23 @@ export function coordinator(instance?: Coordinator): Coordinator;
  * A Mosaic Coordinator manages all database communication for clients and
  * handles selection updates. The Coordinator also performs optimizations
  * including query caching, consolidation, and pre-aggregation.
- * @param {*} [db] Database connector. Defaults to a web socket connection.
- * @param {object} [options] Coordinator options.
- * @param {*} [options.logger=console] The logger to use, defaults to `console`.
- * @param {*} [options.manager] The query manager to use.
- * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
- * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
- * @param {PreAggregateOptions} [options.preagg] Options for the Pre-aggregator.
  */
 export class Coordinator {
-    constructor(db?: {
-        readonly connected: boolean;
-        query(query: {
-            type?: "exec" | "arrow" | "json" | "create-bundle" | "load-bundle";
-            sql?: string;
-            queries?: string[];
-            name?: string;
-        }): Promise<any>;
-    }, { logger, manager, cache, consolidate, preagg }?: {
-        logger?: Console;
+    /**
+     * @param {Connector} [db] Database connector. Defaults to a web socket connection.
+     * @param {object} [options] Coordinator options.
+     * @param {Logger} [options.logger=console] The logger to use, defaults to `console`.
+     * @param {QueryManager} [options.manager] The query manager to use.
+     * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
+     * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
+     * @param {PreAggregateOptions} [options.preagg] Options for the Pre-aggregator.
+     */
+    constructor(db?: Connector, { logger, manager, cache, consolidate, preagg }?: {
+        logger?: Logger;
         manager?: QueryManager;
         cache?: boolean;
         consolidate?: boolean;
-        preagg?: {};
+        preagg?: PreAggregateOptions;
     });
     /** @type {QueryManager} */
     manager: QueryManager;
@@ -49,17 +43,17 @@ export class Coordinator {
     clients: Set<any>;
     /**
      * Get or set the database connector.
-     * @param {*} [db] The database connector to use.
-     * @returns The current database connector.
+     * @param {Connector} [db] The database connector to use.
+     * @returns {Connector} The current database connector.
      */
-    databaseConnector(db?: any): any;
+    databaseConnector(db?: Connector): Connector;
     /**
      * Get or set the logger.
-     * @param {*} logger  The logger to use.
-     * @returns The current logger
+     * @param {Logger} [logger] The logger to use.
+     * @returns {Logger} The current logger
      */
-    logger(logger: any, ...args: any[]): any;
-    _logger: any;
+    logger(logger?: Logger, ...args: any[]): Logger;
+    _logger: Logger;
     /**
      * Cancel previosuly submitted query requests. These queries will be
      * canceled if they are queued but have not yet been submitted.
@@ -162,6 +156,9 @@ export class Coordinator {
 }
 import { QueryManager } from './QueryManager.js';
 import { PreAggregator } from './preagg/PreAggregator.js';
+import type { Connector } from './connectors/Connector.js';
+import type { Logger } from './types.js';
 import type { QueryResult } from './util/query-result.js';
 import type { QueryType } from './types.js';
 import type { MosaicClient } from './MosaicClient.js';
+import type { PreAggregateOptions } from './preagg/PreAggregator.js';

package/dist/types/MosaicClient.d.ts

@@ -22,27 +22,27 @@ export class MosaicClient {
      *  will re-query and update the client when the selection updates.
      */
     constructor(filterSelection?: Selection);
-    /** @type {Selection} */
-    _filterBy: Selection;
+    /** @type {Selection | undefined} */
+    _filterBy: Selection | undefined;
     _requestUpdate: (event: any) => void;
-    /** @type {Coordinator} */
-    _coordinator: Coordinator;
+    /** @type {Coordinator | null} */
+    _coordinator: Coordinator | null;
     /** @type {Promise<any>} */
     _pending: Promise<any>;
     /** @type {boolean} */
     _enabled: boolean;
     /** @type {boolean} */
     _initialized: boolean;
-    /** @type {Query | boolean} */
-    _request: Query | boolean;
+    /** @type {Query | boolean | null} */
+    _request: Query | boolean | null;
     /**
      * Set this client's connected coordinator.
      */
-    set coordinator(coordinator: Coordinator);
+    set coordinator(coordinator: Coordinator | null);
     /**
-     * Return this client's connected coordinator.
+     * @returns {Coordinator | null}  this client's connected coordinator.
      */
-    get coordinator(): Coordinator;
+    get coordinator(): Coordinator | null;
     /**
      * Set this client's enabled state;
      */
@@ -56,9 +56,9 @@ export class MosaicClient {
      */
     get pending(): Promise<any>;
     /**
-     * Return this client's filter selection.
+     * @returns {Selection | undefined} this client's filter selection.
      */
-    get filterBy(): Selection;
+    get filterBy(): Selection | undefined;
     /**
      * Return a boolean indicating if the client query can be sped up with
      * materialized views of pre-aggregated data. Should return true if changes
@@ -122,6 +122,15 @@ export class MosaicClient {
      * method has no effect if the client is not registered with a coordinator.
      */
     initialize(): void;
+    /**
+     * Remove this client: disconnect from the coordinator and free up any
+     * resource use. This method has no effect if the client is not connected
+     * to a coordinator.
+     *
+     * If overriding this method in a client subclass, be sure to also
+     * disconnect from the coordinator.
+     */
+    destroy(): void;
     /**
      * Requests a client update, for example to (re-)render an interface
      * component.

package/dist/types/QueryManager.d.ts

@@ -7,19 +7,16 @@ export class QueryManager {
     constructor(maxConcurrentRequests?: number);
     /** @type {PriorityQueue} */
     queue: PriorityQueue;
-    db: any;
-    clientCache: any;
-    _logger: {
-        debug(..._: any[]): void;
-        info(..._: any[]): void;
-        log(..._: any[]): void;
-        warn(..._: any[]): void;
-        error(..._: any[]): void;
-    };
+    /** @type {Connector} */
+    db: Connector;
+    /** @type {Cache} */
+    clientCache: Cache;
+    /** @type {Logger} */
+    _logger: Logger;
+    /** @type {boolean} */
     _logQueries: boolean;
-    _consolidate: {
-        add(entry: any, priority: any): void;
-    };
+    /** @type {ReturnType<typeof consolidator> | null} */
+    _consolidate: ReturnType<typeof consolidator> | null;
     /**
      * Requests pending with the query manager.
      * @type {QueryResult[]}
@@ -47,11 +44,35 @@ export class QueryManager {
      * @param {QueryResult} result The query result.
      */
     submit(request: any, result: QueryResult): Promise<void>;
-    cache(value: any): any;
-    logger(value: any): any;
-    logQueries(value: any): boolean;
-    connector(connector: any): any;
-    consolidate(flag: any): void;
+    /**
+     * Get or set the current query cache.
+     * @param {Cache | boolean} [value]
+     * @returns {Cache}
+     */
+    cache(value?: Cache | boolean): Cache;
+    /**
+     * Get or set the current logger.
+     * @param {Logger} [value]
+     * @returns {Logger}
+     */
+    logger(value?: Logger): Logger;
+    /**
+     * Get or set if queries should be logged.
+     * @param {boolean} [value]
+     * @returns {boolean}
+     */
+    logQueries(value?: boolean): boolean;
+    /**
+     * Get or set the database connector.
+     * @param {Connector} [connector]
+     * @returns {Connector}
+     */
+    connector(connector?: Connector): Connector;
+    /**
+     * Indicate if query consolidation should be performed.
+     * @param {boolean} flag
+     */
+    consolidate(flag: boolean): void;
     /**
      * Request a query result.
      * @param {*} request The request.
@@ -63,4 +84,8 @@ export class QueryManager {
     clear(): void;
 }
 import { PriorityQueue } from './util/priority-queue.js';
+import type { Connector } from './connectors/Connector.js';
+import type { Cache } from './types.js';
+import type { Logger } from './types.js';
+import { consolidator } from './QueryConsolidator.js';
 import { QueryResult } from './util/query-result.js';

package/dist/types/Selection.d.ts

@@ -232,4 +232,4 @@ export class SelectionResolver {
 }
 import { Param } from './Param.js';
 import type { SelectionClause } from './util/selection-types.js';
-import { MosaicClient } from './MosaicClient.js';
+import type { MosaicClient } from './MosaicClient.js';

package/dist/types/SelectionClause.d.ts

@@ -102,4 +102,4 @@ export type Scale = import("./util/selection-types.js").Scale;
 export type Extent = import("./util/selection-types.js").Extent;
 export type MatchMethod = import("./util/selection-types.js").MatchMethod;
 export type BinMethod = import("./util/selection-types.js").BinMethod;
-import { MosaicClient } from './MosaicClient.js';
+import type { MosaicClient } from './MosaicClient.js';

package/dist/types/connectors/Connector.d.ts

@@ -0,0 +1,25 @@
+import type { Table } from '@uwdata/flechette';
+export interface QueryRequest {
+    /** The query type. */
+    type?: string;
+    /** A SQL query string. */
+    sql: string;
+}
+export interface ArrowQueryRequest extends QueryRequest {
+    /** The query type. */
+    type?: 'arrow';
+}
+export interface ExecQueryRequest extends QueryRequest {
+    /** The query type. */
+    type: 'exec';
+}
+export interface JSONQueryRequest extends QueryRequest {
+    /** The query type. */
+    type: 'json';
+}
+export interface Connector {
+    /** Issue a query and return the result. */
+    query(query: ArrowQueryRequest): Promise<Table>;
+    query(query: ExecQueryRequest): Promise<void>;
+    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
+}

package/dist/types/connectors/rest.d.ts

@@ -1,17 +1,13 @@
-export function restConnector(uri?: string): {
-    /**
-     * Query the DuckDB server.
-     * @param {object} query
-     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
-     * @param {string} [query.sql] A SQL query string.
-     * @param {string[]} [query.queries] The queries used to create a bundle.
-     * @param {string} [query.name] The name of a bundle to create or load.
-     * @returns the query result
-     */
-    query(query: {
-        type?: "exec" | "arrow" | "json" | "create-bundle" | "load-bundle";
-        sql?: string;
-        queries?: string[];
-        name?: string;
-    }): Promise<any>;
-};
+/**
+ * Connect to a DuckDB server over an HTTP REST interface.
+ * @param {object} [options] Connector options.
+ * @param {string} [options.uri] The URI for the DuckDB REST server.
+ * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
+ * @returns {Connector} A connector instance.
+ */
+export function restConnector({ uri, ipc, }?: {
+    uri?: string;
+    ipc?: ExtractionOptions;
+}): Connector;
+import type { ExtractionOptions } from '@uwdata/flechette';
+import type { Connector } from './Connector.js';

package/dist/types/connectors/socket.d.ts

@@ -1,18 +1,100 @@
-export function socketConnector(uri?: string): {
-    readonly connected: boolean;
+/**
+ * Connect to a DuckDB server over a WebSocket interface.
+ * @param {object} [options] Connector options.
+ * @param {string} [options.uri] The URI for the DuckDB REST server.
+ * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
+ * @returns {SocketConnector} A connector instance.
+ */
+export function socketConnector(options?: {
+    uri?: string;
+    ipc?: ExtractionOptions;
+}): SocketConnector;
+/**
+ * DuckDB socket connector.
+ * @implements {Connector}
+ */
+export class SocketConnector implements Connector {
     /**
-     * Query the DuckDB server.
-     * @param {object} query
-     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
-     * @param {string} [query.sql] A SQL query string.
-     * @param {string[]} [query.queries] The queries used to create a bundle.
-     * @param {string} [query.name] The name of a bundle to create or load.
-     * @returns the query result
+     * @param {object} [options] Connector options.
+     * @param {string} [options.uri] The URI for the DuckDB REST server.
+     * @param {ExtractionOptions} [options.ipc] Arrow IPC extraction options.
      */
-    query(query: {
-        type?: "exec" | "arrow" | "json" | "create-bundle" | "load-bundle";
-        sql?: string;
-        queries?: string[];
-        name?: string;
-    }): Promise<any>;
-};
+    constructor({ uri, ipc, }?: {
+        uri?: string;
+        ipc?: ExtractionOptions;
+    });
+    _uri: string;
+    _queue: any[];
+    _connected: boolean;
+    _request: any;
+    _ws: WebSocket;
+    _events: {
+        open(): void;
+        close(): void;
+        error(event: any): void;
+        message({ data }: {
+            data: any;
+        }): void;
+    };
+    get connected(): boolean;
+    init(): void;
+    enqueue(query: any, resolve: any, reject: any): void;
+    next(): void;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ArrowQueryRequest): Promise<Table>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ExecQueryRequest): Promise<void>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
+}
+import type { ExtractionOptions } from '@uwdata/flechette';
+import type { Connector } from './Connector.js';
+import type { ArrowQueryRequest } from './Connector.js';
+import type { Table } from '@uwdata/flechette';
+import type { ExecQueryRequest } from './Connector.js';
+import type { JSONQueryRequest } from './Connector.js';

package/dist/types/connectors/wasm.d.ts

@@ -1,16 +1,135 @@
-export function wasmConnector(options?: {}): {
-    getDuckDB: () => Promise<duckdb.AsyncDuckDB>;
-    getConnection: () => Promise<duckdb.AsyncDuckDBConnection>;
-    /**
-     * Query the DuckDB-WASM instance.
-     * @param {object} query
-     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type.
-     * @param {string} query.sql A SQL query string.
-     * @returns the query result
-     */
-    query: (query: {
-        type?: "exec" | "arrow" | "json";
-        sql: string;
-    }) => Promise<import("@uwdata/flechette").Table | Record<string, any>[]>;
+/**
+ * @typedef {object} DuckDBWASMOptions
+ * @property {boolean} [log] Flag to enable logging.
+ */
+/**
+ * @typedef {object} DuckDBWASMConnectorOptions
+ * @property {boolean} [log] Flag to enable logging.
+ * @property {ExtractionOptions} [ipc]
+ *  Arrow IPC extraction options.
+ * @property {duckdb.AsyncDuckDB} [duckdb]
+ *  Optional pre-existing DuckDB-WASM instance.
+ * @property {duckdb.AsyncDuckDBConnection} [connection]
+ *  Optional pre-existing DuckDB-WASM connection.
+ */
+/**
+ * Connect to a DuckDB-WASM instance.
+ * @param {DuckDBWASMConnectorOptions} [options] Connector options.
+ * @returns {DuckDBWASMConnector} A connector instance.
+ */
+export function wasmConnector(options?: DuckDBWASMConnectorOptions): DuckDBWASMConnector;
+/**
+ * DuckDB-WASM connector.
+ * @implements {Connector}
+ */
+export class DuckDBWASMConnector implements Connector {
+    /**
+     * Create a new DuckDB-WASM connector instance.
+     * @param {DuckDBWASMConnectorOptions} [options]
+     */
+    constructor(options?: DuckDBWASMConnectorOptions);
+    /** @type {ExtractionOptions} */
+    _ipc: ExtractionOptions;
+    /** @type {DuckDBWASMOptions} */
+    _options: DuckDBWASMOptions;
+    /** @type {duckdb.AsyncDuckDB} */
+    _db: duckdb.AsyncDuckDB;
+    /** @type {duckdb.AsyncDuckDBConnection} */
+    _con: duckdb.AsyncDuckDBConnection;
+    /** @type {Promise<unknown>} */
+    _loadPromise: Promise<unknown>;
+    /**
+     * Get the backing DuckDB-WASM instance.
+     * Lazily initializes DuckDB-WASM if not already loaded.
+     * @returns {Promise<duckdb.AsyncDuckDB>} The DuckDB-WASM instance.
+     */
+    getDuckDB(): Promise<duckdb.AsyncDuckDB>;
+    /**
+     * Get the backing DuckDB-WASM connection.
+     * Lazily initializes DuckDB-WASM if not already loaded.
+     * @returns {Promise<duckdb.AsyncDuckDBConnection>} The DuckDB-WASM connection.
+     */
+    getConnection(): Promise<duckdb.AsyncDuckDBConnection>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ArrowQueryRequest): Promise<Table>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: ExecQueryRequest): Promise<void>;
+    /**
+     * @overload
+     * @param {ArrowQueryRequest} query
+     * @returns {Promise<Table>}
+     *
+     * @overload
+     * @param {ExecQueryRequest} query
+     * @returns {Promise<void>}
+     *
+     * @overload
+     * @param {JSONQueryRequest} query
+     * @returns {Promise<Record<string, any>[]>}
+     *
+     * @param {ArrowQueryRequest | ExecQueryRequest | JSONQueryRequest} query
+     * @returns {Promise<Table | void | Record<string, any>[]>}}
+     */
+    query(query: JSONQueryRequest): Promise<Record<string, any>[]>;
+}
+export type DuckDBWASMOptions = {
+    /**
+     * Flag to enable logging.
+     */
+    log?: boolean;
+};
+export type DuckDBWASMConnectorOptions = {
+    /**
+     * Flag to enable logging.
+     */
+    log?: boolean;
+    /**
+     * Arrow IPC extraction options.
+     */
+    ipc?: ExtractionOptions;
+    /**
+     * Optional pre-existing DuckDB-WASM instance.
+     */
+    duckdb?: duckdb.AsyncDuckDB;
+    /**
+     * Optional pre-existing DuckDB-WASM connection.
+     */
+    connection?: duckdb.AsyncDuckDBConnection;
 };
+import type { Connector } from './Connector.js';
+import type { ExtractionOptions } from '@uwdata/flechette';
 import * as duckdb from '@duckdb/duckdb-wasm';
+import type { ArrowQueryRequest } from './Connector.js';
+import type { Table } from '@uwdata/flechette';
+import type { ExecQueryRequest } from './Connector.js';
+import type { JSONQueryRequest } from './Connector.js';

package/dist/types/index-types.d.ts

@@ -1,3 +1,4 @@
 export * from './index.js';
 export * from './types.js';
+export * from './connectors/Connector.js';
 export * from './util/selection-types.js';

package/dist/types/preagg/PreAggregator.d.ts

@@ -176,5 +176,5 @@ import type { MosaicClient } from '../MosaicClient.js';
 import type { Coordinator } from '../Coordinator.js';
 import type { Selection } from '../Selection.js';
 import type { SelectionClause } from '../util/selection-types.js';
-import { SelectQuery } from '@uwdata/mosaic-sql';
+import type { SelectQuery } from '@uwdata/mosaic-sql';
 import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/preagg/preagg-columns.d.ts

@@ -10,5 +10,5 @@ export function preaggColumns(client: MosaicClient): {
     preagg: Record<string, ExprNode>;
     output: Record<string, ExprNode>;
 };
-import { MosaicClient } from '../MosaicClient.js';
-import { ExprNode } from '@uwdata/mosaic-sql';
+import type { MosaicClient } from '../MosaicClient.js';
+import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/preagg/sufficient-statistics.d.ts

@@ -9,5 +9,5 @@
  *  sufficient statistics to service updates.
  */
 export function sufficientStatistics(node: AggregateNode, preagg: Record<string, ExprNode>, avg: any): ExprNode;
-import { AggregateNode } from '@uwdata/mosaic-sql';
-import { ExprNode } from '@uwdata/mosaic-sql';
+import type { AggregateNode } from '@uwdata/mosaic-sql';
+import type { ExprNode } from '@uwdata/mosaic-sql';

package/dist/types/types.d.ts

@@ -40,3 +40,24 @@ export interface Activatable {
      */
     activate(): void;
 }
+/**
+ * Interface for cache implementations.
+ */
+export interface Cache {
+    get(key: string): any;
+    set(key: string, value: any): any;
+    clear(): void;
+}
+/**
+ * Interface for logger implementations
+ */
+export interface Logger {
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    group(label?: any): void;
+    groupCollapsed(label?: any): void;
+    groupEnd(): void;
+}

package/dist/types/util/cache.d.ts

@@ -1,13 +1,17 @@
+/**
+ * Create a new cache that ignores all values.
+ * @returns {Cache}
+ */
+export function voidCache(): Cache;
+/**
+ * Create a new cache that uses an LRU eviction policy.
+ * @param {object} [options] Cache options.
+ * @param {number} [options.max] Maximum number of cache entries.
+ * @param {number} [options.ttl] Time-to-live for cache entries.
+ * @returns {Cache}
+ */
 export function lruCache({ max, ttl }?: {
     max?: number;
     ttl?: number;
-}): {
-    get(key: any): any;
-    set(key: any, value: any): any;
-    clear(): void;
-};
-export function voidCache(): {
-    get: () => any;
-    set: (key: any, value: any) => any;
-    clear: () => void;
-};
+}): Cache;
+import type { Cache } from '../types.js';

package/dist/types/util/decode-ipc.d.ts

@@ -1,7 +1,12 @@
 /**
- * Decode Arrow IPC bytes to a table instance, with an option to map date and
- * timestamp values to JS Date objects.
+ * Decode Arrow IPC bytes to a table instance.
+ * The default options map date and timestamp values to JS Date objects.
  * @param {ArrayBuffer | Uint8Array} data Arrow IPC bytes.
- * @returns {import('@uwdata/flechette').Table} A table instance.
+ * @param {ExtractionOptions} [options] Arrow IPC extraction options.
+ *  If unspecified, the default options will extract date and timestamp
+ *  values to JS Date objects.
+ * @returns {Table} A table instance.
  */
-export function decodeIPC(data: ArrayBuffer | Uint8Array): import("@uwdata/flechette").Table;
+export function decodeIPC(data: ArrayBuffer | Uint8Array, options?: ExtractionOptions): Table;
+import type { ExtractionOptions } from '@uwdata/flechette';
+import type { Table } from '@uwdata/flechette';