@gscdump/analysis 0.38.2 → 0.40.1

package/dist/default-registry.mjs

@@ -6,7 +6,7 @@ import { num } from "@gscdump/engine/analysis-types";
 import { err, ok, unwrapResult } from "gscdump/result";
 import { between, date, extractDateRange, gsc, page, query } from "gscdump/query";
 import { MS_PER_DAY, daysAgoUtc, toIsoDate } from "gscdump/dates";
-import { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
+import { buildExtrasQueries, buildTotalsSql, mergeExtras, resolveComparisonSQL, resolveToSQLOptimized } from "@gscdump/engine/resolver";
 function rowNumber(value) {
 	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
 	if (typeof value === "bigint") return Number(value);
@@ -522,8 +522,7 @@ function analyzeBrandSegmentation(keywords, options) {
 		const impressions = num(row.impressions);
 		if (impressions < minImpressions) continue;
 		const clicks = num(row.clicks);
-		const query = row.query.toLowerCase();
-		if (lowerBrandTerms.some((term) => query.includes(term))) {
+		if ((row.variants?.length ? row.variants : [row.query ?? row.keyword ?? ""]).some((query) => lowerBrandTerms.some((term) => query.toLowerCase().includes(term)))) {
 			brand.push(row);
 			brandClicks += clicks;
 			brandImpressions += impressions;
@@ -665,7 +664,7 @@ function createMetricSorter(defaultMetric, orderByMetric) {
 		return [...items].sort((a, b) => (a[sortBy] - b[sortBy]) * mult);
 	};
 }
-const sortRowResults$1 = createSorter((item, metric) => {
+const sortRowResults = createSorter((item, metric) => {
 	switch (metric) {
 		case "clicks": return item.totalClicks;
 		case "impressions": return item.totalImpressions;
@@ -712,7 +711,7 @@ function analyzeCannibalization(rows, options = {}) {
 			positionSpread
 		});
 	}
-	return sortRowResults$1(results, sortBy, sortOrder);
+	return sortRowResults(results, sortBy, sortOrder);
 }
 const cannibalizationAnalyzer = defineAnalyzer({
 	id: "cannibalization",
@@ -2250,14 +2249,9 @@ function shapeDataQueryRows(rows, params, extras) {
 function buildDataDetailPlan(params, options) {
 	const state = requireBuilderState(params.q, "data-detail");
 	if (!state.dimensions.includes("date")) throw new Error("data-detail: `date` dimension is required");
-	const main = resolveToSQL(state, options);
-	const totals = buildTotalsSql(state, options);
+	const main = resolveToSQLOptimized(state, options);
 	const prev = optionalBuilderState(params.qc, "data-detail", "qc");
-	const extraQueries = [{
-		name: "totals",
-		sql: totals.sql,
-		params: totals.params
-	}];
+	const extraQueries = [];
 	if (prev) {
 		const previousTotals = buildTotalsSql(prev, options);
 		extraQueries.push({
@@ -2275,18 +2269,22 @@ function buildDataDetailPlan(params, options) {
 }
 function shapeDataDetailRows(rows, params, extras) {
 	const { startDate: rangeStart, endDate: rangeEnd } = extractDateRange(requireBuilderState(params.q, "data-detail").filter);
-	const coerced = rows.map(coerceNumericCols);
+	const first = rows[0];
+	const totals = {
+		clicks: Number(first?.totalClicks ?? 0),
+		impressions: Number(first?.totalImpressions ?? 0),
+		ctr: Number(first?.totalCtr ?? 0),
+		position: Number(first?.totalPosition ?? 0)
+	};
+	const coerced = rows.map((raw) => {
+		const { totalCount: _tc, totalClicks: _tclk, totalImpressions: _timp, totalCtr: _tctr, totalPosition: _tpos, sum_position: _sp, ...rest } = raw;
+		return coerceNumericCols(rest);
+	});
 	const daily = rangeStart && rangeEnd ? padTimeseries(coerced, {
 		startDate: rangeStart,
 		endDate: rangeEnd
 	}) : coerced;
-	const totalsRow = extras?.totals?.[0] ?? {};
-	const meta = { totals: {
-		clicks: Number(totalsRow.clicks ?? 0),
-		impressions: Number(totalsRow.impressions ?? 0),
-		ctr: Number(totalsRow.ctr ?? 0),
-		position: Number(totalsRow.position ?? 0)
-	} };
+	const meta = { totals };
 	if (extras?.prevTotals) {
 		const previousTotalsRow = extras.prevTotals[0] ?? {};
 		meta.previousTotals = {
@@ -2403,7 +2401,69 @@ function paginateInMemory(rows, input) {
 	const o = clampOffset(input.offset);
 	return rows.slice(o, o + l);
 }
-const sortResults$1 = createMetricSorter("lostClicks", {
+function paginateSortedInMemory(rows, input, compare) {
+	const limit = clampLimit(input.limit, rows.length);
+	const offset = clampOffset(input.offset);
+	const selectedCount = Math.min(rows.length, offset + limit);
+	if (limit === 0 || offset >= rows.length || selectedCount === 0) return [];
+	const fullSort = () => [...rows].sort(compare).slice(offset, offset + limit);
+	if (selectedCount >= rows.length / 2) return fullSort();
+	let invalidComparison = false;
+	const compareStable = (left, right) => {
+		const order = compare(left.value, right.value);
+		if (Number.isNaN(order)) {
+			invalidComparison = true;
+			return left.index - right.index;
+		}
+		return order || left.index - right.index;
+	};
+	const isWorse = (left, right) => compareStable(left, right) > 0;
+	const heap = [];
+	const siftUp = (start) => {
+		let index = start;
+		while (index > 0) {
+			const parent = index - 1 >>> 1;
+			if (!isWorse(heap[index], heap[parent])) break;
+			const swap = heap[parent];
+			heap[parent] = heap[index];
+			heap[index] = swap;
+			index = parent;
+		}
+	};
+	const siftDown = () => {
+		let index = 0;
+		for (;;) {
+			const left = index * 2 + 1;
+			if (left >= heap.length) return;
+			const right = left + 1;
+			let worse = left;
+			if (right < heap.length && isWorse(heap[right], heap[left])) worse = right;
+			if (!isWorse(heap[worse], heap[index])) return;
+			const swap = heap[index];
+			heap[index] = heap[worse];
+			heap[worse] = swap;
+			index = worse;
+		}
+	};
+	for (let index = 0; index < rows.length; index++) {
+		const candidate = {
+			value: rows[index],
+			index
+		};
+		if (heap.length < selectedCount) {
+			heap.push(candidate);
+			siftUp(heap.length - 1);
+		} else if (compareStable(candidate, heap[0]) < 0) {
+			heap[0] = candidate;
+			siftDown();
+		}
+	}
+	if (invalidComparison) return fullSort();
+	heap.sort(compareStable);
+	if (invalidComparison) return fullSort();
+	return heap.slice(offset, offset + limit).map((entry) => entry.value);
+}
+const sortResults = createMetricSorter("lostClicks", {
 	lostClicks: "desc",
 	declinePercent: "desc",
 	currentClicks: "asc"
@@ -2436,7 +2496,7 @@ function analyzeDecay(input, options = {}) {
 			positionDrop: currentPosition != null ? currentPosition - prev.position : null
 		});
 	}
-	return sortResults$1(results, sortBy);
+	return sortResults(results, sortBy);
 }
 const decayAnalyzer = defineAnalyzer({
 	id: "decay",
@@ -3435,12 +3495,52 @@ function calculateCtrGapScore(actualCtr, position) {
 	const gap = expectedCtr - actualCtr;
 	return Math.min(gap / expectedCtr, 1);
 }
-const sortResults = createMetricSorter("opportunityScore", {
+const SORT_DIR = {
 	opportunityScore: "desc",
 	potentialClicks: "desc",
 	impressions: "desc",
 	position: "asc"
-});
+};
+function analyzeOpportunity(keywords, options = {}) {
+	const minImpressions = options.minImpressions ?? 100;
+	const positionWeight = options.weights?.position ?? 1;
+	const impressionsWeight = options.weights?.impressions ?? 1;
+	const ctrGapWeight = options.weights?.ctrGap ?? 1;
+	const totalWeight = positionWeight + impressionsWeight + ctrGapWeight;
+	const sortBy = options.sortBy ?? "opportunityScore";
+	const results = [];
+	for (const row of keywords) {
+		const impressions = num(row.impressions);
+		if (impressions < minImpressions) continue;
+		const position = num(row.position);
+		const ctr = num(row.ctr);
+		const clicks = num(row.clicks);
+		const positionScore = calculatePositionScore(position);
+		const impressionScore = calculateImpressionScore(impressions);
+		const ctrGapScore = calculateCtrGapScore(ctr, position);
+		const weightedProduct = positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight;
+		const opportunityScore = Math.round(weightedProduct ** (1 / totalWeight) * 100);
+		const potentialClicks = Math.round(impressions * getExpectedCtr(Math.min(3, position)));
+		results.push({
+			keyword: row.query,
+			page: row.page ?? null,
+			clicks,
+			impressions,
+			ctr,
+			position,
+			opportunityScore,
+			potentialClicks,
+			factors: {
+				positionScore,
+				impressionScore,
+				ctrGapScore
+			}
+		});
+	}
+	const direction = SORT_DIR[sortBy];
+	results.sort((left, right) => direction === "asc" ? left[sortBy] - right[sortBy] : right[sortBy] - left[sortBy]);
+	return options.limit ? results.slice(0, options.limit) : results;
+}
 const opportunityAnalyzer = defineAnalyzer({
 	id: "opportunity",
 	buildSql(params) {
@@ -3554,51 +3654,15 @@ const opportunityAnalyzer = defineAnalyzer({
 		return { queries: queriesQueryState(periodOf(params), params.limit) };
 	},
 	reduceRows(rows, params) {
-		const keywords = (Array.isArray(rows) ? rows : []) ?? [];
-		const minImpressions = params.minImpressions ?? 100;
-		const positionWeight = 1;
-		const impressionsWeight = 1;
-		const ctrGapWeight = 1;
-		const sortBy = "opportunityScore";
-		const results = [];
-		for (const row of keywords) {
-			const impressions = num(row.impressions);
-			const position = num(row.position);
-			const ctr = num(row.ctr);
-			const clicks = num(row.clicks);
-			if (impressions < minImpressions) continue;
-			const positionScore = calculatePositionScore(position);
-			const impressionScore = calculateImpressionScore(impressions);
-			const ctrGapScore = calculateCtrGapScore(ctr, position);
-			const geometricMean = (positionScore ** positionWeight * impressionScore ** impressionsWeight * ctrGapScore ** ctrGapWeight) ** (1 / 3);
-			const opportunityScore = Math.round(geometricMean * 100);
-			const targetCtr = getExpectedCtr(Math.min(3, position));
-			const potentialClicks = Math.round(impressions * targetCtr);
-			results.push({
-				keyword: row.query,
-				page: row.page ?? null,
-				clicks,
-				impressions,
-				ctr,
-				position,
-				opportunityScore,
-				potentialClicks,
-				factors: {
-					positionScore,
-					impressionScore,
-					ctrGapScore
-				}
-			});
-		}
-		const sorted = sortResults(results, sortBy);
-		const paged = paginateInMemory(sorted, {
+		const results = analyzeOpportunity((Array.isArray(rows) ? rows : []) ?? [], { minImpressions: params.minImpressions });
+		const paged = paginateSortedInMemory(results, {
 			limit: params.limit,
 			offset: params.offset
-		});
+		}, (left, right) => right.opportunityScore - left.opportunityScore);
 		return {
 			results: paged,
 			meta: {
-				total: sorted.length,
+				total: results.length,
 				returned: paged.length
 			}
 		};
@@ -4270,6 +4334,12 @@ const stlDecomposeAnalyzer = defineAnalyzer({
 	}
 });
 const DEFAULT_ROW_LIMIT$1 = 25e3;
+function paginateStrikingDistance(results, options) {
+	return paginateSortedInMemory(results, {
+		limit: options.limit ?? 1e3,
+		offset: options.offset
+	}, (left, right) => right.potentialClicks - left.potentialClicks);
+}
 function filterStrikingDistance(rows, options = {}) {
 	const minPosition = options.minPosition ?? 4;
 	const maxPosition = options.maxPosition ?? 20;
@@ -4300,11 +4370,7 @@ const strikingDistanceAnalyzer = defineAnalyzer({
 	id: "striking-distance",
 	reduce(rows, params) {
 		const results = filterStrikingDistance(Array.isArray(rows) ? rows : [], params);
-		results.sort((a, b) => b.potentialClicks - a.potentialClicks);
-		const paged = paginateInMemory(results, {
-			limit: params.limit ?? 1e3,
-			offset: params.offset
-		});
+		const paged = paginateStrikingDistance(results, params);
 		return {
 			results: paged,
 			meta: {
@@ -4680,7 +4746,18 @@ const trendsAnalyzer = defineAnalyzer({
 	}
 });
 const DEFAULT_ROW_LIMIT = 25e3;
-const sortRowResults = createSorter((item) => item.impressions, "impressions");
+function analyzeZeroClick(rows, options = {}) {
+	const minImpressions = options.minImpressions ?? 1e3;
+	const maxCtr = options.maxCtr ?? .03;
+	const maxPosition = options.maxPosition ?? 10;
+	const queryMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (row.impressions < minImpressions || row.position > maxPosition || row.ctr > maxCtr) continue;
+		const existing = queryMap.get(row.query);
+		if (!existing || row.position < existing.position) queryMap.set(row.query, { ...row });
+	}
+	return [...queryMap.values()].sort((left, right) => right.impressions - left.impressions);
+}
 const defaultAnalyzerRegistry = createAnalyzerRegistry({ defined: [
 	bayesianCtrAnalyzer,
 	bipartitePagerankAnalyzer,
@@ -4793,30 +4870,15 @@ const defaultAnalyzerRegistry = createAnalyzerRegistry({ defined: [
 			return { rows: gsc.select(query, page).where(between(date, period.startDate, period.endDate)).limit(limit).getState() };
 		},
 		reduceRows(rows, params) {
-			const arr = Array.isArray(rows) ? rows : [];
-			const minImpressions = params.minImpressions ?? 1e3;
-			const maxCtr = params.maxCtr ?? .03;
-			const maxPosition = params.maxPosition ?? 10;
-			const queryMap = /* @__PURE__ */ new Map();
-			for (const row of arr) {
-				if (row.impressions < minImpressions) continue;
-				if (row.position > maxPosition) continue;
-				if (row.ctr > maxCtr) continue;
-				const existing = queryMap.get(row.query);
-				if (!existing || row.position < existing.position) queryMap.set(row.query, {
-					query: row.query,
-					page: row.page,
-					clicks: row.clicks,
-					impressions: row.impressions,
-					ctr: row.ctr,
-					position: row.position
-				});
-			}
-			const results = sortRowResults(Array.from(queryMap.values()), "impressions", "desc");
-			const paged = paginateInMemory(results, {
+			const results = analyzeZeroClick(Array.isArray(rows) ? rows : [], {
+				minImpressions: params.minImpressions ?? 1e3,
+				maxCtr: params.maxCtr ?? .03,
+				maxPosition: params.maxPosition ?? 10
+			});
+			const paged = paginateSortedInMemory(results, {
 				limit: params.limit,
 				offset: params.offset
-			});
+			}, (left, right) => right.impressions - left.impressions);
 			return {
 				results: paged,
 				meta: {

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import { Analyzer, Analyzer as Analyzer$1, AnalyzerCapabilityError, AnalyzerRegistry, AnalyzerRegistry as AnalyzerRegistry$1, AnalyzerRegistryInit, AnalyzerVariants, DefineAnalyzerOptions, DefinedAnalyzer, Plan, ReduceContext, ReduceCtx, Reducer, RequiredCapability, RowQueriesPlan, SqlExtraQuery, SqlPlan, SqlPlanSpec, TypedRowQuery, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
-import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod } from "@gscdump/engine/period";
+import { AnalysisPeriod, ComparisonMode, ComparisonPeriod, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, padTimeseries, periodOf, resolveWindow } from "@gscdump/engine/period";
 import { AnalysisParams, AnalysisParams as AnalysisParams$1, AnalysisResult, AnalysisResult as AnalysisResult$1, AnalysisTool, num } from "@gscdump/engine/analysis-types";
 import { Result } from "gscdump/result";
 import { BuilderState } from "gscdump/query";
-import { AnalysisQuerySource, AnalysisQuerySource as AnalysisQuerySource$1, AnalysisSourceKind, AttachedTableRunner, AttachedTableRunner as AnalyzerRunner, AttachedTableSourceOptions, AttachedTableSourceOptions as BrowserAnalyzeOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, ExecuteSqlOptions, FileSet, QueryRow, QueryRow as QueryRow$1, SourceCapabilities, TypedQuery, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery } from "@gscdump/engine/source";
+import { AnalysisQuerySource, AnalysisQuerySource as AnalysisQuerySource$1, AnalysisSourceKind, AttachedTableRunner, AttachedTableRunner as AnalyzerRunner, AttachedTableSourceOptions, AttachedTableSourceOptions as BrowserAnalyzeOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, ExecuteSqlOptions, FileSet, QueryRow, QueryRow as QueryRow$1, SourceCapabilities, createEngineQuerySource, queryRows, rewriteForTableSource, runAnalyzerWithEngine } from "@gscdump/engine/source";
 import { DefineReportOptions, DefinedReport, DefinedReport as DefinedReport$1, ReportAction, ReportContext, ReportContext as ReportContext$1, ReportFinding, ReportParams, ReportPlanStep, ReportResult, ReportResult as ReportResult$1, ReportSection } from "@gscdump/engine/report";
 import { PlannerCapabilities } from "gscdump/query/plan";
 type ActionSource = 'cannibalization' | 'striking-distance' | 'ctr-anomaly' | 'change-point' | 'opportunity';
@@ -78,6 +78,13 @@ interface BrandSegmentationOptions {
   /** Minimum impressions for a keyword to be included. Default: 10 */
   minImpressions?: number;
 }
+interface BrandSegmentationRow {
+  query?: string;
+  keyword?: string;
+  variants?: readonly string[];
+  clicks?: number | null;
+  impressions?: number | null;
+}
 interface BrandSummary {
   brandClicks: number;
   nonBrandClicks: number;
@@ -85,16 +92,17 @@ interface BrandSummary {
   brandImpressions: number;
   nonBrandImpressions: number;
 }
-interface BrandSegmentationResult {
-  brand: QueriesRow[];
-  nonBrand: QueriesRow[];
+interface BrandSegmentationResult<T extends BrandSegmentationRow = QueriesRow> {
+  brand: T[];
+  nonBrand: T[];
   summary: BrandSummary;
 }
 /**
  * Pure helper: segment keywords into brand and non-brand based on provided
  * brand terms. Re-exported from `@gscdump/analysis` for portable callers.
  */
-declare function analyzeBrandSegmentation(keywords: QueriesRow[], options: BrandSegmentationOptions): BrandSegmentationResult;
+declare function analyzeBrandSegmentation(keywords: QueriesRow[], options: BrandSegmentationOptions): BrandSegmentationResult<QueriesRow>;
+declare function analyzeBrandSegmentation<T extends BrandSegmentationRow>(keywords: T[], options: BrandSegmentationOptions): BrandSegmentationResult<T>;
 type CannibalizationSortMetric = 'clicks' | 'impressions' | 'positionSpread' | 'pageCount';
 interface CannibalizationOptions {
   /** Minimum impressions for a query to be considered. Default: 10 */
@@ -295,6 +303,7 @@ interface MoversResult {
  * recent changes between two periods.
  */
 declare function analyzeMovers(input: MoversInput, options?: MoversOptions): MoversResult;
+type OpportunitySortMetric = 'opportunityScore' | 'potentialClicks' | 'impressions' | 'position';
 interface OpportunityFactors {
   positionScore: number;
   impressionScore: number;
@@ -311,6 +320,19 @@ interface OpportunityResult {
   potentialClicks: number;
   factors: OpportunityFactors;
 }
+interface OpportunityWeights {
+  position?: number;
+  impressions?: number;
+  ctrGap?: number;
+}
+interface OpportunityOptions {
+  minImpressions?: number;
+  weights?: OpportunityWeights;
+  sortBy?: OpportunitySortMetric;
+  limit?: number;
+}
+/** Pure opportunity scorer shared by hosted and package analyzer callers. */
+declare function analyzeOpportunity(keywords: QueriesRow[], options?: OpportunityOptions): OpportunityResult[];
 type SeasonalityMetric = 'clicks' | 'impressions';
 interface SeasonalityOptions {
   /** Metric to analyze for seasonality. Default: clicks */
@@ -371,12 +393,25 @@ interface StrikingDistanceResult {
   /** Estimated clicks at ~15% CTR (the average for positions 1–3). */
   potentialClicks: number;
 }
-/**
- * `zero-click` — high impressions, low CTR, good ranking. SQL groups by
- * (query, url) and applies HAVING/WHERE pushdown; row reducer dedupes to the
- * best-positioned page per query (different semantics, kept for parity with
- * the existing live-GSC behavior).
- */
+interface StrikingDistanceFilterOptions {
+  minPosition?: number;
+  maxPosition?: number;
+  minImpressions?: number;
+  maxCtr?: number;
+}
+interface StrikingDistanceOptions extends StrikingDistanceFilterOptions {
+  limit?: number;
+  offset?: number;
+}
+/** Pure striking-distance analysis for consumers that already own the rows. */
+declare function analyzeStrikingDistance(rows: readonly {
+  query: unknown;
+  page?: unknown;
+  clicks: unknown;
+  impressions: unknown;
+  ctr: unknown;
+  position: unknown;
+}[], options?: StrikingDistanceOptions): StrikingDistanceResult[];
 interface ZeroClickResult {
   query: string;
   page: string;
@@ -385,6 +420,13 @@ interface ZeroClickResult {
   ctr: number;
   position: number;
 }
+interface ZeroClickOptions {
+  minImpressions?: number;
+  maxCtr?: number;
+  maxPosition?: number;
+}
+/** Pure zero-click detector shared by hosted and package analyzer callers. */
+declare function analyzeZeroClick(rows: QueryPageRow[], options?: ZeroClickOptions): ZeroClickResult[];
 declare function analyzeInBrowser(runner: AttachedTableRunner, opts: AttachedTableSourceOptions, params: AnalysisParams$1, registry: AnalyzerRegistry$1): Promise<AnalysisResult$1>;
 /**
  * Default analyzer registry built from every in-tree analyzer. Convenience
@@ -604,4 +646,4 @@ interface InMemoryQuerySourceOptions {
 }
 declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): AnalysisQuerySource$1;
 declare const SQL_ANALYZERS: readonly Analyzer$1[];
-export { type ActionPriorityResult, type ActionPrioritySourceState, type ActionPrioritySourceStatus, type ActionSource, type AnalysisError, type AnalysisErrorKind, type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, type AnalysisSourceKind, type AnalysisTool, type Analyzer, AnalyzerCapabilityError, type AnalyzerRegistry, type AnalyzerRegistryInit, type AnalyzerRunner, type AnalyzerVariants, type BaseMetrics, type BrandSegmentationOptions, type BrandSegmentationResult, type BrandSummary, type BrowserAnalyzeOptions, type CannibalizationCompetitor, type CannibalizationEvent, type CannibalizationOptions, type CannibalizationPage, type CannibalizationResult, type CannibalizationSortMetric, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type CompositeSourceOptions, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, DEFAULT_PRIORITY_SOURCES, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefineReportOptions, type DefinedAnalyzer, type DefinedReport, type DryRunReportResult, ENGINE_QUERY_CAPABILITIES, type Effort, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type FormatReportOptions, INTENT_CLASSIFIER_VERSION, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, type IntentClassification, type KeywordCluster, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, NORMALIZER_VERSION, type OpportunityResult, type PadTimeseriesOptions, type PageRow, type Plan, type PriorityAction, type QueriesRow, type QueryPageRow, type QueryRow, REPORTS, ROW_ANALYZERS, type ReduceContext, type ReduceCtx, type Reducer, type ReportAction, type ReportContext, type ReportFinding, type ReportPlanStep, type ReportResult, type ReportSection, type RequiredCapability, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, type RunReportOptions, SEARCH_INTENT_CODE, SQL_ANALYZERS, type SearchIntent, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SitemapDelta, type SitemapHealthDiff, type SitemapHealthInput, type SitemapHealthRow, type SitemapHealthTotals, type SortOrder, type SourceCapabilities, type SqlExtraQuery, type SqlPlan, type SqlPlanSpec, type StrikingDistanceInputRow, type StrikingDistanceResult, type TypedQuery, type TypedRowQuery, type WindowPreset, type ZeroClickResult, analysisErrorToException, analysisErrors, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzePageConcentration, analyzeSeasonality, classifyQueryIntent, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, decodeIntent, defaultAnalyzerRegistry, defaultReportRegistry, defineAnalyzer, diffSitemapHealth, dryRunReport, encodeIntent, formatAnalysisError, formatReport, isAnalysisError, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryComparisonRows, queryRows, resolveWindow, rewriteForTableSource, runAnalyzerFromSource, runAnalyzerWithEngine, runReport, runReportResult, scorePriorityActions, typedQuery, windowToComparisonPeriod, windowToPeriod };
+export { type ActionPriorityResult, type ActionPrioritySourceState, type ActionPrioritySourceStatus, type ActionSource, type AnalysisError, type AnalysisErrorKind, type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, type AnalysisSourceKind, type AnalysisTool, type Analyzer, AnalyzerCapabilityError, type AnalyzerRegistry, type AnalyzerRegistryInit, type AnalyzerRunner, type AnalyzerVariants, type BaseMetrics, type BrandSegmentationOptions, type BrandSegmentationResult, type BrandSegmentationRow, type BrandSummary, type BrowserAnalyzeOptions, type CannibalizationCompetitor, type CannibalizationEvent, type CannibalizationOptions, type CannibalizationPage, type CannibalizationResult, type CannibalizationSortMetric, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type CompositeSourceOptions, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, DEFAULT_PRIORITY_SOURCES, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefineReportOptions, type DefinedAnalyzer, type DefinedReport, type DryRunReportResult, ENGINE_QUERY_CAPABILITIES, type Effort, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, type FormatReportOptions, INTENT_CLASSIFIER_VERSION, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, type IntentClassification, type KeywordCluster, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, NORMALIZER_VERSION, type OpportunityFactors, type OpportunityOptions, type OpportunityResult, type OpportunitySortMetric, type OpportunityWeights, type PadTimeseriesOptions, type PageRow, type Plan, type PriorityAction, type QueriesRow, type QueryPageRow, type QueryRow, REPORTS, ROW_ANALYZERS, type ReduceContext, type ReduceCtx, type Reducer, type ReportAction, type ReportContext, type ReportFinding, type ReportPlanStep, type ReportResult, type ReportSection, type RequiredCapability, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, type RunReportOptions, SEARCH_INTENT_CODE, SQL_ANALYZERS, type SearchIntent, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SitemapDelta, type SitemapHealthDiff, type SitemapHealthInput, type SitemapHealthRow, type SitemapHealthTotals, type SortOrder, type SourceCapabilities, type SqlExtraQuery, type SqlPlan, type SqlPlanSpec, type StrikingDistanceInputRow, type StrikingDistanceOptions, type StrikingDistanceResult, type TypedRowQuery, type WindowPreset, type ZeroClickOptions, type ZeroClickResult, analysisErrorToException, analysisErrors, analyzeBrandSegmentation, analyzeCannibalization, analyzeClustering, analyzeConcentration, analyzeDecay, analyzeInBrowser, analyzeKeywordConcentration, analyzeMovers, analyzeOpportunity, analyzePageConcentration, analyzeSeasonality, analyzeStrikingDistance, analyzeZeroClick, classifyQueryIntent, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, decodeIntent, defaultAnalyzerRegistry, defaultReportRegistry, defineAnalyzer, diffSitemapHealth, dryRunReport, encodeIntent, formatAnalysisError, formatReport, isAnalysisError, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryRows, resolveWindow, rewriteForTableSource, runAnalyzerFromSource, runAnalyzerWithEngine, runReport, runReportResult, scorePriorityActions };