lakeql 0.1.8 → 0.2.0

package/dist/index.d.ts

@@ -17,7 +17,19 @@ declare function timestampToIsoString(value: TimestampValue): string;
 declare function timestampEpochForUnit(value: TimestampValue, unit: TimestampUnit): bigint;
 declare function compareTimestampValues(left: TimestampValue, right: TimestampValue): number;
 
-type Scalar = string | number | boolean | bigint | TimestampValue | null;
+interface IntervalValue {
+    kind: "interval";
+    months: number;
+    days: number;
+    nanoseconds: string;
+}
+declare function intervalValue(input: string): IntervalValue;
+declare function isIntervalValue(value: unknown): value is IntervalValue;
+declare function isNonNegativeInterval(value: IntervalValue): boolean;
+declare function intervalToString(value: IntervalValue): string;
+declare function applyIntervalToTimestamp(value: TimestampValue, interval: IntervalValue, direction: -1 | 1): TimestampValue;
+
+type Scalar = string | number | boolean | bigint | Uint8Array | TimestampValue | IntervalValue | null;
 type CompareOp = "eq" | "ne" | "lt" | "lte" | "gt" | "gte";
 interface LiteralExpr {
     kind: "literal";
@@ -116,223 +128,6 @@ declare function mul(left: ValueInput, right: ValueInput): ArithmeticExpr;
 declare function div(left: ValueInput, right: ValueInput): ArithmeticExpr;
 declare function mod(left: ValueInput, right: ValueInput): ArithmeticExpr;
 
-type Row = Record<string, unknown>;
-interface BookmarkQuery {
-    source: string;
-    select?: string[];
-    projections?: Record<string, Expr>;
-    where?: Expr;
-    distinct?: boolean;
-    orderBy?: {
-        column: string;
-        direction?: "asc" | "desc";
-        nulls?: "first" | "last";
-    }[];
-    limit?: number;
-    offset?: number;
-    batchSize?: number;
-    hive?: boolean;
-}
-/**
- * A serializable position in a running query. Bookmarks are plain values:
- * the engine only produces and consumes them, and the caller moves them
- * over whatever transport it likes (queue, KV, URL, cron state).
- */
-interface Bookmark {
-    version: 1;
-    planFingerprint: string;
-    snapshot: string;
-    query?: BookmarkQuery;
-    position: {
-        fileIndex: number;
-        rowGroup: number;
-        rowOffset: number;
-        taskId?: string;
-        outputManifestCursor?: number;
-    };
-    writeState?: {
-        taskState?: "planned" | "running" | "output-written" | "manifest-recorded" | "complete";
-        idempotencyKey?: string;
-        multipart?: {
-            uploadId: string;
-            path: string;
-            parts: {
-                partNumber: number;
-                etag: string;
-                byteSize: number;
-            }[];
-        };
-    };
-    operatorState?: {
-        limitEmitted?: number;
-        groupBy?: Uint8Array | {
-            spillRef: string;
-        };
-        topK?: Uint8Array | {
-            spillRef: string;
-        };
-        sort?: Uint8Array | {
-            spillRef: string;
-        };
-        sketches?: Record<string, Uint8Array>;
-    };
-}
-interface SliceResult {
-    rows: Row[];
-    /** Absent when the query completed. */
-    bookmark?: Bookmark;
-}
-interface QueryStats {
-    queryId: string;
-    elapsedMs: number;
-    manifestsRead: number;
-    manifestsSkipped: number;
-    filesPlanned: number;
-    filesRead: number;
-    filesSkipped: number;
-    rowGroupsRead: number;
-    rowGroupsSkipped: number;
-    columnsRead: string[];
-    bytesRequested: number;
-    rangeRequests: number;
-    rowsDecoded: number;
-    rowsMatched: number;
-    rowsReturned: number;
-    cacheHits: number;
-    cacheMisses: number;
-}
-
-type Vector = {
-    type: "null";
-    length: number;
-} | {
-    type: "f64";
-    values: Float64Array;
-    valid?: Uint8Array;
-} | {
-    type: "i64";
-    values: BigInt64Array;
-    valid?: Uint8Array;
-} | {
-    type: "timestamp";
-    values: BigInt64Array;
-    unit: TimestampUnit;
-    isAdjustedToUTC: boolean;
-    valid?: Uint8Array;
-} | {
-    type: "bool";
-    values: Uint8Array;
-    valid?: Uint8Array;
-} | {
-    type: "utf8";
-    values: string[];
-    valid?: Uint8Array;
-} | {
-    type: "dict";
-    indices: Uint32Array;
-    dictionary: Vector;
-    valid?: Uint8Array;
-} | {
-    type: "list";
-    offsets: Int32Array;
-    child: Vector;
-    valid?: Uint8Array;
-} | {
-    type: "struct";
-    fields: Record<string, Vector>;
-    length: number;
-    valid?: Uint8Array;
-} | {
-    type: "map";
-    offsets: Int32Array;
-    keys: Vector;
-    values: Vector;
-    valid?: Uint8Array;
-};
-interface Batch {
-    rowCount: number;
-    columns: Record<string, Vector>;
-}
-type Selection = Uint8Array;
-type VectorValue = unknown;
-declare function batchFromColumns(columns: Record<string, ArrayLike<VectorValue>>): Batch;
-declare function batchFromVectors(columns: Record<string, Vector>): Batch;
-declare function vectorFromValues(values: ArrayLike<VectorValue>): Vector;
-declare function materializeBatchRows(batch: Batch): Row[];
-declare function materializeSelectedBatchRows(batch: Batch, selection?: Selection): Row[];
-declare function selectedRowCount(rowCount: number, selection?: Selection): number;
-declare function selectedRowIndices(rowCount: number, selection?: Selection): Iterable<number>;
-declare function predicateSelection(batch: Batch, expr: Expr | undefined): Selection;
-declare function tryPredicateSelection(batch: Batch, expr: Expr | undefined): Selection | undefined;
-declare function vectorValue(vector: Vector, index: number): string | number | bigint | boolean | TimestampValue | unknown[] | Record<string, unknown> | null;
-declare function vectorLength(vector: Vector): number;
-interface BatchExprValues {
-    rowCount: number;
-    vector?: Vector;
-    literal?: Scalar;
-    valueAt(index: number): Scalar;
-}
-declare function batchExprValues(batch: Batch, expr: Expr): BatchExprValues;
-declare function scalarVectorValue(vector: Vector, index: number): Scalar;
-
-declare const ERROR_CODES: readonly ["LAKEQL_PARSE_ERROR", "LAKEQL_SQL_UNSUPPORTED", "LAKEQL_TYPE_ERROR", "LAKEQL_UNKNOWN_TABLE", "LAKEQL_UNKNOWN_COLUMN", "LAKEQL_UNSUPPORTED_PUSHDOWN", "LAKEQL_BUDGET_EXCEEDED", "LAKEQL_GROUP_LIMIT_EXCEEDED", "LAKEQL_OBJECT_NOT_FOUND", "LAKEQL_CATALOG_ERROR", "LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "LAKEQL_UNSUPPORTED_PARQUET_FEATURE", "LAKEQL_ICEBERG_COMMIT_CONFLICT", "LAKEQL_UNSUPPORTED_DELETE_FILES", "LAKEQL_PARQUET_READ_ERROR", "LAKEQL_PARQUET_WRITE_ERROR", "LAKEQL_VALIDATION_ERROR", "LAKEQL_BOOKMARK_STALE", "LAKEQL_BOOKMARK_INVALID", "LAKEQL_ABORTED", "LAKEQL_GEO_BACKEND_MISSING"];
-type LakeqlErrorCode = (typeof ERROR_CODES)[number];
-type ErrorDetails = Record<string, unknown>;
-declare class LakeqlError extends Error {
-    readonly code: LakeqlErrorCode;
-    readonly details: ErrorDetails;
-    constructor(code: LakeqlErrorCode, message: string, details?: ErrorDetails);
-}
-declare function isLakeqlError(value: unknown): value is LakeqlError;
-
-type SqlBoolean = boolean | null;
-/** External geometry/H3 primitives the evaluator can't compute from bbox math alone. */
-interface GeoBackend {
-    booleanContains(a: GeoJsonGeometry, b: GeoJsonGeometry): boolean;
-    booleanIntersects(a: GeoJsonGeometry, b: GeoJsonGeometry): boolean;
-    cellToParent(cell: string, res: number): string;
-    gridDisk(origin: string, k: number): string[];
-    isValidCell(cell: string): boolean;
-    latLngToCell(lat: number, lon: number, res: number): string;
-}
-/** Install the backend. Called by `./geo-backend.ts` once its libraries load. */
-declare function setGeoBackend(backend: GeoBackend): void;
-declare function requireGeoBackend(): GeoBackend;
-/** Force-load the geo backend (idempotent). Exposed for direct evaluate() callers. */
-declare function loadGeoBackend(): Promise<void>;
-/**
- * Load the geo backend iff any of `exprs` uses a backend-requiring spatial
- * function. Cheap no-op once the backend is installed or when no geo is present,
- * so query execution can call it unconditionally.
- */
-declare function ensureGeoBackendForExprs(exprs: Iterable<Expr | undefined>): Promise<void>;
-type EvalValue = Scalar;
-interface BBox {
-    minx: number;
-    miny: number;
-    maxx: number;
-    maxy: number;
-}
-declare function evaluate(expr: Expr, row: Row): EvalValue;
-declare function matches(expr: Expr | undefined, row: Row): boolean;
-declare function jsonSafeValue(value: unknown): unknown;
-declare function encodeJsonLine(row: Row): Uint8Array;
-declare function envelopeOf(geometry: GeoJsonGeometry): BBox;
-type GeoJsonGeometry = {
-    type: "Point";
-    coordinates: [number, number];
-} | {
-    type: "LineString";
-    coordinates: [number, number][];
-} | {
-    type: "Polygon";
-    coordinates: [number, number][][];
-};
-declare function toGeometry(parsed: Record<string, unknown>, name: string): GeoJsonGeometry;
-declare function parseGeometry(value: EvalValue, name: string): Record<string, unknown>;
-declare function envelopeFromGeometry(parsed: Record<string, unknown>, name: string): BBox;
-declare function bboxIntersects(left: BBox, right: BBox): boolean;
-
 interface PutOptions {
     contentType?: string;
     metadata?: Record<string, string>;
@@ -650,6 +445,82 @@ declare function buildBBoxIndex<T extends Record<string, unknown>>(rows: T[], co
     maxy: string;
 }): BBoxIndex;
 
+interface WindowReadColumnInput {
+    select?: string[];
+    orderBy?: OrderByTerm[];
+    projections?: Record<string, Expr>;
+    windows?: Record<string, WindowExpr>;
+    where?: Expr;
+    qualify?: Expr;
+}
+interface CompatibleWindowSortItem {
+    expr: WindowExpr;
+}
+interface CompatibleWindowSortGroup<T extends CompatibleWindowSortItem> {
+    sortExpr: WindowExpr;
+    items: T[];
+}
+type WindowTaskPlan = {
+    topology: "window-partition-fanout";
+    available: true;
+    bucketCount: number;
+    partitionBy: Expr[];
+} | {
+    topology: "window-partition-fanout";
+    available: false;
+    bucketCount: 1;
+    reason: string;
+};
+interface WindowExplainPlan {
+    expressions: number;
+    sortGroups: number;
+    qualify: boolean;
+    execution: WindowExecutionMode;
+    workUnits: WindowTaskPlan;
+}
+type WindowExecutionMode = "row-materialized" | "vector-window" | "parquet-work-unit-fanout";
+declare function windowReadColumns(input: WindowReadColumnInput): string[] | undefined;
+declare function windowExpressions(windows: Record<string, WindowExpr> | undefined): Expr[];
+declare function collectWindowColumns(expr: WindowExpr, columns: Set<string>): void;
+declare function compatibleWindowSortGroups<T extends CompatibleWindowSortItem>(items: readonly T[]): CompatibleWindowSortGroup<T>[];
+declare function windowSortGroupCount(windows: Record<string, WindowExpr>): number;
+declare function windowTaskPlanForWindows(windows: Record<string, WindowExpr>, plannedBucketCount: number): WindowTaskPlan;
+declare function windowSortSpecsCompatible(left: WindowExpr, right: WindowExpr): boolean;
+
+interface WindowOptions {
+    operatorState?: Uint8Array | WindowOperatorState | {
+        spillRef: string;
+    };
+    spill?: SpillAdapter;
+    spillId?: string;
+}
+interface WindowResult {
+    rows: Row[];
+    operatorState: Uint8Array;
+    operatorSpill?: SpillRef;
+}
+interface WindowOperatorState {
+    version: 1;
+    windows: Record<string, WindowExpr>;
+    rows?: Record<string, WindowSnapshotValue>[];
+    runs?: WindowRunState[];
+}
+type WindowSnapshotValue = string | number | boolean | null;
+type WindowRunState = {
+    rows: Record<string, WindowSnapshotValue>[];
+} | {
+    spillRef: string;
+    rowCount: number;
+    byteSize: number;
+};
+declare function serializeWindowOperatorState(state: WindowOperatorState): Uint8Array;
+declare function deserializeWindowOperatorState(bytes: Uint8Array | WindowOperatorState): WindowOperatorState;
+declare function windowRowsFromState(windows: Record<string, WindowExpr>, options: WindowOptions): Promise<Row[]>;
+declare function windowOperatorState(windows: Record<string, WindowExpr>, rows: Row[]): WindowOperatorState;
+declare function windowOperatorStateFromRuns(windows: Record<string, WindowExpr>, runs: readonly Row[][], spill: SpillAdapter | undefined, spillId: string): Promise<WindowOperatorState>;
+
+declare function parseJsonQuery(input: unknown): PathQueryInit;
+
 interface QueryBudget {
     maxFiles?: number;
     maxBytes?: number;
@@ -659,6 +530,8 @@ interface QueryBudget {
     maxElapsedMs?: number;
     /** Maximum rows an operator may buffer in memory for orderBy/top-k work. */
     maxBufferedRows?: number;
+    /** Maximum rows a single window partition may retain during window evaluation. */
+    maxWindowPartitionRows?: number;
     /** Maximum deterministic serialized bytes an in-memory operator may retain. */
     maxMemoryBytes?: number;
     /** Maximum object-store reads allowed to be in flight at once. */
@@ -690,6 +563,7 @@ interface LakeConfig {
 interface ScanOptions {
     columns?: string[];
     where?: Expr;
+    object?: ObjectInfo;
     rowStart?: number;
     rowEnd?: number;
     canStopEarly?: boolean;
@@ -704,7 +578,22 @@ interface ScanAdapter {
     scanColumns?(path: string, options: ScanOptions): AsyncIterable<Batch>;
     scanVectorBatches?(path: string, options: ScanOptions): AsyncIterable<ScanVectorBatch>;
     scanColumnBatches?(path: string, options: ScanOptions): AsyncIterable<ScanColumnBatch>;
+    planObjects?(objects: ObjectInfo[], options: ScanObjectPlanOptions): Promise<ObjectInfo[]>;
     planTask?(path: string, options: ScanTaskPlanOptions): Promise<ScanTaskPlan>;
+    executeWindowTasks?(tasks: TaskInput[], windows: Record<string, WindowExpr>, options: WindowTaskExecutionOptions): Promise<Row[]>;
+}
+interface ScanObjectPlanOptions {
+    columns?: string[];
+    where?: Expr;
+}
+interface WindowTaskExecutionOptions {
+    budget: QueryBudget;
+    stats: QueryStats;
+    now: () => number;
+    startedAt: number;
+    batchSize: number;
+    maxConcurrentTasks?: number;
+    maxBufferedPartials?: number;
 }
 interface ScanVectorBatch {
     rowOffset: number;
@@ -733,6 +622,8 @@ interface PathQueryInit {
     projections?: Record<string, Expr>;
     where?: Expr;
     distinct?: boolean;
+    windows?: Record<string, WindowExpr>;
+    qualify?: Expr;
     orderBy?: OrderByTerm[];
     limit?: number;
     offset?: number;
@@ -894,6 +785,7 @@ interface TaskInput {
     projectedColumns?: string[];
     residualPredicate?: Expr;
     partitionValues: Record<string, string>;
+    window?: WindowTaskPlan;
 }
 interface ExplainJson {
     queryId: string;
@@ -901,6 +793,7 @@ interface ExplainJson {
     filesSkipped: number;
     projectedColumns: string[];
     predicatePlan: PredicatePlan;
+    windowPlan?: WindowExplainPlan;
     tasks: TaskInput[];
 }
 interface ExplainResult {
@@ -941,137 +834,404 @@ type JsonExpr = {
 } | {
     between: [string, unknown, unknown];
 } | {
-    isNull: string;
+    isNull: string;
+} | {
+    isNotNull: string;
+} | {
+    like: [string, string];
+} | {
+    ilike: [string, string];
+} | {
+    and: JsonExpr[];
+} | {
+    or: JsonExpr[];
+} | {
+    not: JsonExpr;
+};
+declare class Lake {
+    readonly store: ObjectStore;
+    private readonly scanner;
+    private readonly budget;
+    private readonly policy;
+    private readonly now;
+    private readonly queryId;
+    private readonly substrate;
+    private readonly sidecarIndex;
+    private readonly planningCache;
+    constructor(config: LakeConfig);
+    path(source: string): QueryBuilder;
+    hive(source: string): QueryBuilder;
+    query(input: JsonQueryV1): QueryBuilder;
+    resume(bookmark: Bookmark): ResumedQuery;
+    createResult(init: PathQueryInit): QueryResult;
+}
+declare class ResumedQuery {
+    private readonly lake;
+    private readonly bookmark;
+    constructor(lake: Lake, bookmark: Bookmark);
+    run(options: QueryRunOptions): Promise<SliceResult>;
+}
+declare class QueryBuilder {
+    private readonly lake;
+    private readonly init;
+    constructor(lake: Lake, init: PathQueryInit);
+    select(columns: string[]): QueryBuilder;
+    project(projections: Record<string, Expr>): QueryBuilder;
+    window(alias: string, expr: WindowExpr): QueryBuilder;
+    qualify(expr: Expr): QueryBuilder;
+    where(expr: Expr): QueryBuilder;
+    distinct(enabled?: boolean): QueryBuilder;
+    orderBy(terms: OrderByTerm[]): QueryBuilder;
+    limit(limit: number): QueryBuilder;
+    offset(offset: number): QueryBuilder;
+    batchSize(batchSize: number): QueryBuilder;
+    explain(): Promise<ExplainResult>;
+    planTasks(): Promise<TaskInput[]>;
+    taskManifest(jobId?: string): Promise<TaskManifest>;
+    run(): QueryResult;
+    run(options: QueryRunOptions): Promise<SliceResult>;
+    rows(): AsyncIterable<Row>;
+    batches(): AsyncIterable<Row[]>;
+    toArray(): Promise<Row[]>;
+    topKWithState(options?: TopKOptions): Promise<TopKResult>;
+    sortWithState(options?: SortOptions): Promise<SortResult>;
+    windowWithState(options?: WindowOptions): Promise<WindowResult>;
+    first(): Promise<Row | undefined>;
+    count(): Promise<number>;
+    streamNdjson(): ReadableStream<Uint8Array>;
+    streamJson(): ReadableStream<Uint8Array>;
+    streamCsv(options?: CsvStreamOptions): ReadableStream<Uint8Array>;
+    resumableBatches(options: ResumableBatchOptions): AsyncIterable<SliceResult>;
+    groupBy(columns: string[]): AggregationBuilder;
+}
+declare class AggregationBuilder {
+    private readonly result;
+    private readonly columns;
+    constructor(result: QueryResult, columns: string[]);
+    aggregate(spec: AggregateSpec, options?: AggregateOptions): Promise<Row[]>;
+    aggregateWithState(spec: AggregateSpec, options?: AggregateOptions): Promise<AggregateResult>;
+}
+interface QueryResultConfig extends PathQueryInit {
+    lake: Lake;
+    bookmarkQuery: BookmarkQuery;
+    scanner: ScanAdapter;
+    budget: QueryBudget;
+    now: () => number;
+    queryId: string;
+    metrics?: MetricsHook;
+    sidecarIndex?: SidecarFileIndex[];
+    planningCache?: CacheAdapter<ObjectInfo[]>;
+}
+declare class QueryResult {
+    readonly stats: QueryStats;
+    private readonly config;
+    constructor(config: QueryResultConfig);
+    rows(): AsyncIterable<Row>;
+    private matchedRows;
+    batches(): AsyncIterable<Row[]>;
+    private windowedBatches;
+    private windowRunnerOptions;
+    private tryColumnarProjectedBatches;
+    private columnarProjectedBatches;
+    private lateMaterializedLimitRows;
+    toArray(): Promise<Row[]>;
+    topKWithState(options?: TopKOptions): Promise<TopKResult>;
+    sortWithState(options?: SortOptions): Promise<SortResult>;
+    windowWithState(options?: WindowOptions): Promise<WindowResult>;
+    first(): Promise<Row | undefined>;
+    count(): Promise<number>;
+    planTasks(): Promise<TaskInput[]>;
+    taskManifest(jobId?: string): Promise<TaskManifest>;
+    slice(options: SliceOptions): Promise<SliceResult>;
+    resumableBatches(options: ResumableBatchOptions): AsyncIterable<SliceResult>;
+    aggregate(groupColumns: string[], spec: AggregateSpec, options?: AggregateOptions): Promise<Row[]>;
+    private tryColumnarAggregateRows;
+    private tryLateMaterializedAggregateRows;
+    private aggregateMaterializedRows;
+    aggregateWithState(groupColumns: string[], spec: AggregateSpec, options?: AggregateOptions): Promise<AggregateResult>;
+    private orderedBatches;
+    private tryColumnarTopKRows;
+    private tryLateMaterializedTopKRows;
+    private materializeRowRefs;
+    private columnBatches;
+    private collectOrderedMatches;
+    private collectSortRuns;
+    explain(): Promise<ExplainResult>;
+    private tasksFromObjects;
+    private planObjects;
+    streamNdjson(): ReadableStream<Uint8Array>;
+    streamJson(): ReadableStream<Uint8Array>;
+    streamCsv(options?: CsvStreamOptions): ReadableStream<Uint8Array>;
+}
+declare function serializeAggregateOperatorState(state: AggregateOperatorState): Uint8Array;
+declare function deserializeAggregateOperatorState(bytes: Uint8Array | AggregateOperatorState): AggregateOperatorState;
+declare function serializeTopKOperatorState(state: TopKOperatorState): Uint8Array;
+declare function serializeSortOperatorState(state: SortOperatorState): Uint8Array;
+declare function deserializeTopKOperatorState(bytes: Uint8Array | TopKOperatorState): TopKOperatorState;
+declare function deserializeSortOperatorState(bytes: Uint8Array | SortOperatorState): SortOperatorState;
+declare function parseHivePartitions(path: string): Record<string, string>;
+
+interface WindowOrderTerm {
+    expr: Expr;
+    direction?: "asc" | "desc";
+    nulls?: "first" | "last";
+}
+interface WindowFrameBound {
+    kind: "unbounded-preceding" | "preceding" | "current-row" | "following" | "unbounded-following";
+    offset?: Expr;
+}
+interface WindowFrame {
+    mode: "rows" | "range" | "groups";
+    start: WindowFrameBound;
+    end: WindowFrameBound;
+    exclude: "no-others" | "current-row" | "group" | "ties";
+}
+type WindowRankingFn = "row_number" | "rank" | "dense_rank" | "percent_rank" | "cume_dist" | "ntile";
+type WindowValueFn = "lag" | "lead" | "first_value" | "last_value" | "nth_value";
+type WindowFn = WindowRankingFn | WindowValueFn | {
+    aggregate: AggregateOp;
+};
+interface WindowSpec {
+    partitionBy: Expr[];
+    orderBy: WindowOrderTerm[];
+    frame?: WindowFrame;
+}
+interface WindowExpr {
+    fn: WindowFn;
+    args: Expr[];
+    over: WindowSpec;
+    filter?: Expr;
+    ignoreNulls?: boolean;
+    distinct?: boolean;
+}
+
+type Row = Record<string, unknown>;
+interface BookmarkQuery {
+    source: string;
+    select?: string[];
+    projections?: Record<string, Expr>;
+    where?: Expr;
+    distinct?: boolean;
+    windows?: Record<string, WindowExpr>;
+    qualify?: Expr;
+    orderBy?: {
+        column: string;
+        direction?: "asc" | "desc";
+        nulls?: "first" | "last";
+    }[];
+    limit?: number;
+    offset?: number;
+    batchSize?: number;
+    hive?: boolean;
+}
+/**
+ * A serializable position in a running query. Bookmarks are plain values:
+ * the engine only produces and consumes them, and the caller moves them
+ * over whatever transport it likes (queue, KV, URL, cron state).
+ */
+interface Bookmark {
+    version: 1;
+    planFingerprint: string;
+    snapshot: string;
+    query?: BookmarkQuery;
+    position: {
+        fileIndex: number;
+        rowGroup: number;
+        rowOffset: number;
+        taskId?: string;
+        outputManifestCursor?: number;
+    };
+    writeState?: {
+        taskState?: "planned" | "running" | "output-written" | "manifest-recorded" | "complete";
+        idempotencyKey?: string;
+        multipart?: {
+            uploadId: string;
+            path: string;
+            parts: {
+                partNumber: number;
+                etag: string;
+                byteSize: number;
+            }[];
+        };
+    };
+    operatorState?: {
+        limitEmitted?: number;
+        groupBy?: Uint8Array | {
+            spillRef: string;
+        };
+        topK?: Uint8Array | {
+            spillRef: string;
+        };
+        sort?: Uint8Array | {
+            spillRef: string;
+        };
+        sketches?: Record<string, Uint8Array>;
+    };
+}
+interface SliceResult {
+    rows: Row[];
+    /** Absent when the query completed. */
+    bookmark?: Bookmark;
+}
+interface QueryStats {
+    queryId: string;
+    elapsedMs: number;
+    manifestsRead: number;
+    manifestsSkipped: number;
+    filesPlanned: number;
+    filesRead: number;
+    filesSkipped: number;
+    rowGroupsRead: number;
+    rowGroupsSkipped: number;
+    columnsRead: string[];
+    bytesRequested: number;
+    rangeRequests: number;
+    rowsDecoded: number;
+    rowsMatched: number;
+    rowsReturned: number;
+    cacheHits: number;
+    cacheMisses: number;
+}
+
+type Vector = {
+    type: "null";
+    length: number;
+} | {
+    type: "f64";
+    values: Float64Array;
+    valid?: Uint8Array;
+} | {
+    type: "i64";
+    values: BigInt64Array;
+    valid?: Uint8Array;
+} | {
+    type: "timestamp";
+    values: BigInt64Array;
+    unit: TimestampUnit;
+    isAdjustedToUTC: boolean;
+    valid?: Uint8Array;
+} | {
+    type: "bool";
+    values: Uint8Array;
+    valid?: Uint8Array;
 } | {
-    isNotNull: string;
+    type: "utf8";
+    values: string[];
+    valid?: Uint8Array;
 } | {
-    like: [string, string];
+    type: "binary";
+    values: Uint8Array[];
+    valid?: Uint8Array;
 } | {
-    ilike: [string, string];
+    type: "dict";
+    indices: Uint32Array;
+    dictionary: Vector;
+    valid?: Uint8Array;
 } | {
-    and: JsonExpr[];
+    type: "list";
+    offsets: Int32Array;
+    child: Vector;
+    valid?: Uint8Array;
 } | {
-    or: JsonExpr[];
+    type: "struct";
+    fields: Record<string, Vector>;
+    length: number;
+    valid?: Uint8Array;
 } | {
-    not: JsonExpr;
+    type: "map";
+    offsets: Int32Array;
+    keys: Vector;
+    values: Vector;
+    valid?: Uint8Array;
 };
-declare class Lake {
-    readonly store: ObjectStore;
-    private readonly scanner;
-    private readonly budget;
-    private readonly policy;
-    private readonly now;
-    private readonly queryId;
-    private readonly substrate;
-    private readonly sidecarIndex;
-    private readonly planningCache;
-    constructor(config: LakeConfig);
-    path(source: string): QueryBuilder;
-    hive(source: string): QueryBuilder;
-    query(input: JsonQueryV1): QueryBuilder;
-    resume(bookmark: Bookmark): ResumedQuery;
-    createResult(init: PathQueryInit): QueryResult;
-}
-declare class ResumedQuery {
-    private readonly lake;
-    private readonly bookmark;
-    constructor(lake: Lake, bookmark: Bookmark);
-    run(options: QueryRunOptions): Promise<SliceResult>;
+interface Batch {
+    rowCount: number;
+    columns: Record<string, Vector>;
 }
-declare class QueryBuilder {
-    private readonly lake;
-    private readonly init;
-    constructor(lake: Lake, init: PathQueryInit);
-    select(columns: string[]): QueryBuilder;
-    project(projections: Record<string, Expr>): QueryBuilder;
-    where(expr: Expr): QueryBuilder;
-    distinct(enabled?: boolean): QueryBuilder;
-    orderBy(terms: OrderByTerm[]): QueryBuilder;
-    limit(limit: number): QueryBuilder;
-    offset(offset: number): QueryBuilder;
-    batchSize(batchSize: number): QueryBuilder;
-    explain(): Promise<ExplainResult>;
-    planTasks(): Promise<TaskInput[]>;
-    taskManifest(jobId?: string): Promise<TaskManifest>;
-    run(): QueryResult;
-    run(options: QueryRunOptions): Promise<SliceResult>;
-    rows(): AsyncIterable<Row>;
-    batches(): AsyncIterable<Row[]>;
-    toArray(): Promise<Row[]>;
-    topKWithState(options?: TopKOptions): Promise<TopKResult>;
-    sortWithState(options?: SortOptions): Promise<SortResult>;
-    first(): Promise<Row | undefined>;
-    count(): Promise<number>;
-    streamNdjson(): ReadableStream<Uint8Array>;
-    streamJson(): ReadableStream<Uint8Array>;
-    streamCsv(options?: CsvStreamOptions): ReadableStream<Uint8Array>;
-    resumableBatches(options: ResumableBatchOptions): AsyncIterable<SliceResult>;
-    groupBy(columns: string[]): AggregationBuilder;
+type Selection = Uint8Array;
+type VectorValue = unknown;
+declare function batchFromColumns(columns: Record<string, ArrayLike<VectorValue>>): Batch;
+declare function batchFromVectors(columns: Record<string, Vector>): Batch;
+declare function vectorFromValues(values: ArrayLike<VectorValue>): Vector;
+declare function materializeBatchRows(batch: Batch): Row[];
+declare function materializeBatchRow(batch: Batch, index: number): Row;
+declare function materializeSelectedBatchRows(batch: Batch, selection?: Selection): Row[];
+declare function selectedRowCount(rowCount: number, selection?: Selection): number;
+declare function selectedRowIndices(rowCount: number, selection?: Selection): Iterable<number>;
+declare function predicateSelection(batch: Batch, expr: Expr | undefined): Selection;
+declare function tryPredicateSelection(batch: Batch, expr: Expr | undefined): Selection | undefined;
+declare function vectorValue(vector: Vector, index: number): string | number | bigint | boolean | Uint8Array | TimestampValue | unknown[] | Record<string, unknown> | null;
+declare function vectorLength(vector: Vector): number;
+interface BatchExprValues {
+    rowCount: number;
+    vector?: Vector;
+    literal?: Scalar;
+    valueAt(index: number): Scalar;
 }
-declare class AggregationBuilder {
-    private readonly result;
-    private readonly columns;
-    constructor(result: QueryResult, columns: string[]);
-    aggregate(spec: AggregateSpec, options?: AggregateOptions): Promise<Row[]>;
-    aggregateWithState(spec: AggregateSpec, options?: AggregateOptions): Promise<AggregateResult>;
+declare function batchExprValues(batch: Batch, expr: Expr): BatchExprValues;
+declare function scalarVectorValue(vector: Vector, index: number): Scalar;
+
+declare const ERROR_CODES: readonly ["LAKEQL_PARSE_ERROR", "LAKEQL_SQL_UNSUPPORTED", "LAKEQL_TYPE_ERROR", "LAKEQL_UNKNOWN_TABLE", "LAKEQL_UNKNOWN_COLUMN", "LAKEQL_UNSUPPORTED_PUSHDOWN", "LAKEQL_BUDGET_EXCEEDED", "LAKEQL_GROUP_LIMIT_EXCEEDED", "LAKEQL_OBJECT_NOT_FOUND", "LAKEQL_NO_FILES_MATCHED", "LAKEQL_SCHEMA_CONFLICT", "LAKEQL_CATALOG_ERROR", "LAKEQL_UNSUPPORTED_ICEBERG_FEATURE", "LAKEQL_UNSUPPORTED_PARQUET_FEATURE", "LAKEQL_ICEBERG_COMMIT_CONFLICT", "LAKEQL_UNSUPPORTED_DELETE_FILES", "LAKEQL_PARQUET_READ_ERROR", "LAKEQL_PARQUET_WRITE_ERROR", "LAKEQL_VALIDATION_ERROR", "LAKEQL_BOOKMARK_STALE", "LAKEQL_BOOKMARK_INVALID", "LAKEQL_ABORTED", "LAKEQL_GEO_BACKEND_MISSING"];
+type LakeqlErrorCode = (typeof ERROR_CODES)[number];
+type ErrorDetails = Record<string, unknown>;
+declare class LakeqlError extends Error {
+    readonly code: LakeqlErrorCode;
+    readonly details: ErrorDetails;
+    constructor(code: LakeqlErrorCode, message: string, details?: ErrorDetails);
 }
-interface QueryResultConfig extends PathQueryInit {
-    lake: Lake;
-    bookmarkQuery: BookmarkQuery;
-    scanner: ScanAdapter;
-    budget: QueryBudget;
-    now: () => number;
-    queryId: string;
-    metrics?: MetricsHook;
-    sidecarIndex?: SidecarFileIndex[];
-    planningCache?: CacheAdapter<ObjectInfo[]>;
+declare function isLakeqlError(value: unknown): value is LakeqlError;
+
+type SqlBoolean = boolean | null;
+/** External geometry/H3 primitives the evaluator can't compute from bbox math alone. */
+interface GeoBackend {
+    booleanContains(a: GeoJsonGeometry, b: GeoJsonGeometry): boolean;
+    booleanIntersects(a: GeoJsonGeometry, b: GeoJsonGeometry): boolean;
+    cellToParent(cell: string, res: number): string;
+    gridDisk(origin: string, k: number): string[];
+    isValidCell(cell: string): boolean;
+    latLngToCell(lat: number, lon: number, res: number): string;
 }
-declare class QueryResult {
-    readonly stats: QueryStats;
-    private readonly config;
-    constructor(config: QueryResultConfig);
-    rows(): AsyncIterable<Row>;
-    private matchedRows;
-    batches(): AsyncIterable<Row[]>;
-    private tryColumnarProjectedBatches;
-    private columnarProjectedBatches;
-    private lateMaterializedLimitRows;
-    toArray(): Promise<Row[]>;
-    topKWithState(options?: TopKOptions): Promise<TopKResult>;
-    sortWithState(options?: SortOptions): Promise<SortResult>;
-    first(): Promise<Row | undefined>;
-    count(): Promise<number>;
-    planTasks(): Promise<TaskInput[]>;
-    taskManifest(jobId?: string): Promise<TaskManifest>;
-    slice(options: SliceOptions): Promise<SliceResult>;
-    resumableBatches(options: ResumableBatchOptions): AsyncIterable<SliceResult>;
-    aggregate(groupColumns: string[], spec: AggregateSpec, options?: AggregateOptions): Promise<Row[]>;
-    private tryColumnarAggregateRows;
-    private tryLateMaterializedAggregateRows;
-    private aggregateMaterializedRows;
-    aggregateWithState(groupColumns: string[], spec: AggregateSpec, options?: AggregateOptions): Promise<AggregateResult>;
-    private orderedBatches;
-    private tryColumnarTopKRows;
-    private tryLateMaterializedTopKRows;
-    private materializeRowRefs;
-    private columnBatches;
-    private collectOrderedMatches;
-    private collectSortRuns;
-    explain(): Promise<ExplainResult>;
-    private tasksFromObjects;
-    private planObjects;
-    streamNdjson(): ReadableStream<Uint8Array>;
-    streamJson(): ReadableStream<Uint8Array>;
-    streamCsv(options?: CsvStreamOptions): ReadableStream<Uint8Array>;
+/** Install the backend. Called by `./geo-backend.ts` once its libraries load. */
+declare function setGeoBackend(backend: GeoBackend): void;
+declare function requireGeoBackend(): GeoBackend;
+/** Force-load the geo backend (idempotent). Exposed for direct evaluate() callers. */
+declare function loadGeoBackend(): Promise<void>;
+/**
+ * Load the geo backend iff any of `exprs` uses a backend-requiring spatial
+ * function. Cheap no-op once the backend is installed or when no geo is present,
+ * so query execution can call it unconditionally.
+ */
+declare function ensureGeoBackendForExprs(exprs: Iterable<Expr | undefined>): Promise<void>;
+type EvalValue = Scalar;
+interface BBox {
+    minx: number;
+    miny: number;
+    maxx: number;
+    maxy: number;
 }
-declare function serializeAggregateOperatorState(state: AggregateOperatorState): Uint8Array;
-declare function deserializeAggregateOperatorState(bytes: Uint8Array | AggregateOperatorState): AggregateOperatorState;
-declare function serializeTopKOperatorState(state: TopKOperatorState): Uint8Array;
-declare function serializeSortOperatorState(state: SortOperatorState): Uint8Array;
-declare function deserializeTopKOperatorState(bytes: Uint8Array | TopKOperatorState): TopKOperatorState;
-declare function deserializeSortOperatorState(bytes: Uint8Array | SortOperatorState): SortOperatorState;
-declare function parseJsonQuery(input: unknown): PathQueryInit;
-declare function parseHivePartitions(path: string): Record<string, string>;
+declare function evaluate(expr: Expr, row: Row): EvalValue;
+declare function matches(expr: Expr | undefined, row: Row): boolean;
+declare function jsonSafeValue(value: unknown): unknown;
+declare function encodeJsonLine(row: Row): Uint8Array;
+declare function envelopeOf(geometry: GeoJsonGeometry): BBox;
+type GeoJsonGeometry = {
+    type: "Point";
+    coordinates: [number, number];
+} | {
+    type: "LineString";
+    coordinates: [number, number][];
+} | {
+    type: "Polygon";
+    coordinates: [number, number][][];
+};
+declare function toGeometry(parsed: Record<string, unknown>, name: string): GeoJsonGeometry;
+declare function parseGeometry(value: EvalValue, name: string): Record<string, unknown>;
+declare function envelopeFromGeometry(parsed: Record<string, unknown>, name: string): BBox;
+declare function bboxIntersects(left: BBox, right: BBox): boolean;
+declare function bboxDistance(left: BBox, right: BBox): number;
+declare function geometryDistance(left: GeoJsonGeometry, right: GeoJsonGeometry): number;
+
+declare function collectExprColumns(expr: Expr | undefined, columns: Set<string>): void;
 
 interface InMemoryTableOptions {
     maxRows?: number;
@@ -1147,6 +1307,8 @@ declare class MemoryObjectStore implements ObjectStore {
 }
 declare function memoryStore(): MemoryObjectStore;
 
+declare function isPrototypeMutationKey(key: string): boolean;
+
 interface ObjectStoreCacheOptions {
     /** Maximum cached object/range bytes retained in memory. Defaults to 64 MiB. */
     maxBytes?: number;
@@ -1391,6 +1553,36 @@ declare function vectorTopKIndices(batch: Batch, orderBy: readonly OrderByTerm[]
 declare function gatherBatch(batch: Batch, indices: readonly number[]): Batch;
 declare function concatBatches(batches: readonly Batch[]): Batch;
 
+interface WindowExecutionOptions {
+    estimateMemoryBytes?: (value: unknown) => number;
+    enforceBufferedRows?: (rows: number) => void;
+    enforceWindowPartitionRows?: (rows: number) => void;
+    enforceMemoryBytes?: (bytes: number) => void;
+}
+
+interface WindowWorkUnitRow {
+    ordinal: WindowWorkUnitOrdinal;
+    row: Row;
+}
+interface WindowWorkUnitOrdinal {
+    task: number;
+    row: number;
+}
+interface WindowWorkUnitBucket {
+    bucket: number;
+    rows: WindowWorkUnitRow[];
+}
+interface WindowWorkUnitPartial {
+    bucketCount: number;
+    buckets: WindowWorkUnitBucket[];
+}
+interface WindowWorkUnitEvaluationOptions extends WindowExecutionOptions {
+    bucketCount?: number;
+}
+declare function partitionWindowWorkUnitRows(rows: readonly WindowWorkUnitRow[], windows: Record<string, WindowExpr>, bucketCount: number): WindowWorkUnitPartial;
+declare function evaluateWindowWorkUnitPartials(partials: readonly WindowWorkUnitPartial[], windows: Record<string, WindowExpr>, options?: WindowWorkUnitEvaluationOptions): Promise<Row[]>;
+declare function windowPartitionBucket(row: Row, windows: Record<string, WindowExpr>, bucketCount: number): number;
+
 interface WorkUnitFanInOptions<Input, Partial, Accumulator> {
     inputs: readonly Input[];
     initial: Accumulator;
@@ -1791,6 +1983,9 @@ interface ScanParquetTaskOptions {
     batchSize?: number;
     stats?: QueryStats;
     metadataCache?: CacheAdapter<ParquetMetadata>;
+    budget?: QueryBudget;
+    now?: () => number;
+    startedAt?: number;
 }
 interface PlanParquetTaskWorkUnitsOptions {
     maxRowGroupsPerTask?: number;
@@ -1842,11 +2037,13 @@ declare class ParquetScanAdapter implements ScanAdapter {
         decodedColumnCache?: DecodedColumnCache;
         scanRangeCache?: RangeCacheOptions;
     });
+    planObjects(objects: ObjectInfo[], _options: ScanObjectPlanOptions): Promise<ObjectInfo[]>;
     scan(path: string, options: ScanOptions): AsyncIterable<Row[]>;
     scanColumns(path: string, options: ScanOptions): AsyncIterable<Batch>;
     scanColumnBatches(path: string, options: ScanOptions): AsyncIterable<ScanColumnBatch>;
     scanVectorBatches(path: string, options: ScanOptions): AsyncIterable<ScanVectorBatch>;
     planTask(path: string, options: ScanTaskPlanOptions): Promise<ScanTaskPlan>;
+    executeWindowTasks(tasks: TaskInput[], windows: Record<string, WindowExpr>, options: WindowTaskExecutionOptions): Promise<Row[]>;
     private metadata;
     private scanBuffer;
 }
@@ -1867,6 +2064,16 @@ declare function planParquetTaskWorkUnits(store: ObjectStore, task: TaskInput, o
 /** Read Parquet footer metadata (row groups, schema, stats). */
 declare function readParquetMetadata(store: ObjectStore, path: string, metadataCache?: ScanParquetTaskOptions["metadataCache"]): Promise<ParquetMetadata>;
 
+interface WindowParquetTasksOptions extends ScanParquetTaskOptions {
+    bucketCount?: number;
+    budget?: QueryBudget;
+    maxConcurrentTasks?: number;
+    maxBufferedPartials?: number;
+    partialBoundary?(partial: WindowWorkUnitPartial, task: TaskInput, index: number): WindowWorkUnitPartial | Promise<WindowWorkUnitPartial>;
+}
+declare function windowParquetTask(store: ObjectStore, task: TaskInput, windows: Record<string, WindowExpr>, index: number, options?: WindowParquetTasksOptions): Promise<WindowWorkUnitPartial>;
+declare function windowParquetTasks(store: ObjectStore, tasks: TaskInput[], windows: Record<string, WindowExpr>, options?: WindowParquetTasksOptions): Promise<Row[]>;
+
 interface PlanParquetRowGroupsOptions {
     where?: Expr;
 }
@@ -2026,4 +2233,40 @@ declare function planFiles(table: EngineTable, options?: PlanIcebergFilesOptions
 declare function scanBatches(plan: EngineFilePlan, options?: ScanEngineOptions): AsyncIterable<ScanBatch>;
 declare function scanRows(plan: EngineFilePlan, options?: ScanEngineOptions): AsyncIterable<Row>;
 
-export { type AggregateExpr, type AggregateGroupSnapshot, type AggregateOp, type AggregateOperatorState, type AggregateOptions, type AggregateParquetGroupTaskOptions, type AggregateParquetGroupTasksOptions, type AggregateParquetTaskOptions, type AggregateParquetTasksOptions, type AggregateResult, type AggregateSnapshotValue, type AggregateSpec, type AggregateStateSnapshot, AggregationBuilder, type ApplyIcebergDeletesOptions, type ArithmeticExpr, type BBox, type BBoxIndex, type Batch, type BatchExprValues, type BetweenExpr, type Bookmark, type BookmarkInit, type BookmarkPosition, type BookmarkQuery, type BroadcastJoinOptions, type CacheAdapter, CacheApiCache, type CacheApiCacheOptions, type CacheEntry, type CachePolicy, type CallExpr, type CaseExpr, type CaseWhenExpr, type CheckpointAdapter, type CheckpointStore, type Clock, type ColumnExpr, type ColumnInput, type CompareExpr, type CompareOp, type ConditionalObjectStore, type ConditionalPutOptions, type CreateParquetTableAsOptions, type CreateParquetTableAsQuery, type CreateParquetTableAsResult, type CsvStreamOptions, type DecodedIcebergDeletes, type DecodedIcebergParquetDeletes, ERROR_CODES, type EngineFilePlan, type EngineTable, type ErrorDetails, type ExplainJson, type ExplainResult, type Expr, type GeoBackend, type GeoJsonGeometry, type IcebergAppendFile, type IcebergAppendOptions, type IcebergAppendOutputManifestOptions, type IcebergAppendResult, type IcebergCatalog, type IcebergCommitCatalog, type IcebergCommitInput, type IcebergCommitResult, type IcebergDeleteFile, type IcebergDeletionVector, type IcebergEnginePlan, type IcebergEngineTable, type IcebergEqualityDelete, type IcebergField, type IcebergGlueCatalogOptions, type IcebergLoadTableOptions, type IcebergNessieCatalogOptions, type IcebergParquetDeleteFile, type IcebergParquetDeleteFileContent, type IcebergPartitionField, type IcebergPartitionSpec, type IcebergPlan, type IcebergPositionDelete, type IcebergReadMode, type IcebergRestAccessDelegation, IcebergRestCatalog, type IcebergRestCatalogConfig, type IcebergRestCatalogOptions, type IcebergRestLoadContext, type IcebergRestLoadTableOptions, type IcebergRestLoadTableResult, type IcebergRestStorageCredential, type IcebergRowBatch, type IcebergSortOrder, IcebergTable, type IcebergTableIdentifier, IcebergUnsupportedCatalog, type IdGenerator, type InExpr, type InMemoryLakeOptions, InMemoryRowsScanner, InMemoryRowsStore, type InMemoryTableOptions, type IndexPruneResult, type IndexValue, type InsertValidationRules, type JoinKey, type JoinType, type JsonExpr, type JsonOrderByTerm, type JsonQueryV1, Lake, type LakeConfig, LakeqlError, type LakeqlErrorCode, type LikeExpr, type ListOptions, type LiteralExpr, type LoadIcebergEngineTableOptions, type LoadIcebergTableFromObjectStoreOptions, type LoadIcebergTableFromRestOptions, type LoadIcebergTableOptions, type LoadParquetEngineTableOptions, type LoadTableOptions, type LockAdapter, type LogHook, type LogicalExpr, type LookupJoinFunction, type LookupJoinOptions, type Manifest, type ManifestDeleteFile, type ManifestFile, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, type MemorySpillAdapterOptions, type MetadataFile, type MetricsHook, type MinMaxColumnIndex, type NotExpr, type NullCheckExpr, type ObjectHead, type ObjectInfo, type ObjectStore, type ObjectStoreCacheOptions, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, type ObjectStoreJsonCacheOptions, type ObjectStoreReadControls, type ObjectStoreUriAuthority, type OperatorSnapshotValue, type OrderByTerm, type OutputManifest, type OutputManifestEntry, PACKAGE, type ParquetColumnBatch, type ParquetEnginePlan, type ParquetEngineTable, type ParquetLakeConfig, type ParquetMetadata, type ParquetRowBatch, type ParquetRowGroupPlan, ParquetScanAdapter, type PartitionedParquetOutputEntryOptions, type PathQueryInit, type PlanIcebergFilesOptions, type PlanParquetRowGroupsOptions, type PlanParquetTaskWorkUnitsOptions, type PlannedIcebergFile, type PlannedParquetRowGroup, type PredicatePlan, type PredicatePlanOptions, type ProjectIcebergRowOptions, type PutOptions, type QueryBudget, QueryBuilder, type QueryPolicy, type QueryPolicyContext, QueryResult, type QueryRunOptions, type QueryStats, type QueueAdapter, type ReadParquetBatchOptions, type ReadParquetOptions, type ResumableBatchOptions, ResumedQuery, type Row, type RuntimeSubstrate, type Scalar, type ScanAdapter, type ScanBatch, type ScanColumnBatch, type ScanEngineOptions, type ScanOptions, type ScanParquetTaskOptions, type ScanPlannedIcebergRowsOptions, type ScanTaskPlan, type ScanTaskPlanOptions, type ScanVectorBatch, type Selection, type SharedCacheEntry, type SharedCacheSetOptions, SharedMemoryCache, type SidecarFileIndex, type SliceOptions, type SliceResult, type Snapshot, type SortOperatorState, type SortOptions, type SortResult, type SortRunState, type SpillAdapter, type SpillRef, type SpillUsage, type SqlBoolean, type TaskCheckpoint, type TaskInput, type TaskManifest, type TaskManifestTask, type TaskState, type TaskTransitionInput, type TimestampUnit, TimestampValue, type TopKOperatorState, type TopKOptions, type TopKResult, type ValueInput, type Vector, type VectorAggregateOptions, type VectorAggregateSnapshotValue, type VectorAggregateState, type VectorAggregateStateSnapshot, type VectorAggregateStateSnapshots, type VectorAggregateStates, type VectorAggregateValue, type VectorGroup, type VectorGroupByGroupSnapshot, type VectorGroupByOptions, type VectorGroupBySnapshotValue, type VectorGroupByState, type VectorGroupByStateSnapshot, type VectorHashJoinOptions, type VectorProjectionSpec, type VectorTopKOptions, type WorkUnitFanInOptions, type WriteParquetOptions, type WriteParquetRowsOptions, type WritePartitionedParquetFile, type WritePartitionedParquetResult, type WritePartitionedParquetTaskOptions, type WritePartitionedParquetTaskResult, add, advanceTaskCheckpoint, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, applyIcebergDeletes, assertBookmarkMatches, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxIntersects, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, compareTimestampValues, concatBatches, createBookmark, createInMemoryLake, createParquetLake as createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, div, encodeJsonLine, enforceVectorGroupByBudget, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, eq, evaluate, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fingerprint, fn, gatherBatch, getOrCreateVectorGroup, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, inMemoryRowsScanner, isIn, isLakeqlError, isNotNull, isNull, isTimestampValue, jsonSafeValue, jsonWorkUnitBoundary, like, lit, loadGeoBackend, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, objectStoreJsonCache, or, parquetScanner, parseGeometry, parseHivePartitions, parseJsonQuery, partitionedParquetOutputEntries, planFiles, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, requireGeoBackend, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanBatches, scanParquetTaskBatches, scanParquetTaskColumnBatches, scanPlannedIcebergRows, scanRows, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, setGeoBackend, signPaginationToken, snapshotVectorAggregateStates, snapshotVectorGroupByState, stableStringify, sub, throwIfAborted, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry, transitionTaskCheckpoint, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorHashJoin, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask };
+type SqlParameterValue = Scalar;
+
+interface SqlQueryOptions {
+    path?: string;
+    tables?: Record<string, string>;
+    parameters?: readonly SqlParameterValue[];
+    joinMaxRightRows?: number;
+}
+interface SqlCsvOptions {
+    /**
+     * Prefix cells that spreadsheet apps may interpret as formulae. Defaults to
+     * false so CSV remains a faithful data export unless a spreadsheet-targeted
+     * response opts in.
+     */
+    preventFormulae?: boolean;
+}
+type SqlLake = ReturnType<typeof createParquetLake> & {
+    sql(sql: string, options?: SqlQueryOptions): SqlQueryResult;
+};
+type ParquetLake = ReturnType<typeof createParquetLake>;
+declare function createLake(config: ParquetLakeConfig): SqlLake;
+declare function querySql(lake: ParquetLake, sql: string, options?: SqlQueryOptions): SqlQueryResult;
+declare class SqlQueryResult {
+    private readonly execute;
+    private rowsPromise;
+    constructor(execute: () => Promise<Row[]>);
+    toArray(): Promise<Row[]>;
+    first(): Promise<Row | undefined>;
+    count(): Promise<number>;
+    rows(): AsyncIterable<Row>;
+    batches(): AsyncIterable<Row[]>;
+    streamJson(): ReadableStream<Uint8Array>;
+    streamNdjson(): ReadableStream<Uint8Array>;
+    streamCsv(options?: SqlCsvOptions): ReadableStream<Uint8Array>;
+}
+
+export { type AggregateExpr, type AggregateGroupSnapshot, type AggregateOp, type AggregateOperatorState, type AggregateOptions, type AggregateParquetGroupTaskOptions, type AggregateParquetGroupTasksOptions, type AggregateParquetTaskOptions, type AggregateParquetTasksOptions, type AggregateResult, type AggregateSnapshotValue, type AggregateSpec, type AggregateStateSnapshot, AggregationBuilder, type ApplyIcebergDeletesOptions, type ArithmeticExpr, type BBox, type BBoxIndex, type Batch, type BatchExprValues, type BetweenExpr, type Bookmark, type BookmarkInit, type BookmarkPosition, type BookmarkQuery, type BroadcastJoinOptions, type CacheAdapter, CacheApiCache, type CacheApiCacheOptions, type CacheEntry, type CachePolicy, type CallExpr, type CaseExpr, type CaseWhenExpr, type CheckpointAdapter, type CheckpointStore, type Clock, type ColumnExpr, type ColumnInput, type CompareExpr, type CompareOp, type CompatibleWindowSortGroup, type CompatibleWindowSortItem, type ConditionalObjectStore, type ConditionalPutOptions, type CreateParquetTableAsOptions, type CreateParquetTableAsQuery, type CreateParquetTableAsResult, type CsvStreamOptions, type DecodedIcebergDeletes, type DecodedIcebergParquetDeletes, ERROR_CODES, type EngineFilePlan, type EngineTable, type ErrorDetails, type ExplainJson, type ExplainResult, type Expr, type GeoBackend, type GeoJsonGeometry, type IcebergAppendFile, type IcebergAppendOptions, type IcebergAppendOutputManifestOptions, type IcebergAppendResult, type IcebergCatalog, type IcebergCommitCatalog, type IcebergCommitInput, type IcebergCommitResult, type IcebergDeleteFile, type IcebergDeletionVector, type IcebergEnginePlan, type IcebergEngineTable, type IcebergEqualityDelete, type IcebergField, type IcebergGlueCatalogOptions, type IcebergLoadTableOptions, type IcebergNessieCatalogOptions, type IcebergParquetDeleteFile, type IcebergParquetDeleteFileContent, type IcebergPartitionField, type IcebergPartitionSpec, type IcebergPlan, type IcebergPositionDelete, type IcebergReadMode, type IcebergRestAccessDelegation, IcebergRestCatalog, type IcebergRestCatalogConfig, type IcebergRestCatalogOptions, type IcebergRestLoadContext, type IcebergRestLoadTableOptions, type IcebergRestLoadTableResult, type IcebergRestStorageCredential, type IcebergRowBatch, type IcebergSortOrder, IcebergTable, type IcebergTableIdentifier, IcebergUnsupportedCatalog, type IdGenerator, type InExpr, type InMemoryLakeOptions, InMemoryRowsScanner, InMemoryRowsStore, type InMemoryTableOptions, type IndexPruneResult, type IndexValue, type InsertValidationRules, type IntervalValue, type JoinKey, type JoinType, type JsonExpr, type JsonOrderByTerm, type JsonQueryV1, Lake, type LakeConfig, LakeqlError, type LakeqlErrorCode, type LikeExpr, type ListOptions, type LiteralExpr, type LoadIcebergEngineTableOptions, type LoadIcebergTableFromObjectStoreOptions, type LoadIcebergTableFromRestOptions, type LoadIcebergTableOptions, type LoadParquetEngineTableOptions, type LoadTableOptions, type LockAdapter, type LogHook, type LogicalExpr, type LookupJoinFunction, type LookupJoinOptions, type Manifest, type ManifestDeleteFile, type ManifestFile, MemoryCache, MemoryCheckpointAdapter, MemoryObjectStore, MemorySpillAdapter, type MemorySpillAdapterOptions, type MetadataFile, type MetricsHook, type MinMaxColumnIndex, type NotExpr, type NullCheckExpr, type ObjectHead, type ObjectInfo, type ObjectStore, type ObjectStoreCacheOptions, ObjectStoreIcebergCommitCatalog, ObjectStoreJsonCache, type ObjectStoreJsonCacheOptions, type ObjectStoreReadControls, type ObjectStoreUriAuthority, type OperatorSnapshotValue, type OrderByTerm, type OutputManifest, type OutputManifestEntry, PACKAGE, type ParquetColumnBatch, type ParquetEnginePlan, type ParquetEngineTable, type ParquetLakeConfig, type ParquetMetadata, type ParquetRowBatch, type ParquetRowGroupPlan, ParquetScanAdapter, type PartitionedParquetOutputEntryOptions, type PathQueryInit, type PlanIcebergFilesOptions, type PlanParquetRowGroupsOptions, type PlanParquetTaskWorkUnitsOptions, type PlannedIcebergFile, type PlannedParquetRowGroup, type PredicatePlan, type PredicatePlanOptions, type ProjectIcebergRowOptions, type PutOptions, type QueryBudget, QueryBuilder, type QueryPolicy, type QueryPolicyContext, QueryResult, type QueryRunOptions, type QueryStats, type QueueAdapter, type ReadParquetBatchOptions, type ReadParquetOptions, type ResumableBatchOptions, ResumedQuery, type Row, type RuntimeSubstrate, type Scalar, type ScanAdapter, type ScanBatch, type ScanColumnBatch, type ScanEngineOptions, type ScanObjectPlanOptions, type ScanOptions, type ScanParquetTaskOptions, type ScanPlannedIcebergRowsOptions, type ScanTaskPlan, type ScanTaskPlanOptions, type ScanVectorBatch, type Selection, type SharedCacheEntry, type SharedCacheSetOptions, SharedMemoryCache, type SidecarFileIndex, type SliceOptions, type SliceResult, type Snapshot, type SortOperatorState, type SortOptions, type SortResult, type SortRunState, type SpillAdapter, type SpillRef, type SpillUsage, type SqlBoolean, type SqlCsvOptions, type SqlLake, type SqlQueryOptions, SqlQueryResult, type TaskCheckpoint, type TaskInput, type TaskManifest, type TaskManifestTask, type TaskState, type TaskTransitionInput, type TimestampUnit, TimestampValue, type TopKOperatorState, type TopKOptions, type TopKResult, type ValueInput, type Vector, type VectorAggregateOptions, type VectorAggregateSnapshotValue, type VectorAggregateState, type VectorAggregateStateSnapshot, type VectorAggregateStateSnapshots, type VectorAggregateStates, type VectorAggregateValue, type VectorGroup, type VectorGroupByGroupSnapshot, type VectorGroupByOptions, type VectorGroupBySnapshotValue, type VectorGroupByState, type VectorGroupByStateSnapshot, type VectorHashJoinOptions, type VectorProjectionSpec, type VectorTopKOptions, type WindowExecutionMode, type WindowExplainPlan, type WindowExpr, type WindowFn, type WindowFrame, type WindowFrameBound, type WindowOperatorState, type WindowOptions, type WindowOrderTerm, type WindowParquetTasksOptions, type WindowRankingFn, type WindowReadColumnInput, type WindowResult, type WindowRunState, type WindowSnapshotValue, type WindowSpec, type WindowTaskExecutionOptions, type WindowTaskPlan, type WindowValueFn, type WindowWorkUnitBucket, type WindowWorkUnitEvaluationOptions, type WindowWorkUnitOrdinal, type WindowWorkUnitPartial, type WindowWorkUnitRow, type WorkUnitFanInOptions, type WriteParquetOptions, type WriteParquetRowsOptions, type WritePartitionedParquetFile, type WritePartitionedParquetResult, type WritePartitionedParquetTaskOptions, type WritePartitionedParquetTaskResult, add, advanceTaskCheckpoint, aggregateParquetGroupTask, aggregateParquetGroupTasks, aggregateParquetGroupTasksBatch, aggregateParquetTask, aggregateParquetTasks, and, applyIcebergDeletes, applyIntervalToTimestamp, assertBookmarkMatches, asyncBufferFromStore, batchExprValues, batchFromColumns, batchFromVectors, bboxDistance, bboxIntersects, bboxMayIntersect, between, broadcastJoin, buildBBoxIndex, buildMinMaxIndex, cacheApiCache, cachedObjectStore, classifyPredicate, col, collectExprColumns, collectWindowColumns, compareTimestampValues, compatibleWindowSortGroups, concatBatches, createBookmark, createInMemoryLake, createLake, createOutputManifest, createOutputManifestFromCheckpoints, createParquetLake, createParquetTableAs, createTaskManifest, createVectorAggregateStates, createVectorGroupByState, deserializeAggregateOperatorState, deserializeSortOperatorState, deserializeTopKOperatorState, deserializeWindowOperatorState, div, encodeJsonLine, enforceVectorGroupByBudget, ensureGeoBackendForExprs, envelopeFromGeometry, envelopeOf, eq, evaluate, evaluateWindowWorkUnitPartials, fanInWorkUnits, finalizeVectorAggregateStates, finalizeVectorGroupByBatch, finalizeVectorGroupByRows, fingerprint, fn, gatherBatch, geometryDistance, getOrCreateVectorGroup, gt, gte, icebergGlueCatalog, icebergNessieCatalog, icebergRestCatalog, ilike, inMemoryRowsScanner, intervalToString, intervalValue, isIn, isIntervalValue, isLakeqlError, isNonNegativeInterval, isNotNull, isNull, isPrototypeMutationKey, isTimestampValue, jsonSafeValue, jsonWorkUnitBoundary, like, lit, loadGeoBackend, loadIcebergTable, loadIcebergTableFromObjectStore, loadIcebergTableFromRest, loadTable, lookupJoin, lt, lte, matches, materializeBatchRow, materializeBatchRows, materializeSelectedBatchRows, memoryCache, memoryCheckpointAdapter, memorySpillAdapter, memoryStore, mergeVectorAggregateStateSnapshots, mergeVectorAggregateStates, mergeVectorGroupByStates, mod, mul, ne, not, notIn, objectStoreJsonCache, or, parquetScanner, parseGeometry, parseHivePartitions, parseJsonQuery, partitionWindowWorkUnitRows, partitionedParquetOutputEntries, planFiles, planParquetTaskWorkUnits, planRowGroups, planRowGroupsFromMetadata, predicateSelection, pruneFilesWithIndex, querySql, readControlSignal, readIcebergParquetDeletes, readOutputManifest, readParquetColumnBatches, readParquetMetadata, readParquetObjectBatches, readParquetObjects, rejectUnsupportedParquetSchema, requireGeoBackend, restoreVectorAggregateStates, restoreVectorGroupByState, rowGroupMayMatch, rowGroupMustMatch, scalarVectorValue, scanBatches, scanParquetTaskBatches, scanParquetTaskColumnBatches, scanPlannedIcebergRows, scanRows, selectedRowCount, selectedRowIndices, serializeAggregateOperatorState, serializeSortOperatorState, serializeTopKOperatorState, serializeWindowOperatorState, setGeoBackend, signPaginationToken, snapshotVectorAggregateStates, snapshotVectorGroupByState, stableStringify, sub, throwIfAborted, timestampEpochForUnit, timestampFromEpoch, timestampToIsoString, timestampValueFromIso, toGeometry, transitionTaskCheckpoint, tryPredicateSelection, updateVectorAggregateStateValue, updateVectorAggregateStates, updateVectorGroupAggregateValue, updateVectorGroupByState, uriObjectStore, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorHashJoin, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, windowExpressions, windowOperatorState, windowOperatorStateFromRuns, windowParquetTask, windowParquetTasks, windowPartitionBucket, windowReadColumns, windowRowsFromState, windowSortGroupCount, windowSortSpecsCompatible, windowTaskPlanForWindows, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask };