@motherduck/wasm-client 0.6.2 → 0.6.4

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';

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

@@ -0,0 +1,27 @@
+import { S3Config } from "../bindings";
+export interface S3Params {
+    url: string;
+    query: string;
+    host: string;
+    region: string;
+    service: string;
+    method: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken: string;
+    dateNow: string;
+    datetimeNow: string;
+}
+export interface S3PayloadParams {
+    contentHash: string | null;
+    contentType: string | null;
+}
+export declare function getS3Params(config: S3Config | undefined, url: string, method: string): S3Params;
+export declare function uriEncode(input: string, encode_slash?: boolean): string;
+export declare function createS3Headers(params: S3Params, payloadParams?: S3PayloadParams | null): Map<string, string>;
+export declare function addS3Headers(xhr: XMLHttpRequest, config: S3Config | undefined, url: string, method: string, contentType?: string | null, payload?: Uint8Array | null): void;
+export declare function parseS3Url(url: string): {
+    bucket: string;
+    path: string;
+};
+export declare function getHTTPUrl(config: S3Config | undefined, url: string): string;

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

@@ -0,0 +1,5 @@
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
+export declare const PACKAGE_VERSION_MAJOR: string;
+export declare const PACKAGE_VERSION_MINOR: string;
+export declare const PACKAGE_VERSION_PATCH: string;

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

@@ -0,0 +1 @@
+export declare function createWorker(url: string): Promise<Worker>;

package/types/getAsyncDuckDb.d.ts

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

package/types/getDuckDBBundlesFromDuckDBAssets.d.ts

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

package/types/index.d.ts

@@ -1,8 +1,8 @@
-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 { 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';

package/types/instantiateDB.d.ts

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

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

@@ -0,0 +1,12 @@
+import { RecordBatch } from 'apache-arrow';
+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;
+    constructor(recordBatchIterator: AsyncRecordBatchIterator);
+    next(): Promise<DuckDBDataBatchIteratorResult>;
+    return(value?: DuckDBData): Promise<DuckDBDataBatchIteratorResult>;
+    throw(e?: any): Promise<DuckDBDataBatchIteratorResult>;
+    [Symbol.asyncIterator](): AsyncDuckDBDataBatchIterator;
+}

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

@@ -0,0 +1,14 @@
+import { DuckDBData } from '../../motherduck/duckdb-data';
+import { DuckDBType } from '../../motherduck/duckdb-types';
+import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { RecordBatch } from 'apache-arrow';
+import { TypedTypeMap } from './TypedTypeMap.js';
+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/motherduck/duckdb-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/motherduck/duckdb-arrow/duckDBTypeFromArrowType.d.ts

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

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

@@ -0,0 +1,8 @@
+import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { Data, DataType, Type } from 'apache-arrow';
+import { TypedTypeMap } from './TypedTypeMap.js';
+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/motherduck/duckdb-arrow/index.d.ts

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

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

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

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

@@ -0,0 +1,56 @@
+import { DuckDBType } from '../../motherduck/duckdb-types';
+import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { DuckDBRow } from './DuckDBRow.js';
+/**
+ * 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/motherduck/duckdb-data/DuckDBDataReader.d.ts

@@ -0,0 +1,68 @@
+import { DuckDBType } from '../../motherduck/duckdb-types';
+import { DuckDBValue } from '../../motherduck/duckdb-values';
+import { AsyncDuckDBDataBatchIterator } from './AsyncDuckDBDataBatchIterator.js';
+import { DuckDBData } from './DuckDBData.js';
+/**
+ * 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/motherduck/duckdb-data/DuckDBRow.d.ts

@@ -0,0 +1,4 @@
+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/motherduck/duckdb-values/DuckDBBlob.d.ts

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

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

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

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

@@ -0,0 +1,10 @@
+import { DuckDBDecimalFormatOptions } from './conversion/stringFromDecimal.js';
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+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/motherduck/duckdb-values/DuckDBInterval.d.ts

@@ -0,0 +1,8 @@
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+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/motherduck/duckdb-values/DuckDBList.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { SpecialDuckDBValue } from './SpecialDuckDBValue.js';
+export declare class DuckDBTimestampMicroseconds extends SpecialDuckDBValue {
+    readonly microseconds: bigint;
+    readonly timezone: string | null | undefined;
+    constructor(microseconds: bigint, timezone?: string | null);
+    toDuckDBString(): string;
+}
+export type DuckDBTimestamp = DuckDBTimestampMicroseconds;

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

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

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

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