@gscdump/analysis 0.7.1 → 0.7.6

package/dist/index.d.mts

@@ -1,138 +1,11 @@
+import * as _$_gscdump_engine_analyzer0 from "@gscdump/engine/analyzer";
+import { Analyzer, Analyzer as Analyzer$1, AnalyzerCapabilityError, AnalyzerRegistry, AnalyzerRegistry as AnalyzerRegistry$1, AnalyzerRegistryInit, AnalyzerVariants, Capability, DefineAnalyzerOptions, DefinedAnalyzer, Plan, ReduceContext, ReduceCtx, Reducer, RowQueriesPlan, SqlExtraQuery, SqlPlan, SqlPlanSpec, TypedRowQuery, createAnalyzerRegistry, defineAnalyzer, runAnalyzerFromSource } from "@gscdump/engine/analyzer";
+import { AnalysisParams, AnalysisParams as AnalysisParams$1, AnalysisResult, AnalysisResult as AnalysisResult$1, AnalysisTool, num } from "@gscdump/engine/analysis-types";
+import { AnalysisPeriod, AnalysisPeriod as AnalysisPeriod$1, ComparisonMode, ComparisonPeriod, ComparisonPeriod as ComparisonPeriod$1, PadTimeseriesOptions, ResolveWindowOptions, ResolvedWindow, WindowPreset, comparisonOf, padTimeseries, periodOf, resolveWindow, windowToComparisonPeriod, windowToPeriod } from "@gscdump/engine/period";
 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 { AttachedTableRunner, AttachedTableRunner as AnalyzerRunner, AttachedTableSourceOptions, AttachedTableSourceOptions as BrowserAnalyzeOptions, ENGINE_QUERY_CAPABILITIES, EngineQuerySourceOptions, TypedQuery, createEngineQuerySource, queryComparisonRows, queryRows, rewriteForTableSource, runAnalyzerWithEngine, typedQuery } from "@gscdump/engine/source";
+import { AnalysisQuerySource, AnalysisQuerySource as AnalysisQuerySource$1, ExecuteSqlOptions, FileSet, QueryRow, QueryRow as QueryRow$1, RowQuerySource, RowQuerySource as RowQuerySource$1, SourceCapabilities, SqlQuerySource, SqlQuerySource as SqlQuerySource$1, 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 {
@@ -165,13 +38,13 @@ interface ActionPriorityRunOptions {
   sources?: ActionSource[];
   limit?: number;
   continueOnError?: boolean;
-  paramsBySource?: Partial<Record<ActionSource, Omit<AnalysisParams, 'type'>>>;
+  paramsBySource?: Partial<Record<ActionSource, Omit<AnalysisParams$1, 'type'>>>;
   onSourceStatus?: (state: ActionPrioritySourceState) => void;
 }
 interface ActionPriorityAnalyzer {
-  analyze: (params: AnalysisParams) => Promise<AnalysisResult>;
+  analyze: (params: AnalysisParams$1) => Promise<AnalysisResult$1>;
 }
-declare function normalizePriorityActions(source: ActionSource, result: AnalysisResult): PriorityAction[];
+declare function normalizePriorityActions(source: ActionSource, result: AnalysisResult$1): PriorityAction[];
 declare function mergePriorityActions(all: PriorityAction[]): PriorityAction[];
 declare function scorePriorityActions(actions: PriorityAction[]): PriorityAction[];
 declare function analyzeActionPriority(analyzer: ActionPriorityAnalyzer, options?: ActionPriorityRunOptions): Promise<ActionPriorityResult>;
@@ -183,19 +56,41 @@ declare function analyzeActionPriority(analyzer: ActionPriorityAnalyzer, options
  * 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[]);
-}
+declare function analyzeActionPriorityFromSource(source: AnalysisQuerySource$1, registry: AnalyzerRegistry$1, options?: ActionPriorityRunOptions): Promise<ActionPriorityResult>;
+declare const ROW_ANALYZERS: readonly Analyzer$1[];
 /**
- * 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).
+ * Domain row shapes + analysis utilities. Analyzer-call contracts
+ * (`AnalysisParams`, `AnalysisResult`, `AnalysisTool`, `num`) live in
+ * `@gscdump/engine/analysis-types`.
  */
-declare function runAnalyzerFromSource(source: AnalysisQuerySource, params: AnalysisParams, registry: AnalyzerRegistry): Promise<AnalysisResult>;
-declare const ROW_ANALYZERS: readonly Analyzer[];
+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;
+}
+/** 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[];
 interface BrandSegmentationOptions {
   /** Brand terms to match against keywords (case-insensitive) */
   brandTerms: string[];
@@ -471,94 +366,39 @@ interface ZeroClickResult {
   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;
-};
+declare function analyzeInBrowser(runner: AttachedTableRunner, opts: AttachedTableSourceOptions, params: AnalysisParams$1): Promise<AnalysisResult$1>;
 /**
- * Pad rows so every calendar day in `[startDate, endDate]` appears at least
- * once. Existing dates keep all their rows (grouped timeseries safe).
+ * Default analyzer registry built from every in-tree analyzer: row analyzers
+ * plus DuckDB SQL analyzers. Convenience for callers who don't care about
+ * bundle size; edge / browser consumers should compose their own narrower
+ * registry via `createAnalyzerRegistry`.
  */
-declare function padTimeseries<T extends DateRowShape = DateRowShape>(rows: readonly T[], options: PadTimeseriesOptions<T>): T[];
+declare const defaultAnalyzerRegistry: _$_gscdump_engine_analyzer0.AnalyzerRegistry;
 /**
  * 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;
+declare function analyzeFromSource(source: AnalysisQuerySource$1, params: AnalysisParams$1, registry: AnalyzerRegistry$1): Promise<AnalysisResult$1>;
+interface CompositeSourceOptions {
+  engine: SqlQuerySource$1;
+  live: AnalysisQuerySource$1;
+  site: {
+    oldestDateSynced: string | null;
+    newestDateSynced: string | null;
+  };
 }
+declare function createCompositeSource(opts: CompositeSourceOptions): SqlQuerySource$1;
 /**
- * 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)`.
+ * Permissive defaults: in-memory sources are usually test doubles, so they
+ * advertise every capability unless the test explicitly narrows them.
  */
-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;
+declare const IN_MEMORY_DEFAULT_CAPABILITIES: PlannerCapabilities;
 interface InMemoryQuerySourceOptions {
-  queryRows: (state: BuilderState) => Promise<QueryRow[]> | QueryRow[];
+  queryRows: (state: BuilderState) => Promise<QueryRow$1[]> | QueryRow$1[];
   capabilities?: PlannerCapabilities;
 }
-declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): RowQuerySource;
+declare function createInMemoryQuerySource(options: InMemoryQuerySourceOptions): RowQuerySource$1;
 interface StrikingDistanceResult {
   keyword: string;
   page: string | null;
@@ -606,15 +446,16 @@ interface ComparisonQueryResult {
 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 };
+declare function queryAnalyticsFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: QueryOptions): Promise<QueryResult>;
+declare function queryComparisonFromSource(source: AnalysisQuerySource$1, periods: ComparisonPeriod$1, options?: QueryOptions): Promise<ComparisonQueryResult>;
+declare function analyzeStrikingDistanceFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: StrikingDistanceOptions): Promise<StrikingDistanceResult[]>;
+declare function analyzeOpportunityFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: OpportunityOptions): Promise<OpportunityResult[]>;
+declare function analyzeBrandSegmentationFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options: BrandSegmentationOptions): Promise<BrandSegmentationResult>;
+declare function analyzePageConcentrationFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: ConcentrationOptions): Promise<ConcentrationResult>;
+declare function analyzeKeywordConcentrationFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: ConcentrationOptions): Promise<ConcentrationResult>;
+declare function analyzeClusteringFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: ClusteringOptions): Promise<ClusteringResult>;
+declare function analyzeSeasonalityFromSource(source: AnalysisQuerySource$1, period: AnalysisPeriod$1, options?: SeasonalityOptions): Promise<SeasonalityResult>;
+declare function analyzeDecayFromSource(source: AnalysisQuerySource$1, periods: ComparisonPeriod$1, options?: DecayOptions): Promise<DecayResult[]>;
+declare function analyzeMoversFromSource(source: AnalysisQuerySource$1, periods: ComparisonPeriod$1, options?: MoversOptions): Promise<MoversResult>;
+declare const SQL_ANALYZERS: readonly Analyzer$1[];
+export { type ActionPriorityAnalyzer, type ActionPriorityResult, type ActionPriorityRunOptions, type ActionPrioritySourceState, type ActionPrioritySourceStatus, type ActionSource, type AnalysisParams, type AnalysisPeriod, type AnalysisQuerySource, type AnalysisResult, 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 Capability, type ClusterType, type ClusteringOptions, type ClusteringResult, type ComparisonMode, type ComparisonPeriod, type ComparisonQueryResult, type CompositeSourceOptions, type ConcentrationInput, type ConcentrationItem, type ConcentrationOptions, type ConcentrationResult, type ConcentrationRiskLevel, type DateRow, type DecayInput, type DecayOptions, type DecayResult, type DecaySeriesPoint, type DecaySortMetric, type DefineAnalyzerOptions, type DefinedAnalyzer, ENGINE_QUERY_CAPABILITIES, type Effort, type EngineQuerySourceOptions, type ExecuteSqlOptions, type FileSet, IN_MEMORY_DEFAULT_CAPABILITIES, type InMemoryQuerySourceOptions, type KeywordCluster, type KeywordRow, type MonthlyData, type MoverData, type MoversInput, type MoversOptions, type MoversResult, type MoversSortMetric, type OpportunityResult, type PadTimeseriesOptions, type PageRow, type Plan, type PriorityAction, type QueryDimension, type QueryOptions, type QueryPageRow, type QueryResult, type QueryRow, ROW_ANALYZERS, type ReduceContext, type ReduceCtx, type Reducer, type ResolveWindowOptions, type ResolvedWindow, type RowQueriesPlan, type RowQuerySource, SQL_ANALYZERS, type SeasonalityMetric, type SeasonalityOptions, type SeasonalityResult, type SortOrder, type SourceCapabilities, type SqlExtraQuery, type SqlPlan, type SqlPlanSpec, type SqlQuerySource, type StrikingDistanceOptions, type StrikingDistanceResult, type StrikingDistanceSortMetric, type TypedQuery, type TypedRowQuery, type WindowPreset, type ZeroClickResult, analyzeActionPriority, analyzeActionPriorityFromSource, analyzeBrandSegmentation, analyzeBrandSegmentationFromSource, analyzeCannibalization, analyzeClustering, analyzeClusteringFromSource, analyzeConcentration, analyzeDecay, analyzeDecayFromSource, analyzeFromSource, analyzeInBrowser, analyzeKeywordConcentration, analyzeKeywordConcentrationFromSource, analyzeMovers, analyzeMoversFromSource, analyzeOpportunityFromSource, analyzePageConcentration, analyzePageConcentrationFromSource, analyzeSeasonality, analyzeSeasonalityFromSource, analyzeStrikingDistance, analyzeStrikingDistanceFromSource, comparisonOf, createAnalyzerRegistry, createCompositeSource, createEngineQuerySource, createInMemoryQuerySource, createSorter, defaultAnalyzerRegistry, defineAnalyzer, isSqlQuerySource, mergePriorityActions, normalizePriorityActions, normalizeQuery, num, padTimeseries, periodOf, queryAnalyticsFromSource, queryComparisonFromSource, queryComparisonRows, queryRows, resolveWindow, rewriteForTableSource, runAnalyzerFromSource, runAnalyzerWithEngine, scorePriorityActions, typedQuery, windowToComparisonPeriod, windowToPeriod };