drizzle-cube 0.5.8 → 0.6.1

package/dist/server/server/adapters/mysql-adapter.d.ts

@@ -1,122 +0,0 @@
-import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
-export declare class MySQLAdapter extends BaseDatabaseAdapter {
-    getEngineType(): 'mysql' | 'singlestore';
-    /**
-     * MySQL supports LATERAL joins since version 8.0.14
-     */
-    supportsLateralJoins(): boolean;
-    /**
-     * Build MySQL INTERVAL from ISO 8601 duration
-     * MySQL uses DATE_ADD with INTERVAL syntax but intervals must be added separately
-     * For simplicity, we convert to seconds for consistent handling
-     */
-    buildIntervalFromISO(duration: string): SQL;
-    /**
-     * Build MySQL time difference in seconds using TIMESTAMPDIFF
-     * Returns (end - start) as seconds
-     */
-    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
-    /**
-     * Build MySQL timestamp + interval expression
-     * Uses DATE_ADD function
-     */
-    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build MySQL conditional aggregation using CASE WHEN
-     * MySQL doesn't support FILTER clause, so we use CASE WHEN pattern
-     * Example: AVG(CASE WHEN step_1_time IS NOT NULL THEN time_diff END)
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
-    /**
-     * Build MySQL date difference in periods using TIMESTAMPDIFF
-     * For retention analysis period calculations
-     */
-    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
-    /**
-     * Build MySQL period series using recursive CTE
-     * MySQL 8.0+ supports recursive CTEs for generating sequences
-     */
-    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
-    /**
-     * Build MySQL time dimension using DATE_FORMAT function
-     * MySQL equivalent to PostgreSQL's DATE_TRUNC
-     */
-    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build MySQL string matching conditions using LIKE
-     * MySQL LIKE is case-insensitive by default (depending on collation)
-     * For guaranteed case-insensitive matching, we use LOWER() functions
-     */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
-    /**
-     * Build MySQL type casting using CAST() function
-     * MySQL equivalent to PostgreSQL's :: casting syntax
-     */
-    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build MySQL AVG aggregation with IFNULL for NULL handling
-     * MySQL AVG returns NULL for empty sets, using IFNULL for consistency
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build MySQL CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build MySQL boolean literal
-     * MySQL uses TRUE/FALSE keywords (equivalent to 1/0)
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - MySQL uses native types
-     * No conversion needed for MySQL
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for MySQL
-     * MySQL accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * MySQL stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * MySQL time dimensions already return proper values
-     * No conversion needed
-     */
-    convertTimeDimensionResult(value: any): any;
-    /**
-     * MySQL 8.0+ has support for statistical and window functions
-     * but not PERCENTILE_CONT
-     */
-    getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build MySQL STDDEV aggregation
-     * Uses STDDEV_POP for population, STDDEV_SAMP for sample
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build MySQL VARIANCE aggregation
-     * Uses VAR_POP for population, VAR_SAMP for sample
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * MySQL does not support PERCENTILE_CONT
-     * Returns null for graceful degradation
-     */
-    buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL | null;
-    /**
-     * Build MySQL window function expression
-     * MySQL 8.0+ has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
-}

package/dist/server/server/adapters/postgres-adapter.d.ts

@@ -1,119 +0,0 @@
-import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
-export declare class PostgresAdapter extends BaseDatabaseAdapter {
-    getEngineType(): 'postgres';
-    /**
-     * PostgreSQL supports LATERAL joins since version 9.3
-     */
-    supportsLateralJoins(): boolean;
-    /**
-     * Build PostgreSQL INTERVAL from ISO 8601 duration
-     * PostgreSQL supports INTERVAL literal syntax: INTERVAL '7 days'
-     */
-    buildIntervalFromISO(duration: string): SQL;
-    /**
-     * Build PostgreSQL time difference in seconds using EXTRACT(EPOCH FROM ...)
-     * Returns (end - start) as seconds
-     */
-    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
-    /**
-     * Build PostgreSQL timestamp + interval expression
-     */
-    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build PostgreSQL conditional aggregation using FILTER clause
-     * PostgreSQL supports the standard SQL FILTER clause for efficient conditional aggregation
-     * Example: AVG(time_diff) FILTER (WHERE step_1_time IS NOT NULL)
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
-    /**
-     * Build PostgreSQL date difference in periods using AGE and EXTRACT
-     * For retention analysis period calculations
-     */
-    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
-    /**
-     * Build PostgreSQL period series using generate_series
-     * PostgreSQL's generate_series returns a set directly usable as a table
-     */
-    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
-    /**
-     * Build PostgreSQL time dimension using DATE_TRUNC function
-     * Extracted from executor.ts:649-670 and multi-cube-builder.ts:306-320
-     */
-    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build PostgreSQL string matching conditions using ILIKE (case-insensitive)
-     * Extracted from executor.ts:807-813 and multi-cube-builder.ts:468-474
-     */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
-    /**
-     * Build PostgreSQL type casting using :: syntax
-     * Extracted from various locations where ::timestamp was used
-     */
-    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build PostgreSQL AVG aggregation with COALESCE for NULL handling
-     * PostgreSQL AVG returns NULL for empty sets, so we use COALESCE for consistent behavior
-     * Extracted from multi-cube-builder.ts:284
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build PostgreSQL CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build PostgreSQL boolean literal
-     * PostgreSQL uses TRUE/FALSE keywords
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - PostgreSQL uses native types
-     * No conversion needed for PostgreSQL
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for PostgreSQL
-     * PostgreSQL accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * PostgreSQL stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * PostgreSQL time dimensions already return proper values
-     * No conversion needed
-     */
-    convertTimeDimensionResult(value: any): any;
-    /**
-     * PostgreSQL has full support for statistical and window functions
-     */
-    getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build PostgreSQL STDDEV aggregation
-     * Uses STDDEV_POP for population, STDDEV_SAMP for sample
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build PostgreSQL VARIANCE aggregation
-     * Uses VAR_POP for population, VAR_SAMP for sample
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build PostgreSQL PERCENTILE_CONT aggregation
-     * Uses ordered-set aggregate function
-     */
-    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
-    /**
-     * Build PostgreSQL window function expression
-     * PostgreSQL has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
-}

package/dist/server/server/adapters/snowflake-adapter.d.ts

@@ -1,116 +0,0 @@
-import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
-export declare class SnowflakeAdapter extends BaseDatabaseAdapter {
-    getEngineType(): 'snowflake';
-    /**
-     * Snowflake supports LATERAL joins
-     */
-    supportsLateralJoins(): boolean;
-    /**
-     * Build Snowflake INTERVAL from ISO 8601 duration
-     * Snowflake doesn't support INTERVAL literal syntax directly in all contexts,
-     * so we chain DATEADD calls. For standalone interval expressions, we return
-     * a DATEADD chain applied to TIMESTAMP '1970-01-01' and subtract it back.
-     * However, buildIntervalFromISO is typically used with buildDateAddInterval,
-     * so we return a structured representation.
-     */
-    buildIntervalFromISO(duration: string): SQL;
-    /**
-     * Build Snowflake time difference in seconds
-     * Uses DATEDIFF('SECOND', start, end)
-     */
-    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
-    /**
-     * Build Snowflake timestamp + interval expression
-     * Uses chained DATEADD(unit, amount, timestamp) calls
-     */
-    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build Snowflake conditional aggregation using CASE WHEN
-     * Snowflake supports FILTER clause but CASE WHEN is more portable
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
-    /**
-     * Build Snowflake date difference in periods using DATEDIFF
-     */
-    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
-    /**
-     * Build Snowflake period series using TABLE(GENERATOR(ROWCOUNT => n)) + ROW_NUMBER()
-     */
-    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
-    /**
-     * Build Snowflake time dimension using DATE_TRUNC function
-     * Snowflake supports DATE_TRUNC with quoted granularity like PostgreSQL
-     */
-    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build Snowflake string matching conditions using native ILIKE
-     * Snowflake supports ILIKE natively
-     */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
-    /**
-     * Build Snowflake type casting using :: syntax
-     * Snowflake supports both :: syntax and CAST() function
-     */
-    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build Snowflake AVG aggregation with COALESCE for NULL handling
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build Snowflake CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build Snowflake boolean literal
-     * Snowflake uses TRUE/FALSE keywords
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - Snowflake uses native types
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for Snowflake
-     * Snowflake accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * Snowflake stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * Snowflake time dimensions already return proper values
-     */
-    convertTimeDimensionResult(value: any): any;
-    /**
-     * Snowflake capabilities - full SQL support
-     */
-    getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build Snowflake STDDEV aggregation
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build Snowflake VARIANCE aggregation
-     * Snowflake supports native VAR_POP/VAR_SAMP
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build Snowflake PERCENTILE_CONT aggregation
-     * Uses ordered-set aggregate function
-     */
-    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
-    /**
-     * Build Snowflake window function expression
-     * Snowflake has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
-}

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

@@ -1,11 +0,0 @@
-/**
- * Agent Module - Public Exports
- * Agentic AI notebook handler for drizzle-cube
- */
-export { handleAgentChat } from './handler';
-export { getToolDefinitions, createToolExecutor } from './tools';
-export type { ToolExecutionResult } from './tools';
-export { buildAgentSystemPrompt } from './system-prompt';
-export { createProvider } from './providers';
-export type { LLMProvider, ProviderName } from './providers';
-export type { AgentChatRequest, AgentConfig, AgentObservabilityHooks, AgentSSEEvent, AgentHistoryMessage, AgentHistoryToolCall, PortletBlockData, MarkdownBlockData, DashboardSavedData } from './types';

package/dist/server/server/agent/providers/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * LLM Provider exports
- */
-export type { LLMProvider, ToolDefinition, InternalMessage, ContentBlock, ToolResult, NormalizedEvent } from './types';
-export type { ProviderName } from './factory';
-export { createProvider } from './factory';

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

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

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

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

package/dist/server/server/cache-providers/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Cache providers for Drizzle Cube
- */
-export { MemoryCacheProvider } from './memory';
-export type { MemoryCacheProviderOptions } from './memory';

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

@@ -1,9 +0,0 @@
-/**
- * EXPLAIN plan parsers
- * Normalize raw EXPLAIN output from different databases to a common format
- */
-export { parsePostgresExplain } from './postgres-parser';
-export { parseMySQLExplain } from './mysql-parser';
-export { parseSQLiteExplain } from './sqlite-parser';
-export { parseDuckDBExplain } from './duckdb-parser';
-export type { ExplainOperation, ExplainResult, ExplainSummary, ExplainOptions } from '../types/executor';

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

@@ -1,36 +0,0 @@
-import { DrizzleDatabase } from './types';
-import { SemanticLayerCompiler } from './compiler';
-/**
- * Drizzle Cube - Semantic Layer for Drizzle ORM
- * Drizzle ORM-first semantic layer with Cube.js compatibility
- */
-export { SemanticLayerCompiler } from './compiler';
-export { QueryExecutor } from './executor';
-export { LogicalPlanner } from './logical-plan';
-export { DrizzleSqlBuilder } from './physical-plan';
-export { CTEBuilder, ComparisonQueryBuilder, FunnelQueryBuilder, FlowQueryBuilder, RetentionQueryBuilder } from './builders';
-export { CalculatedMeasureResolver, JoinPathResolver } from './resolvers';
-export { LogicalPlanBuilder, IdentityOptimiser, OptimiserPipeline } from './logical-plan';
-export type { LogicalNode, QueryNode, SimpleSource, CTEPreAggregate, CubeRef, MeasureRef, DimensionRef, LogicalPlanWithAnalysis, PlanOptimiser, OptimiserContext } from './logical-plan';
-export { DrizzlePlanBuilder } from './physical-plan';
-export { createDatabaseExecutor, createPostgresExecutor, createSQLiteExecutor, createMySQLExecutor, createDuckDBExecutor, createDatabendExecutor, createSnowflakeExecutor, BaseDatabaseExecutor, PostgresExecutor, SQLiteExecutor, MySQLExecutor, DuckDBExecutor, DatabendExecutor, SnowflakeExecutor } from './executors';
-export { resolveSqlExpression, createMultiCubeContext, resolveCubeReference, getJoinType } from './cube-utils';
-export { defineCube } from './cube-utils';
-export { generateCacheKey, normalizeQuery, fnv1aHash, getCubeInvalidationPattern } from './cache-utils';
-export { MemoryCacheProvider } from './cache-providers';
-export { STEP0_VALIDATION_PROMPT, SYSTEM_PROMPT_TEMPLATE, STEP1_SYSTEM_PROMPT, STEP2_SYSTEM_PROMPT, buildStep0Prompt, buildSystemPrompt, buildStep1Prompt, buildStep2Prompt, EXPLAIN_ANALYSIS_PROMPT, buildExplainAnalysisPrompt, formatCubeSchemaForExplain, formatExistingIndexes } from './prompts';
-export type { Step0Result, PromptContext, DimensionValues, Step1Result } from './prompts';
-export { handleAgentChat, getToolDefinitions, createToolExecutor, buildAgentSystemPrompt } from './agent';
-export type { AgentChatRequest, AgentConfig, AgentObservabilityHooks, AgentSSEEvent, PortletBlockData, MarkdownBlockData, ToolExecutionResult } from './agent';
-export { discoverCubes, findBestFieldMatch, suggestQuery, validateQuery as aiValidateQuery } from './ai';
-export type { CubeDiscoveryResult, DiscoveryOptions, QuerySuggestion, ValidationResult as AIValidationResult, ValidationError as AIValidationError, ValidationWarning as AIValidationWarning } from './ai';
-export type * from './types';
-export type { SQL } from 'drizzle-orm';
-/**
- * Create a new semantic layer instance with Drizzle integration
- * Use this when you need multiple isolated instances
- */
-export declare function createDrizzleSemanticLayer(options: {
-    drizzle: DrizzleDatabase;
-    schema?: any;
-}): SemanticLayerCompiler;