import type { LogicalType } from "./logical-types";
import type { QuackDataChunk, QuackValue } from "./vector";
/** Input for one column when building a flat DuckDB DataChunk. */
export interface ColumnInput {
    /** Optional column name kept for local row materialization. */
    name?: string;
    /** DuckDB logical type used to encode the column values. */
    type: LogicalType;
    /** Column values in row order. */
    values: readonly QuackValue[];
}
/** Named logical type used by row-to-chunk helpers. */
export interface ColumnDefinition {
    /** Row property name and resulting chunk column name. */
    name: string;
    /** DuckDB logical type for the column. */
    type: LogicalType;
}
/** Column schema accepted by {@link dataChunkFromRows}. */
export type ColumnSchema<T extends Record<string, unknown>> = Partial<Record<Extract<keyof T, string>, LogicalType>> | readonly ColumnDefinition[];
/** Options for building a DataChunk from row objects. */
export interface DataChunkFromRowsOptions<T extends Record<string, unknown>> {
    /** Explicit column types and order. Required for empty rows or all-null columns. */
    columns?: ColumnSchema<T>;
}
/** Create one flat DataChunk column input. */
export declare function column(type: LogicalType, values: readonly QuackValue[], name?: string): ColumnInput;
/**
 * Build a flat DuckDB DataChunk from column-oriented values.
 *
 * All columns must have the same number of values.
 */
export declare function dataChunk(columns: readonly ColumnInput[]): QuackDataChunk;
/**
 * Build a flat DuckDB DataChunk from row objects.
 *
 * When `columns` is omitted, logical types are inferred from the first
 * non-null value in each column. Explicit column schemas are recommended for
 * append workloads.
 */
export declare function dataChunkFromRows<T extends Record<string, unknown>>(rows: readonly T[], options?: DataChunkFromRowsOptions<T>): QuackDataChunk;