drizzle-cube 0.5.6 → 0.5.8

package/dist/server/server/ai/schemas.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Generic query schemas for AI agents
+ * Teaches AI how to construct analysis queries
+ *
+ * These schemas are returned by the `discover` tool to help LLMs
+ * understand the correct query shape for each analysis mode.
+ */
+export declare const QUERY_SCHEMAS: {
+    readonly funnel: {
+        readonly description: "Track conversion through sequential steps. Entities (identified by bindingKey) move through ordered steps.";
+        readonly structure: {
+            readonly funnel: {
+                readonly bindingKey: "Cube.dimension - identifies entities moving through funnel";
+                readonly timeDimension: "Cube.dimension - time field for ordering events";
+                readonly steps: readonly [{
+                    readonly name: "string - human readable step name";
+                    readonly filter: "{ member, operator, values } or array of filters. Put inDateRange ONLY on step 0.";
+                    readonly timeToConvert: "optional - ISO 8601 duration e.g. \"P7D\" for 7 days, \"PT1H\" for 1 hour";
+                }];
+                readonly includeTimeMetrics: "optional boolean - include avg/median/p90 time-to-convert";
+                readonly globalTimeWindow: "optional - ISO 8601 duration, all steps must complete within this window";
+            };
+        };
+    };
+    readonly flow: {
+        readonly description: "Analyze paths users take before/after a specific event. Shows event sequences as Sankey/sunburst.";
+        readonly structure: {
+            readonly flow: {
+                readonly bindingKey: "Cube.dimension - identifies entities";
+                readonly timeDimension: "Cube.dimension - time field for ordering";
+                readonly eventDimension: "Cube.dimension - the event type field (values become node labels)";
+                readonly startingStep: {
+                    readonly name: "string - display name for the starting step";
+                    readonly filter: "{ member, operator, values } - filter identifying the starting event";
+                };
+                readonly stepsBefore: "number (0-5) - how many steps to show before starting step";
+                readonly stepsAfter: "number (0-5) - how many steps to show after starting step";
+                readonly entityLimit: "optional number - max entities to process (performance)";
+                readonly outputMode: "optional \"sankey\" | \"sunburst\" (default: sankey)";
+            };
+        };
+    };
+    readonly retention: {
+        readonly description: "Measure how many users return over time periods after initial activity.";
+        readonly structure: {
+            readonly retention: {
+                readonly timeDimension: "Cube.dimension - time field for cohort assignment";
+                readonly bindingKey: "Cube.dimension - identifies entities";
+                readonly dateRange: {
+                    readonly start: "YYYY-MM-DD - cohort start date";
+                    readonly end: "YYYY-MM-DD - cohort end date";
+                };
+                readonly granularity: "day | week | month - period size";
+                readonly periods: "number - how many periods to analyze";
+                readonly retentionType: "\"classic\" (returned in period N) | \"rolling\" (returned in N or later)";
+                readonly cohortFilters: "optional - filters on cohort entry events";
+                readonly activityFilters: "optional - filters on return activity events";
+                readonly breakdownDimensions: "optional string[] - segment by these dimensions";
+            };
+        };
+    };
+};
+export type QuerySchemas = typeof QUERY_SCHEMAS;

package/dist/server/server/ai/suggestion.d.ts

@@ -0,0 +1,19 @@
+import { CubeMetadata } from '../types/metadata';
+import { SemanticQuery } from '../types/query';
+/**
+ * Suggested query result
+ */
+export interface QuerySuggestion {
+    query: Partial<SemanticQuery>;
+    confidence: number;
+    reasoning: string[];
+    warnings?: string[];
+    /** Detected analysis mode */
+    analysisMode: 'query' | 'funnel' | 'flow' | 'retention';
+    /** Next steps when mode != 'query' */
+    nextSteps?: string[];
+}
+/**
+ * Suggest a query based on natural language input
+ */
+export declare function suggestQuery(metadata: CubeMetadata[], naturalLanguage: string, targetCube?: string): QuerySuggestion;

package/dist/server/server/ai/validation.d.ts

@@ -0,0 +1,34 @@
+import { CubeMetadata } from '../types/metadata';
+import { SemanticQuery } from '../types/query';
+/**
+ * Validation result with corrections
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+    correctedQuery?: SemanticQuery;
+}
+/**
+ * Validation error with optional correction
+ */
+export interface ValidationError {
+    type: 'cube_not_found' | 'measure_not_found' | 'dimension_not_found' | 'invalid_filter' | 'invalid_time_dimension' | 'syntax_error';
+    message: string;
+    field?: string;
+    suggestion?: string;
+    correctedValue?: string;
+}
+/**
+ * Validation warning (query will work but may have issues)
+ */
+export interface ValidationWarning {
+    type: 'ambiguous_field' | 'performance' | 'best_practice';
+    message: string;
+    field?: string;
+    suggestion?: string;
+}
+/**
+ * Validate a query with helpful corrections
+ */
+export declare function validateQuery(query: SemanticQuery, metadata: CubeMetadata[]): ValidationResult;

package/dist/server/server/builders/comparison-query-builder.d.ts

@@ -0,0 +1,70 @@
+import { SemanticQuery, TimeDimension, QueryResult, TimeGranularity } from '../types';
+import { DatabaseAdapter } from '../adapters/base-adapter';
+/**
+ * Normalized period range with start/end dates and metadata
+ */
+export interface NormalizedPeriod {
+    /** Start date of the period */
+    start: Date;
+    /** End date of the period */
+    end: Date;
+    /** Human-readable label for the period */
+    label: string;
+    /** Index in the comparison (0 = first/current, 1 = second/prior, etc.) */
+    index: number;
+}
+/**
+ * Extended result row with period metadata for alignment
+ */
+export interface ComparisonResultRow extends Record<string, unknown> {
+    /** Period label (e.g., "2024-01-01 - 2024-01-31") */
+    __period: string;
+    /** Period index (0 = current, 1 = prior, etc.) */
+    __periodIndex: number;
+    /** Day-of-period index for alignment in overlay mode */
+    __periodDayIndex: number;
+}
+export declare class ComparisonQueryBuilder {
+    private dateTimeBuilder;
+    constructor(databaseAdapter: DatabaseAdapter);
+    /**
+     * Check if a query contains compareDateRange
+     */
+    hasComparison(query: SemanticQuery): boolean;
+    /**
+     * Get the time dimension with compareDateRange
+     */
+    getComparisonTimeDimension(query: SemanticQuery): TimeDimension | undefined;
+    /**
+     * Normalize compareDateRange entries to concrete date ranges
+     * Handles both relative strings ('last 30 days') and explicit arrays (['2024-01-01', '2024-01-31'])
+     */
+    normalizePeriods(compareDateRange: (string | [string, string])[]): NormalizedPeriod[];
+    /**
+     * Create sub-query for a specific period
+     * Replaces compareDateRange with a concrete dateRange for that period
+     */
+    createPeriodQuery(query: SemanticQuery, period: NormalizedPeriod): SemanticQuery;
+    /**
+     * Calculate the day-of-period index for a date
+     * Used for aligning data points across periods in overlay mode
+     */
+    calculatePeriodDayIndex(date: Date | string, periodStart: Date, granularity: TimeGranularity): number;
+    /**
+     * Add period metadata to result rows
+     */
+    addPeriodMetadata(data: Record<string, unknown>[], period: NormalizedPeriod, timeDimensionKey: string, granularity: TimeGranularity): ComparisonResultRow[];
+    /**
+     * Merge results from multiple period queries
+     * Adds period metadata and creates combined result with annotation
+     */
+    mergeComparisonResults(periodResults: Array<{
+        result: QueryResult;
+        period: NormalizedPeriod;
+    }>, timeDimension: TimeDimension, granularity: TimeGranularity): QueryResult;
+    /**
+     * Sort merged results by period index and then by time dimension
+     * Ensures consistent ordering for client-side processing
+     */
+    sortComparisonResults(data: ComparisonResultRow[], timeDimensionKey: string): ComparisonResultRow[];
+}

package/dist/server/server/builders/cte-builder.d.ts

@@ -0,0 +1,62 @@
+import { SQL } from 'drizzle-orm';
+import { SemanticQuery, QueryContext, PhysicalQueryPlan, PropagatingFilter } from '../types';
+import { DrizzleSqlBuilder } from '../physical-plan/drizzle-sql-builder';
+/**
+ * CTE information type extracted from runtime physical plan context
+ */
+export type CTEInfo = NonNullable<PhysicalQueryPlan['preAggregationCTEs']>[0];
+/**
+ * CTEBuilder handles the construction of Common Table Expressions
+ * for pre-aggregation in hasMany relationship queries.
+ *
+ * This enables efficient aggregation of "many" side data before joining,
+ * preventing the Cartesian product explosion that would occur with direct JOINs.
+ */
+export declare class CTEBuilder {
+    private queryBuilder;
+    constructor(queryBuilder: DrizzleSqlBuilder);
+    /**
+     * Build pre-aggregation CTE for hasMany relationships
+     *
+     * Creates a CTE that:
+     * 1. Selects join keys and aggregated measures
+     * 2. Applies security context filtering
+     * 3. Groups by join keys and requested dimensions
+     * 4. Handles propagating filters from related cubes
+     * 5. Handles multi-hop join paths by absorbing intermediate tables (fan-out prevention)
+     */
+    buildPreAggregationCTE(cteInfo: CTEInfo, query: SemanticQuery, context: QueryContext, queryPlan: PhysicalQueryPlan, preBuiltFilterMap?: Map<string, SQL[]>): any;
+    /**
+     * Build join condition for CTE
+     *
+     * Creates the ON clause for joining a CTE to the main query.
+     * Uses stored column objects for type-safe joins.
+     *
+     * For multi-hop paths with intermediate joins:
+     * - The CTE includes columns from intermediate tables
+     * - The join condition uses the intermediate's primary-connected column
+     * - Example: departments.id = employeeteams_agg.department_id (not employee_id!)
+     */
+    buildCTEJoinCondition(joinCube: PhysicalQueryPlan['joinCubes'][0], cteAlias: string, queryPlan: PhysicalQueryPlan): SQL;
+    /**
+     * Resolve source-side join expression for CTE joins.
+     *
+     * When two cubes are both materialized as CTEs in the same query, join keys can
+     * still point to the original table column object (e.g. departments.id). In that
+     * case the table is no longer present in FROM/JOIN, so rewrite to the upstream CTE
+     * alias column (e.g. departments_agg.id).
+     */
+    private resolveCTEJoinSourceColumn;
+    /**
+     * Build a subquery filter for propagating filters from related cubes.
+     *
+     * This generates: cteCube.FK IN (SELECT sourceCube.PK FROM sourceCube WHERE filters...)
+     *
+     * Example: For Productivity CTE with Employees.createdAt filter:
+     * employee_id IN (SELECT id FROM employees WHERE organisation_id = $1 AND created_at >= $date)
+     *
+     * For composite keys, uses EXISTS instead of IN for better database compatibility:
+     * EXISTS (SELECT 1 FROM source WHERE source.pk1 = cte.fk1 AND source.pk2 = cte.fk2 AND <filters>)
+     */
+    buildPropagatingFilterSubquery(propFilter: PropagatingFilter, context: QueryContext): SQL | null;
+}

package/dist/server/server/builders/date-time-builder.d.ts

@@ -0,0 +1,29 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { QueryContext } from '../types';
+import { DatabaseAdapter } from '../adapters/base-adapter';
+export declare class DateTimeBuilder {
+    private databaseAdapter;
+    constructor(databaseAdapter: DatabaseAdapter);
+    /**
+     * Build time dimension expression with granularity using database adapter
+     */
+    buildTimeDimensionExpression(dimensionSql: any, granularity: string | undefined, context: QueryContext): SQL;
+    /**
+     * Build date range condition for time dimensions
+     */
+    buildDateRangeCondition(fieldExpr: AnyColumn | SQL, dateRange: string | string[]): SQL | null;
+    /**
+     * Parse relative date range expressions like "today", "yesterday", "last 7 days", "this month", etc.
+     * Handles all 14 DATE_RANGE_OPTIONS from the client
+     */
+    parseRelativeDateRange(dateRange: string): {
+        start: Date;
+        end: Date;
+    } | null;
+    /**
+     * Normalize date values to handle strings, numbers, and Date objects
+     * Returns ISO string for PostgreSQL/MySQL, Unix timestamp for SQLite, or null
+     * Ensures dates are in the correct format for each database engine
+     */
+    normalizeDate(value: any): string | number | null;
+}

package/dist/server/server/builders/filter-builder.d.ts

@@ -0,0 +1,23 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { FilterOperator, Filter, Cube, QueryContext } from '../types';
+import { DatabaseAdapter } from '../adapters/base-adapter';
+import { DateTimeBuilder } from './date-time-builder';
+export declare class FilterBuilder {
+    private databaseAdapter;
+    private dateTimeBuilder;
+    constructor(databaseAdapter: DatabaseAdapter, dateTimeBuilder: DateTimeBuilder);
+    /**
+     * Build filter condition using Drizzle operators
+     */
+    buildFilterCondition(fieldExpr: AnyColumn | SQL, operator: FilterOperator, values: any[], field?: any, dateRange?: string | string[]): SQL | null;
+    /**
+     * Build a logical filter (AND/OR) - used by executor for cache preloading
+     * This handles nested filter structures and builds combined SQL
+     */
+    buildLogicalFilter(filter: Filter, cubes: Map<string, Cube>, context: QueryContext): SQL | null;
+    /**
+     * Build SQL for a single filter condition (simple or logical)
+     * Used for cache preloading to build filters independently of query context
+     */
+    buildSingleFilter(filter: Filter, cubes: Map<string, Cube>, context: QueryContext): SQL | null;
+}

package/dist/server/server/builders/flow-query-builder.d.ts

@@ -0,0 +1,109 @@
+import { DatabaseAdapter } from '../adapters/base-adapter';
+import { FlowQueryConfig, FlowResultRow, FlowValidationResult } from '../types/flow';
+import { Cube, QueryContext, SemanticQuery } from '../types';
+export declare class FlowQueryBuilder {
+    private filterBuilder;
+    private dateTimeBuilder;
+    private databaseAdapter;
+    constructor(databaseAdapter: DatabaseAdapter);
+    /**
+     * Check if query contains flow configuration
+     */
+    hasFlow(query: SemanticQuery): boolean;
+    /**
+     * Validate flow configuration
+     */
+    validateConfig(config: FlowQueryConfig, cubes: Map<string, Cube>): FlowValidationResult;
+    /**
+     * Build complete flow query using Drizzle's query builder pattern
+     *
+     * Creates a series of CTEs to:
+     * 1. Find entities at the starting step
+     * 2. Walk backwards N steps to find preceding events
+     * 3. Walk forwards N steps to find following events
+     * 4. Aggregate into nodes and links for Sankey visualization
+     */
+    buildFlowQuery(config: FlowQueryConfig, cubes: Map<string, Cube>, context: QueryContext): ReturnType<typeof context.db.select>;
+    /**
+     * Transform raw SQL result to FlowResultRow
+     * The raw result contains rows with record_type = 'node' or 'link'
+     */
+    transformResult(rawResult: Record<string, unknown>[]): FlowResultRow;
+    /**
+     * Resolve flow configuration to SQL expressions
+     */
+    private resolveFlowConfig;
+    /**
+     * Resolve the cube for flow analysis
+     */
+    private resolveCube;
+    /**
+     * Resolve binding key expression
+     */
+    private resolveBindingKey;
+    /**
+     * Resolve time dimension expression
+     */
+    private resolveTimeDimension;
+    /**
+     * Resolve event dimension expression
+     */
+    private resolveEventDimension;
+    /**
+     * Build filter conditions for the starting step
+     */
+    private buildStartingStepFilters;
+    /**
+     * Build a single filter condition
+     */
+    private buildFilterCondition;
+    /**
+     * Build the starting entities CTE
+     * Finds all entities matching the starting step filter with their start time and event type
+     * For sunburst mode, also initializes event_path with the starting event type
+     */
+    private buildStartingEntitiesCTE;
+    /**
+     * Build CTEs for steps BEFORE the starting point using LATERAL joins
+     * Uses ORDER BY ... DESC LIMIT 1 to fetch immediate predecessor via index
+     */
+    private buildBeforeCTEsLateral;
+    /**
+     * Build CTEs for steps AFTER the starting point using LATERAL joins
+     * Uses ORDER BY ... ASC LIMIT 1 to fetch immediate successor via index
+     */
+    private buildAfterCTEsLateral;
+    /**
+     * Build CTEs for steps BEFORE the starting point
+     * Each CTE finds the immediate predecessor event for entities from the previous CTE
+     *
+     * Uses ROW_NUMBER() window function to get exactly the Nth previous event
+     * For sunburst mode, accumulates event_path by prepending to previous path
+     */
+    private buildBeforeCTEsWindow;
+    /**
+     * Build CTEs for steps AFTER the starting point
+     * Each CTE finds the immediate successor event for entities from the previous CTE
+     *
+     * Uses ROW_NUMBER() window function to get exactly the Nth following event
+     * For sunburst mode, accumulates event_path by concatenating with previous path
+     */
+    private buildAfterCTEsWindow;
+    /**
+     * Build the nodes aggregation CTE
+     * Aggregates counts per (layer, event_type) combination using UNION ALL
+     * For sunburst mode, aggregates by event_path for unique tree branches
+     */
+    private buildNodesAggregationCTE;
+    /**
+     * Build the links aggregation CTE
+     * Counts transitions between adjacent layers
+     * For sunburst mode, uses event_path for unique branch identification
+     */
+    private buildLinksAggregationCTE;
+    /**
+     * Build the final result CTE
+     * Combines nodes and links into a single result set with record_type discriminator
+     */
+    private buildFinalResultCTE;
+}

package/dist/server/server/builders/funnel-query-builder.d.ts

@@ -0,0 +1,134 @@
+import { DatabaseAdapter } from '../adapters/base-adapter';
+import { FunnelQueryConfig, FunnelResultRow } from '../types/funnel';
+import { Cube, QueryContext, SemanticQuery } from '../types';
+export declare class FunnelQueryBuilder {
+    private databaseAdapter;
+    private filterBuilder;
+    private dateTimeBuilder;
+    constructor(databaseAdapter: DatabaseAdapter);
+    /**
+     * Check if query contains funnel configuration
+     */
+    hasFunnel(query: SemanticQuery): boolean;
+    /**
+     * Validate funnel configuration
+     */
+    validateConfig(config: FunnelQueryConfig, cubes: Map<string, Cube>): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Build complete funnel query using Drizzle's query builder pattern
+     *
+     * Uses the industry-standard "sequential CTEs" pattern where each step
+     * joins to the previous step CTE. This automatically enforces funnel
+     * constraints (monotonically decreasing counts).
+     *
+     * Returns a Drizzle query builder that supports .toSQL() for dry-run
+     * and can be executed directly for results.
+     */
+    buildFunnelQuery(config: FunnelQueryConfig, cubes: Map<string, Cube>, context: QueryContext): ReturnType<typeof context.db.select>;
+    /**
+     * Transform raw SQL result to FunnelResultRow[]
+     */
+    transformResult(rawResult: Record<string, unknown>[], config: FunnelQueryConfig): FunnelResultRow[];
+    /**
+     * Extract cube names referenced in step filters
+     */
+    private extractFilterCubeNames;
+    /**
+     * Resolve steps with their cube, SQL expressions, and filter conditions
+     */
+    private resolveSteps;
+    /**
+     * Resolve the cube for a step
+     */
+    private resolveCubeForStep;
+    /**
+     * Resolve binding key expression for a cube
+     */
+    private resolveBindingKey;
+    /**
+     * Resolve time dimension expression for a cube
+     */
+    private resolveTimeDimension;
+    /**
+     * Build filter conditions for a step
+     * @param step - The funnel step
+     * @param baseCube - The step's primary cube
+     * @param cubes - All cubes available for cross-cube filtering
+     * @param context - Query context with security context
+     */
+    private buildStepFilters;
+    /**
+     * Build a single filter condition
+     * @param filter - The filter to build
+     * @param baseCube - The step's primary cube
+     * @param cubes - All cubes available for cross-cube filtering
+     * @param context - Query context with security context
+     */
+    private buildFilterCondition;
+    /**
+     * Build CTE for a single step using Drizzle's $with() pattern
+     *
+     * For step 0 (entry point): queries raw data directly
+     * For subsequent steps: joins to the previous step CTE to enforce sequential progression
+     *
+     * This implements the industry-standard "sequential CTEs" pattern where each step
+     * only includes binding_keys that successfully completed the previous step.
+     *
+     * @param step - The resolved step configuration
+     * @param context - Query context with security context
+     * @param previousStepCTE - Reference to the previous step's CTE (undefined for step 0)
+     */
+    private buildStepCTE;
+    /**
+     * Build CTE for the first step (step 0) - entry point
+     *
+     * Queries raw data directly with security context and step filters.
+     * Gets the first occurrence per binding key.
+     */
+    private buildFirstStepCTE;
+    /**
+     * Build CTE for subsequent steps (step 1+) - joins to previous step
+     *
+     * This is the key to the sequential funnel pattern:
+     * - INNER JOINs to the previous step CTE (only includes binding_keys that completed previous step)
+     * - Applies temporal constraints (must occur after previous step)
+     * - Applies step-specific filters and time-to-convert windows
+     *
+     * This automatically ensures monotonically decreasing counts.
+     */
+    private buildSubsequentStepCTE;
+    /**
+     * Helper to add cross-cube JOINs to a step query
+     * Extracted to avoid duplication between first and subsequent step methods
+     */
+    private addCrossJoinsToQuery;
+    /**
+     * Build funnel results CTE that joins all step times for time metric calculation
+     *
+     * With the sequential CTE pattern, each step CTE already contains only the
+     * binding_keys that successfully completed that step. This CTE simply joins
+     * them together to enable time difference calculations.
+     *
+     * No CASE expressions needed - the temporal filtering is already done in each step CTE.
+     */
+    private buildFunnelResultsCTE;
+    /**
+     * Build aggregation CTE with counts and optional time metrics
+     *
+     * OPTIMIZATION: Uses single-pass aggregation over funnel_joined CTE instead of
+     * multiple scalar subqueries. This reduces table scans from 13+ to 1 for a typical
+     * 3-step funnel with time metrics.
+     *
+     * - Step counts: COUNT(*) for step_0, COUNT(step_N_time) for subsequent steps
+     * - Time metrics: Uses database-specific conditional aggregation (FILTER clause for
+     *   PostgreSQL, CASE WHEN for MySQL/SQLite)
+     * - Percentiles: Still use subqueries since PERCENTILE_CONT with FILTER is non-standard
+     *
+     * Important: All SQL fields must have explicit aliases via .as() for Drizzle
+     * to properly reference them when selecting from the CTE
+     */
+    private buildAggregationCTE;
+}

package/dist/server/server/builders/group-by-builder.d.ts

@@ -0,0 +1,27 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { Cube, SemanticQuery, QueryContext, PhysicalQueryPlan } from '../types';
+import { DateTimeBuilder } from './date-time-builder';
+export declare class GroupByBuilder {
+    private dateTimeBuilder;
+    constructor(dateTimeBuilder: DateTimeBuilder);
+    /**
+     * Check if a measure type is a window function
+     */
+    isWindowFunctionType(measureType: string): boolean;
+    /**
+     * Check if a measure type is an aggregate function (requires GROUP BY)
+     *
+     * Note: 'number' is included because users commonly define measures with raw SQL
+     * aggregations (e.g., sql`COUNT(DISTINCT ...)`) and set type: 'number' for the output.
+     * These measures still require GROUP BY when used with time dimensions.
+     */
+    isAggregateFunctionType(measureType: string): boolean;
+    /**
+     * Build GROUP BY fields from dimensions and time dimensions
+     * Works for both single and multi-cube queries
+     *
+     * NOTE: GROUP BY is only added when there are AGGREGATE measures.
+     * Window functions do not require GROUP BY and operate on individual rows.
+     */
+    buildGroupByFields(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext, queryPlan?: PhysicalQueryPlan): (SQL | AnyColumn)[];
+}

package/dist/server/server/builders/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builders Index
+ * Re-exports all query builder components for modular imports
+ */
+export { DateTimeBuilder } from './date-time-builder';
+export { FilterBuilder } from './filter-builder';
+export { GroupByBuilder } from './group-by-builder';
+export { MeasureBuilder } from './measure-builder';
+export { CTEBuilder } from './cte-builder';
+export { ComparisonQueryBuilder } from './comparison-query-builder';
+export { FunnelQueryBuilder } from './funnel-query-builder';
+export { FlowQueryBuilder } from './flow-query-builder';
+export { RetentionQueryBuilder } from './retention-query-builder';