@gscdump/engine 3.4.4 → 3.6.0

package/dist/rollups/traffic.d.mts

@@ -8,22 +8,22 @@ import { RollupDef } from "./core.mjs";
  * — surfaces GSC's anonymous-query gap so the dashboard can warn users not
  * to trust query-grained breakdowns as comprehensive.
  */
-declare const dailyTotalsRollup: RollupDef;
+export declare const dailyTotalsRollup: RollupDef;
 /** Weekly totals, ISO week aligned. Cheap and stable for trend widgets. */
-declare const weeklyTotalsRollup: RollupDef;
+export declare const weeklyTotalsRollup: RollupDef;
 /**
  * Top 1000 pages by clicks over the trailing 28-day window. JSON for v1;
  * promote to parquet (`top_pages_28d.parquet`) when the dashboard needs
  * server-side WHERE filtering on this rollup.
  */
-declare const topPages28dRollup: RollupDef;
+export declare const topPages28dRollup: RollupDef;
 /**
  * Top 250 countries by clicks over the trailing 28-day window. Countries
  * cardinality is bounded (~250 ISO codes), so the list fits in a tiny JSON
  * payload regardless of traffic shape. Powers a geo-overview widget without
  * spinning up DuckDB-WASM.
  */
-declare const topCountries28dRollup: RollupDef;
+export declare const topCountries28dRollup: RollupDef;
 /**
  * Parquet-format companion to `topKeywords28dRollup`. Same shape, but persists
  * as a parquet object plus JSON sidecar pointer so widgets that need
@@ -34,5 +34,4 @@ declare const topCountries28dRollup: RollupDef;
  * the JSON variant; the runner treats the two as independent ids so they can
  * coexist during a migration.
  */
-declare const topKeywords28dParquetRollup: RollupDef;
-export { dailyTotalsRollup, topCountries28dRollup, topKeywords28dParquetRollup, topPages28dRollup, weeklyTotalsRollup };
+export declare const topKeywords28dParquetRollup: RollupDef;

package/dist/rollups/windows.d.mts

@@ -14,7 +14,7 @@ import { SearchType } from "gscdump/query";
  * conservatively below the guard. Re-measure the parquet→IPC ratio against
  * production and raise if headroom allows.
  */
-declare const WINDOW_BYTE_BUDGET: number;
+export declare const WINDOW_BYTE_BUDGET: number;
 /**
  * Per-page OUTPUT row cap for key-paginated rollups (`runWindowed({ paginate })`
  * and `runPagedQuery`). `planRollupWindows` bounds the *input* parquet bytes a
@@ -33,15 +33,15 @@ declare const WINDOW_BYTE_BUDGET: number;
  * `GROUP_CONCAT` variants string (up to ~10 variants × ~60 chars) the heuristic
  * under-counts, so they page smaller to keep the real IPC payload bounded.
  */
-declare const ROLLUP_PAGE_ROWS = 50000;
-declare const ROLLUP_PAGE_ROWS_WIDE = 20000;
-declare const ROLLUP_PAGE_ROWS_DAILY = 70000;
+export declare const ROLLUP_PAGE_ROWS = 50000;
+export declare const ROLLUP_PAGE_ROWS_WIDE = 20000;
+export declare const ROLLUP_PAGE_ROWS_DAILY = 70000;
 /**
  * Plan byte-bounded windows over a partition set. Each window names the
  * partitions whose span intersects it; a coarse tier file can land in two
  * windows, so every windowed SQL MUST also date-filter to the window bounds.
  */
-declare function planRollupWindows(parts: Array<{
+export declare function planRollupWindows(parts: Array<{
   partition: string;
   bytes: number;
 }>, clampRange?: {
@@ -64,7 +64,7 @@ declare function planRollupWindows(parts: Array<{
  * The two are orthogonal and compose. When `paginate` is set, `sqlFor` MUST emit
  * no trailing `ORDER BY`/`LIMIT` and `paginate.orderBy` MUST be a total order.
  */
-declare function runWindowed(opts: {
+export declare function runWindowed(opts: {
   engine: RollupEngine;
   ctx: TenantCtx;
   table: TableName$1;
@@ -86,5 +86,4 @@ declare function runWindowed(opts: {
   };
   /** Cap each window's day span (output-cardinality bound). See `planRollupWindows`. */
   maxWindowDays?: number;
-}): Promise<Row$1[]>;
-export { ROLLUP_PAGE_ROWS, ROLLUP_PAGE_ROWS_DAILY, ROLLUP_PAGE_ROWS_WIDE, WINDOW_BYTE_BUDGET, planRollupWindows, runWindowed };
+}): Promise<Row$1[]>;

package/dist/schedule.d.mts

@@ -1,9 +1,9 @@
-interface ScheduleState {
+export interface ScheduleState {
   nextAt: number;
   consecutiveUnchanged: number;
   policyVersion: number;
 }
-interface SchedulePolicy {
+export interface SchedulePolicy {
   readonly version: number;
   initial: (now: number) => ScheduleState;
   observe: (prev: ScheduleState, evt: {
@@ -12,8 +12,7 @@ interface SchedulePolicy {
   }) => ScheduleState;
   isDue: (state: ScheduleState, now: number) => boolean;
 }
-declare const sitemapPolicy: SchedulePolicy;
-type InspectionVerdict = 'PASS' | 'FAIL' | 'NEUTRAL';
-declare function inspectionPolicy(verdict: InspectionVerdict): SchedulePolicy;
-declare function fixedPolicy(intervalMs: number): SchedulePolicy;
-export { InspectionVerdict, SchedulePolicy, ScheduleState, fixedPolicy, inspectionPolicy, sitemapPolicy };
+export declare const sitemapPolicy: SchedulePolicy;
+export type InspectionVerdict = 'PASS' | 'FAIL' | 'NEUTRAL';
+export declare function inspectionPolicy(verdict: InspectionVerdict): SchedulePolicy;
+export declare function fixedPolicy(intervalMs: number): SchedulePolicy;

package/dist/schema.d.mts

@@ -1,21 +1,21 @@
 import { DrizzleSchema, TABLE_METADATA, countries, dates, drizzleSchema, hourly_pages, page_queries, pages, queries, search_appearance, search_appearance_page_queries, search_appearance_pages, search_appearance_queries } from "./drizzle-schema.mjs";
 import { ColumnDef, ColumnType, Row, TableName, TableSchema, TableSchema as TableSchema$1 } from "@gscdump/contracts";
-declare const SCHEMAS: Record<TableName, TableSchema$1>;
-declare function currentSchemaVersion(table: TableName): number;
+export declare const SCHEMAS: Record<TableName, TableSchema$1>;
+export declare function currentSchemaVersion(table: TableName): number;
 /**
  * DATE column names for a table. The single schema-derived source every read
  * path uses to build the legacy-VARCHAR date canonicalization (see
  * `dateReplaceClause` in `./sql-fragments`), so the engine codec and the CLI
  * `dump`/`export` commands agree on which columns to cast.
  */
-declare function dateColumnsFor(table: TableName): string[];
-declare function allTables(): readonly TableName[];
-declare function inferTable(dimensions: readonly string[]): TableName;
+export declare function dateColumnsFor(table: TableName): string[];
+export declare function allTables(): readonly TableName[];
+export declare function inferTable(dimensions: readonly string[]): TableName;
 /**
  * Natural-key columns for a table: the `sortKey` dimensions that uniquely
  * identify a metric row (e.g. `['date', 'url']` for `pages`).
  */
-declare function naturalKeyColumns(table: TableName): readonly string[];
+export declare function naturalKeyColumns(table: TableName): readonly string[];
 /**
  * Collapse rows that share a natural key (see {@link naturalKeyColumns}) to a
  * single survivor.
@@ -30,6 +30,6 @@ declare function naturalKeyColumns(table: TableName): readonly string[];
  * Last occurrence wins. Observed duplicates are byte-identical, so the choice
  * of survivor is immaterial.
  */
-declare function dedupeByNaturalKey(table: TableName, rows: readonly Row[]): Row[];
-declare function dimensionToColumn(dim: string, _table: TableName): string;
-export { type ColumnDef, type ColumnType, type DrizzleSchema, SCHEMAS, TABLE_METADATA, type TableSchema, allTables, countries, currentSchemaVersion, dateColumnsFor, dates, dedupeByNaturalKey, dimensionToColumn, drizzleSchema, hourly_pages, inferTable, naturalKeyColumns, page_queries, pages, queries, search_appearance, search_appearance_page_queries, search_appearance_pages, search_appearance_queries };
+export declare function dedupeByNaturalKey(table: TableName, rows: readonly Row[]): Row[];
+export declare function dimensionToColumn(dim: string, _table: TableName): string;
+export { type ColumnDef, type ColumnType, type DrizzleSchema, TABLE_METADATA, type TableSchema, countries, dates, drizzleSchema, hourly_pages, page_queries, pages, queries, search_appearance, search_appearance_page_queries, search_appearance_pages, search_appearance_queries };

package/dist/scope.d.mts

@@ -4,12 +4,12 @@ import { SQL } from "drizzle-orm";
  * Inlined here to avoid the cross-module type import in this leaf module;
  * any object with `start`/`end` strings (and optional `days`) satisfies it.
  */
-interface ResolvedWindow {
+export interface ResolvedWindow {
   start: string;
   end: string;
   days?: number;
 }
-interface ScopedRunnerOptions {
+export interface ScopedRunnerOptions {
   siteId?: string;
   window?: ResolvedWindow;
   /** Inclusive lower bound for `date`. Ignored if `window` is supplied. */
@@ -23,12 +23,12 @@ interface ScopedRunnerOptions {
    */
   grain?: 'day' | 'hour';
 }
-interface TableScope {
+export interface TableScope {
   wherePredicates: SQL[];
   window?: ResolvedWindow;
   siteId?: string;
 }
-declare function mergeScope(scope: TableScope, ...extra: SQL[]): SQL | undefined;
+export declare function mergeScope(scope: TableScope, ...extra: SQL[]): SQL | undefined;
 /**
  * Bind `buildTableScope` + `mergeScope` to a specific drizzle schema. Engine
  * adapters (`engine-sqlite`, `engine-duckdb-wasm`) call this once at module load and
@@ -36,8 +36,7 @@ declare function mergeScope(scope: TableScope, ...extra: SQL[]): SQL | undefined
  * `keyof Schema` table parameter without each adapter re-implementing the
  * pass-through wrapper.
  */
-declare function createScopedHelpers<S extends Record<string, Record<string, any>>>(schema: S): {
+export declare function createScopedHelpers<S extends Record<string, Record<string, any>>>(schema: S): {
   scopeFor: (table: keyof S, opts: ScopedRunnerOptions) => TableScope;
   mergeScope: typeof mergeScope;
-};
-export { ResolvedWindow, ScopedRunnerOptions, TableScope, createScopedHelpers, mergeScope };
+};

package/dist/sink.d.mts

@@ -8,7 +8,7 @@ import { CommitRetryOptions, ConnectIcebergOptions, IcebergCatalogConfig } from
  * tenant-scoped sinks (local/in-memory); the prod Iceberg table is global
  * and keys only on `siteId`.
  */
-interface SinkSlice {
+export interface SinkSlice {
   ctx: TenantCtx;
   table: IcebergTableName;
   /** GSC search-type partition. */
@@ -20,7 +20,7 @@ interface SinkSlice {
  * Outcome of a sink write. `rowCount` is the number of rows accepted;
  * `bytes` is best-effort — `IcebergAppendSink` does not report it (undefined there).
  */
-interface SinkWriteResult {
+export interface SinkWriteResult {
   rowCount: number;
   bytes?: number;
 }
@@ -29,14 +29,14 @@ interface SinkWriteResult {
  * v5 stability-cutoff model. Test and revision-path adapters may expose an
  * overwrite capability explicitly.
  */
-interface SinkCapabilities {
+export interface SinkCapabilities {
   /** When true, re-emitting a slice accumulates duplicate rows. */
   appendOnly: boolean;
   /** Whether the sink exposes partition overwrite semantics. */
   canOverwrite?: boolean;
 }
 /** Partition-overwrite writer for revision paths. */
-interface SliceOverwriteWriter {
+export interface SliceOverwriteWriter {
   overwriteSlice: (slice: SinkSlice, rows: readonly Row[]) => Promise<SinkWriteResult>;
 }
 /**
@@ -50,7 +50,7 @@ interface SliceOverwriteWriter {
  * leaves its slices un-recorded so the next sync re-emits them. This is what
  * keeps the D1 ledger from ever running ahead of Iceberg.
  */
-interface SinkCloseResult {
+export interface SinkCloseResult {
   /** Tables whose buffered rows committed durably. */
   flushed: IcebergTableName[];
   /**
@@ -63,7 +63,7 @@ interface SinkCloseResult {
     error: EngineError;
   }[];
 }
-interface Sink {
+export interface Sink {
   readonly capabilities: SinkCapabilities;
   /**
    * Emit the fact rows for one slice. Append semantics — for `IcebergAppendSink`
@@ -89,7 +89,7 @@ interface Sink {
   close: () => Promise<SinkCloseResult>;
 }
 /** Construction options shared by all sink implementations. */
-interface SinkOptions {
+export interface SinkOptions {
   now?: () => number;
 }
 /**
@@ -97,7 +97,7 @@ interface SinkOptions {
  * sink appends to via `icebird`. The catalog config shape (`IcebergCatalogConfig`)
  * is type-only here so this contract file stays implementation-free.
  */
-interface IcebergAppendSinkOptions extends SinkOptions {
+export interface IcebergAppendSinkOptions extends SinkOptions {
   /** R2 Data Catalog connection config (catalog URI, warehouse, namespace, token, S3 creds). */
   catalog: IcebergCatalogConfig;
   /**
@@ -121,5 +121,4 @@ interface IcebergAppendSinkOptions extends SinkOptions {
    * {@link import('./iceberg/schema').PartitionKeyEncoding}.
    */
   encoding?: PartitionKeyEncoding;
-}
-export { IcebergAppendSinkOptions, Sink, SinkCapabilities, SinkCloseResult, SinkOptions, SinkSlice, SinkWriteResult, SliceOverwriteWriter };
+}

package/dist/sinks/in-memory-sink.d.mts

@@ -2,11 +2,11 @@ import { Row } from "../storage.mjs";
 import { IcebergTableName } from "../iceberg/schema.mjs";
 import { Sink, SinkSlice } from "../sink.mjs";
 /** A row as stored by the fake — data columns plus the injected identity columns. */
-type StoredRow = Row & {
+export type StoredRow = Row & {
   site_id: string;
   search_type: string;
 };
-interface InMemorySink extends Sink {
+export interface InMemorySink extends Sink {
   /** All rows accepted, in partition order. */
   readonly rows: readonly StoredRow[];
   /** Rows for one table. */
@@ -21,5 +21,4 @@ interface InMemorySink extends Sink {
 /**
  * Create an in-memory append-only `Sink`.
  */
-declare function createInMemorySink(): InMemorySink;
-export { InMemorySink, StoredRow, createInMemorySink };
+export declare function createInMemorySink(): InMemorySink;

package/dist/snapshot.d.mts

@@ -4,11 +4,10 @@
  * via `cold-${yearMonth}.duckdb`; hot is always `hot.duckdb` when
  * `hot: true`.
  */
-interface SnapshotIndex {
+export interface SnapshotIndex {
   version: 1;
   builtAt: string;
   cold: string[];
   hot: boolean;
   hotDays: number;
-}
-export { SnapshotIndex };
+}

package/dist/source/attached-table.d.mts

@@ -3,7 +3,7 @@ import { ResolverAdapter } from "../resolver/types.mjs";
 import { AnalysisQuerySource } from "./source-types.mjs";
 import { EngineError } from "../errors.mjs";
 import "../contracts.mjs";
-interface AttachedTableRunner {
+export interface AttachedTableRunner {
   /**
    * Run a query with positional (`?`) bound parameters. Return objects keyed
    * by column name. BIGINT → number coercion is applied by the source factory
@@ -12,7 +12,7 @@ interface AttachedTableRunner {
    */
   query: (sql: string, params?: unknown[], signal?: AbortSignal) => Promise<Row[]>;
 }
-interface AttachedTableSourceOptions {
+export interface AttachedTableSourceOptions {
   /** Schema name the exported DuckDB file was attached under — e.g. `gsc`. */
   schema: string;
   /**
@@ -36,10 +36,9 @@ interface AttachedTableSourceOptions {
    */
   adapter?: ResolverAdapter<any>;
 }
-declare class AttachedTableMissingError extends Error {
+export declare class AttachedTableMissingError extends Error {
   readonly missing: readonly string[];
   readonly engineError: EngineError;
   constructor(missing: readonly string[]);
 }
-declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;
-export { AttachedTableMissingError, AttachedTableRunner, AttachedTableSourceOptions, createAttachedTableSource };
+export declare function createAttachedTableSource(runner: AttachedTableRunner, options: AttachedTableSourceOptions): AnalysisQuerySource;

package/dist/source/create-sql-query-source.d.mts

@@ -1,6 +1,6 @@
 import { ResolverAdapter } from "../resolver/types.mjs";
 import { AnalysisQuerySource, AnalysisSourceKind, QueryRow, SourceCapabilities } from "./source-types.mjs";
-interface CreateSqlQuerySourceOptions<TKey extends string> {
+export interface CreateSqlQuerySourceOptions<TKey extends string> {
   /** Debug-only identifier surfaced on the source for error messages. */
   name: string;
   /** Telemetry tag stamped onto analyzer result meta. */
@@ -20,5 +20,4 @@ interface CreateSqlQuerySourceOptions<TKey extends string> {
   /** Additional capability flags merged on top of `adapter.capabilities`. */
   extraCapabilities?: Partial<SourceCapabilities>;
 }
-declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;
-export { CreateSqlQuerySourceOptions, createSqlQuerySource };
+export declare function createSqlQuerySource<TKey extends string>(options: CreateSqlQuerySourceOptions<TKey>): AnalysisQuerySource;

package/dist/source/index.d.mts

@@ -12,8 +12,8 @@ import { BuilderState } from "gscdump/query";
  * multi-dataset queries belong to the analyzer dispatcher, not the engine's
  * builder-state query path.
  */
-declare const ENGINE_QUERY_CAPABILITIES: PlannerCapabilities;
-interface EngineQuerySourceOptions {
+export declare const ENGINE_QUERY_CAPABILITIES: PlannerCapabilities;
+export interface EngineQuerySourceOptions {
   engine: StorageEngine;
   ctx: TenantCtx;
   /**
@@ -31,14 +31,14 @@ interface EngineQuerySourceOptions {
  * `engine.runSQL` and requires `opts.fileSets` (with a `FILES` entry so the
  * target table can be resolved for partition lookup).
  */
-declare function createEngineQuerySource(options: EngineQuerySourceOptions): AnalysisQuerySource;
+export declare function createEngineQuerySource(options: EngineQuerySourceOptions): AnalysisQuerySource;
 /**
  * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
  * Equivalent to wrapping `createEngineQuerySource`, with omitted searchType
  * defaulted to web at this public helper boundary.
  */
-declare function runAnalyzerWithEngine(deps: {
+export declare function runAnalyzerWithEngine(deps: {
   engine: StorageEngine;
 }, ctx: TenantCtx, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
-declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, state: BuilderState): Promise<TRow[]>;
-export { type AnalysisQuerySource, type AnalysisSourceKind, AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, type CreateSqlQuerySourceOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type QueryRow, type SourceCapabilities, createAttachedTableSource, createEngineQuerySource, createSqlQuerySource, queryRows, runAnalyzerWithEngine };
+export declare function queryRows<TRow = QueryRow>(source: AnalysisQuerySource, state: BuilderState): Promise<TRow[]>;
+export { type AnalysisQuerySource, type AnalysisSourceKind, AttachedTableMissingError, type AttachedTableRunner, type AttachedTableSourceOptions, type CreateSqlQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type QueryRow, type SourceCapabilities, createAttachedTableSource, createSqlQuerySource };

package/dist/source/source-types.d.mts

@@ -2,12 +2,12 @@ import { ResolverAdapter } from "../resolver/types.mjs";
 import { PlannerCapabilities } from "gscdump/query/plan";
 import { TableName } from "@gscdump/contracts";
 import { BuilderState } from "gscdump/query";
-type QueryRow = Record<string, unknown>;
-interface FileSet {
+export type QueryRow = Record<string, unknown>;
+export interface FileSet {
   table: TableName;
   partitions: string[];
 }
-interface ExecuteSqlOptions {
+export interface ExecuteSqlOptions {
   fileSets?: Record<string, FileSet>;
 }
 /**
@@ -15,7 +15,7 @@ interface ExecuteSqlOptions {
  * mixed with storage-side flags. SQL execution is not a capability flag —
  * callers probe `typeof source.executeSql === 'function'`.
  */
-interface SourceCapabilities extends PlannerCapabilities {
+export interface SourceCapabilities extends PlannerCapabilities {
   attachedTables?: boolean;
   fileSets?: boolean;
   /**
@@ -24,8 +24,8 @@ interface SourceCapabilities extends PlannerCapabilities {
    */
   adapter?: boolean;
 }
-type AnalysisSourceKind = 'local' | 'browser' | 'live' | 'in-memory' | 'composite' | 'attached-table';
-interface AnalysisQuerySource {
+export type AnalysisSourceKind = 'local' | 'browser' | 'live' | 'in-memory' | 'composite' | 'attached-table';
+export interface AnalysisQuerySource {
   name?: string;
   /** Telemetry tag stamped onto analyzer result meta; not used for routing. */
   kind?: AnalysisSourceKind;
@@ -45,5 +45,4 @@ interface AnalysisQuerySource {
    * BigInts to numbers before returning (see Source invariant above).
    */
   executeSql?: (sql: string, params?: unknown[], opts?: ExecuteSqlOptions) => Promise<QueryRow[]>;
-}
-export { AnalysisQuerySource, AnalysisSourceKind, ExecuteSqlOptions, FileSet, QueryRow, SourceCapabilities };
+}

package/dist/sql-bind.d.mts

@@ -1,5 +1,4 @@
 /** Escape single quotes for inlining inside a SQL string literal (SQL-standard `''` escaping). */
-declare function sqlEscape(s: string): string;
-declare function formatLiteral(value: unknown): string;
-declare function bindLiterals(sql: string, params: readonly unknown[]): string;
-export { bindLiterals, formatLiteral, sqlEscape };
+export declare function sqlEscape(s: string): string;
+export declare function formatLiteral(value: unknown): string;
+export declare function bindLiterals(sql: string, params: readonly unknown[]): string;

package/dist/sql-fragments.d.mts

@@ -3,7 +3,7 @@ import { Metric } from "gscdump/query";
  * Standard SQL `LIKE` escape. Backslash is the explicit ESCAPE char so
  * literal `%`, `_`, and `\` survive a `contains` predicate unchanged.
  */
-declare function escapeLike(value: string): string;
+export declare function escapeLike(value: string): string;
 /**
  * Per-metric raw SQL aggregate expression.
  *
@@ -12,12 +12,12 @@ declare function escapeLike(value: string): string;
  * - `position` reverses the ingestion offset (`sum_position = position - 1`
  *   summed; divide by impressions and add 1 back).
  */
-declare const METRIC_EXPR: Record<Metric, string>;
+export declare const METRIC_EXPR: Record<Metric, string>;
 /**
  * Top-level page predicate: matches paths with at most one `/`. Parameterized
  * on the resolved column expression so drizzle can pass a column ref.
  */
-declare function topLevelPagePredicateSql(pathExpr: string): string;
+export declare function topLevelPagePredicateSql(pathExpr: string): string;
 /**
  * How a canonicalized date column is emitted by {@link dateReplaceClause}:
  * - `'date'` keeps a real `DATE` value (`CAST(col AS DATE)`). Right for views
@@ -26,7 +26,7 @@ declare function topLevelPagePredicateSql(pathExpr: string): string;
  *   Right for row materialisation to JSON/CSV/NDJSON, where a `DATE` would
  *   serialize as an opaque object / epoch.
  */
-type DateCanonicalForm = 'date' | 'string';
+export type DateCanonicalForm = 'date' | 'string';
 /**
  * Build a `read_parquet` `REPLACE (…)` clause that canonicalizes legacy `date`
  * columns. `date` lands as VARCHAR in older parquets (BYTE_ARRAY/UTF8, written
@@ -40,5 +40,4 @@ type DateCanonicalForm = 'date' | 'string';
  * table has no DATE columns, so callers can interpolate it unconditionally:
  *   `SELECT * ${dateReplaceClause(cols)} FROM read_parquet(…)`.
  */
-declare function dateReplaceClause(dateColumns: readonly string[], form?: DateCanonicalForm): string;
-export { DateCanonicalForm, METRIC_EXPR, dateReplaceClause, escapeLike, topLevelPagePredicateSql };
+export declare function dateReplaceClause(dateColumns: readonly string[], form?: DateCanonicalForm): string;