@gscdump/analysis 0.6.3 → 0.7.5

package/dist/source/index.mjs

@@ -1,220 +1,14 @@
-import { createEngine as createBrowserQuerySource } from "@gscdump/engine-wasm";
-import { between, clicks, date, extractDateRange, extractMetricFilters, extractSpecialOperatorFilters, gsc, page, query } from "gscdump/query";
-import { daysAgo, googleSearchConsole } from "gscdump";
-import { assertDimensionsSupported, getDimensionFilters, getFilterDimensions, isSqlQuerySource, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, metricValue } from "@gscdump/engine/resolver";
-import { buildLogicalPlan } from "gscdump/query/plan";
+import { AnalyzerCapabilityError, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { canProxyToGsc } from "@gscdump/engine-gsc-api";
+import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
+import { queryRows, typedQuery } from "@gscdump/engine/source";
+import { num } from "@gscdump/engine/analysis-types";
+import { comparisonOf, periodOf } from "@gscdump/engine/period";
 import { enumeratePartitions } from "@gscdump/engine/planner";
 import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
-import { createEngine as createSqliteQuerySource } from "@gscdump/engine-sqlite";
-var AnalyzerCapabilityError = class extends Error {
-	constructor(tool, missing) {
-		super(`analyzer "${tool}" requires capabilities [${missing.join(", ")}] not provided by source`);
-		this.tool = tool;
-		this.missing = missing;
-		this.name = "AnalyzerCapabilityError";
-	}
-};
-function sourceCapabilities(source) {
-	const caps = /* @__PURE__ */ new Set();
-	if (source.executeSql) caps.add("executeSql");
-	if (source.capabilities.fileSets) caps.add("partitionedParquet");
-	if (source.capabilities.regex) caps.add("regex");
-	if (source.capabilities.windowTotals) caps.add("windowTotals");
-	if (source.capabilities.comparisonJoin) caps.add("comparisonJoin");
-	if (source.capabilities.attachedTables) caps.add("attachedTables");
-	return caps;
-}
-function assertSatisfies(analyzer, caps) {
-	const missing = analyzer.requires.filter((c) => !caps.has(c));
-	if (missing.length > 0) throw new AnalyzerCapabilityError(analyzer.id, missing);
-}
-async function runAnalyzerFromSource(source, params, registry) {
-	const caps = sourceCapabilities(source);
-	const analyzer = registry.resolveAnalyzer(params.type, caps.has("executeSql") || caps.has("attachedTables"));
-	if (!analyzer) throw new AnalyzerCapabilityError(params.type, ["executeSql"]);
-	assertSatisfies(analyzer, caps);
-	const plan = analyzer.build(params);
-	if (plan.kind === "rows") return runRowsPlanAgainstSource(source, analyzer, plan, params);
-	return runSqlPlanAgainstSource(source, analyzer, plan, params);
-}
-async function runRowsPlanAgainstSource(source, analyzer, plan, params) {
-	const entries = Object.entries(plan.queries);
-	const resolved = await Promise.all(entries.map(async ([k, q]) => [k, await source.queryRows(q.state)]));
-	const rowMap = Object.fromEntries(resolved);
-	const { results, meta } = analyzer.reduce(rowMap, { params });
-	return {
-		results,
-		meta: {
-			tool: params.type,
-			...meta
-		}
-	};
-}
-function fileSetsFor(plan) {
-	const fileSets = { FILES: plan.current };
-	if (plan.previous) fileSets.FILES_PREV = plan.previous;
-	if (plan.extraFiles) for (const [key, fs] of Object.entries(plan.extraFiles)) fileSets[`FILES_${key}`] = fs;
-	return fileSets;
-}
-async function runSqlPlanAgainstSource(source, analyzer, plan, params) {
-	if (!source.executeSql) throw new AnalyzerCapabilityError(analyzer.id, ["executeSql"]);
-	if (plan.requiresAttachedTables && !source.capabilities.attachedTables) throw new AnalyzerCapabilityError(analyzer.id, ["attachedTables"]);
-	const fileSets = source.capabilities.fileSets ? fileSetsFor(plan) : void 0;
-	const rows = await source.executeSql(plan.sql, plan.params, fileSets ? { fileSets } : void 0);
-	const extras = {};
-	if (plan.extraQueries) for (const q of plan.extraQueries) {
-		const extraRows = await source.executeSql(q.sql, q.params, fileSets ? { fileSets } : void 0);
-		extras[q.name] = extraRows;
-	}
-	const { results, meta } = analyzer.reduce(rows, {
-		params,
-		extras
-	});
-	const sourceMeta = source.capabilities.localSource ? { source: "local" } : {};
-	return {
-		results,
-		meta: {
-			tool: params.type,
-			...sourceMeta,
-			...meta
-		}
-	};
-}
 async function analyzeFromSource(source, params, registry) {
 	return runAnalyzerFromSource(source, params, registry);
 }
-async function collectRows(gen) {
-	const out = [];
-	for await (const batch of gen) out.push(...batch);
-	return out;
-}
-async function fetchGscTopN(opts) {
-	const { client, siteUrl, dimension, range, orderByClicksDesc, limit, sliceTop } = opts;
-	let builder = gsc.select(dimension).where(between(date, range.start, range.end));
-	if (orderByClicksDesc) builder = builder.orderBy(clicks, "desc");
-	if (typeof limit === "number") builder = builder.limit(limit);
-	const mapped = (await collectRows(client.query(siteUrl, builder))).map((r) => {
-		const row = r;
-		const key = row[dimension.dimension];
-		if (typeof key !== "string" || !key) return null;
-		const impressions = Number(row.impressions ?? 0);
-		const position = Number(row.position ?? 0);
-		return {
-			key,
-			clicks: Number(row.clicks ?? 0),
-			impressions,
-			sum_position: position * impressions
-		};
-	}).filter((x) => x != null);
-	if (!orderByClicksDesc) mapped.sort((a, b) => b.clicks - a.clicks);
-	return typeof sliceTop === "number" ? mapped.slice(0, sliceTop) : mapped;
-}
-async function fetchGscDaily(opts) {
-	const { client, siteUrl, range } = opts;
-	const builder = gsc.select(date).where(between(date, range.start, range.end));
-	return (await collectRows(client.query(siteUrl, builder))).map((r) => {
-		const row = r;
-		if (!row.date) return null;
-		const impressions = row.impressions ?? 0;
-		return {
-			date: Date.parse(`${row.date}T00:00:00Z`),
-			clicks: row.clicks ?? 0,
-			impressions,
-			sum_position: (row.position ?? 0) * impressions,
-			anonymizedImpressionsPct: 0
-		};
-	}).filter((x) => x != null).sort((a, b) => a.date - b.date);
-}
-const METRIC_NAMES = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position"
-];
-function isMetricDimension$2(dim) {
-	return METRIC_NAMES.includes(dim);
-}
-function applyBuilderStatePostProcessing(rows, state) {
-	const dimensionFilters = getDimensionFilters(state.filter, isMetricDimension$2);
-	const metricFilters = extractMetricFilters(state.filter);
-	const specialFilters = extractSpecialOperatorFilters(state.filter);
-	const ordered = [...rows.filter((row) => {
-		if (!dimensionFilters.every((filter) => matchesDimensionFilter(row, filter))) return false;
-		if (!metricFilters.every((filter) => matchesMetricFilter(row, filter))) return false;
-		if (specialFilters.some((filter) => filter.operator === "topLevel") && !matchesTopLevelPage(row)) return false;
-		return true;
-	})].sort((a, b) => {
-		const column = state.orderBy?.column ?? "clicks";
-		const dir = state.orderBy?.dir ?? "desc";
-		const left = column === "date" ? String(a.date ?? "") : metricValue(a, column);
-		const right = column === "date" ? String(b.date ?? "") : metricValue(b, column);
-		if (left === right) return 0;
-		if (dir === "asc") return left < right ? -1 : 1;
-		return left > right ? -1 : 1;
-	});
-	const offset = Math.max(0, Number(state.startRow ?? 0));
-	const limit = Math.max(0, Number((state.rowLimit ?? ordered.length) || 0));
-	return ordered.slice(offset, offset + limit);
-}
-const GSC_API_CAPABILITIES = {
-	regex: true,
-	multiDataset: false,
-	comparisonJoin: false,
-	windowTotals: false
-};
-function isMetricDimension$1(dim) {
-	return [
-		"clicks",
-		"impressions",
-		"ctr",
-		"position"
-	].includes(dim);
-}
-function builderFromState(state) {
-	return { getState: () => state };
-}
-function createGscApiQuerySource(options) {
-	const { client, siteUrl } = options;
-	return {
-		name: "gsc-api",
-		capabilities: GSC_API_CAPABILITIES,
-		async queryRows(state) {
-			buildLogicalPlan(state, GSC_API_CAPABILITIES);
-			const filterDims = getFilterDimensions(state.filter, isMetricDimension$1);
-			assertDimensionsSupported([...state.dimensions, ...filterDims], "api", "gsc-api query source");
-			return applyBuilderStatePostProcessing(await collectRows(client.query(siteUrl, builderFromState(state))), state);
-		}
-	};
-}
-const PRO_ONLY_DIMENSIONS = new Set(["queryCanonical", "page_keywords"]);
-function canProxyToGsc(state) {
-	if (state.dimensions.some((d) => PRO_ONLY_DIMENSIONS.has(d))) return false;
-	if (extractMetricFilters(state.filter).length > 0) return false;
-	if (extractSpecialOperatorFilters(state.filter).length > 0) return false;
-	return true;
-}
-function createLiveGscSource(opts) {
-	let clientPromise = null;
-	function getClient() {
-		if (!clientPromise) clientPromise = opts.getAccessToken().then((accessToken) => googleSearchConsole({ accessToken }));
-		return clientPromise;
-	}
-	return {
-		name: "gsc-api",
-		capabilities: {
-			regex: true,
-			multiDataset: false,
-			comparisonJoin: false,
-			windowTotals: false
-		},
-		async queryRows(state) {
-			return createGscApiQuerySource({
-				client: await getClient(),
-				siteUrl: opts.siteUrl
-			}).queryRows(state);
-		}
-	};
-}
 function createCompositeSource(opts) {
 	const { engine, live, site } = opts;
 	function rangeCovered(state) {
@@ -231,56 +25,6 @@ function createCompositeSource(opts) {
 		executeSql: engine.executeSql
 	};
 }
-function isMetricDimension(dim) {
-	return [
-		"clicks",
-		"impressions",
-		"ctr",
-		"position"
-	].includes(dim);
-}
-const ENGINE_QUERY_CAPABILITIES = {
-	regex: true,
-	multiDataset: false,
-	comparisonJoin: false,
-	windowTotals: false
-};
-const ENGINE_SOURCE_CAPABILITIES = {
-	...ENGINE_QUERY_CAPABILITIES,
-	fileSets: true,
-	localSource: true
-};
-function createEngineQuerySource(options) {
-	const { engine, ctx } = options;
-	return {
-		name: "engine",
-		capabilities: ENGINE_SOURCE_CAPABILITIES,
-		async queryRows(state) {
-			const filterDims = getFilterDimensions(state.filter, isMetricDimension);
-			assertDimensionsSupported([...state.dimensions, ...filterDims], "stored", "engine query source");
-			if (state.dimensions.includes("queryCanonical") || filterDims.includes("queryCanonical")) throw new Error("engine query source does not support queryCanonical; use browser/sqlite query sources for derived dimensions");
-			return (await engine.query(ctx, state)).rows;
-		},
-		async executeSql(sql, params, opts) {
-			const fileSets = opts?.fileSets;
-			if (!fileSets?.FILES) throw new Error("engine query source: executeSql requires opts.fileSets with a FILES entry");
-			const { rows } = await engine.runSQL({
-				ctx,
-				table: fileSets.FILES.table,
-				fileSets,
-				sql,
-				params: params ?? []
-			});
-			return rows;
-		}
-	};
-}
-async function runAnalyzerWithEngine(deps, ctx, params, registry) {
-	return runAnalyzerFromSource(createEngineQuerySource({
-		engine: deps.engine,
-		ctx
-	}), params, registry);
-}
 const IN_MEMORY_DEFAULT_CAPABILITIES = {
 	regex: true,
 	multiDataset: true,
@@ -306,114 +50,6 @@ function pagesQueryState(period, limit = DEFAULT_LIMIT$1) {
 function datesQueryState(period, limit = DEFAULT_LIMIT$1) {
 	return gsc.select(date).where(between(date, period.startDate, period.endDate)).limit(limit).getState();
 }
-const DEFAULT_SQL_REQUIRES = ["executeSql", "partitionedParquet"];
-function defineAnalyzer(opts) {
-	const { id, reduce, reduceSql, reduceRows, buildSql, buildRows, sqlRequires = DEFAULT_SQL_REQUIRES, rowsRequires = [] } = opts;
-	const sqlReducer = reduceSql ?? reduce;
-	const rowsReducer = reduceRows ?? reduce;
-	if (buildSql && !sqlReducer) throw new Error(`defineAnalyzer(${id}): buildSql requires reduce or reduceSql`);
-	if (buildRows && !rowsReducer) throw new Error(`defineAnalyzer(${id}): buildRows requires reduce or reduceRows`);
-	const wrap = (fn) => (rows, params, ctx) => {
-		return fn(Array.isArray(rows) ? rows : pickSingle(rows) ?? rows, params, ctx);
-	};
-	return {
-		id,
-		sql: buildSql && sqlReducer ? {
-			id,
-			requires: sqlRequires,
-			build(params) {
-				const spec = buildSql(params);
-				return {
-					kind: "sql",
-					sql: spec.sql,
-					params: spec.params,
-					current: spec.current,
-					previous: spec.previous,
-					extraFiles: spec.extraFiles,
-					extraQueries: spec.extraQueries,
-					requiresAttachedTables: spec.requiresAttachedTables
-				};
-			},
-			reduce(rows, ctx) {
-				const { results, meta } = wrap(sqlReducer)(rows, ctx.params, { extras: ctx.extras });
-				return {
-					results,
-					meta
-				};
-			}
-		} : void 0,
-		rows: buildRows && rowsReducer ? {
-			id,
-			requires: rowsRequires,
-			build(params) {
-				const queries = buildRows(params);
-				return {
-					kind: "rows",
-					queries: Object.fromEntries(Object.entries(queries).map(([k, state]) => [k, { state }]))
-				};
-			},
-			reduce(rows, ctx) {
-				const { results, meta } = wrap(rowsReducer)(rows, ctx.params, {});
-				return {
-					results,
-					meta
-				};
-			}
-		} : void 0
-	};
-}
-function pickSingle(rows) {
-	const keys = Object.keys(rows);
-	return keys.length === 1 ? rows[keys[0]] : void 0;
-}
-function defaultEndDate() {
-	return daysAgo(3);
-}
-function defaultStartDate() {
-	return daysAgo(31);
-}
-function periodOf(params) {
-	return {
-		startDate: params.startDate || defaultStartDate(),
-		endDate: params.endDate || defaultEndDate()
-	};
-}
-function comparisonOf(params) {
-	if (!params.prevStartDate || !params.prevEndDate) throw new Error(`${params.type} analysis requires prevStartDate and prevEndDate`);
-	return {
-		current: periodOf(params),
-		previous: {
-			startDate: params.prevStartDate,
-			endDate: params.prevEndDate
-		}
-	};
-}
-function num(v) {
-	if (typeof v === "number") return v;
-	if (typeof v === "bigint") return Number(v);
-	if (v == null) return 0;
-	return Number(v);
-}
-function buildPeriodMap(rows, key, value, filter) {
-	const out = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (filter && !filter(row)) continue;
-		out.set(key(row), value(row));
-	}
-	return out;
-}
-function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
-	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
-		const mult = sortOrder === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
-	};
-}
-function createMetricSorter(defaultMetric, orderByMetric) {
-	return (items, sortBy = defaultMetric) => {
-		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
-		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
-	};
-}
 function escapeRegexAlt(s) {
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -939,6 +575,26 @@ defineAnalyzer({
 		};
 	}
 });
+function buildPeriodMap(rows, key, value, filter) {
+	const out = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (filter && !filter(row)) continue;
+		out.set(key(row), value(row));
+	}
+	return out;
+}
+function createSorter(getValue, defaultMetric, defaultOrder = "desc") {
+	return (items, sortBy = defaultMetric, sortOrder = defaultOrder) => {
+		const mult = sortOrder === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (getValue(a, sortBy) - getValue(b, sortBy)) * mult);
+	};
+}
+function createMetricSorter(defaultMetric, orderByMetric) {
+	return (items, sortBy = defaultMetric) => {
+		const mult = orderByMetric[sortBy] === "desc" ? -1 : 1;
+		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
+	};
+}
 const sortResults$2 = createMetricSorter("lostClicks", {
 	lostClicks: "desc",
 	declinePercent: "desc",
@@ -1769,23 +1425,6 @@ function analyzeStrikingDistance(keywords, options = {}) {
 	}
 	return sortResults(results, sortBy, sortOrder);
 }
-function typedQuery(state) {
-	return { state };
-}
-function isTypedQuery(value) {
-	return "state" in value;
-}
-async function queryRows(source, query) {
-	const state = isTypedQuery(query) ? query.state : query;
-	return await source.queryRows(state);
-}
-async function queryComparisonRows(source, current, previous) {
-	const [currentRows, previousRows] = await Promise.all([queryRows(source, current), queryRows(source, previous)]);
-	return {
-		current: currentRows,
-		previous: previousRows
-	};
-}
 function keywordQuery(period, limit) {
 	return typedQuery(keywordsQueryState(period, limit));
 }
@@ -1907,4 +1546,4 @@ async function analyzeDecayFromSource(source, periods, options) {
 async function analyzeMoversFromSource(source, periods, options) {
 	return runPortableAnalyzer(source, PORTABLE_ANALYZERS.movers, periods, options);
 }
-export { AnalyzerCapabilityError, ENGINE_QUERY_CAPABILITIES, GSC_API_CAPABILITIES, IN_MEMORY_DEFAULT_CAPABILITIES, analyzeBrandSegmentationFromSource, analyzeClusteringFromSource, analyzeDecayFromSource, analyzeFromSource, analyzeKeywordConcentrationFromSource, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentrationFromSource, analyzeSeasonalityFromSource, analyzeStrikingDistanceFromSource, canProxyToGsc, collectRows as collectGscRows, createBrowserQuerySource, createCompositeSource, createEngineQuerySource, createGscApiQuerySource, createInMemoryQuerySource, createLiveGscSource, createSqliteQuerySource, fetchGscDaily, fetchGscTopN, isSqlQuerySource, queryAnalyticsFromSource, queryComparisonFromSource, queryComparisonRows, queryRows, runAnalyzerWithEngine, typedQuery };
+export { AnalyzerCapabilityError, IN_MEMORY_DEFAULT_CAPABILITIES, analyzeBrandSegmentationFromSource, analyzeClusteringFromSource, analyzeDecayFromSource, analyzeFromSource, analyzeKeywordConcentrationFromSource, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentrationFromSource, analyzeSeasonalityFromSource, analyzeStrikingDistanceFromSource, createCompositeSource, createInMemoryQuerySource, queryAnalyticsFromSource, queryComparisonFromSource };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/analysis",
   "type": "module",
-  "version": "0.6.3",
+  "version": "0.7.5",
   "description": "GSC analyzers — striking-distance, opportunity, movers, decay, brand, clustering, concentration, seasonality. Pure row-based + DuckDB-native.",
   "author": {
     "name": "Harlan Wilton",
@@ -23,31 +23,43 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
     "./analyzer": {
       "types": "./dist/analyzer/index.d.mts",
-      "import": "./dist/analyzer/index.mjs"
+      "import": "./dist/analyzer/index.mjs",
+      "default": "./dist/analyzer/index.mjs"
     },
     "./registry": {
       "types": "./dist/default-registry.d.mts",
-      "import": "./dist/default-registry.mjs"
+      "import": "./dist/default-registry.mjs",
+      "default": "./dist/default-registry.mjs"
     },
     "./query": {
       "types": "./dist/query/index.d.mts",
-      "import": "./dist/query/index.mjs"
+      "import": "./dist/query/index.mjs",
+      "default": "./dist/query/index.mjs"
     },
     "./source": {
       "types": "./dist/source/index.d.mts",
-      "import": "./dist/source/index.mjs"
+      "import": "./dist/source/index.mjs",
+      "default": "./dist/source/index.mjs"
     },
     "./semantic": {
       "types": "./dist/semantic/index.d.mts",
-      "import": "./dist/semantic/index.mjs"
+      "import": "./dist/semantic/index.mjs",
+      "default": "./dist/semantic/index.mjs"
     },
-    "./period": {
-      "types": "./dist/period/index.d.mts",
-      "import": "./dist/period/index.mjs"
+    "./routing": {
+      "types": "./dist/routing/index.d.mts",
+      "import": "./dist/routing/index.mjs",
+      "default": "./dist/routing/index.mjs"
+    },
+    "./rollups": {
+      "types": "./dist/rollups.d.mts",
+      "import": "./dist/rollups.mjs",
+      "default": "./dist/rollups.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -68,11 +80,9 @@
   },
   "dependencies": {
     "drizzle-orm": "^0.45.2",
-    "@gscdump/engine-duckdb-node": "0.6.3",
-    "@gscdump/engine-sqlite": "0.6.3",
-    "@gscdump/engine-wasm": "0.6.3",
-    "gscdump": "0.6.3",
-    "@gscdump/engine": "0.6.3"
+    "@gscdump/engine": "0.7.5",
+    "@gscdump/engine-gsc-api": "0.7.5",
+    "gscdump": "0.7.5"
   },
   "devDependencies": {
     "vitest": "^4.1.5"

package/dist/period/index.d.mts

@@ -1,57 +0,0 @@
-import { AnalysisParams } from "gscdump/contracts";
-type WindowPreset = 'last-7d' | 'last-28d' | 'last-30d' | 'last-90d' | 'last-180d' | 'last-365d' | 'mtd' | 'ytd' | 'custom';
-type ComparisonMode = 'none' | 'prev-period' | 'yoy';
-interface ResolveWindowOptions {
-  preset: WindowPreset;
-  comparison?: ComparisonMode;
-  anchor?: string;
-  start?: string;
-  end?: string;
-}
-interface ResolvedWindow {
-  start: string;
-  end: string;
-  days: number;
-  comparison?: {
-    start: string;
-    end: string;
-  };
-}
-interface AnalysisPeriod {
-  startDate: string;
-  endDate: string;
-}
-interface ComparisonPeriod {
-  current: AnalysisPeriod;
-  previous: AnalysisPeriod;
-}
-declare function defaultEndDate(): string;
-declare function defaultStartDate(): string;
-declare function periodOf(params: AnalysisParams): AnalysisPeriod;
-declare function comparisonOf(params: AnalysisParams): ComparisonPeriod;
-declare function resolveWindow(opts: ResolveWindowOptions): ResolvedWindow;
-/** Convert a ResolvedWindow into the AnalysisPeriod / ComparisonPeriod shape. */
-declare function windowToPeriod(w: ResolvedWindow): AnalysisPeriod;
-declare function windowToComparisonPeriod(w: ResolvedWindow): ComparisonPeriod | undefined;
-interface PadTimeseriesOptions<T> {
-  /** ISO date (YYYY-MM-DD), inclusive lower bound. */
-  startDate: string;
-  /** ISO date (YYYY-MM-DD), inclusive upper bound. */
-  endDate: string;
-  /**
-   * Row to insert for missing dates. Defaults to `{ clicks: 0, impressions: 0, ctr: 0, position: 0 }`.
-   * The `date` field is set automatically.
-   */
-  fill?: Omit<T, 'date'>;
-  /** Row-field that carries the ISO date. Defaults to `date`. */
-  dateKey?: string;
-}
-type DateRowShape = Record<string, unknown> & {
-  date?: unknown;
-};
-/**
- * Pad rows so every calendar day in `[startDate, endDate]` appears at least
- * once. Existing dates keep all their rows (grouped timeseries safe).
- */
-declare function padTimeseries<T extends DateRowShape = DateRowShape>(rows: readonly T[], options: PadTimeseriesOptions<T>): T[];
-export { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, defaultEndDate, defaultStartDate, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod };