lakeql 0.1.7 → 0.1.9

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>;
@@ -386,6 +181,13 @@ interface ObjectStoreReadControls {
     signal?: AbortSignal;
     maxElapsedMs?: number;
 }
+interface ObjectStoreUriAuthority {
+    scheme: string;
+    authority: string;
+    prefix?: string;
+}
+declare function uriObjectStore(store: ConditionalObjectStore, authorities: ObjectStoreUriAuthority | readonly ObjectStoreUriAuthority[]): ConditionalObjectStore;
+declare function uriObjectStore(store: ObjectStore, authorities: ObjectStoreUriAuthority | readonly ObjectStoreUriAuthority[]): ObjectStore;
 declare function withObjectStoreReadControls(store: ObjectStore, controls: ObjectStoreReadControls): ObjectStore;
 declare function readControlSignal(controls: ObjectStoreReadControls): AbortSignal | undefined;
 declare function throwIfAborted(signal: AbortSignal | undefined): void;
@@ -643,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;
@@ -652,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. */
@@ -685,6 +565,7 @@ interface ScanOptions {
     where?: Expr;
     rowStart?: number;
     rowEnd?: number;
+    canStopEarly?: boolean;
     batchSize: number;
     stats: QueryStats;
     budget: QueryBudget;
@@ -697,6 +578,16 @@ interface ScanAdapter {
     scanVectorBatches?(path: string, options: ScanOptions): AsyncIterable<ScanVectorBatch>;
     scanColumnBatches?(path: string, options: ScanOptions): AsyncIterable<ScanColumnBatch>;
     planTask?(path: string, options: ScanTaskPlanOptions): Promise<ScanTaskPlan>;
+    executeWindowTasks?(tasks: TaskInput[], windows: Record<string, WindowExpr>, options: WindowTaskExecutionOptions): Promise<Row[]>;
+}
+interface WindowTaskExecutionOptions {
+    budget: QueryBudget;
+    stats: QueryStats;
+    now: () => number;
+    startedAt: number;
+    batchSize: number;
+    maxConcurrentTasks?: number;
+    maxBufferedPartials?: number;
 }
 interface ScanVectorBatch {
     rowOffset: number;
@@ -725,6 +616,8 @@ interface PathQueryInit {
     projections?: Record<string, Expr>;
     where?: Expr;
     distinct?: boolean;
+    windows?: Record<string, WindowExpr>;
+    qualify?: Expr;
     orderBy?: OrderByTerm[];
     limit?: number;
     offset?: number;
@@ -886,6 +779,7 @@ interface TaskInput {
     projectedColumns?: string[];
     residualPredicate?: Expr;
     partitionValues: Record<string, string>;
+    window?: WindowTaskPlan;
 }
 interface ExplainJson {
     queryId: string;
@@ -893,6 +787,7 @@ interface ExplainJson {
     filesSkipped: number;
     projectedColumns: string[];
     predicatePlan: PredicatePlan;
+    windowPlan?: WindowExplainPlan;
     tasks: TaskInput[];
 }
 interface ExplainResult {
@@ -976,6 +871,8 @@ declare class QueryBuilder {
     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;
@@ -992,6 +889,7 @@ declare class QueryBuilder {
     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>;
@@ -1025,11 +923,15 @@ declare class QueryResult {
     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[]>;
@@ -1061,9 +963,270 @@ declare function serializeTopKOperatorState(state: TopKOperatorState): Uint8Arra
 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>;
 
+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;
+} | {
+    type: "utf8";
+    values: string[];
+    valid?: Uint8Array;
+} | {
+    type: "binary";
+    values: Uint8Array[];
+    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 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 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;
+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;
     maxBytes?: number;
@@ -1138,6 +1301,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;
@@ -1170,6 +1335,25 @@ declare class SharedMemoryCache {
 }
 declare function cachedObjectStore(inner: ObjectStore, options?: ObjectStoreCacheOptions, sharedCache?: SharedMemoryCache): ObjectStore;
 
+interface ObjectStoreJsonCacheOptions {
+    store: ObjectStore;
+    prefix: string;
+    ttlMs?: number;
+    now?: () => number;
+}
+declare class ObjectStoreJsonCache<T> implements CacheAdapter<T> {
+    private readonly store;
+    private readonly prefix;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(options: ObjectStoreJsonCacheOptions);
+    get(key: string): Promise<CacheEntry<T> | undefined>;
+    set(key: string, entry: CacheEntry<T>): Promise<void>;
+    delete(key: string): Promise<void>;
+    private pathFor;
+}
+declare function objectStoreJsonCache<T>(options: ObjectStoreJsonCacheOptions): CacheAdapter<T>;
+
 type VectorDistinctAggregateState = {
     op: "count_distinct" | "approx_count_distinct";
     values: Set<string>;
@@ -1363,6 +1547,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;
@@ -1380,16 +1594,20 @@ type IcebergReadMode = "strict" | "ignore-deletes" | "ignore-unsupported-deletes
 interface LoadIcebergTableOptions extends ObjectStoreReadControls {
     store: ObjectStore;
     metadataPath: string;
+    cache?: CacheAdapter<unknown>;
 }
 interface LoadIcebergTableFromObjectStoreOptions extends ObjectStoreReadControls {
     store: ObjectStore;
     tableLocation: string;
+    cache?: CacheAdapter<unknown>;
 }
 interface IcebergRestCatalogOptions {
     url: string;
     namespace: string | string[];
     table: string;
+    warehouse?: string;
     prefix?: string;
+    accessDelegation?: readonly IcebergRestAccessDelegation[];
     token?: string;
     fetch?: typeof fetch;
 }
@@ -1407,7 +1625,34 @@ interface IcebergNessieCatalogOptions {
     token?: string;
 }
 interface LoadIcebergTableFromRestOptions extends IcebergRestCatalogOptions, ObjectStoreReadControls {
-    store: ObjectStore;
+    store?: ObjectStore;
+    storeFactory?: (context: IcebergRestLoadContext) => ObjectStore | Promise<ObjectStore>;
+    cache?: CacheAdapter<unknown>;
+}
+type IcebergRestAccessDelegation = "vended-credentials" | "remote-signing" | (string & {});
+interface IcebergRestStorageCredential {
+    prefix: string;
+    config: Record<string, string>;
+}
+interface IcebergRestLoadTableOptions {
+    ifNoneMatch?: string;
+    snapshots?: "all" | "refs";
+}
+interface IcebergRestLoadTableResult {
+    "metadata-location": string;
+    metadata: MetadataFile;
+    config: Record<string, string>;
+    "storage-credentials": IcebergRestStorageCredential[];
+    etag: string | null;
+}
+interface IcebergRestCatalogConfig {
+    defaults: Record<string, string>;
+    overrides: Record<string, string>;
+    endpoints?: string[];
+    "idempotency-key-lifetime"?: string;
+}
+interface IcebergRestLoadContext extends IcebergRestLoadTableResult {
+    catalog: IcebergRestCatalog;
 }
 interface PlanIcebergFilesOptions {
     snapshotId?: number;
@@ -1443,9 +1688,12 @@ interface IcebergCommitCatalog {
     commitAppend(input: IcebergCommitInput): Promise<boolean | IcebergCommitResult>;
 }
 interface IcebergCatalog extends IcebergCommitCatalog {
-    loadTable(store: ObjectStore): Promise<IcebergTable>;
+    loadTable(store: ObjectStore, options?: IcebergLoadTableOptions): Promise<IcebergTable>;
     listTables(): Promise<IcebergTableIdentifier[]>;
 }
+interface IcebergLoadTableOptions extends ObjectStoreReadControls {
+    cache?: CacheAdapter<unknown>;
+}
 interface IcebergTableIdentifier {
     namespace: string[];
     name: string;
@@ -1614,18 +1862,28 @@ declare class IcebergRestCatalog implements IcebergCatalog {
     private readonly url;
     private readonly namespace;
     private readonly table;
-    private readonly prefix;
+    private readonly explicitPrefix;
+    private readonly warehouse;
+    private readonly accessDelegation;
     private readonly token;
     private readonly fetchFn;
+    private configPromise;
+    private prefixPromise;
     constructor(options: IcebergRestCatalogOptions);
-    loadTable(store: ObjectStore): Promise<IcebergTable>;
+    loadTable(store: ObjectStore, options?: IcebergLoadTableOptions): Promise<IcebergTable>;
+    loadTableResult(options?: IcebergRestLoadTableOptions): Promise<IcebergRestLoadTableResult>;
+    loadConfig(): Promise<IcebergRestCatalogConfig>;
     listTables(): Promise<IcebergTableIdentifier[]>;
     commitAppend(input: IcebergCommitInput): Promise<IcebergCommitResult>;
     private requestJson;
+    private requestJsonResponse;
     private headers;
     private tableUrl;
     private namespaceTablesUrl;
     private namespaceTableSegments;
+    private prefixParts;
+    private computePrefixParts;
+    private configUrl;
 }
 declare function icebergRestCatalog(options: IcebergRestCatalogOptions): IcebergRestCatalog;
 declare class IcebergUnsupportedCatalog implements IcebergCatalog {
@@ -1633,7 +1891,7 @@ declare class IcebergUnsupportedCatalog implements IcebergCatalog {
     private readonly namespace;
     private readonly table;
     constructor(catalog: string, namespace: string | string[], table: string);
-    loadTable(_store: ObjectStore): Promise<IcebergTable>;
+    loadTable(_store: ObjectStore, _options?: IcebergLoadTableOptions): Promise<IcebergTable>;
     listTables(): Promise<IcebergTableIdentifier[]>;
     commitAppend(_input: IcebergCommitInput): Promise<IcebergCommitResult>;
     private unsupported;
@@ -1669,6 +1927,7 @@ interface ReadParquetOptions {
 interface ReadParquetBatchOptions extends ReadParquetOptions {
     batchSize?: number;
     where?: Expr;
+    canStopEarly?: boolean;
     stats?: QueryStats;
     decodedColumnCache?: DecodedColumnCache;
     decodedColumnCacheKey?: string;
@@ -1718,6 +1977,9 @@ interface ScanParquetTaskOptions {
     batchSize?: number;
     stats?: QueryStats;
     metadataCache?: CacheAdapter<ParquetMetadata>;
+    budget?: QueryBudget;
+    now?: () => number;
+    startedAt?: number;
 }
 interface PlanParquetTaskWorkUnitsOptions {
     maxRowGroupsPerTask?: number;
@@ -1774,11 +2036,15 @@ declare class ParquetScanAdapter implements ScanAdapter {
     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;
 }
 
-declare function rejectUnsupportedParquetSchema(metadata: ParquetMetadata): void;
+interface RejectUnsupportedParquetSchemaOptions {
+    columns?: readonly string[] | undefined;
+}
+declare function rejectUnsupportedParquetSchema(metadata: ParquetMetadata, options?: RejectUnsupportedParquetSchemaOptions): void;
 
 /**
  * Bridge an ObjectStore path to hyparquet's AsyncBuffer (length + ranged slice).
@@ -1791,6 +2057,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;
 }
@@ -1950,4 +2226,4 @@ 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 IcebergNessieCatalogOptions, type IcebergParquetDeleteFile, type IcebergParquetDeleteFileContent, type IcebergPartitionField, type IcebergPartitionSpec, type IcebergPlan, type IcebergPositionDelete, type IcebergReadMode, IcebergRestCatalog, type IcebergRestCatalogOptions, 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, type ObjectStoreReadControls, 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, 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, vectorAggregateBatch, vectorFromValues, vectorGroupByBatch, vectorHashJoin, vectorLength, vectorOrderByBatch, vectorProjectBatch, vectorSortIndices, vectorTopKBatch, vectorTopKIndices, vectorValue, verifyPaginationToken, withObjectStoreReadControls, writeOutputManifest, writeParquet, writePartitionedParquet, writePartitionedParquetTask };
+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 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 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, createParquetLake as 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, 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 };