@gscdump/analysis 0.4.0

package/dist/index.d.mts

@@ -0,0 +1,620 @@
+import { BuilderState } from "gscdump/query";
+import { GoogleSearchConsoleClient } from "gscdump";
+import { createEngine as createBrowserQuerySource } from "@gscdump/engine-wasm";
+import { AnalysisQuerySource, AnalysisQuerySource as AnalysisQuerySource$1, FileSet, QueryRow, QueryRow as QueryRow$1, RowQuerySource, SourceCapabilities, SqlQuerySource, isSqlQuerySource } from "@gscdump/engine/resolver";
+import { PlannerCapabilities } from "gscdump/query/plan";
+import { createEngine as createSqliteQuerySource } from "@gscdump/engine-sqlite";
+import { Row, StorageEngine, TenantCtx } from "@gscdump/engine/contracts";
+import { AnalysisParams, AnalysisResult, AnalysisTool } from "gscdump/contracts";
+type SortOrder = 'asc' | 'desc';
+/** Base search metrics */
+interface BaseMetrics {
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+}
+/** Keyword row from query */
+interface KeywordRow extends BaseMetrics {
+  query: string;
+  page?: string;
+}
+/** Page row from query */
+interface PageRow extends BaseMetrics {
+  page: string;
+}
+/** Row with both query and page dimensions, both required */
+interface QueryPageRow extends BaseMetrics {
+  query: string;
+  page: string;
+}
+/** Date row from query */
+interface DateRow extends BaseMetrics {
+  date: string;
+}
+/** Coerce arbitrary value (number, bigint, string, null) to number, defaulting to 0. */
+declare function num(v: unknown): number;
+/** Create a generic sorter for any metric type */
+declare function createSorter<T, M extends string>(getValue: (item: T, metric: M) => number, defaultMetric: M, defaultOrder?: SortOrder): (items: T[], sortBy?: M, sortOrder?: SortOrder) => T[];
+/**
+ * Capabilities a Plan may require of its host. A dispatcher matches these
+ * against a source's declared capabilities and rejects mismatches.
+ */
+type Capability = 'executeSql' | 'partitionedParquet' | 'attachedTables' | 'regex' | 'windowTotals' | 'comparisonJoin';
+interface SqlExtraQuery {
+  name: string;
+  sql: string;
+  params: unknown[];
+}
+/**
+ * SQL-native plan: SQL string + placeholders, with optional extra file sets
+ * and follow-up queries. Mirrors the existing `AnalyzerSpec` shape but
+ * renamed for clarity under the unified contract.
+ */
+interface SqlPlan {
+  kind: 'sql';
+  sql: string;
+  params: unknown[];
+  current: FileSet;
+  previous?: FileSet;
+  extraFiles?: Record<string, FileSet>;
+  extraQueries?: SqlExtraQuery[];
+  /** Emits direct table refs (browser-only). Dispatcher rejects for manifest path. */
+  requiresAttachedTables?: boolean;
+}
+interface TypedRowQuery<T extends Row = Row> {
+  state: BuilderState;
+  /** Optional type tag for downstream narrowing. */
+  rowType?: (row: Row) => T;
+}
+/**
+ * Row-queries plan: a named set of typed `BuilderState` queries. A portable
+ * dispatcher runs each against a source's `queryRows` and hands the row
+ * collection to `reduce`.
+ */
+interface RowQueriesPlan {
+  kind: 'rows';
+  queries: Record<string, TypedRowQuery>;
+}
+type Plan = SqlPlan | RowQueriesPlan;
+interface ReduceContext<TRow extends Row = Row> {
+  params: AnalysisParams;
+  /** Extra SQL-query results keyed by `SqlExtraQuery.name`. */
+  extras?: Record<string, TRow[]>;
+}
+/**
+ * Unified analyzer contract. `TRow` lets authors narrow from the default
+ * `Row = Record<string, unknown>` to a typed row shape (e.g. `KeywordRow`)
+ * when their reducer assumes specific columns exist — catches drift between
+ * `build` (SELECT list) and `reduce` (column access) at compile time.
+ */
+interface Analyzer<P extends AnalysisParams = AnalysisParams, R = unknown, TRow extends Row = Row> {
+  /** Stable tool id (e.g. `striking-distance`, `opportunity`). */
+  id: string;
+  /** Capabilities a host source must provide. */
+  requires: readonly Capability[];
+  /** Pure: params → plan. Snapshot-testable. */
+  build: (params: P) => Plan;
+  /** Pure: rows + context → typed result + meta. */
+  reduce: (rows: TRow[] | Record<string, TRow[]>, ctx: ReduceContext<TRow>) => {
+    results: R;
+    meta?: Record<string, unknown>;
+  };
+}
+interface AnalyzerVariants {
+  sql?: Analyzer;
+  rows?: Analyzer;
+}
+interface AnalyzerRegistryInit {
+  rows?: readonly Analyzer[];
+  sql?: readonly Analyzer[];
+}
+interface AnalyzerRegistry {
+  listAnalyzerIds: () => readonly string[];
+  getAnalyzerVariants: (id: string) => AnalyzerVariants | undefined;
+  resolveAnalyzer: (id: string, sourceSupportsSql: boolean) => Analyzer | undefined;
+  listAnalyzersFor: (sourceSupportsSql: boolean) => readonly Analyzer[];
+  listAnalyzerIdsFor: (source: {
+    executeSql?: unknown;
+  }) => readonly string[];
+}
+/**
+ * Build an immutable registry from collections of row / SQL analyzers.
+ * No global state; call this once per logical use (typically at startup
+ * or per-request in a worker).
+ */
+declare function createAnalyzerRegistry(init?: AnalyzerRegistryInit): AnalyzerRegistry;
+interface TypedQuery<TRow> {
+  state: BuilderState;
+  readonly __row?: TRow;
+}
+declare function queryRows<TRow = QueryRow$1>(source: AnalysisQuerySource$1, query: BuilderState | TypedQuery<TRow>): Promise<TRow[]>;
+declare function queryComparisonRows<TRow = QueryRow$1>(source: AnalysisQuerySource$1, current: BuilderState | TypedQuery<TRow>, previous: BuilderState | TypedQuery<TRow>): Promise<{
+  current: TRow[];
+  previous: TRow[];
+}>;
+type ActionSource = 'cannibalization' | 'striking-distance' | 'ctr-anomaly' | 'change-point' | 'opportunity';
+type Effort = 'low' | 'medium' | 'high';
+interface PriorityAction {
+  id: string;
+  title: string;
+  keyword: string;
+  page: string;
+  sources: ActionSource[];
+  severity: number;
+  impressions: number;
+  impact: number;
+  why: string;
+  effort: Effort;
+  priorityScore: number;
+  data: Partial<Record<ActionSource, Record<string, unknown>>>;
+}
+type ActionPrioritySourceStatus = 'pending' | 'running' | 'done' | 'skipped' | 'error';
+interface ActionPrioritySourceState {
+  source: ActionSource;
+  status: ActionPrioritySourceStatus;
+  count: number;
+  error?: string;
+}
+interface ActionPriorityResult {
+  actions: PriorityAction[];
+  totalSignals: number;
+  sources: ActionPrioritySourceState[];
+}
+interface ActionPriorityRunOptions {
+  sources?: ActionSource[];
+  limit?: number;
+  continueOnError?: boolean;
+  paramsBySource?: Partial<Record<ActionSource, Omit<AnalysisParams, 'type'>>>;
+  onSourceStatus?: (state: ActionPrioritySourceState) => void;
+}
+interface ActionPriorityAnalyzer {
+  analyze: (params: AnalysisParams) => Promise<AnalysisResult>;
+}
+declare function normalizePriorityActions(source: ActionSource, result: AnalysisResult): PriorityAction[];
+declare function mergePriorityActions(all: PriorityAction[]): PriorityAction[];
+declare function scorePriorityActions(actions: PriorityAction[]): PriorityAction[];
+declare function analyzeActionPriority(analyzer: ActionPriorityAnalyzer, options?: ActionPriorityRunOptions): Promise<ActionPriorityResult>;
+/**
+ * Convenience wrapper: build the analyzer callback from an
+ * {@link AnalysisQuerySource} so consumers don't hand-roll the adapter.
+ * SQL-only tools (e.g. `cannibalization`, `ctr-anomaly`, `change-point`) will
+ * surface as `status: 'error'` on their source state when the source lacks a
+ * row-based implementation — `continueOnError` defaults to true, so the
+ * overall run still produces whatever the other analyzers found.
+ */
+declare function analyzeActionPriorityFromSource(source: AnalysisQuerySource, registry: AnalyzerRegistry, options?: ActionPriorityRunOptions): Promise<ActionPriorityResult>;
+declare class AnalyzerCapabilityError extends Error {
+  readonly tool: string;
+  readonly missing: readonly Capability[];
+  constructor(tool: string, missing: readonly Capability[]);
+}
+/**
+ * Run an analyzer against a generic `AnalysisQuerySource`. The registry is
+ * an explicit parameter — callers build one via `createAnalyzerRegistry` (or
+ * reuse `defaultAnalyzerRegistry` from the main barrel).
+ */
+declare function runAnalyzerFromSource(source: AnalysisQuerySource, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
+declare const ROW_ANALYZERS: readonly Analyzer[];
+interface BrandSegmentationOptions {
+  /** Brand terms to match against keywords (case-insensitive) */
+  brandTerms: string[];
+  /** Minimum impressions for a keyword to be included. Default: 10 */
+  minImpressions?: number;
+}
+interface BrandSummary {
+  brandClicks: number;
+  nonBrandClicks: number;
+  brandShare: number;
+  brandImpressions: number;
+  nonBrandImpressions: number;
+}
+interface BrandSegmentationResult {
+  brand: KeywordRow[];
+  nonBrand: KeywordRow[];
+  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: KeywordRow[], options: BrandSegmentationOptions): BrandSegmentationResult;
+type CannibalizationSortMetric = 'clicks' | 'impressions' | 'positionSpread' | 'pageCount';
+interface CannibalizationOptions {
+  /** Minimum impressions for a query to be considered. Default: 10 */
+  minImpressions?: number;
+  /** Maximum position spread to flag as cannibalization. Default: 10 */
+  maxPositionSpread?: number;
+  /** Minimum number of pages ranking for same query. Default: 2 */
+  minPages?: number;
+  /** Sort metric. Default: clicks */
+  sortBy?: CannibalizationSortMetric;
+  /** Sort order. Default: desc */
+  sortOrder?: SortOrder;
+}
+interface CannibalizationPage {
+  page: string;
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+}
+interface CannibalizationResult {
+  query: string;
+  pages: CannibalizationPage[];
+  totalClicks: number;
+  totalImpressions: number;
+  positionSpread: number;
+}
+interface CannibalizationCompetitor {
+  url: string;
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+  share: number;
+  rank: number;
+}
+interface CannibalizationEvent {
+  keyword: string;
+  totalImpressions: number;
+  totalClicks: number;
+  competitorCount: number;
+  leaderUrl: string;
+  leaderCtr: number;
+  leaderPosition: number;
+  hhi: number;
+  fragmentation: number;
+  stolenClicks: number;
+  severity: number;
+  competitors: CannibalizationCompetitor[];
+}
+/**
+ * Pure helper: detects keyword cannibalization from row data — queries
+ * ranking for multiple pages within a small position spread. Re-exported
+ * from `@gscdump/analysis` for portable callers.
+ */
+declare function analyzeCannibalization(rows: QueryPageRow[], options?: CannibalizationOptions): CannibalizationResult[];
+type ClusterType = 'prefix' | 'intent' | 'both';
+interface ClusteringOptions {
+  /** Minimum keywords for a cluster to be reported. Default: 2 */
+  minClusterSize?: number;
+  /** Minimum impressions for a keyword to be included. Default: 10 */
+  minImpressions?: number;
+  /** Clustering method. Default: 'both' */
+  clusterBy?: ClusterType;
+}
+interface KeywordCluster {
+  clusterName: string;
+  clusterType: 'prefix' | 'intent';
+  keywords: KeywordRow[];
+  totalClicks: number;
+  totalImpressions: number;
+  avgPosition: number;
+  keywordCount: number;
+}
+interface ClusteringResult {
+  clusters: KeywordCluster[];
+  unclustered: KeywordRow[];
+}
+/**
+ * Pure helper: clusters keywords by intent prefix or common word prefix.
+ * Re-exported from `@gscdump/analysis` for portable callers.
+ */
+declare function analyzeClustering(keywords: KeywordRow[], options?: ClusteringOptions): ClusteringResult;
+type ConcentrationRiskLevel = 'low' | 'medium' | 'high';
+interface ConcentrationOptions {
+  /** Number of top items to report. Default: 10 */
+  topN?: number;
+}
+interface ConcentrationItem {
+  key: string;
+  clicks: number;
+  share: number;
+}
+interface ConcentrationInput {
+  key: string;
+  clicks: number;
+}
+interface ConcentrationResult {
+  /** Gini coefficient: 0 = equal distribution, 1 = fully concentrated */
+  giniCoefficient: number;
+  /** Herfindahl-Hirschman Index: 0-10000, >2500 = highly concentrated */
+  hhi: number;
+  /** Percentage of total clicks from top N items */
+  topNConcentration: number;
+  topNItems: ConcentrationItem[];
+  totalItems: number;
+  totalClicks: number;
+  /** Risk level derived from HHI: <1500 low, 1500-2500 medium, >2500 high */
+  riskLevel: ConcentrationRiskLevel;
+}
+/**
+ * Pure helper: analyze traffic concentration across items (pages or keywords).
+ * Re-exported from `@gscdump/analysis` for portable callers.
+ */
+declare function analyzeConcentration(items: ConcentrationInput[], options?: ConcentrationOptions): ConcentrationResult;
+/**
+ * Page concentration analysis.
+ */
+declare function analyzePageConcentration(pages: PageRow[], options?: ConcentrationOptions): ConcentrationResult;
+/**
+ * Keyword concentration analysis.
+ */
+declare function analyzeKeywordConcentration(keywords: KeywordRow[], options?: ConcentrationOptions): ConcentrationResult;
+type DecaySortMetric = 'lostClicks' | 'declinePercent' | 'currentClicks';
+interface DecayOptions {
+  /** Minimum clicks in previous period to consider. Default: 50 */
+  minPreviousClicks?: number;
+  /** Minimum decline percentage (0-1). Default: 0.2 (20%) */
+  threshold?: number;
+  /** Metric to sort results by. Default: lostClicks */
+  sortBy?: DecaySortMetric;
+}
+interface DecayInput {
+  current: PageRow[];
+  previous: PageRow[];
+}
+interface DecaySeriesPoint {
+  week: string;
+  clicks: number;
+  impressions: number;
+}
+interface DecayResult {
+  page: string;
+  currentClicks: number;
+  previousClicks: number;
+  lostClicks: number;
+  declinePercent: number;
+  currentPosition: number;
+  previousPosition: number;
+  positionDrop: number;
+  series?: DecaySeriesPoint[];
+}
+/**
+ * Pure helper: identify "decaying" content — pages that have lost
+ * significant traffic between two periods.
+ */
+declare function analyzeDecay(input: DecayInput, options?: DecayOptions): DecayResult[];
+type MoversSortMetric = 'clicks' | 'impressions' | 'clicksChange' | 'impressionsChange' | 'positionChange';
+interface MoversOptions {
+  /** Minimum change threshold to flag. Default: 0.2 (20%) */
+  changeThreshold?: number;
+  /** Minimum impressions in recent period. Default: 50 */
+  minImpressions?: number;
+  /** Metric to sort results by. Default: clicksChange */
+  sortBy?: MoversSortMetric;
+}
+interface MoversInput {
+  current: KeywordRow[];
+  previous: KeywordRow[];
+  /** If periods have different lengths, provide normalization factor (previous/current) */
+  normalizationFactor?: number;
+}
+interface MoverData {
+  keyword: string;
+  page: string | null;
+  recentClicks: number;
+  recentImpressions: number;
+  recentPosition: number;
+  baselineClicks: number;
+  baselineImpressions: number;
+  baselinePosition: number;
+  clicksChange: number;
+  clicksChangePercent: number;
+  impressionsChangePercent: number;
+  positionChange: number;
+}
+interface MoversResult {
+  rising: MoverData[];
+  declining: MoverData[];
+  stable: MoverData[];
+}
+/**
+ * Pure helper: identify "movers and shakers" — keywords with significant
+ * recent changes between two periods.
+ */
+declare function analyzeMovers(input: MoversInput, options?: MoversOptions): MoversResult;
+interface OpportunityFactors {
+  positionScore: number;
+  impressionScore: number;
+  ctrGapScore: number;
+}
+interface OpportunityResult {
+  keyword: string;
+  page: string | null;
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+  opportunityScore: number;
+  potentialClicks: number;
+  factors: OpportunityFactors;
+}
+type SeasonalityMetric = 'clicks' | 'impressions';
+interface SeasonalityOptions {
+  /** Metric to analyze for seasonality. Default: clicks */
+  metric?: SeasonalityMetric;
+}
+interface MonthlyData {
+  month: string;
+  value: number;
+  vsAverage: number;
+  isPeak: boolean;
+  isTrough: boolean;
+}
+interface SeasonalityResult {
+  hasSeasonality: boolean;
+  /** Coefficient of variation: std dev / mean. Higher = more seasonal. */
+  strength: number;
+  peakMonths: string[];
+  troughMonths: string[];
+  monthlyBreakdown: MonthlyData[];
+  insufficientData: boolean;
+}
+/**
+ * Pure helper: detects seasonality patterns by analyzing monthly traffic
+ * variation. Re-exported from `@gscdump/analysis` for portable callers.
+ */
+declare function analyzeSeasonality(dates: DateRow[], options?: SeasonalityOptions): SeasonalityResult;
+/**
+ * `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 ZeroClickResult {
+  query: string;
+  page: string;
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+}
+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 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[];
+/**
+ * Produce a canonical form of a search query for grouping near-duplicates.
+ * Idempotent: `normalizeQuery(normalizeQuery(q)) === normalizeQuery(q)`.
+ */
+declare function normalizeQuery(query: string): string;
+declare function analyzeFromSource(source: AnalysisQuerySource, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
+interface EngineQuerySourceOptions {
+  engine: StorageEngine;
+  ctx: TenantCtx;
+}
+/**
+ * Wraps a storage engine as a {@link SqlQuerySource}. `queryRows` runs typed
+ * builder-state queries; `executeSql` delegates to `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): SqlQuerySource;
+/**
+ * Convenience: wrap a storage engine + tenant ctx in a source and dispatch.
+ * Equivalent to
+ * `runAnalyzerFromSource(createEngineQuerySource({ engine, ctx }), params, registry)`.
+ */
+declare function runAnalyzerWithEngine(deps: {
+  engine: StorageEngine;
+}, ctx: TenantCtx, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
+interface GscApiQuerySourceOptions {
+  client: GoogleSearchConsoleClient;
+  siteUrl: string;
+}
+declare function createGscApiQuerySource(options: GscApiQuerySourceOptions): RowQuerySource;
+interface InMemoryQuerySourceOptions {
+  queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
+  capabilities?: PlannerCapabilities;
+}
+declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): RowQuerySource;
+interface StrikingDistanceResult {
+  keyword: string;
+  page: string | null;
+  clicks: number;
+  impressions: number;
+  ctr: number;
+  position: number;
+  /** Estimated clicks at ~15% CTR (the average for positions 1–3). */
+  potentialClicks: number;
+}
+type StrikingDistanceSortMetric = 'clicks' | 'impressions' | 'ctr' | 'position' | 'potentialClicks';
+interface StrikingDistanceOptions {
+  /** Minimum position (inclusive). Default: 4 */
+  minPosition?: number;
+  /** Maximum position (inclusive). Default: 20 */
+  maxPosition?: number;
+  /** Minimum impressions. Default: 100 */
+  minImpressions?: number;
+  /** Maximum CTR (queries with low CTR have more potential). Default: 0.05 (5%) */
+  maxCtr?: number;
+  /** Sort metric. Default: potentialClicks */
+  sortBy?: StrikingDistanceSortMetric;
+  /** Sort order. Default: desc */
+  sortOrder?: SortOrder;
+}
+/**
+ * Finds striking distance keywords - high impressions, low CTR, position 4-20.
+ * These are "quick wins" that could gain significant traffic with small ranking improvements.
+ */
+declare function analyzeStrikingDistance(keywords: KeywordRow[], options?: StrikingDistanceOptions): StrikingDistanceResult[];
+type QueryDimension = 'keywords' | 'pages' | 'dates';
+interface QueryOptions {
+  dimension?: QueryDimension;
+  limit?: number;
+}
+interface QueryResult {
+  keywords: KeywordRow[];
+  pages: PageRow[];
+  dates: DateRow[];
+}
+interface ComparisonQueryResult {
+  current: QueryResult;
+  previous: QueryResult;
+}
+interface OpportunityOptions {
+  minImpressions?: number;
+}
+declare function queryAnalyticsFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: QueryOptions): Promise<QueryResult>;
+declare function queryComparisonFromSource(source: AnalysisQuerySource, periods: ComparisonPeriod, options?: QueryOptions): Promise<ComparisonQueryResult>;
+declare function analyzeStrikingDistanceFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: StrikingDistanceOptions): Promise<StrikingDistanceResult[]>;
+declare function analyzeOpportunityFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: OpportunityOptions): Promise<OpportunityResult[]>;
+declare function analyzeBrandSegmentationFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options: BrandSegmentationOptions): Promise<BrandSegmentationResult>;
+declare function analyzePageConcentrationFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: ConcentrationOptions): Promise<ConcentrationResult>;
+declare function analyzeKeywordConcentrationFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: ConcentrationOptions): Promise<ConcentrationResult>;
+declare function analyzeClusteringFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: ClusteringOptions): Promise<ClusteringResult>;
+declare function analyzeSeasonalityFromSource(source: AnalysisQuerySource, period: AnalysisPeriod, options?: SeasonalityOptions): Promise<SeasonalityResult>;
+declare function analyzeDecayFromSource(source: AnalysisQuerySource, periods: ComparisonPeriod, options?: DecayOptions): Promise<DecayResult[]>;
+declare function analyzeMoversFromSource(source: AnalysisQuerySource, periods: ComparisonPeriod, options?: MoversOptions): Promise<MoversResult>;
+export { type ActionPriorityAnalyzer, type ActionPriorityResult, type ActionPriorityRunOptions, type ActionPrioritySourceState, type ActionPrioritySourceStatus, type ActionSource, type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, type AnalysisTool, AnalyzerCapabilityError, type AnalyzerRegistry, type AnalyzerRegistryInit, type AnalyzerVariants, type BaseMetrics, type BrandSegmentationOptions, type BrandSegmentationResult, type BrandSummary, type CannibalizationCompetitor, type CannibalizationEvent, type CannibalizationOptions, type CannibalizationPage, type CannibalizationResult, type CannibalizationSortMetric, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type ComparisonQueryResult, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type Effort, type KeywordCluster, type KeywordRow, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, type OpportunityResult, type PadTimeseriesOptions, type PageRow, type PriorityAction, type QueryDimension, type QueryOptions, type QueryPageRow, type QueryResult, type QueryRow, ROW_ANALYZERS, type ResolveWindowOptions, type ResolvedWindow, type RowQuerySource, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SortOrder, type SourceCapabilities, type SqlQuerySource, type StrikingDistanceOptions, type StrikingDistanceResult, type StrikingDistanceSortMetric, type WindowPreset, type ZeroClickResult, analyzeActionPriority, analyzeActionPriorityFromSource, analyzeBrandSegmentation, analyzeBrandSegmentationFromSource, analyzeCannibalization, analyzeClustering, analyzeClusteringFromSource, analyzeConcentration, analyzeDecay, analyzeDecayFromSource, analyzeFromSource, analyzeKeywordConcentration, analyzeKeywordConcentrationFromSource, analyzeMovers, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentration, analyzePageConcentrationFromSource, analyzeSeasonality, analyzeSeasonalityFromSource, analyzeStrikingDistance, analyzeStrikingDistanceFromSource, comparisonOf, createAnalyzerRegistry, createBrowserQuerySource, createEngineQuerySource, createGscApiQuerySource, createInMemoryQuerySource, createSorter, createSqliteQuerySource, isSqlQuerySource, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryAnalyticsFromSource, queryComparisonFromSource, queryComparisonRows, queryRows, resolveWindow, runAnalyzerFromSource, runAnalyzerWithEngine, scorePriorityActions, windowToComparisonPeriod, windowToPeriod };