import { TableName } from "../contracts.mjs";
import { Result } from "../core/result.mjs";
import { BuilderState, Dimension, FilterOperator, Metric, MetricOperator, QueryParamName } from "./types.mjs";
import { QueryError, QueryErrorKind, UnresolvableDatasetError, UnsupportedLogicalCapabilityError } from "./errors.mjs";
type LogicalDataset = TableName;
type ComparisonFilter = 'new' | 'lost' | 'improving' | 'declining';
interface PlannerCapabilities {
  regex?: boolean;
  multiDataset?: boolean;
  comparisonJoin?: boolean;
  windowTotals?: boolean;
}
interface LogicalDimensionFilter {
  dimension: Dimension;
  operator: FilterOperator;
  expression: string;
  expression2?: string;
}
interface LogicalMetricFilter {
  metric: Metric;
  operator: MetricOperator;
  expression: number;
  expression2?: number;
}
interface LogicalFilterLeaf {
  kind: 'leaf';
  filter: LogicalDimensionFilter;
}
interface LogicalFilterGroup {
  kind: 'group';
  groupType: 'and' | 'or';
  children: LogicalFilterNode[];
}
type LogicalFilterNode = LogicalFilterLeaf | LogicalFilterGroup;
interface LogicalQueryPlan {
  dataset: LogicalDataset;
  dimensions: Dimension[];
  groupByDimensions: Dimension[];
  hasDate: boolean;
  metrics: Metric[];
  dateRange: {
    startDate: string;
    endDate: string;
  };
  dimensionFilters: LogicalDimensionFilter[];
  dimensionFilterTree?: LogicalFilterNode;
  metricFilters: LogicalMetricFilter[];
  prefilters: LogicalMetricFilter[];
  specialFilters: {
    topLevel: boolean;
  };
  queryParams: Partial<Record<QueryParamName, string>>;
  orderBy?: BuilderState['orderBy'];
  rowLimit?: number;
  startRow?: number;
}
interface LogicalComparisonPlan {
  current: LogicalQueryPlan;
  previous: LogicalQueryPlan;
  comparisonFilter?: ComparisonFilter;
}
declare function inferDataset(dimensions: readonly Dimension[], filterDims?: readonly Dimension[]): LogicalDataset;
/**
 * True when every grouped + filtered dimension fits inside one stored dataset,
 * i.e. the query is answerable from stored Parquet/D1 tables without a live
 * GSC call. `inferDataset` always returns *some* dataset; this predicate is
 * how callers tell a genuine match from one that will fail at column-resolve
 * time.
 */
declare function isDatasetResolvable(dimensions: readonly Dimension[], filterDims?: readonly Dimension[]): boolean;
/**
 * `BuilderState`-level convenience for {@link isDatasetResolvable}: extracts
 * the state's dimension filters (the same way `buildLogicalPlan` does) and
 * checks them against the grouped dimensions. Lets routing code (e.g. the
 * composite source) detect a cross-dimension query without rebuilding a plan.
 */
declare function isStateResolvable(state: BuilderState): boolean;
/**
 * Errors-as-values core: builds the logical plan or returns a typed `QueryError`
 * for every modelled failure (missing date range, a regex filter on an engine
 * without regex pushdown, a cross-dimension query with no stored home).
 * `buildLogicalPlan` is the throwing wrapper for call sites that prefer exceptions.
 */
declare function buildLogicalPlanResult(state: BuilderState, capabilities?: PlannerCapabilities): Result<LogicalQueryPlan, QueryError>;
declare function buildLogicalPlan(state: BuilderState, capabilities?: PlannerCapabilities): LogicalQueryPlan;
/**
 * Errors-as-values core for the comparison plan: returns a typed `QueryError`
 * when the engine lacks the comparison-join or multi-dataset capability the
 * paired queries need, or when either side fails to plan.
 */
declare function buildLogicalComparisonPlanResult(current: BuilderState, previous: BuilderState, capabilities?: PlannerCapabilities, comparisonFilter?: ComparisonFilter): Result<LogicalComparisonPlan, QueryError>;
declare function buildLogicalComparisonPlan(current: BuilderState, previous: BuilderState, capabilities?: PlannerCapabilities, comparisonFilter?: ComparisonFilter): LogicalComparisonPlan;
export { ComparisonFilter, LogicalComparisonPlan, LogicalDataset, LogicalDimensionFilter, LogicalFilterGroup, LogicalFilterLeaf, LogicalFilterNode, LogicalMetricFilter, LogicalQueryPlan, PlannerCapabilities, type QueryError, type QueryErrorKind, type TableName, UnresolvableDatasetError, UnsupportedLogicalCapabilityError, buildLogicalComparisonPlan, buildLogicalComparisonPlanResult, buildLogicalPlan, buildLogicalPlanResult, inferDataset, isDatasetResolvable, isStateResolvable };