drizzle-cube 0.1.17 → 0.1.19

package/dist/server/index.d.ts

@@ -1,14 +1,17 @@
 import { AnyColumn } from 'drizzle-orm';
+import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
 import { SQL } from 'drizzle-orm';
 
 /**
  * Abstract base class for database executors
  */
-export declare abstract class BaseDatabaseExecutor<TSchema extends Record<string, any> = Record<string, any>> implements DatabaseExecutor<TSchema> {
-    db: DrizzleDatabase<TSchema>;
-    schema?: TSchema | undefined;
+export declare abstract class BaseDatabaseExecutor implements DatabaseExecutor {
+    db: DrizzleDatabase;
+    schema?: any | undefined;
     databaseAdapter: DatabaseAdapter;
-    constructor(db: DrizzleDatabase<TSchema>, schema?: TSchema | undefined, engineType?: 'postgres' | 'mysql' | 'sqlite');
+    constructor(db: DrizzleDatabase, schema?: any | undefined, engineType?: 'postgres' | 'mysql' | 'sqlite');
     abstract execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
     abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite';
 }
@@ -33,7 +36,7 @@ export declare interface BaseQueryDefinition {
 /**
  * Compiled cube with execution function
  */
-export declare interface CompiledCube<TSchema extends Record<string, any> = Record<string, any>> extends Cube<TSchema> {
+export declare interface CompiledCube extends Cube {
     /** Execute a query against this cube */
     queryFn: (query: SemanticQuery, securityContext: SecurityContext) => Promise<QueryResult>;
 }
@@ -45,45 +48,51 @@ export declare interface CompiledCube<TSchema extends Record<string, any> = Reco
  * @param engineType - Optional explicit engine type override
  * @returns Appropriate database executor
  */
-export declare function createDatabaseExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema, engineType?: 'postgres' | 'mysql' | 'sqlite'): DatabaseExecutor<TSchema>;
+export declare function createDatabaseExecutor(db: DrizzleDatabase, schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite'): DatabaseExecutor;
 
 /**
  * Create a new semantic layer instance with Drizzle integration
  * Use this when you need multiple isolated instances
  */
-export declare function createDrizzleSemanticLayer<TSchema extends Record<string, any>>(options: {
-    drizzle: DrizzleDatabase<TSchema>;
-    schema?: TSchema;
-}): SemanticLayerCompiler<TSchema>;
+export declare function createDrizzleSemanticLayer(options: {
+    drizzle: DrizzleDatabase;
+    schema?: any;
+}): SemanticLayerCompiler;
 
 /**
  * Helper to create multi-cube query context
  */
-export declare function createMultiCubeContext<TSchema extends Record<string, any>>(baseContext: QueryContext<TSchema>, cubes: Map<string, Cube<TSchema>>, currentCube: Cube<TSchema>): MultiCubeQueryContext<TSchema>;
+export declare function createMultiCubeContext(baseContext: QueryContext, cubes: Map<string, Cube>, currentCube: Cube): MultiCubeQueryContext;
 
-export declare function createMySQLExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): MySQLExecutor<TSchema>;
+/**
+ * Factory function for creating MySQL executors
+ */
+export declare function createMySQLExecutor(db: DrizzleDatabase, schema?: any): MySQLExecutor;
 
 /**
- * Factory functions for creating database executors
+ * Factory function for creating PostgreSQL executors
  */
-export declare function createPostgresExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): PostgresExecutor<TSchema>;
+export declare function createPostgresExecutor(db: DrizzleDatabase, schema?: any): PostgresExecutor;
 
 /**
  * Create a new semantic layer compiler with type inference
  */
-export declare function createSemanticLayer<TSchema extends Record<string, any>>(options?: {
-    drizzle?: DatabaseExecutor<TSchema>['db'];
-    schema?: TSchema;
-    databaseExecutor?: DatabaseExecutor<TSchema>;
+export declare function createSemanticLayer(options?: {
+    drizzle?: DatabaseExecutor['db'];
+    schema?: any;
+    databaseExecutor?: DatabaseExecutor;
     engineType?: 'postgres' | 'mysql' | 'sqlite';
-}): SemanticLayerCompiler<TSchema>;
+}): SemanticLayerCompiler;
 
-export declare function createSQLiteExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): SQLiteExecutor<TSchema>;
+/**
+ * Factory function for creating SQLite executors
+ */
+export declare function createSQLiteExecutor(db: DrizzleDatabase, schema?: any): SQLiteExecutor;
 
 /**
- * Cube definition focused on dynamic query building
+ * Cube definition focused on Drizzle query building
  */
-export declare interface Cube<TSchema extends Record<string, any> = Record<string, any>> {
+declare interface Cube {
     name: string;
     title?: string;
     description?: string;
@@ -91,20 +100,30 @@ export declare interface Cube<TSchema extends Record<string, any> = Record<strin
      * Base query setup - returns the foundation that can be extended
      * Should return FROM/JOIN/WHERE setup, NOT a complete SELECT
      */
-    sql: (ctx: QueryContext<TSchema>) => BaseQueryDefinition;
+    sql: (ctx: QueryContext) => BaseQueryDefinition;
     /** Cube dimensions using direct column references */
-    dimensions: Record<string, Dimension<TSchema>>;
+    dimensions: Record<string, Dimension>;
     /** Cube measures using direct column references */
-    measures: Record<string, Measure<TSchema>>;
+    measures: Record<string, Measure>;
     /** Optional joins to other cubes for multi-cube queries */
-    joins?: Record<string, CubeJoin<TSchema>>;
+    joins?: Record<string, CubeJoin>;
+    /** Whether cube is publicly accessible */
+    public?: boolean;
+    /** SQL alias for the cube */
+    sqlAlias?: string;
+    /** Data source identifier */
+    dataSource?: string;
+    /** Additional metadata */
+    meta?: Record<string, any>;
 }
+export { Cube }
+export { Cube as SemanticCube }
 
 /**
  * Helper type for creating type-safe cubes
  */
-export declare interface CubeDefiner<TSchema extends Record<string, any>> {
-    <TName extends string>(name: TName, definition: CubeDefinition<TSchema>): SemanticCube<TSchema> & {
+export declare interface CubeDefiner {
+    <TName extends string>(name: TName, definition: CubeDefinition): Cube & {
         name: TName;
     };
 }
@@ -112,16 +131,16 @@ export declare interface CubeDefiner<TSchema extends Record<string, any>> {
 /**
  * Utility type for cube definition with schema inference
  */
-export declare type CubeDefinition<TSchema extends Record<string, any>> = Omit<SemanticCube<TSchema>, 'name'> & {
+export declare type CubeDefinition = Omit<Cube, 'name'> & {
     name?: string;
 };
 
 /**
  * Type-safe cube join definition with lazy loading support
  */
-export declare interface CubeJoin<TSchema extends Record<string, any> = Record<string, any>> {
+declare interface CubeJoin {
     /** Target cube reference - lazy loaded to avoid circular dependencies */
-    targetCube: Cube<TSchema> | (() => Cube<TSchema>);
+    targetCube: Cube | (() => Cube);
     /** Semantic relationship - determines join behavior */
     relationship: 'belongsTo' | 'hasOne' | 'hasMany';
     /** Array of join conditions - supports multi-column joins */
@@ -136,6 +155,8 @@ export declare interface CubeJoin<TSchema extends Record<string, any> = Record<s
     /** Override default SQL join type (derived from relationship) */
     sqlJoinType?: 'inner' | 'left' | 'right' | 'full';
 }
+export { CubeJoin }
+export { CubeJoin as SemanticJoin }
 
 /**
  * Cube metadata for API responses
@@ -224,14 +245,14 @@ declare interface DatabaseAdapter {
 }
 
 /**
- * Database executor that wraps Drizzle ORM
+ * Database executor interface that wraps Drizzle ORM
  * Provides type-safe SQL execution with engine-specific implementations
  */
-export declare interface DatabaseExecutor<TSchema extends Record<string, any> = Record<string, any>> {
+export declare interface DatabaseExecutor {
     /** The Drizzle database instance */
-    db: DrizzleDatabase<TSchema>;
+    db: DrizzleDatabase;
     /** Optional schema for type inference */
-    schema?: TSchema;
+    schema?: any;
     /** Database adapter for SQL dialect-specific operations */
     databaseAdapter: DatabaseAdapter;
     /** Execute a Drizzle SQL query or query object */
@@ -244,38 +265,34 @@ export declare interface DatabaseExecutor<TSchema extends Record<string, any> =
  * Main semantic layer instance
  * Use this for simple single-instance usage
  */
-export declare const defaultSemanticLayer: SemanticLayerCompiler<Record<string, any>>;
+export declare const defaultSemanticLayer: SemanticLayerCompiler;
 
 /**
  * Helper function to create cubes
  */
-export declare function defineCube<TSchema extends Record<string, any>>(name: string, definition: Omit<Cube<TSchema>, 'name'>): Cube<TSchema>;
-
-/**
- * Create a type-safe cube definition with schema inference
- * @param _schema - Drizzle schema containing table definitions (used for type inference only)
- * @param definition - Cube definition with type inference
- * @returns Type-safe semantic cube
- */
-export declare function defineLegacyCube<TSchema extends Record<string, any>>(_schema: TSchema, definition: CubeDefinition<TSchema> & {
-    name: string;
-}): SemanticCube<TSchema>;
+export declare function defineCube(name: string, definition: Omit<Cube, 'name'>): Cube;
 
 /**
  * Dimension definition
  */
-export declare interface Dimension<TSchema extends Record<string, any> = Record<string, any>> {
+declare interface Dimension {
     name: string;
     title?: string;
     description?: string;
     type: DimensionType;
     /** Direct column reference or SQL expression */
-    sql: AnyColumn | SQL | ((ctx: QueryContext<TSchema>) => AnyColumn | SQL);
+    sql: AnyColumn | SQL | ((ctx: QueryContext) => AnyColumn | SQL);
     /** Whether this is a primary key */
     primaryKey?: boolean;
+    /** Whether to show in UI */
+    shown?: boolean;
     /** Display format */
     format?: string;
+    /** Additional metadata */
+    meta?: Record<string, any>;
 }
+export { Dimension }
+export { Dimension as SemanticDimension }
 
 export declare interface DimensionAnnotation {
     title: string;
@@ -286,6 +303,9 @@ export declare interface DimensionAnnotation {
 
 export declare type DimensionFormat = 'currency' | 'percent' | 'number' | 'date' | 'datetime' | 'id' | 'link';
 
+/**
+ * Dimension metadata for API responses
+ */
 export declare interface DimensionMetadata {
     name: string;
     title: string;
@@ -299,32 +319,35 @@ export declare type DimensionType = 'string' | 'number' | 'time' | 'boolean';
 
 /**
  * Drizzle column reference type
+ * Use native Drizzle AnyColumn type for better type safety
  */
-export declare type DrizzleColumn = {
-    _: {
-        name: string;
-        dataType: string;
-        columnType: string;
-    };
-};
+export declare type DrizzleColumn = AnyColumn;
 
 /**
- * Generic Drizzle database type
- * Supports any Drizzle client (PostgreSQL, MySQL, SQLite)
+ * Core database interface that supports all Drizzle instances
+ * Uses flexible typing for maximum compatibility across different database drivers
  */
-export declare type DrizzleDatabase<TSchema extends Record<string, any> = Record<string, any>> = {
+export declare interface DrizzleDatabase {
     select: (fields?: any) => any;
     insert: (table: any) => any;
     update: (table: any) => any;
     delete: (table: any) => any;
-    execute?: (query: SQL) => Promise<any>;
-    run?: (query: SQL) => any;
-    all?: (query: SQL) => any[];
-    get?: (query: SQL) => any;
-    $with: (alias: string) => any;
+    execute?: (query: SQL) => Promise<unknown[]>;
+    run?: (query: SQL) => unknown;
+    all?: (query: SQL) => unknown[];
+    get?: (query: SQL) => unknown;
+    $with: (alias: string) => {
+        as: (query: any) => any;
+    };
     with: (...args: any[]) => any;
-    schema?: TSchema;
-};
+    schema?: unknown;
+}
+
+/**
+ * Type-level utility to extract the schema type from a cube reference
+ * Since we removed generics, this now returns 'any'
+ */
+export declare type ExtractSchemaFromCubeRef = any;
 
 /**
  * Filter definitions with logical operators
@@ -347,31 +370,12 @@ export declare type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notC
  */
 export declare function getJoinType(relationship: string, override?: string): string;
 
-export declare type JoinType = 'left' | 'right' | 'inner' | 'full';
-
 /**
- * Compiled cube with executable query function
+ * Type guard to check if value is a function-based SQL expression
  */
-export declare interface LegacyCompiledCube<TSchema extends Record<string, any> = Record<string, any>> extends SemanticCube<TSchema> {
-    queryFn: (query: SemanticQuery, securityContext: SecurityContext) => Promise<QueryResult>;
-}
+export declare function isFunctionSqlExpression(expr: SqlExpression): expr is (ctx: QueryContext) => AnyColumn | SQL;
 
-/**
- * Query context passed to cube SQL functions
- * Provides access to database, schema, and security context
- */
-export declare interface LegacyQueryContext<TSchema extends Record<string, any> = Record<string, any>> {
-    /** Drizzle database instance */
-    db: DrizzleDatabase<TSchema>;
-    /** Database schema (tables, columns, etc.) */
-    schema: TSchema;
-    /** Security context for filtering */
-    securityContext: SecurityContext;
-    /** The semantic query being executed */
-    query: SemanticQuery;
-    /** The compiled cube being queried */
-    cube: LegacyCompiledCube<TSchema>;
-}
+export declare type JoinType = 'left' | 'right' | 'inner' | 'full';
 
 export declare interface LogicalFilter {
     and?: Filter[];
@@ -381,18 +385,30 @@ export declare interface LogicalFilter {
 /**
  * Measure definition
  */
-export declare interface Measure<TSchema extends Record<string, any> = Record<string, any>> {
+declare interface Measure {
     name: string;
     title?: string;
     description?: string;
     type: MeasureType;
     /** Column to aggregate or SQL expression */
-    sql: AnyColumn | SQL | ((ctx: QueryContext<TSchema>) => AnyColumn | SQL);
+    sql: AnyColumn | SQL | ((ctx: QueryContext) => AnyColumn | SQL);
     /** Display format */
     format?: string;
+    /** Whether to show in UI */
+    shown?: boolean;
     /** Filters applied to this measure */
-    filters?: Array<(ctx: QueryContext<TSchema>) => SQL>;
+    filters?: Array<(ctx: QueryContext) => SQL>;
+    /** Rolling window configuration */
+    rollingWindow?: {
+        trailing?: string;
+        leading?: string;
+        offset?: string;
+    };
+    /** Additional metadata */
+    meta?: Record<string, any>;
 }
+export { Measure }
+export { Measure as SemanticMeasure }
 
 /**
  * Annotation interfaces for UI metadata
@@ -404,11 +420,11 @@ export declare interface MeasureAnnotation {
     format?: MeasureFormat;
 }
 
-/**
- * Display formats
- */
 export declare type MeasureFormat = 'currency' | 'percent' | 'number' | 'integer';
 
+/**
+ * Measure metadata for API responses
+ */
 export declare interface MeasureMetadata {
     name: string;
     title: string;
@@ -419,27 +435,23 @@ export declare interface MeasureMetadata {
 }
 
 /**
- * Measure aggregation types
+ * Type enums and constants
  */
 export declare type MeasureType = 'count' | 'countDistinct' | 'countDistinctApprox' | 'sum' | 'avg' | 'min' | 'max' | 'runningTotal' | 'number';
 
 /**
  * Multi-cube query context for cross-cube operations
  */
-export declare interface MultiCubeQueryContext<TSchema extends Record<string, any> = Record<string, any>> extends QueryContext<TSchema> {
+export declare interface MultiCubeQueryContext extends QueryContext {
     /** Available cubes for cross-cube operations */
-    cubes: Map<string, Cube<TSchema>>;
+    cubes: Map<string, Cube>;
     /** Current cube being processed */
-    currentCube: Cube<TSchema>;
+    currentCube: Cube;
 }
 
-export declare type MultiCubeQueryPlan<TSchema extends Record<string, any> = Record<string, any>> = QueryPlan<TSchema>;
+export declare type MySQLDatabase = MySql2Database<any>;
 
-/**
- * MySQL database executor
- * Works with mysql2 driver
- */
-export declare class MySQLExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+export declare class MySQLExecutor extends BaseDatabaseExecutor {
     execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
     /**
      * Convert numeric string fields to numbers (measure fields + numeric dimensions)
@@ -453,10 +465,11 @@ export declare class MySQLExecutor<TSchema extends Record<string, any> = Record<
 }
 
 /**
- * PostgreSQL database executor
- * Works with postgres.js and Neon drivers
+ * Type helpers for specific database types
  */
-export declare class PostgresExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+export declare type PostgresDatabase = PostgresJsDatabase<any>;
+
+export declare class PostgresExecutor extends BaseDatabaseExecutor {
     execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
     /**
      * Convert numeric string fields to numbers (only for measure fields)
@@ -469,14 +482,14 @@ export declare class PostgresExecutor<TSchema extends Record<string, any> = Reco
     getEngineType(): 'postgres';
 }
 
-export declare class QueryBuilder<TSchema extends Record<string, any> = Record<string, any>> {
+export declare class QueryBuilder {
     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>;
+    buildSelections(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext): Record<string, SQL | AnyColumn>;
     /**
      * Build measure expression for HAVING clause, handling CTE references correctly
      */
@@ -484,21 +497,21 @@ export declare class QueryBuilder<TSchema extends Record<string, any> = Record<s
     /**
      * Build measure expression with aggregation and filters
      */
-    buildMeasureExpression(measure: any, context: QueryContext<TSchema>): SQL;
+    buildMeasureExpression(measure: any, context: QueryContext): SQL;
     /**
      * Build time dimension expression with granularity using database adapter
      */
-    buildTimeDimensionExpression(dimensionSql: any, granularity: string | undefined, context: QueryContext<TSchema>): SQL;
+    buildTimeDimensionExpression(dimensionSql: any, granularity: string | undefined, context: QueryContext): 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[];
+    buildWhereConditions(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext, queryPlan?: QueryPlan): 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[];
+    buildHavingConditions(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext, queryPlan?: QueryPlan): SQL[];
     /**
      * Process a single filter (basic or logical)
      * @param filterType - 'where' for dimension filters, 'having' for measure filters
@@ -527,7 +540,7 @@ export declare class QueryBuilder<TSchema extends Record<string, any> = Record<s
      * 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)[];
+    buildGroupByFields(cubes: Map<string, Cube> | Cube, query: SemanticQuery, context: QueryContext, queryPlan?: any): (SQL | AnyColumn)[];
     /**
      * Build ORDER BY clause with automatic time dimension sorting
      */
@@ -536,7 +549,7 @@ export declare class QueryBuilder<TSchema extends Record<string, any> = Record<s
      * 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[];
+    collectNumericFields(cubes: Map<string, Cube> | Cube, query: SemanticQuery): string[];
     /**
      * Apply LIMIT and OFFSET to a query with validation
      * If offset is provided without limit, add a reasonable default limit
@@ -545,31 +558,38 @@ export declare class QueryBuilder<TSchema extends Record<string, any> = Record<s
 }
 
 /**
- * Query context for dynamic building
+ * Query context passed to cube SQL functions
+ * Provides access to database, schema, and security context
  */
-export declare interface QueryContext<TSchema extends Record<string, any> = Record<string, any>> {
+declare interface QueryContext {
     /** Drizzle database instance */
-    db: DrizzleDatabase<TSchema>;
-    /** Database schema */
-    schema: TSchema;
+    db: DrizzleDatabase;
+    /** Database schema (tables, columns, etc.) */
+    schema?: any;
     /** Security context for filtering */
     securityContext: SecurityContext;
+    /** The semantic query being executed */
+    query?: SemanticQuery;
+    /** The compiled cube being queried */
+    cube?: Cube;
 }
+export { QueryContext }
+export { QueryContext as SemanticQueryContext }
 
-export declare class QueryExecutor<TSchema extends Record<string, any> = Record<string, any>> {
+export declare class QueryExecutor {
     private dbExecutor;
     private queryBuilder;
     private queryPlanner;
     private databaseAdapter;
-    constructor(dbExecutor: DatabaseExecutor<TSchema>);
+    constructor(dbExecutor: DatabaseExecutor);
     /**
      * Unified query execution method that handles both single and multi-cube queries
      */
-    execute(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    execute(cubes: Map<string, Cube>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
     /**
      * Legacy interface for single cube queries
      */
-    executeQuery(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    executeQuery(cube: Cube, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
     /**
      * Build pre-aggregation CTE for hasMany relationships
      */
@@ -589,14 +609,14 @@ export declare class QueryExecutor<TSchema extends Record<string, any> = Record<
     /**
      * Generate raw SQL for debugging (without execution) - unified approach
      */
-    generateSQL(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
+    generateSQL(cube: Cube, query: SemanticQuery, securityContext: SecurityContext): Promise<{
         sql: string;
         params?: any[];
     }>;
     /**
      * Generate raw SQL for multi-cube queries without execution - unified approach
      */
-    generateMultiCubeSQL(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
+    generateMultiCubeSQL(cubes: Map<string, Cube>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
         sql: string;
         params?: any[];
     }>;
@@ -616,12 +636,12 @@ export declare class QueryExecutor<TSchema extends Record<string, any> = Record<
  * - 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>> {
+export declare interface QueryPlan {
     /** Primary cube that drives the query */
-    primaryCube: Cube<TSchema>;
+    primaryCube: Cube;
     /** Additional cubes to join (empty for single-cube queries) */
     joinCubes: Array<{
-        cube: Cube<TSchema>;
+        cube: Cube;
         alias: string;
         joinType: 'inner' | 'left' | 'right' | 'full';
         joinCondition: SQL;
@@ -634,7 +654,7 @@ export declare interface QueryPlan<TSchema extends Record<string, any> = Record<
     groupByFields: (SQL | AnyColumn)[];
     /** Pre-aggregation CTEs for hasMany relationships to prevent fan-out */
     preAggregationCTEs?: Array<{
-        cube: Cube<TSchema>;
+        cube: Cube;
         alias: string;
         cteAlias: string;
         joinKeys: Array<{
@@ -650,7 +670,7 @@ export declare interface QueryPlan<TSchema extends Record<string, any> = Record<
 /**
  * Pre-aggregation plan for handling hasMany relationships
  */
-export declare class QueryPlanner<TSchema extends Record<string, any> = Record<string, any>> {
+export declare class QueryPlanner {
     /**
      * Analyze a semantic query to determine which cubes are involved
      */
@@ -670,12 +690,12 @@ export declare class QueryPlanner<TSchema extends Record<string, any> = Record<s
     /**
      * Create a unified query plan that works for both single and multi-cube queries
      */
-    createQueryPlan(cubes: Map<string, Cube<TSchema>>, query: SemanticQuery, ctx: QueryContext<TSchema>): QueryPlan<TSchema>;
+    createQueryPlan(cubes: Map<string, Cube>, query: SemanticQuery, _ctx: QueryContext): QueryPlan;
     /**
      * Choose the primary cube based on query analysis
      * Uses a consistent strategy to avoid measure order dependencies
      */
-    choosePrimaryCube(cubeNames: string[], query: SemanticQuery, cubes?: Map<string, Cube<TSchema>>): string;
+    choosePrimaryCube(cubeNames: string[], query: SemanticQuery, cubes?: Map<string, Cube>): string;
     /**
      * Check if a cube can reach all other cubes in the list via joins
      */
@@ -708,11 +728,11 @@ export declare class QueryPlanner<TSchema extends Record<string, any> = Record<s
  * Query execution result
  */
 export declare interface QueryResult {
-    data: any[];
+    data: Record<string, unknown>[];
     annotation: {
         measures: Record<string, MeasureAnnotation>;
         dimensions: Record<string, DimensionAnnotation>;
-        segments: Record<string, any>;
+        segments: Record<string, unknown>;
         timeDimensions: Record<string, TimeDimensionAnnotation>;
     };
 }
@@ -720,103 +740,39 @@ 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>;
+export declare function resolveCubeReference(ref: Cube | (() => Cube)): Cube;
 
 /**
  * Helper to resolve SQL expressions
  */
-export declare function resolveSqlExpression<TSchema extends Record<string, any>>(expr: AnyColumn | SQL | ((ctx: QueryContext<TSchema>) => AnyColumn | SQL), ctx: QueryContext<TSchema>): AnyColumn | SQL;
+export declare function resolveSqlExpression(expr: AnyColumn | SQL | ((ctx: QueryContext) => AnyColumn | SQL), ctx: QueryContext): AnyColumn | SQL;
 
 /**
  * Security context passed to cube SQL functions
  * Contains user/tenant-specific data for filtering
  */
 export declare interface SecurityContext {
-    [key: string]: any;
+    [key: string]: unknown;
 }
 
-/**
- * Semantic cube definition with Drizzle integration
- */
-export declare interface SemanticCube<TSchema extends Record<string, any> = Record<string, any>> {
-    name: string;
-    title?: string;
-    description?: string;
-    /** Base SQL for the cube - can use Drizzle query builder */
-    sql: string | SQL | ((context: LegacyQueryContext<TSchema>) => SQL | Promise<SQL>);
-    /** Cube dimensions */
-    dimensions: Record<string, SemanticDimension<TSchema>>;
-    /** Cube measures */
-    measures: Record<string, SemanticMeasure<TSchema>>;
-    /** Joins to other cubes */
-    joins?: Record<string, SemanticJoin<TSchema>>;
-    /** Whether cube is publicly accessible */
-    public?: boolean;
-    /** SQL alias for the cube */
-    sqlAlias?: string;
-    /** Data source identifier */
-    dataSource?: string;
-    /** Refresh configuration */
-    refreshKey?: {
-        every?: string;
-        sql?: string | SQL;
-    };
-    /** Pre-aggregation definitions */
-    preAggregations?: Record<string, SemanticPreAggregation>;
-    /** Additional metadata */
-    meta?: Record<string, any>;
-}
+export declare const semanticLayer: SemanticLayerCompiler;
 
-/**
- * Semantic dimension with Drizzle column support
- */
-export declare interface SemanticDimension<TSchema extends Record<string, any> = Record<string, any>> {
-    name: string;
-    title?: string;
-    description?: string;
-    type: DimensionType;
-    /** SQL expression - can be Drizzle column reference or SQL template */
-    sql: string | SQL | DrizzleColumn | ((context: LegacyQueryContext<TSchema>) => SQL | DrizzleColumn);
-    /** Whether this is a primary key */
-    primaryKey?: boolean;
-    /** Whether to show in UI */
-    shown?: boolean;
-    /** Display format */
-    format?: DimensionFormat;
-    /** Additional metadata */
-    meta?: Record<string, any>;
-}
-
-/**
- * Join definition between cubes
- */
-export declare interface SemanticJoin<TSchema extends Record<string, any> = Record<string, any>> {
-    name?: string;
-    type?: JoinType;
-    /** Join condition using Drizzle SQL */
-    sql: string | SQL | ((context: LegacyQueryContext<TSchema>) => SQL);
-    /** Relationship type */
-    relationship: 'belongsTo' | 'hasOne' | 'hasMany';
-}
-
-export declare const semanticLayer: SemanticLayerCompiler<Record<string, any>>;
-
-export declare class SemanticLayerCompiler<TSchema extends Record<string, any> = Record<string, any>> {
+export declare class SemanticLayerCompiler {
     private cubes;
     private dbExecutor?;
     private metadataCache?;
     private metadataCacheTimestamp?;
     private readonly METADATA_CACHE_TTL;
     constructor(options?: {
-        drizzle?: DatabaseExecutor<TSchema>['db'];
-        schema?: TSchema;
-        databaseExecutor?: DatabaseExecutor<TSchema>;
+        drizzle?: DatabaseExecutor['db'];
+        schema?: any;
+        databaseExecutor?: DatabaseExecutor;
         engineType?: 'postgres' | 'mysql' | 'sqlite';
     });
     /**
      * Set or update the database executor
      */
-    setDatabaseExecutor(executor: DatabaseExecutor<TSchema>): void;
+    setDatabaseExecutor(executor: DatabaseExecutor): void;
     /**
      * Get the database engine type for SQL formatting
      */
@@ -824,7 +780,7 @@ export declare class SemanticLayerCompiler<TSchema extends Record<string, any> =
     /**
      * Set Drizzle instance and schema directly
      */
-    setDrizzle(db: DatabaseExecutor<TSchema>['db'], schema?: TSchema, engineType?: 'postgres' | 'mysql' | 'sqlite'): void;
+    setDrizzle(db: DatabaseExecutor['db'], schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite'): void;
     /**
      * Check if database executor is configured
      */
@@ -832,19 +788,19 @@ export declare class SemanticLayerCompiler<TSchema extends Record<string, any> =
     /**
      * Register a simplified cube with dynamic query building
      */
-    registerCube(cube: Cube<TSchema>): void;
+    registerCube(cube: Cube): void;
     /**
      * Get a cube by name
      */
-    getCube(name: string): Cube<TSchema> | undefined;
+    getCube(name: string): Cube | undefined;
     /**
      * Get all registered cubes
      */
-    getAllCubes(): Cube<TSchema>[];
+    getAllCubes(): Cube[];
     /**
      * Get all cubes as a Map for multi-cube queries
      */
-    getAllCubesMap(): Map<string, Cube<TSchema>>;
+    getAllCubesMap(): Map<string, Cube>;
     /**
      * Unified query execution method that handles both single and multi-cube queries
      */
@@ -1180,34 +1136,6 @@ export declare const SemanticLayerUtils: {
     };
 };
 
-/**
- * Semantic measure with Drizzle aggregation support
- */
-export declare interface SemanticMeasure<TSchema extends Record<string, any> = Record<string, any>> {
-    name: string;
-    title?: string;
-    description?: string;
-    type: MeasureType;
-    /** SQL expression - can be Drizzle column or aggregation function */
-    sql: string | SQL | DrizzleColumn | ((context: LegacyQueryContext<TSchema>) => SQL | DrizzleColumn);
-    /** Display format */
-    format?: MeasureFormat;
-    /** Whether to show in UI */
-    shown?: boolean;
-    /** Filters applied to this measure */
-    filters?: Array<{
-        sql: string | SQL | ((context: LegacyQueryContext<TSchema>) => SQL);
-    }>;
-    /** Rolling window configuration */
-    rollingWindow?: {
-        trailing?: string;
-        leading?: string;
-        offset?: string;
-    };
-    /** Additional metadata */
-    meta?: Record<string, any>;
-}
-
 /**
  * Pre-aggregation configuration
  */
@@ -1221,7 +1149,7 @@ export declare interface SemanticPreAggregation {
     };
     refreshKey?: {
         every: string;
-        sql?: string | SQL;
+        sql?: string;
     };
     indexes?: Record<string, string[]>;
 }
@@ -1242,10 +1170,13 @@ export declare interface SemanticQuery {
 export { SQL }
 
 /**
- * SQLite database executor
- * Works with better-sqlite3 driver
+ * Type for SQL expressions that can be functions or direct values
  */
-export declare class SQLiteExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+export declare type SqlExpression = AnyColumn | SQL | ((ctx: QueryContext) => AnyColumn | SQL);
+
+export declare type SQLiteDatabase = BetterSQLite3Database<any>;
+
+export declare class SQLiteExecutor extends BaseDatabaseExecutor {
     execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
     /**
      * Convert numeric string fields to numbers (only for measure fields)
@@ -1263,7 +1194,7 @@ export declare class SQLiteExecutor<TSchema extends Record<string, any> = Record
  */
 export declare interface SqlResult {
     sql: string;
-    params?: any[];
+    params?: unknown[];
 }
 
 /**