drizzle-cube 0.1.0 → 0.1.1

package/dist/server/index.d.ts

@@ -1,13 +1,146 @@
-export declare interface CompiledCube extends SemanticCube {
-    queryFn: (query: SemanticQuery, context: SecurityContext) => Promise<QueryResult>;
+import { AnyColumn } from 'drizzle-orm';
+import { Many } from 'drizzle-orm';
+import { One } from 'drizzle-orm';
+import { PgColumn } from 'drizzle-orm/pg-core';
+import { PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { Relations } from 'drizzle-orm';
+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;
+    constructor(db: DrizzleDatabase<TSchema>, schema?: TSchema | undefined);
+    abstract execute<T = any[]>(query: SQL | any): Promise<T>;
+    abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite';
 }
 
 /**
- * Create a new semantic layer instance
+ * Base query definition that can be extended dynamically
+ * Returns just the FROM/JOIN/WHERE setup, not a complete SELECT
+ */
+export declare interface BaseQueryDefinition {
+    /** Main table to query from */
+    from: any;
+    /** Optional joins to other tables */
+    joins?: Array<{
+        table: any;
+        on: SQL;
+        type?: 'left' | 'right' | 'inner' | 'full';
+    }>;
+    /** Base WHERE conditions (typically security context filtering) */
+    where?: SQL;
+}
+
+/**
+ * Compiled cube with execution function
+ */
+export declare interface CompiledCube<TSchema extends Record<string, any> = Record<string, any>> extends Cube<TSchema> {
+    /** Execute a query against this cube */
+    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
+ * @param schema - Optional schema for type inference
+ * @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>;
+
+/**
+ * Create a new semantic layer instance with Drizzle integration
  * Use this when you need multiple isolated instances
  */
-export declare function createSemanticLayer(dbExecutor?: DatabaseExecutor): SemanticLayerCompiler;
+export declare function createDrizzleSemanticLayer<TSchema extends Record<string, any>>(options: {
+    drizzle: DrizzleDatabase<TSchema>;
+    schema?: TSchema;
+}): SemanticLayerCompiler<TSchema>;
+
+/**
+ * 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 createMySQLExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): MySQLExecutor<TSchema>;
+
+/**
+ * Factory functions for creating database executors
+ */
+export declare function createPostgresExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): PostgresExecutor<TSchema>;
+
+/**
+ * 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>;
+    engineType?: 'postgres' | 'mysql' | 'sqlite';
+}): SemanticLayerCompiler<TSchema>;
+
+export declare function createSQLiteExecutor<TSchema extends Record<string, any>>(db: DrizzleDatabase<TSchema>, schema?: TSchema): SQLiteExecutor<TSchema>;
+
+/**
+ * Cube definition focused on dynamic query building
+ */
+export declare interface Cube<TSchema extends Record<string, any> = Record<string, any>> {
+    name: string;
+    title?: string;
+    description?: string;
+    /**
+     * 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;
+    /** Cube dimensions using direct column references */
+    dimensions: Record<string, Dimension<TSchema>>;
+    /** Cube measures using direct column references */
+    measures: Record<string, Measure<TSchema>>;
+}
+
+/**
+ * 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> & {
+        name: TName;
+    };
+}
+
+/**
+ * Utility type for cube definition with schema inference
+ */
+export declare type CubeDefinition<TSchema extends Record<string, any>> = Omit<SemanticCube<TSchema>, 'name'> & {
+    name?: string;
+};
+
+/**
+ * Cube join definition for multi-cube queries
+ */
+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 */
+    relationship: 'belongsTo' | 'hasOne' | 'hasMany';
+}
 
+/**
+ * Cube metadata for API responses
+ */
 export declare interface CubeMetadata {
     name: string;
     title: string;
@@ -17,17 +150,180 @@ export declare interface CubeMetadata {
     segments: any[];
 }
 
-export declare interface DatabaseExecutor {
-    execute(sql: string, params?: any[]): Promise<any[]>;
+/**
+ * Enhanced Cube with join definitions for multi-cube support
+ */
+export declare interface CubeWithJoins<TSchema extends Record<string, any> = Record<string, any>> extends Cube<TSchema> {
+    /** Joins to other cubes for multi-cube queries */
+    joins?: Record<string, CubeJoin<TSchema>>;
+}
+
+/**
+ * Database executor 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>> {
+    /** The Drizzle database instance */
+    db: DrizzleDatabase<TSchema>;
+    /** Optional schema for type inference */
+    schema?: TSchema;
+    /** Execute a Drizzle SQL query or query object */
+    execute<T = any[]>(query: SQL | any): Promise<T>;
+    /** Get the database engine type */
+    getEngineType(): 'postgres' | 'mysql' | 'sqlite';
 }
 
 /**
  * Main semantic layer instance
  * Use this for simple single-instance usage
  */
-export declare const defaultSemanticLayer: SemanticLayerCompiler;
+export declare const defaultSemanticLayer: SemanticLayerCompiler<Record<string, any>>;
+
+/**
+ * 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 const departments: PgTableWithColumns<    {
+name: "departments";
+schema: undefined;
+columns: {
+id: PgColumn<    {
+name: "id";
+tableName: "departments";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: true;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+name: PgColumn<    {
+name: "name";
+tableName: "departments";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+description: PgColumn<    {
+name: "description";
+tableName: "departments";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+organisation: PgColumn<    {
+name: "organisation";
+tableName: "departments";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+createdAt: PgColumn<    {
+name: "created_at";
+tableName: "departments";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+updatedAt: PgColumn<    {
+name: "updated_at";
+tableName: "departments";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+};
+dialect: "pg";
+}>;
 
-export declare const departmentsCube: SemanticCube;
+export declare const departmentsRelations: Relations<"departments", {
+organisation: One<"organisations", true>;
+employees: Many<"employees">;
+}>;
+
+/**
+ * Dimension definition
+ */
+export declare interface Dimension<TSchema extends Record<string, any> = Record<string, any>> {
+    name: string;
+    title?: string;
+    description?: string;
+    type: DimensionType;
+    /** Direct column reference or SQL expression */
+    sql: AnyColumn | SQL | ((ctx: QueryContext<TSchema>) => AnyColumn | SQL);
+    /** Whether this is a primary key */
+    primaryKey?: boolean;
+    /** Display format */
+    format?: string;
+}
 
 export declare interface DimensionAnnotation {
     title: string;
@@ -36,7 +332,7 @@ export declare interface DimensionAnnotation {
     format?: DimensionFormat;
 }
 
-export declare type DimensionFormat = 'currency' | 'percent' | 'number' | 'date' | 'datetime';
+export declare type DimensionFormat = 'currency' | 'percent' | 'number' | 'date' | 'datetime' | 'id' | 'link';
 
 export declare interface DimensionMetadata {
     name: string;
@@ -47,18 +343,892 @@ export declare interface DimensionMetadata {
     description?: string;
 }
 
-export declare const employeeDepartmentsCube: SemanticCube;
+export declare type DimensionType = 'string' | 'number' | 'time' | 'boolean';
+
+/**
+ * Drizzle column reference type
+ */
+export declare type DrizzleColumn = {
+    _: {
+        name: string;
+        dataType: string;
+        columnType: string;
+    };
+};
 
 /**
- * Example cube definitions for documentation and testing
- * These show the basic patterns for defining cubes
+ * Generic Drizzle database type
+ * Supports any Drizzle client (PostgreSQL, MySQL, SQLite)
  */
-export declare const employeesCube: SemanticCube;
+export declare type DrizzleDatabase<TSchema extends Record<string, any> = Record<string, any>> = {
+    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;
+    with: (...args: any[]) => any;
+    schema?: TSchema;
+};
+
+export declare const employees: PgTableWithColumns<    {
+name: "employees";
+schema: undefined;
+columns: {
+id: PgColumn<    {
+name: "id";
+tableName: "employees";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: true;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+name: PgColumn<    {
+name: "name";
+tableName: "employees";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+email: PgColumn<    {
+name: "email";
+tableName: "employees";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+active: PgColumn<    {
+name: "active";
+tableName: "employees";
+dataType: "boolean";
+columnType: "PgBoolean";
+data: boolean;
+driverParam: boolean;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+fteBasis: PgColumn<    {
+name: "fte_basis";
+tableName: "employees";
+dataType: "string";
+columnType: "PgNumeric";
+data: string;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+startDate: PgColumn<    {
+name: "start_date";
+tableName: "employees";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+endDate: PgColumn<    {
+name: "end_date";
+tableName: "employees";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+department: PgColumn<    {
+name: "department";
+tableName: "employees";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+supplier: PgColumn<    {
+name: "supplier";
+tableName: "employees";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+organisation: PgColumn<    {
+name: "organisation";
+tableName: "employees";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+createdAt: PgColumn<    {
+name: "created_at";
+tableName: "employees";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+updatedAt: PgColumn<    {
+name: "updated_at";
+tableName: "employees";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+};
+dialect: "pg";
+}>;
+
+export declare const employeesRelations: Relations<"employees", {
+organisation: One<"organisations", true>;
+department: One<"departments", false>;
+supplier: One<"suppliers", false>;
+}>;
+
+export declare type ExampleSchema = typeof exampleSchema;
+
+export declare const exampleSchema: {
+    organisations: PgTableWithColumns<    {
+    name: "organisations";
+    schema: undefined;
+    columns: {
+    id: PgColumn<    {
+    name: "id";
+    tableName: "organisations";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    name: PgColumn<    {
+    name: "name";
+    tableName: "organisations";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    description: PgColumn<    {
+    name: "description";
+    tableName: "organisations";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    createdAt: PgColumn<    {
+    name: "created_at";
+    tableName: "organisations";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    updatedAt: PgColumn<    {
+    name: "updated_at";
+    tableName: "organisations";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    };
+    dialect: "pg";
+    }>;
+    departments: PgTableWithColumns<    {
+    name: "departments";
+    schema: undefined;
+    columns: {
+    id: PgColumn<    {
+    name: "id";
+    tableName: "departments";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    name: PgColumn<    {
+    name: "name";
+    tableName: "departments";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    description: PgColumn<    {
+    name: "description";
+    tableName: "departments";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    organisation: PgColumn<    {
+    name: "organisation";
+    tableName: "departments";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    createdAt: PgColumn<    {
+    name: "created_at";
+    tableName: "departments";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    updatedAt: PgColumn<    {
+    name: "updated_at";
+    tableName: "departments";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    };
+    dialect: "pg";
+    }>;
+    suppliers: PgTableWithColumns<    {
+    name: "suppliers";
+    schema: undefined;
+    columns: {
+    id: PgColumn<    {
+    name: "id";
+    tableName: "suppliers";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    name: PgColumn<    {
+    name: "name";
+    tableName: "suppliers";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    description: PgColumn<    {
+    name: "description";
+    tableName: "suppliers";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    internal: PgColumn<    {
+    name: "internal";
+    tableName: "suppliers";
+    dataType: "boolean";
+    columnType: "PgBoolean";
+    data: boolean;
+    driverParam: boolean;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    organisation: PgColumn<    {
+    name: "organisation";
+    tableName: "suppliers";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    createdAt: PgColumn<    {
+    name: "created_at";
+    tableName: "suppliers";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    updatedAt: PgColumn<    {
+    name: "updated_at";
+    tableName: "suppliers";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    };
+    dialect: "pg";
+    }>;
+    employees: PgTableWithColumns<    {
+    name: "employees";
+    schema: undefined;
+    columns: {
+    id: PgColumn<    {
+    name: "id";
+    tableName: "employees";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: true;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    name: PgColumn<    {
+    name: "name";
+    tableName: "employees";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    email: PgColumn<    {
+    name: "email";
+    tableName: "employees";
+    dataType: "string";
+    columnType: "PgText";
+    data: string;
+    driverParam: string;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: [string, ...string[]];
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    active: PgColumn<    {
+    name: "active";
+    tableName: "employees";
+    dataType: "boolean";
+    columnType: "PgBoolean";
+    data: boolean;
+    driverParam: boolean;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    fteBasis: PgColumn<    {
+    name: "fte_basis";
+    tableName: "employees";
+    dataType: "string";
+    columnType: "PgNumeric";
+    data: string;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    startDate: PgColumn<    {
+    name: "start_date";
+    tableName: "employees";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    endDate: PgColumn<    {
+    name: "end_date";
+    tableName: "employees";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    department: PgColumn<    {
+    name: "department";
+    tableName: "employees";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    supplier: PgColumn<    {
+    name: "supplier";
+    tableName: "employees";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: false;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    organisation: PgColumn<    {
+    name: "organisation";
+    tableName: "employees";
+    dataType: "number";
+    columnType: "PgInteger";
+    data: number;
+    driverParam: string | number;
+    notNull: true;
+    hasDefault: false;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    createdAt: PgColumn<    {
+    name: "created_at";
+    tableName: "employees";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    updatedAt: PgColumn<    {
+    name: "updated_at";
+    tableName: "employees";
+    dataType: "date";
+    columnType: "PgTimestamp";
+    data: Date;
+    driverParam: string;
+    notNull: false;
+    hasDefault: true;
+    isPrimaryKey: false;
+    isAutoincrement: false;
+    hasRuntimeDefault: false;
+    enumValues: undefined;
+    baseColumn: never;
+    identity: undefined;
+    generated: undefined;
+    }, {}, {}>;
+    };
+    dialect: "pg";
+    }>;
+    organisationsRelations: Relations<"organisations", {
+    departments: Many<"departments">;
+    suppliers: Many<"suppliers">;
+    employees: Many<"employees">;
+    }>;
+    departmentsRelations: Relations<"departments", {
+    organisation: One<"organisations", true>;
+    employees: Many<"employees">;
+    }>;
+    suppliersRelations: Relations<"suppliers", {
+    organisation: One<"organisations", true>;
+    employees: Many<"employees">;
+    }>;
+    employeesRelations: Relations<"employees", {
+    organisation: One<"organisations", true>;
+    department: One<"departments", false>;
+    supplier: One<"suppliers", false>;
+    }>;
+};
 
-export declare const exampleCubes: SemanticCube[];
+/**
+ * Filter definitions with logical operators
+ */
+export declare type Filter = FilterCondition | LogicalFilter;
 
+export declare interface FilterCondition {
+    member: string;
+    operator: FilterOperator;
+    values: any[];
+}
+
+/**
+ * Supported filter operators
+ */
 export declare type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'set' | 'notSet' | 'inDateRange' | 'beforeDate' | 'afterDate';
 
+export declare type JoinType = 'left' | 'right' | 'inner' | 'full';
+
+/**
+ * Compiled cube with executable query function
+ */
+export declare interface LegacyCompiledCube<TSchema extends Record<string, any> = Record<string, any>> extends SemanticCube<TSchema> {
+    queryFn: (query: SemanticQuery, securityContext: SecurityContext) => Promise<QueryResult>;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * 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[];
+}
+
+/**
+ * Measure definition
+ */
+export declare interface Measure<TSchema extends Record<string, any> = Record<string, any>> {
+    name: string;
+    title?: string;
+    description?: string;
+    type: MeasureType;
+    /** Column to aggregate or SQL expression */
+    sql: AnyColumn | SQL | ((ctx: QueryContext<TSchema>) => AnyColumn | SQL);
+    /** Display format */
+    format?: string;
+    /** Filters applied to this measure */
+    filters?: Array<(ctx: QueryContext<TSchema>) => SQL>;
+}
+
+/**
+ * Annotation interfaces for UI metadata
+ */
 export declare interface MeasureAnnotation {
     title: string;
     shortTitle: string;
@@ -66,6 +1236,9 @@ export declare interface MeasureAnnotation {
     format?: MeasureFormat;
 }
 
+/**
+ * Display formats
+ */
 export declare type MeasureFormat = 'currency' | 'percent' | 'number' | 'integer';
 
 export declare interface MeasureMetadata {
@@ -77,17 +1250,307 @@ export declare interface MeasureMetadata {
     description?: string;
 }
 
+/**
+ * Measure aggregation types
+ */
 export declare type MeasureType = 'count' | 'countDistinct' | 'countDistinctApprox' | 'sum' | 'avg' | 'min' | 'max' | 'runningTotal' | 'number';
 
-export declare interface QueryContext {
+export declare class MultiCubeBuilder<TSchema extends Record<string, any> = Record<string, any>> {
+    /**
+     * 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, CubeWithJoins<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;
+    /**
+     * Filter condition builder (would reuse logic from DrizzleExecutor)
+     */
+    private buildFilterCondition;
+    /**
+     * Build GROUP BY fields for multi-cube query
+     */
+    private buildMultiCubeGroupByFields;
+}
+
+/**
+ * Multi-cube query context for cross-cube operations
+ */
+export declare interface MultiCubeQueryContext<TSchema extends Record<string, any> = Record<string, any>> extends QueryContext<TSchema> {
+    /** Available cubes for cross-cube operations */
+    cubes: Map<string, Cube<TSchema>>;
+    /** Current cube being processed */
+    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)[];
+}
+
+/**
+ * MySQL database executor
+ * Works with mysql2 driver
+ */
+export declare class MySQLExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+    execute<T = any[]>(query: SQL | any): Promise<T>;
+    getEngineType(): 'mysql';
+}
+
+/**
+ * Example schema for demonstrating Drizzle cube definitions
+ * This shows how to define cubes using actual Drizzle schema
+ */
+export declare const organisations: PgTableWithColumns<    {
+name: "organisations";
+schema: undefined;
+columns: {
+id: PgColumn<    {
+name: "id";
+tableName: "organisations";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: true;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+name: PgColumn<    {
+name: "name";
+tableName: "organisations";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+description: PgColumn<    {
+name: "description";
+tableName: "organisations";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+createdAt: PgColumn<    {
+name: "created_at";
+tableName: "organisations";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+updatedAt: PgColumn<    {
+name: "updated_at";
+tableName: "organisations";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+};
+dialect: "pg";
+}>;
+
+export declare const organisationsRelations: Relations<"organisations", {
+departments: Many<"departments">;
+suppliers: Many<"suppliers">;
+employees: Many<"employees">;
+}>;
+
+/**
+ * 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
+ */
+export declare class PostgresExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+    execute<T = any[]>(query: SQL | any): Promise<T>;
+    /**
+     * Convert numeric string fields to numbers
+     */
+    private convertNumericFields;
+    getEngineType(): 'postgres';
+}
+
+/**
+ * Query context for dynamic building
+ */
+export declare interface QueryContext<TSchema extends Record<string, any> = Record<string, any>> {
+    /** Drizzle database instance */
+    db: DrizzleDatabase<TSchema>;
+    /** Database schema */
+    schema: TSchema;
+    /** Security context for filtering */
     securityContext: SecurityContext;
-    cube: CompiledCube;
-    query: SemanticQuery;
-    table: {
-        [column: string]: string;
-    };
 }
 
+export declare class QueryExecutor<TSchema extends Record<string, any> = Record<string, any>> {
+    private dbExecutor;
+    private multiCubeBuilder;
+    constructor(dbExecutor: DatabaseExecutor<TSchema>);
+    /**
+     * Unified query execution method that handles both single and multi-cube queries
+     */
+    execute(cubes: Map<string, CubeWithJoins<TSchema>>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    /**
+     * Legacy interface for single cube queries
+     */
+    executeQuery(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    /**
+     * Execute a single cube query
+     */
+    private executeSingleCube;
+    /**
+     * Execute a Cube query (dynamic query building)
+     */
+    private executeCube;
+    /**
+     * Execute multi-cube query using JOIN resolution
+     */
+    private executeMultiCube;
+    /**
+     * Generate raw SQL for debugging (without execution)
+     */
+    generateSQL(cube: Cube<TSchema>, query: SemanticQuery, securityContext: SecurityContext): Promise<{
+        sql: string;
+        params?: any[];
+    }>;
+    /**
+     * Generate SQL for Cube
+     */
+    private generateCubeSQL;
+    /**
+     * Build dynamic selections for Cube measures and dimensions
+     */
+    private buildSelections;
+    /**
+     * Build measure expression with aggregation and filters for Cube
+     */
+    private buildMeasureExpression;
+    /**
+     * Build time dimension expression with granularity
+     */
+    private buildTimeDimensionExpression;
+    /**
+     * Build WHERE conditions from semantic query filters (Cube)
+     */
+    private buildWhereConditions;
+    /**
+     * Process a single filter for Cube (basic or logical)
+     */
+    private processFilter;
+    /**
+     * Build filter condition using Drizzle operators
+     */
+    private buildFilterCondition;
+    /**
+     * Build GROUP BY fields from dimensions and time dimensions (Cube)
+     */
+    private buildGroupByFields;
+    /**
+     * Build ORDER BY clause
+     */
+    private buildOrderBy;
+    /**
+     * Generate annotations for UI metadata
+     */
+    private generateAnnotations;
+    /**
+     * Generate annotations for multi-cube queries
+     */
+    private generateMultiCubeAnnotations;
+}
+
+/**
+ * Query execution result
+ */
 export declare interface QueryResult {
     data: any[];
     annotation: {
@@ -99,55 +1562,169 @@ export declare interface QueryResult {
 }
 
 /**
- * Core types for Drizzle Cube semantic layer
- * Framework-agnostic definitions
+ * 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;
+
+/**
+ * Security context passed to cube SQL functions
+ * Contains user/tenant-specific data for filtering
  */
 export declare interface SecurityContext {
     [key: string]: any;
 }
 
-export declare interface SemanticCube {
+/**
+ * Semantic cube definition with Drizzle integration
+ */
+export declare interface SemanticCube<TSchema extends Record<string, any> = Record<string, any>> {
     name: string;
     title?: string;
     description?: string;
-    sql: string | ((context: QueryContext) => SQL | string);
-    dimensions: Record<string, SemanticDimension>;
-    measures: Record<string, SemanticMeasure>;
-    joins?: Record<string, SemanticJoin>;
+    /** 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 interface SemanticDimension {
+/**
+ * Create a YAML cube definition from a SemanticCube (for export/migration)
+ */
+export declare function semanticCubeToYaml(cube: SemanticCube): string;
+
+/**
+ * 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: 'string' | 'number' | 'time' | 'boolean';
-    sql: string | ((context: QueryContext) => SQL | 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>;
 }
 
-export declare interface SemanticJoin {
-    sql: string;
+/**
+ * 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;
+export declare const semanticLayer: SemanticLayerCompiler<Record<string, any>>;
 
-export declare class SemanticLayerCompiler {
+export declare class SemanticLayerCompiler<TSchema extends Record<string, any> = Record<string, any>> {
     private cubes;
     private dbExecutor?;
-    constructor(dbExecutor?: DatabaseExecutor);
-    setDatabaseExecutor(executor: DatabaseExecutor): void;
-    registerCube(cube: SemanticCube): void;
-    getCube(name: string): CompiledCube | undefined;
-    getAllCubes(): CompiledCube[];
+    constructor(options?: {
+        drizzle?: DatabaseExecutor<TSchema>['db'];
+        schema?: TSchema;
+        databaseExecutor?: DatabaseExecutor<TSchema>;
+        engineType?: 'postgres' | 'mysql' | 'sqlite';
+    });
+    /**
+     * Set or update the database executor
+     */
+    setDatabaseExecutor(executor: DatabaseExecutor<TSchema>): void;
+    /**
+     * Set Drizzle instance and schema directly
+     */
+    setDrizzle(db: DatabaseExecutor<TSchema>['db'], schema?: TSchema, engineType?: 'postgres' | 'mysql' | 'sqlite'): void;
+    /**
+     * Check if database executor is configured
+     */
+    hasExecutor(): boolean;
+    /**
+     * Register a simplified cube with dynamic query building
+     */
+    registerCube(cube: CubeWithJoins<TSchema>): void;
+    /**
+     * Get a cube by name
+     */
+    getCube(name: string): CubeWithJoins<TSchema> | undefined;
+    /**
+     * Get all registered cubes
+     */
+    getAllCubes(): CubeWithJoins<TSchema>[];
+    /**
+     * Get all cubes as a Map for multi-cube queries
+     */
+    getAllCubesMap(): Map<string, CubeWithJoins<TSchema>>;
+    /**
+     * Unified query execution method that handles both single and multi-cube queries
+     */
+    execute(query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    /**
+     * Execute a multi-cube query
+     */
+    executeMultiCubeQuery(query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    /**
+     * Execute a single cube query
+     */
+    executeQuery(cubeName: string, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
+    /**
+     * Get metadata for all cubes (for API responses)
+     */
     getMetadata(): CubeMetadata[];
-    private validateCube;
-    private compileCube;
+    /**
+     * Generate cube metadata for API responses from cubes
+     */
     private generateCubeMetadata;
+    /**
+     * Get SQL for a query without executing it (debugging)
+     */
+    generateSQL(cubeName: string, query: SemanticQuery, securityContext: SecurityContext): Promise<{
+        sql: string;
+        params?: any[];
+    }>;
+    /**
+     * Check if a cube exists
+     */
+    hasCube(name: string): boolean;
+    /**
+     * Remove a cube
+     */
+    removeCube(name: string): boolean;
+    /**
+     * Clear all cubes
+     */
+    clearCubes(): void;
+    /**
+     * Get cube names
+     */
+    getCubeNames(): string[];
 }
 
 /**
@@ -157,7 +1734,7 @@ export declare const SemanticLayerUtils: {
     /**
      * Create a simple query builder
      */
-    query: (_cubeName: string) => {
+    query: () => {
         measures: (measures: string[]) => {
             dimensions: (dimensions?: string[]) => {
                 filters: (filters?: any[]) => {
@@ -418,71 +1995,225 @@ export declare const SemanticLayerUtils: {
     };
 };
 
-export declare interface SemanticMeasure {
+/**
+ * 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: string | ((context: QueryContext) => SQL | string);
+    /** 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: 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
+ */
+export declare interface SemanticPreAggregation {
+    name: string;
+    measures: string[];
+    dimensions: string[];
+    timeDimension?: {
+        dimension: string;
+        granularity: TimeGranularity[];
+    };
+    refreshKey?: {
+        every: string;
+        sql?: string | SQL;
+    };
+    indexes?: Record<string, string[]>;
+}
+
+/**
+ * Semantic query structure (Cube.js compatible)
+ */
 export declare interface SemanticQuery {
     measures?: string[];
     dimensions?: string[];
-    filters?: Array<{
-        member: string;
-        operator: FilterOperator;
-        values: any[];
-    }>;
-    timeDimensions?: Array<{
-        dimension: string;
-        granularity?: TimeGranularity;
-        dateRange?: string | string[];
-    }>;
+    filters?: Array<Filter>;
+    timeDimensions?: Array<TimeDimension>;
     limit?: number;
     offset?: number;
     order?: Record<string, 'asc' | 'desc'>;
 }
 
-export declare class SemanticQueryExecutor {
-    private dbExecutor;
-    constructor(dbExecutor: DatabaseExecutor);
-    executeQuery(cube: SemanticCube, query: SemanticQuery, securityContext: SecurityContext): Promise<QueryResult>;
-    generateSQL(cube: SemanticCube, query: SemanticQuery, securityContext: SecurityContext): {
-        sql: string;
-        params?: any[];
-    };
-    private substituteSecurityVariables;
-    private buildSelectClause;
-    private buildMeasureSQL;
-    private buildWhereClause;
-    private buildFilterCondition;
-    private buildGroupByClause;
-    private buildOrderByClause;
-    private buildLimitClause;
-    private generateAnnotations;
-}
+export { SQL }
 
-export declare interface SQL {
-    sql: string;
-    params?: any[];
+/**
+ * SQLite database executor
+ * Works with better-sqlite3 driver
+ */
+export declare class SQLiteExecutor<TSchema extends Record<string, any> = Record<string, any>> extends BaseDatabaseExecutor<TSchema> {
+    execute<T = any[]>(query: SQL | any): Promise<T>;
+    getEngineType(): 'sqlite';
 }
 
+/**
+ * SQL generation result
+ */
 export declare interface SqlResult {
     sql: string;
     params?: any[];
 }
 
+export declare const suppliers: PgTableWithColumns<    {
+name: "suppliers";
+schema: undefined;
+columns: {
+id: PgColumn<    {
+name: "id";
+tableName: "suppliers";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: true;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+name: PgColumn<    {
+name: "name";
+tableName: "suppliers";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+description: PgColumn<    {
+name: "description";
+tableName: "suppliers";
+dataType: "string";
+columnType: "PgText";
+data: string;
+driverParam: string;
+notNull: false;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: [string, ...string[]];
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+internal: PgColumn<    {
+name: "internal";
+tableName: "suppliers";
+dataType: "boolean";
+columnType: "PgBoolean";
+data: boolean;
+driverParam: boolean;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+organisation: PgColumn<    {
+name: "organisation";
+tableName: "suppliers";
+dataType: "number";
+columnType: "PgInteger";
+data: number;
+driverParam: string | number;
+notNull: true;
+hasDefault: false;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+createdAt: PgColumn<    {
+name: "created_at";
+tableName: "suppliers";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+updatedAt: PgColumn<    {
+name: "updated_at";
+tableName: "suppliers";
+dataType: "date";
+columnType: "PgTimestamp";
+data: Date;
+driverParam: string;
+notNull: false;
+hasDefault: true;
+isPrimaryKey: false;
+isAutoincrement: false;
+hasRuntimeDefault: false;
+enumValues: undefined;
+baseColumn: never;
+identity: undefined;
+generated: undefined;
+}, {}, {}>;
+};
+dialect: "pg";
+}>;
+
+export declare const suppliersRelations: Relations<"suppliers", {
+organisation: One<"organisations", true>;
+employees: Many<"employees">;
+}>;
+
+/**
+ * Time dimension with granularity
+ */
+export declare interface TimeDimension {
+    dimension: string;
+    granularity?: TimeGranularity;
+    dateRange?: string | string[];
+}
+
 export declare interface TimeDimensionAnnotation {
     title: string;
     shortTitle: string;
@@ -492,4 +2223,174 @@ 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 { }