drizzle-cube 0.1.14 → 0.1.15

package/dist/server/index.d.ts

@@ -38,12 +38,6 @@ export declare interface CompiledCube<TSchema extends Record<string, any> = Reco
     queryFn: (query: SemanticQuery, securityContext: SecurityContext) => Promise<QueryResult>;
 }
 
-/**
- * Helper function to convert Cube.dev-style YAML references
- * Converts {CUBE}, {CubeName.field}, etc. to our format
- */
-export declare function convertCubeReferences(sql: string): string;
-
 /**
  * Auto-detect database type and create appropriate executor
  * @param db - Drizzle database instance
@@ -123,17 +117,24 @@ export declare type CubeDefinition<TSchema extends Record<string, any>> = Omit<S
 };
 
 /**
- * Cube join definition for multi-cube queries
+ * Type-safe cube join definition with lazy loading support
  */
 export declare interface CubeJoin<TSchema extends Record<string, any> = Record<string, any>> {
-    /** Target cube name to join with */
-    targetCube: string;
-    /** Join condition */
-    condition: (ctx: MultiCubeQueryContext<TSchema>) => SQL;
-    /** Join type */
-    type?: 'inner' | 'left' | 'right' | 'full';
-    /** Relationship type for metadata */
+    /** Target cube reference - lazy loaded to avoid circular dependencies */
+    targetCube: Cube<TSchema> | (() => Cube<TSchema>);
+    /** Semantic relationship - determines join behavior */
     relationship: 'belongsTo' | 'hasOne' | 'hasMany';
+    /** Array of join conditions - supports multi-column joins */
+    on: Array<{
+        /** Column from source cube */
+        source: AnyColumn;
+        /** Column from target cube */
+        target: AnyColumn;
+        /** Comparison operator - defaults to eq */
+        as?: (source: AnyColumn, target: AnyColumn) => SQL;
+    }>;
+    /** Override default SQL join type (derived from relationship) */
+    sqlJoinType?: 'inner' | 'left' | 'right' | 'full';
 }
 
 /**
@@ -176,41 +177,50 @@ declare interface DatabaseAdapter {
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
     /**
-     * Build COUNT aggregation expression
-     * @param fieldExpr - The field expression to count
-     * @returns SQL expression for COUNT aggregation
+     * Build AVG aggregation expression with database-specific null handling
+     * @param fieldExpr - The field expression to average
+     * @returns SQL expression for AVG aggregation (COALESCE vs IFNULL for null handling)
      */
-    buildCount(fieldExpr: AnyColumn | SQL): SQL;
+    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build COUNT DISTINCT aggregation expression
-     * @param fieldExpr - The field expression to count distinct values
-     * @returns SQL expression for COUNT DISTINCT aggregation
+     * Build CASE WHEN conditional expression
+     * @param conditions - Array of condition/result pairs
+     * @param elseValue - Optional ELSE clause value
+     * @returns SQL expression for CASE WHEN statement
      */
-    buildCountDistinct(fieldExpr: AnyColumn | SQL): SQL;
+    buildCaseWhen(conditions: Array<{
+        when: SQL;
+        then: any;
+    }>, elseValue?: any): SQL;
     /**
-     * Build SUM aggregation expression
-     * @param fieldExpr - The field expression to sum
-     * @returns SQL expression for SUM aggregation
+     * Build boolean literal expression
+     * @param value - Boolean value to represent
+     * @returns SQL expression for boolean literal (TRUE/FALSE/1/0 depending on database)
      */
-    buildSum(fieldExpr: AnyColumn | SQL): SQL;
+    buildBooleanLiteral(value: boolean): SQL;
     /**
-     * Build AVG aggregation expression
-     * @param fieldExpr - The field expression to average
-     * @returns SQL expression for AVG aggregation
+     * Convert filter values to database-compatible types
+     * @param value - The filter value to convert
+     * @returns Converted value for database queries
      */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
+    convertFilterValue(value: any): any;
+    /**
+     * Prepare date value for database-specific storage format
+     * @param date - Date value to prepare
+     * @returns Database-compatible date representation
+     */
+    prepareDateValue(date: Date): any;
     /**
-     * Build MIN aggregation expression
-     * @param fieldExpr - The field expression to find minimum
-     * @returns SQL expression for MIN aggregation
+     * Check if this database stores timestamps as integers
+     * @returns True if timestamps are stored as integers (milliseconds), false for native timestamps
      */
-    buildMin(fieldExpr: AnyColumn | SQL): SQL;
+    isTimestampInteger(): boolean;
     /**
-     * Build MAX aggregation expression
-     * @param fieldExpr - The field expression to find maximum
-     * @returns SQL expression for MAX aggregation
+     * Convert time dimension result values back to Date objects for consistency
+     * @param value - The time dimension value from query results
+     * @returns Date object or original value if not a time dimension
      */
-    buildMax(fieldExpr: AnyColumn | SQL): SQL;
+    convertTimeDimensionResult(value: any): any;
 }
 
 /**
@@ -332,6 +342,11 @@ export declare interface FilterCondition {
  */
 export declare type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'set' | 'notSet' | 'inDateRange' | 'beforeDate' | 'afterDate';
 
+/**
+ * Derive SQL join type from semantic relationship
+ */
+export declare function getJoinType(relationship: string, override?: string): string;
+
 export declare type JoinType = 'left' | 'right' | 'inner' | 'full';
 
 /**
@@ -358,16 +373,6 @@ export declare interface LegacyQueryContext<TSchema extends Record<string, any>
     cube: LegacyCompiledCube<TSchema>;
 }
 
-/**
- * Load and parse YAML cubes from file content
- */
-export declare function loadYamlCubes(yamlContent: string): SemanticCube[];
-
-/**
- * Load YAML cubes from file system (Node.js only)
- */
-export declare function loadYamlCubesFromFile(filePath: string): Promise<SemanticCube[]>;
-
 export declare interface LogicalFilter {
     and?: Filter[];
     or?: Filter[];
@@ -418,68 +423,6 @@ export declare interface MeasureMetadata {
  */
 export declare type MeasureType = 'count' | 'countDistinct' | 'countDistinctApprox' | 'sum' | 'avg' | 'min' | 'max' | 'runningTotal' | 'number';
 
-export declare class MultiCubeBuilder<TSchema extends Record<string, any> = Record<string, any>> {
-    private databaseAdapter?;
-    constructor(databaseAdapter?: DatabaseAdapter | undefined);
-    /**
-     * Set the database adapter (for use when not provided in constructor)
-     */
-    setDatabaseAdapter(adapter: DatabaseAdapter): void;
-    /**
-     * Analyze a semantic query to determine which cubes are involved
-     */
-    analyzeCubeUsage(query: SemanticQuery): Set<string>;
-    /**
-     * Build a multi-cube query plan
-     */
-    buildMultiCubeQueryPlan(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, ctx: QueryContext<TSchema>): MultiCubeQueryPlan<TSchema>;
-    /**
-     * Choose the primary cube based on query analysis
-     */
-    choosePrimaryCube(cubeNames: string[], query: SemanticQuery): string;
-    /**
-     * Build join plan for multi-cube query
-     */
-    private buildJoinPlan;
-    /**
-     * Build selections across multiple cubes
-     */
-    private buildMultiCubeSelections;
-    /**
-     * Build measure expression with aggregation (similar to single-cube approach)
-     */
-    private buildMeasureExpression;
-    /**
-     * Build time dimension expression (similar to single-cube approach)
-     */
-    private buildTimeDimensionExpression;
-    /**
-     * Build WHERE conditions for multi-cube query
-     */
-    private buildMultiCubeWhereConditions;
-    /**
-     * Process a single filter for multi-cube queries (handles logical and simple filters)
-     */
-    private processMultiCubeFilter;
-    /**
-     * Filter condition builder with comprehensive operator support
-     */
-    private buildFilterCondition;
-    /**
-     * Build date range condition for time dimensions
-     */
-    private buildDateRangeCondition;
-    /**
-     * Normalize date values to handle both string and Date objects
-     * For PostgreSQL timestamp fields, Drizzle expects Date objects
-     */
-    private normalizeDate;
-    /**
-     * Build GROUP BY fields for multi-cube query
-     */
-    private buildMultiCubeGroupByFields;
-}
-
 /**
  * Multi-cube query context for cross-cube operations
  */
@@ -490,26 +433,7 @@ export declare interface MultiCubeQueryContext<TSchema extends Record<string, an
     currentCube: Cube<TSchema>;
 }
 
-/**
- * Multi-cube query plan - describes how to execute a cross-cube query
- */
-export declare interface MultiCubeQueryPlan<TSchema extends Record<string, any> = Record<string, any>> {
-    /** Primary cube that drives the query */
-    primaryCube: Cube<TSchema>;
-    /** Additional cubes to join */
-    joinCubes: Array<{
-        cube: Cube<TSchema>;
-        alias: string;
-        joinType: 'inner' | 'left' | 'right' | 'full';
-        joinCondition: SQL;
-    }>;
-    /** Combined field selections across all cubes */
-    selections: Record<string, SQL | AnyColumn>;
-    /** WHERE conditions for the entire query */
-    whereConditions: SQL[];
-    /** GROUP BY fields if aggregations are present */
-    groupByFields: (SQL | AnyColumn)[];
-}
+export declare type MultiCubeQueryPlan<TSchema extends Record<string, any> = Record<string, any>> = QueryPlan<TSchema>;
 
 /**
  * MySQL database executor
@@ -528,11 +452,6 @@ export declare class MySQLExecutor<TSchema extends Record<string, any> = Record<
     getEngineType(): 'mysql';
 }
 
-/**
- * Parse YAML content and return validation result with converted cubes
- */
-export declare function parseYamlCubes(yamlContent: string): YamlValidationResult;
-
 /**
  * PostgreSQL database executor
  * Works with postgres.js and Neon drivers
@@ -550,6 +469,81 @@ export declare class PostgresExecutor<TSchema extends Record<string, any> = Reco
     getEngineType(): 'postgres';
 }
 
+export declare class QueryBuilder<TSchema extends Record<string, any> = Record<string, any>> {
+    private databaseAdapter;
+    constructor(databaseAdapter: DatabaseAdapter);
+    /**
+     * Build dynamic selections for measures, dimensions, and time dimensions
+     * Works for both single and multi-cube queries
+     */
+    buildSelections(cubes: Map<string, Cube<TSchema>> | Cube<TSchema>, query: SemanticQuery, context: QueryContext<TSchema>): Record<string, SQL | AnyColumn>;
+    /**
+     * Build measure expression for HAVING clause, handling CTE references correctly
+     */
+    private buildHavingMeasureExpression;
+    /**
+     * Build measure expression with aggregation and filters
+     */
+    buildMeasureExpression(measure: any, context: QueryContext<TSchema>): SQL;
+    /**
+     * Build time dimension expression with granularity using database adapter
+     */
+    buildTimeDimensionExpression(dimensionSql: any, granularity: string | undefined, context: QueryContext<TSchema>): SQL;
+    /**
+     * Build WHERE conditions from semantic query filters (dimensions only)
+     * Works for both single and multi-cube queries
+     */
+    buildWhereConditions(cubes: Map<string, Cube<TSchema>> | Cube<TSchema>, query: SemanticQuery, context: QueryContext<TSchema>, queryPlan?: QueryPlan<TSchema>): SQL[];
+    /**
+     * Build HAVING conditions from semantic query filters (measures only)
+     * Works for both single and multi-cube queries
+     */
+    buildHavingConditions(cubes: Map<string, Cube<TSchema>> | Cube<TSchema>, query: SemanticQuery, context: QueryContext<TSchema>, queryPlan?: QueryPlan<TSchema>): SQL[];
+    /**
+     * Process a single filter (basic or logical)
+     * @param filterType - 'where' for dimension filters, 'having' for measure filters
+     */
+    private processFilter;
+    /**
+     * Build filter condition using Drizzle operators
+     */
+    private buildFilterCondition;
+    /**
+     * 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
+     */
+    private parseRelativeDateRange;
+    /**
+     * Normalize date values to handle strings, numbers, and Date objects
+     * Always returns a JavaScript Date object or null
+     * Database-agnostic - just ensures we have a valid Date
+     */
+    private normalizeDate;
+    /**
+     * Build GROUP BY fields from dimensions and time dimensions
+     * Works for both single and multi-cube queries
+     */
+    buildGroupByFields(cubes: Map<string, Cube<TSchema>> | Cube<TSchema>, query: SemanticQuery, context: QueryContext<TSchema>, queryPlan?: any): (SQL | AnyColumn)[];
+    /**
+     * Build ORDER BY clause with automatic time dimension sorting
+     */
+    buildOrderBy(query: SemanticQuery, selectedFields?: string[]): SQL[];
+    /**
+     * Collect numeric field names (measures + numeric dimensions) for type conversion
+     * Works for both single and multi-cube queries
+     */
+    collectNumericFields(cubes: Map<string, Cube<TSchema>> | Cube<TSchema>, query: SemanticQuery): string[];
+    /**
+     * Apply LIMIT and OFFSET to a query with validation
+     * If offset is provided without limit, add a reasonable default limit
+     */
+    applyLimitAndOffset<T>(query: T, semanticQuery: SemanticQuery): T;
+}
+
 /**
  * Query context for dynamic building
  */
@@ -564,7 +558,8 @@ export declare interface QueryContext<TSchema extends Record<string, any> = Reco
 
 export declare class QueryExecutor<TSchema extends Record<string, any> = Record<string, any>> {
     private dbExecutor;
-    private multiCubeBuilder;
+    private queryBuilder;
+    private queryPlanner;
     private databaseAdapter;
     constructor(dbExecutor: DatabaseExecutor<TSchema>);
     /**
@@ -576,105 +571,137 @@ export declare class QueryExecutor<TSchema extends Record<string, any> = Record<
      */
     executeQuery(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
     /**
-     * Execute a single cube query
+     * Build pre-aggregation CTE for hasMany relationships
      */
-    private executeSingleCube;
+    private buildPreAggregationCTE;
     /**
-     * Execute a Cube query (dynamic query building)
+     * Build join condition for CTE
      */
-    private executeCube;
+    private buildCTEJoinCondition;
     /**
-     * Execute multi-cube query using JOIN resolution
+     * Build unified query that works for both single and multi-cube queries
      */
-    private executeMultiCube;
+    private buildUnifiedQuery;
     /**
-     * Generate raw SQL for debugging (without execution)
+     * Convert query plan to cube map for QueryBuilder methods
+     */
+    private getCubesFromPlan;
+    /**
+     * Generate raw SQL for debugging (without execution) - unified approach
      */
     generateSQL(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
         sql: string;
         params?: any[];
     }>;
     /**
-     * Generate raw SQL for multi-cube queries without execution
+     * Generate raw SQL for multi-cube queries without execution - unified approach
      */
     generateMultiCubeSQL(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
         sql: string;
         params?: any[];
     }>;
     /**
-     * Build multi-cube query (extracted from executeMultiCube for reuse)
+     * Generate SQL using unified approach (works for both single and multi-cube)
      */
-    private buildMultiCubeQuery;
+    private generateUnifiedSQL;
     /**
-     * Collect numeric field names (measures + numeric dimensions) for type conversion
+     * Generate annotations for UI metadata - unified approach
      */
-    private collectNumericFields;
-    /**
-     * Collect numeric field names for multi-cube queries
-     */
-    private collectNumericFieldsMultiCube;
-    /**
-     * Apply LIMIT and OFFSET to a query with validation
-     * If offset is provided without limit, add a reasonable default limit
-     */
-    private applyLimitAndOffset;
-    /**
-     * Generate SQL for Cube
-     */
-    private generateCubeSQL;
-    /**
-     * Build dynamic selections for Cube measures and dimensions
-     */
-    private buildSelections;
+    private generateAnnotations;
+}
+
+/**
+ * Unified Query Plan for both single and multi-cube queries
+ * - For single-cube queries: joinCubes array is empty
+ * - For multi-cube queries: joinCubes contains the additional cubes to join
+ * - selections, whereConditions, and groupByFields are populated by QueryBuilder
+ */
+export declare interface QueryPlan<TSchema extends Record<string, any> = Record<string, any>> {
+    /** Primary cube that drives the query */
+    primaryCube: Cube<TSchema>;
+    /** Additional cubes to join (empty for single-cube queries) */
+    joinCubes: Array<{
+        cube: Cube<TSchema>;
+        alias: string;
+        joinType: 'inner' | 'left' | 'right' | 'full';
+        joinCondition: SQL;
+    }>;
+    /** Combined field selections across all cubes (built by QueryBuilder) */
+    selections: Record<string, SQL | AnyColumn>;
+    /** WHERE conditions for the entire query (built by QueryBuilder) */
+    whereConditions: SQL[];
+    /** GROUP BY fields if aggregations are present (built by QueryBuilder) */
+    groupByFields: (SQL | AnyColumn)[];
+    /** Pre-aggregation CTEs for hasMany relationships to prevent fan-out */
+    preAggregationCTEs?: Array<{
+        cube: Cube<TSchema>;
+        alias: string;
+        cteAlias: string;
+        joinKeys: Array<{
+            sourceColumn: string;
+            targetColumn: string;
+            sourceColumnObj?: AnyColumn;
+            targetColumnObj?: AnyColumn;
+        }>;
+        measures: string[];
+    }>;
+}
+
+/**
+ * Pre-aggregation plan for handling hasMany relationships
+ */
+export declare class QueryPlanner<TSchema extends Record<string, any> = Record<string, any>> {
     /**
-     * Build measure expression with aggregation and filters for Cube
+     * Analyze a semantic query to determine which cubes are involved
      */
-    private buildMeasureExpression;
+    analyzeCubeUsage(query: SemanticQuery): Set<string>;
     /**
-     * Build time dimension expression with granularity using database adapter
+     * Recursively extract cube names from filters (handles logical filters)
      */
-    private buildTimeDimensionExpression;
+    private extractCubeNamesFromFilter;
     /**
-     * Build WHERE conditions from semantic query filters (Cube)
+     * Extract measures referenced in filters (for CTE inclusion)
      */
-    private buildWhereConditions;
+    private extractMeasuresFromFilters;
     /**
-     * Process a single filter for Cube (basic or logical)
+     * Recursively extract measures from filters for a specific cube
      */
-    private processFilter;
+    private extractMeasuresFromFilter;
     /**
-     * Build filter condition using Drizzle operators
+     * Create a unified query plan that works for both single and multi-cube queries
      */
-    private buildFilterCondition;
+    createQueryPlan(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, ctx: QueryContext<TSchema>): QueryPlan<TSchema>;
     /**
-     * Build date range condition for time dimensions
+     * Choose the primary cube based on query analysis
+     * Uses a consistent strategy to avoid measure order dependencies
      */
-    private buildDateRangeCondition;
+    choosePrimaryCube(cubeNames: string[], query: SemanticQuery, cubes?: Map<string, Cube<TSchema>>): string;
     /**
-     * Parse relative date range expressions like "last 7 days", "this month"
+     * Check if a cube can reach all other cubes in the list via joins
      */
-    private parseRelativeDateRange;
+    private canReachAllCubes;
     /**
-     * Normalize date values to handle both string and Date objects
-     * For PostgreSQL timestamp fields, Drizzle expects Date objects
+     * Build join plan for multi-cube query
+     * Supports both direct joins and transitive joins through intermediate cubes
      */
-    private normalizeDate;
+    private buildJoinPlan;
     /**
-     * Build GROUP BY fields from dimensions and time dimensions (Cube)
+     * Build join condition from new array-based join definition
      */
-    private buildGroupByFields;
+    private buildJoinCondition;
     /**
-     * Build ORDER BY clause with automatic time dimension sorting
+     * Find join path from source cube to target cube
+     * Returns array of join steps to reach target
      */
-    private buildOrderBy;
+    private findJoinPath;
     /**
-     * Generate annotations for UI metadata
+     * Plan pre-aggregation CTEs for hasMany relationships to prevent fan-out
      */
-    private generateAnnotations;
+    private planPreAggregationCTEs;
     /**
-     * Generate annotations for multi-cube queries
+     * Find hasMany join definition from primary cube to target cube
      */
-    private generateMultiCubeAnnotations;
+    private findHasManyJoinDef;
 }
 
 /**
@@ -690,6 +717,11 @@ export declare interface QueryResult {
     };
 }
 
+/**
+ * Resolve cube reference (handles both direct and lazy references)
+ */
+export declare function resolveCubeReference<TSchema extends Record<string, any>>(ref: Cube<TSchema> | (() => Cube<TSchema>)): Cube<TSchema>;
+
 /**
  * Helper to resolve SQL expressions
  */
@@ -735,11 +767,6 @@ export declare interface SemanticCube<TSchema extends Record<string, any> = Reco
     meta?: Record<string, any>;
 }
 
-/**
- * Create a YAML cube definition from a SemanticCube (for export/migration)
- */
-export declare function semanticCubeToYaml(cube: SemanticCube): string;
-
 /**
  * Semantic dimension with Drizzle column support
  */
@@ -790,6 +817,10 @@ export declare class SemanticLayerCompiler<TSchema extends Record<string, any> =
      * Set or update the database executor
      */
     setDatabaseExecutor(executor: DatabaseExecutor<TSchema>): void;
+    /**
+     * Get the database engine type for SQL formatting
+     */
+    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | undefined;
     /**
      * Set Drizzle instance and schema directly
      */
@@ -1253,174 +1284,4 @@ export declare interface TimeDimensionAnnotation {
 
 export declare type TimeGranularity = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
 
-/**
- * Single YAML Cube Definition
- */
-export declare interface YamlCube {
-    name: string;
-    title?: string;
-    description?: string;
-    sql?: string;
-    sql_table?: string;
-    sqlTable?: string;
-    sql_alias?: string;
-    sqlAlias?: string;
-    data_source?: string;
-    dataSource?: string;
-    refresh_key?: {
-        every?: string;
-        sql?: string;
-    };
-    refreshKey?: {
-        every?: string;
-        sql?: string;
-    };
-    dimensions?: YamlDimension[];
-    measures?: YamlMeasure[];
-    joins?: YamlJoin[];
-    pre_aggregations?: YamlPreAggregation[];
-    preAggregations?: YamlPreAggregation[];
-    meta?: Record<string, any>;
-}
-
-/**
- * Convert YAML cube to SemanticCube object
- */
-export declare function yamlCubeToSemanticCube(yamlCube: YamlCube): SemanticCube;
-
-/**
- * YAML Dimension Definition
- */
-export declare interface YamlDimension {
-    name: string;
-    title?: string;
-    description?: string;
-    type: DimensionType;
-    sql: string;
-    primary_key?: boolean;
-    primaryKey?: boolean;
-    shown?: boolean;
-    format?: 'id' | 'link' | 'currency' | 'percent' | 'number' | 'date' | 'datetime';
-    meta?: Record<string, any>;
-}
-
-/**
- * YAML Join Definition
- */
-export declare interface YamlJoin {
-    name: string;
-    type?: JoinType;
-    relationship: 'one_to_one' | 'one_to_many' | 'many_to_one';
-    sql: string;
-}
-
-/**
- * YAML Measure Definition
- */
-export declare interface YamlMeasure {
-    name: string;
-    title?: string;
-    description?: string;
-    type: MeasureType;
-    sql: string;
-    format?: 'currency' | 'percent' | 'number' | 'integer';
-    shown?: boolean;
-    filters?: Array<{
-        sql: string;
-    }>;
-    rolling_window?: {
-        trailing?: string;
-        leading?: string;
-        offset?: string;
-    };
-    rollingWindow?: {
-        trailing?: string;
-        leading?: string;
-        offset?: string;
-    };
-    meta?: Record<string, any>;
-}
-
-/**
- * YAML Pre-aggregation Definition
- */
-export declare interface YamlPreAggregation {
-    name: string;
-    measures: string[];
-    dimensions: string[];
-    time_dimension?: {
-        dimension: string;
-        granularity: TimeGranularity[];
-    };
-    timeDimension?: {
-        dimension: string;
-        granularity: TimeGranularity[];
-    };
-    refresh_key?: {
-        every: string;
-        sql?: string;
-    };
-    refreshKey?: {
-        every: string;
-        sql?: string;
-    };
-    indexes?: Record<string, string[]>;
-}
-
-/**
- * Root YAML Schema - supports multiple formats:
- * 1. Single cube definition (properties at root)
- * 2. Multiple cubes (cubes array)
- * 3. Cubes and views (separate arrays)
- */
-export declare interface YamlSchema {
-    name?: string;
-    title?: string;
-    description?: string;
-    sql?: string;
-    sql_table?: string;
-    sqlTable?: string;
-    sql_alias?: string;
-    sqlAlias?: string;
-    data_source?: string;
-    dataSource?: string;
-    refresh_key?: YamlCube['refresh_key'];
-    refreshKey?: YamlCube['refreshKey'];
-    dimensions?: YamlDimension[];
-    measures?: YamlMeasure[];
-    joins?: YamlJoin[];
-    pre_aggregations?: YamlPreAggregation[];
-    preAggregations?: YamlPreAggregation[];
-    meta?: Record<string, any>;
-    cubes?: YamlCube[];
-    views?: YamlView[];
-}
-
-/**
- * Validation result for YAML parsing
- */
-export declare interface YamlValidationResult {
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-    cubes: YamlCube[];
-}
-
-/**
- * YAML View Definition (for future support)
- */
-export declare interface YamlView {
-    name: string;
-    title?: string;
-    description?: string;
-    cubes: Array<{
-        join_path?: string;
-        joinPath?: string;
-        prefix?: boolean;
-        includes?: string[];
-        excludes?: string[];
-    }>;
-    meta?: Record<string, any>;
-}
-
 export { }