drizzle-cube 0.1.0 → 0.1.1

package/dist/server/index.js

@@ -1,583 +1,3487 @@
-var u = Object.defineProperty;
-var y = (l, e, n) => e in l ? u(l, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : l[e] = n;
-var c = (l, e, n) => y(l, typeof e != "symbol" ? e + "" : e, n);
-class f {
+var kr = Object.defineProperty;
+var eo = (n, e, t) => e in n ? kr(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var r = (n, e, t) => eo(n, typeof e != "symbol" ? e + "" : e, t);
+import { and as B, sql as y, eq as di, count as Y, max as to, min as no, avg as so, sum as io, countDistinct as ro, or as oo, gt as re, lt as oe, gte as ae, lte as ue, isNull as ao, isNotNull as uo, ne as co, relations as J } from "drizzle-orm";
+import { parse as lo, stringify as mo } from "yaml";
+function Sa(n, e) {
+  return {
+    ...e,
+    name: e.name
+  };
+}
+class ee {
+  constructor(e, t) {
+    this.db = e, this.schema = t;
+  }
+}
+class fo extends ee {
+  async execute(e) {
+    if (e && typeof e == "object") {
+      if (typeof e.execute == "function") {
+        const s = await e.execute();
+        return Array.isArray(s) ? s.map((i) => this.convertNumericFields(i)) : s;
+      }
+      if (this.db && typeof this.db.execute == "function")
+        try {
+          const s = await this.db.execute(e);
+          return Array.isArray(s) ? s.map((i) => this.convertNumericFields(i)) : s;
+        } catch (s) {
+          if (typeof e.getSQL == "function") {
+            const i = e.getSQL(), o = await this.db.execute(i);
+            return Array.isArray(o) ? o.map((l) => this.convertNumericFields(l)) : o;
+          }
+          throw s;
+        }
+    }
+    if (!this.db.execute)
+      throw new Error("PostgreSQL database instance must have an execute method");
+    const t = await this.db.execute(e);
+    return Array.isArray(t) ? t.map((s) => this.convertNumericFields(s)) : t;
+  }
+  /**
+   * Convert numeric string fields to numbers
+   */
+  convertNumericFields(e) {
+    if (!e || typeof e != "object") return e;
+    const t = {};
+    for (const [s, i] of Object.entries(e))
+      typeof i == "string" && /^\d+(\.\d+)?$/.test(i) ? t[s] = i.includes(".") ? parseFloat(i) : parseInt(i, 10) : t[s] = i;
+    return t;
+  }
+  getEngineType() {
+    return "postgres";
+  }
+}
+class po extends ee {
+  async execute(e) {
+    if (e && typeof e == "object" && typeof e.execute == "function")
+      return await e.execute();
+    try {
+      if (this.db.all)
+        return this.db.all(e);
+      if (this.db.run)
+        return this.db.run(e);
+      throw new Error("SQLite database instance must have an all() or run() method");
+    } catch (t) {
+      throw new Error(`SQLite execution failed: ${t instanceof Error ? t.message : "Unknown error"}`);
+    }
+  }
+  getEngineType() {
+    return "sqlite";
+  }
+}
+class ho extends ee {
+  async execute(e) {
+    if (e && typeof e == "object" && typeof e.execute == "function")
+      return await e.execute();
+    if (!this.db.execute)
+      throw new Error("MySQL database instance must have an execute method");
+    return await this.db.execute(e);
+  }
+  getEngineType() {
+    return "mysql";
+  }
+}
+function ce(n, e) {
+  return new fo(n, e);
+}
+function le(n, e) {
+  return new po(n, e);
+}
+function go(n, e) {
+  return new ho(n, e);
+}
+function me(n, e, t) {
+  if (t)
+    switch (t) {
+      case "postgres":
+        return ce(n, e);
+      case "mysql":
+        return go(n, e);
+      case "sqlite":
+        return le(n, e);
+    }
+  if (n.all && n.run)
+    return le(n, e);
+  if (n.execute)
+    return ce(n, e);
+  throw new Error("Unable to determine database engine type. Please specify engineType parameter.");
+}
+function Pa(n, e) {
+  return {
+    name: n,
+    ...e
+  };
+}
+function v(n, e) {
+  return typeof n == "function" ? n(e) : n;
+}
+function bo(n, e, t) {
+  return {
+    ...n,
+    cubes: e,
+    currentCube: t
+  };
+}
+class yo {
+  /**
+   * Analyze a semantic query to determine which cubes are involved
+   */
+  analyzeCubeUsage(e) {
+    const t = /* @__PURE__ */ new Set();
+    if (e.measures)
+      for (const s of e.measures) {
+        const [i] = s.split(".");
+        t.add(i);
+      }
+    if (e.dimensions)
+      for (const s of e.dimensions) {
+        const [i] = s.split(".");
+        t.add(i);
+      }
+    if (e.timeDimensions)
+      for (const s of e.timeDimensions) {
+        const [i] = s.dimension.split(".");
+        t.add(i);
+      }
+    return t;
+  }
+  /**
+   * Build a multi-cube query plan
+   */
+  buildMultiCubeQueryPlan(e, t, s) {
+    const i = this.analyzeCubeUsage(t), o = Array.from(i);
+    if (o.length === 1)
+      throw new Error("Single cube query should use QueryExecutor directly");
+    const l = this.choosePrimaryCube(o, t), a = e.get(l);
+    if (!a)
+      throw new Error(`Primary cube '${l}' not found`);
+    const m = this.buildJoinPlan(e, a, o, s.securityContext), d = this.buildMultiCubeSelections(e, t, s.securityContext), u = this.buildMultiCubeWhereConditions(e, t, s), f = this.buildMultiCubeGroupByFields(e, t, s.securityContext);
+    return {
+      primaryCube: a,
+      joinCubes: m,
+      selections: d,
+      whereConditions: u,
+      groupByFields: f
+    };
+  }
+  /**
+   * Choose the primary cube based on query analysis
+   */
+  choosePrimaryCube(e, t) {
+    if (t.measures && t.measures.length > 0) {
+      const [s] = t.measures[0].split(".");
+      return s;
+    }
+    if (t.dimensions && t.dimensions.length > 0) {
+      const [s] = t.dimensions[0].split(".");
+      return s;
+    }
+    return e[0];
+  }
+  /**
+   * Build join plan for multi-cube query
+   */
+  buildJoinPlan(e, t, s, i) {
+    var a;
+    const o = [], l = s.filter((m) => m !== t.name);
+    for (const m of l) {
+      const d = e.get(m);
+      if (!d)
+        throw new Error(`Cube '${m}' not found`);
+      const u = (a = t.joins) == null ? void 0 : a[m];
+      if (!u)
+        throw new Error(`No join definition found from '${t.name}' to '${m}'`);
+      const f = bo(
+        {
+          db: {},
+          // Will be filled in during execution
+          schema: {},
+          // Will be filled in during execution
+          securityContext: i
+        },
+        e,
+        d
+      ), p = u.condition(f);
+      o.push({
+        cube: d,
+        alias: `${m.toLowerCase()}_cube`,
+        joinType: u.type || "left",
+        joinCondition: p
+      });
+    }
+    return o;
+  }
+  /**
+   * Build selections across multiple cubes
+   */
+  buildMultiCubeSelections(e, t, s) {
+    const i = {}, o = {
+      db: {},
+      // Filled during execution
+      schema: {},
+      // Filled during execution
+      securityContext: s
+    };
+    if (t.dimensions)
+      for (const l of t.dimensions) {
+        const [a, m] = l.split("."), d = e.get(a);
+        if (d && d.dimensions[m]) {
+          const u = d.dimensions[m], f = v(u.sql, o);
+          i[l] = f;
+        }
+      }
+    if (t.measures)
+      for (const l of t.measures) {
+        const [a, m] = l.split("."), d = e.get(a);
+        if (d && d.measures[m]) {
+          const u = d.measures[m], f = this.buildMeasureExpression(u, o);
+          i[l] = f;
+        }
+      }
+    if (t.timeDimensions)
+      for (const l of t.timeDimensions) {
+        const [a, m] = l.dimension.split("."), d = e.get(a);
+        if (d && d.dimensions[m]) {
+          const u = d.dimensions[m], f = this.buildTimeDimensionExpression(
+            u.sql,
+            l.granularity,
+            o
+          );
+          i[l.dimension] = f;
+        }
+      }
+    return i;
+  }
+  /**
+   * Build measure expression with aggregation (similar to single-cube approach)
+   */
+  buildMeasureExpression(e, t) {
+    let s = v(e.sql, t);
+    if (e.filters && e.filters.length > 0) {
+      const i = e.filters.map((o) => o(t));
+      s = y`CASE WHEN ${B(...i)} THEN ${s} END`;
+    }
+    switch (e.type) {
+      case "count":
+        return y`COUNT(${s})`;
+      case "countDistinct":
+        return y`COUNT(DISTINCT ${s})`;
+      case "sum":
+        return y`SUM(${s})`;
+      case "avg":
+        return y`AVG(${s})`;
+      case "min":
+        return y`MIN(${s})`;
+      case "max":
+        return y`MAX(${s})`;
+      case "number":
+        return s;
+      default:
+        return y`COUNT(${s})`;
+    }
+  }
+  /**
+   * Build time dimension expression (similar to single-cube approach)
+   */
+  buildTimeDimensionExpression(e, t, s) {
+    const i = v(e, s);
+    if (!t)
+      return i;
+    switch (t) {
+      case "year":
+        return y`DATE_TRUNC('year', ${i}::timestamptz)`;
+      case "quarter":
+        return y`DATE_TRUNC('quarter', ${i}::timestamptz)`;
+      case "month":
+        return y`DATE_TRUNC('month', ${i}::timestamptz)`;
+      case "week":
+        return y`DATE_TRUNC('week', ${i}::timestamptz)`;
+      case "day":
+        return y`DATE_TRUNC('day', ${i}::timestamptz)`;
+      case "hour":
+        return y`DATE_TRUNC('hour', ${i}::timestamptz)`;
+      case "minute":
+        return y`DATE_TRUNC('minute', ${i}::timestamptz)`;
+      case "second":
+        return y`DATE_TRUNC('second', ${i}::timestamptz)`;
+      default:
+        return i;
+    }
+  }
+  /**
+   * Build WHERE conditions for multi-cube query
+   */
+  buildMultiCubeWhereConditions(e, t, s) {
+    const i = [];
+    if (t.filters) {
+      for (const o of t.filters)
+        if ("member" in o) {
+          const [l] = o.member.split("."), a = e.get(l);
+          if (a) {
+            const m = this.buildFilterCondition(o, a, s);
+            m && i.push(m);
+          }
+        }
+    }
+    return i;
+  }
+  /**
+   * Filter condition builder (would reuse logic from DrizzleExecutor)
+   */
+  buildFilterCondition(e, t, s) {
+    if (e.operator === "equals" && e.values && e.values.length > 0) {
+      const [i, o] = e.member.split(".");
+      if (i === t.name) {
+        const l = t.dimensions[o] || t.measures[o];
+        if (l) {
+          const a = typeof l.sql == "function" ? l.sql(s) : l.sql;
+          return di(a, e.values[0]);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Build GROUP BY fields for multi-cube query
+   */
+  buildMultiCubeGroupByFields(e, t, s) {
+    const i = [];
+    if (!(t.measures && t.measures.length > 0))
+      return [];
+    const l = {
+      db: {},
+      schema: {},
+      securityContext: s
+    };
+    if (t.dimensions)
+      for (const a of t.dimensions) {
+        const [m, d] = a.split("."), u = e.get(m);
+        if (u && u.dimensions[d]) {
+          const f = u.dimensions[d], p = v(f.sql, l);
+          i.push(p);
+        }
+      }
+    if (t.timeDimensions)
+      for (const a of t.timeDimensions) {
+        const [m, d] = a.dimension.split("."), u = e.get(m);
+        if (u && u.dimensions[d]) {
+          const f = u.dimensions[d], p = this.buildTimeDimensionExpression(
+            f.sql,
+            a.granularity,
+            l
+          );
+          i.push(p);
+        }
+      }
+    return i;
+  }
+}
+class de {
   constructor(e) {
-    this.dbExecutor = e;
+    r(this, "multiCubeBuilder");
+    this.dbExecutor = e, this.multiCubeBuilder = new yo();
+  }
+  /**
+   * Unified query execution method that handles both single and multi-cube queries
+   */
+  async execute(e, t, s) {
+    try {
+      const i = this.multiCubeBuilder.analyzeCubeUsage(t);
+      if (i.size === 0)
+        throw new Error("No cubes found for query");
+      if (i.size === 1) {
+        const o = Array.from(i)[0], l = e.get(o);
+        if (!l)
+          throw new Error(`Cube '${o}' not found`);
+        return this.executeSingleCube(l, t, s);
+      } else
+        return this.executeMultiCube(e, t, s);
+    } catch (i) {
+      throw new Error(`Query execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Legacy interface for single cube queries
+   */
+  async executeQuery(e, t, s) {
+    const i = /* @__PURE__ */ new Map();
+    return i.set(e.name, e), this.execute(i, t, s);
+  }
+  /**
+   * Execute a single cube query
+   */
+  async executeSingleCube(e, t, s) {
+    return this.executeCube(e, t, s);
   }
-  async executeQuery(e, n, i) {
+  /**
+   * Execute a Cube query (dynamic query building)
+   */
+  async executeCube(e, t, s) {
     try {
-      const t = this.generateSQL(e, n, i), s = await this.dbExecutor.execute(t.sql, t.params), a = this.generateAnnotations(e, n);
+      const i = {
+        db: this.dbExecutor.db,
+        schema: this.dbExecutor.schema,
+        securityContext: s
+      }, o = e.sql(i), l = this.buildSelections(e, t, i);
+      let a = i.db.select(l).from(o.from);
+      if (o.joins)
+        for (const h of o.joins)
+          switch (h.type || "left") {
+            case "left":
+              a = a.leftJoin(h.table, h.on);
+              break;
+            case "inner":
+              a = a.innerJoin(h.table, h.on);
+              break;
+            case "right":
+              a = a.rightJoin(h.table, h.on);
+              break;
+            case "full":
+              a = a.fullJoin(h.table, h.on);
+              break;
+          }
+      o.where && (a = a.where(o.where));
+      const m = this.buildWhereConditions(e, t, i);
+      if (m.length > 0) {
+        const h = m.length === 1 ? m[0] : B(...m);
+        a = a.where(h);
+      }
+      const d = this.buildGroupByFields(e, t, i);
+      d.length > 0 && (a = a.groupBy(...d));
+      const u = this.buildOrderBy(t);
+      u.length > 0 && (a = a.orderBy(...u)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
+      const f = await this.dbExecutor.execute(a), p = this.generateAnnotations(e, t);
       return {
-        data: s,
-        annotation: a
+        data: Array.isArray(f) ? f : [f],
+        annotation: p
       };
-    } catch (t) {
-      throw new Error(`Query execution failed: ${t instanceof Error ? t.message : "Unknown error"}`);
+    } catch (i) {
+      throw new Error(`Cube query execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
     }
   }
-  generateSQL(e, n, i) {
-    const t = this.substituteSecurityVariables(
-      typeof e.sql == "string" ? e.sql : e.sql.toString(),
-      i
-    ), s = this.buildSelectClause(e, n), a = this.buildWhereClause(e, n), r = this.buildGroupByClause(e, n), o = this.buildOrderByClause(n), m = this.buildLimitClause(n), p = [
-      `SELECT ${s.join(", ")}`,
-      `FROM (${t}) as base_query`
-    ];
-    return a && p.push(`WHERE ${a}`), r && p.push(`GROUP BY ${r}`), o && p.push(`ORDER BY ${o}`), m && p.push(m), { sql: p.join(" "), params: [] };
+  /**
+   * Execute multi-cube query using JOIN resolution
+   */
+  async executeMultiCube(e, t, s) {
+    const i = {
+      db: this.dbExecutor.db,
+      schema: this.dbExecutor.schema,
+      securityContext: s
+    }, o = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, i), l = o.primaryCube.sql(i);
+    let a = i.db.select(o.selections).from(l.from);
+    if (l.joins)
+      for (const h of l.joins)
+        switch (h.type || "left") {
+          case "left":
+            a = a.leftJoin(h.table, h.on);
+            break;
+          case "inner":
+            a = a.innerJoin(h.table, h.on);
+            break;
+          case "right":
+            a = a.rightJoin(h.table, h.on);
+            break;
+          case "full":
+            a = a.fullJoin(h.table, h.on);
+            break;
+        }
+    if (o.joinCubes && o.joinCubes.length > 0)
+      for (const h of o.joinCubes) {
+        const A = h.cube.sql(i);
+        switch (h.joinType || "left") {
+          case "left":
+            a = a.leftJoin(A.from, h.joinCondition);
+            break;
+          case "inner":
+            a = a.innerJoin(A.from, h.joinCondition);
+            break;
+          case "right":
+            a = a.rightJoin(A.from, h.joinCondition);
+            break;
+          case "full":
+            a = a.fullJoin(A.from, h.joinCondition);
+            break;
+        }
+      }
+    const m = [];
+    if (l.where && m.push(l.where), o.whereConditions.length > 0 && m.push(...o.whereConditions), m.length > 0) {
+      const h = m.length === 1 ? m[0] : B(...m);
+      a = a.where(h);
+    }
+    o.groupByFields.length > 0 && (a = a.groupBy(...o.groupByFields));
+    const d = this.buildOrderBy(t);
+    d.length > 0 && (a = a.orderBy(...d)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
+    const u = a, f = await this.dbExecutor.execute(u), p = this.generateMultiCubeAnnotations(o, t);
+    return {
+      data: Array.isArray(f) ? f : [f],
+      annotation: p
+    };
+  }
+  /**
+   * Generate raw SQL for debugging (without execution)
+   */
+  async generateSQL(e, t, s) {
+    return this.generateCubeSQL(e, t, s);
   }
-  substituteSecurityVariables(e, n) {
-    let i = e;
-    return Object.entries(n).forEach(([t, s]) => {
-      const a = `\${SECURITY_CONTEXT.${t}}`;
-      i = i.replaceAll(a, `'${s}'`);
-    }), i;
+  /**
+   * Generate SQL for Cube
+   */
+  async generateCubeSQL(e, t, s) {
+    const i = {
+      db: this.dbExecutor.db,
+      schema: this.dbExecutor.schema,
+      securityContext: s
+    }, o = e.sql(i), l = this.buildSelections(e, t, i);
+    let a = i.db.select(l).from(o.from);
+    if (o.joins)
+      for (const p of o.joins)
+        switch (p.type || "left") {
+          case "left":
+            a = a.leftJoin(p.table, p.on);
+            break;
+          case "inner":
+            a = a.innerJoin(p.table, p.on);
+            break;
+          case "right":
+            a = a.rightJoin(p.table, p.on);
+            break;
+          case "full":
+            a = a.fullJoin(p.table, p.on);
+            break;
+        }
+    o.where && (a = a.where(o.where));
+    const m = this.buildWhereConditions(e, t, i);
+    if (m.length > 0) {
+      const p = m.length === 1 ? m[0] : B(...m);
+      a = a.where(p);
+    }
+    const d = this.buildGroupByFields(e, t, i);
+    d.length > 0 && (a = a.groupBy(...d));
+    const u = this.buildOrderBy(t);
+    u.length > 0 && (a = a.orderBy(...u)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
+    const f = a.toSQL();
+    return {
+      sql: f.sql,
+      params: f.params
+    };
   }
-  buildSelectClause(e, n) {
-    const i = [];
-    if (n.measures)
-      for (const t of n.measures) {
-        const [s, a] = t.split(".");
-        if (s === e.name && e.measures[a]) {
-          const r = e.measures[a], o = this.buildMeasureSQL(r, a);
-          i.push(`${o} as "${t}"`);
+  /**
+   * Build dynamic selections for Cube measures and dimensions
+   */
+  buildSelections(e, t, s) {
+    const i = {};
+    if (t.dimensions)
+      for (const o of t.dimensions) {
+        const [l, a] = o.split(".");
+        if (l === e.name && e.dimensions[a]) {
+          const m = e.dimensions[a], d = v(m.sql, s);
+          i[o] = d;
         }
       }
-    if (n.dimensions)
-      for (const t of n.dimensions) {
-        const [s, a] = t.split(".");
-        if (s === e.name && e.dimensions[a]) {
-          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
-          i.push(`${o} as "${t}"`);
+    if (t.measures)
+      for (const o of t.measures) {
+        const [l, a] = o.split(".");
+        if (l === e.name && e.measures[a]) {
+          const m = e.measures[a], d = this.buildMeasureExpression(m, s);
+          i[o] = d;
         }
       }
-    if (n.timeDimensions)
-      for (const t of n.timeDimensions) {
-        const [s, a] = t.dimension.split(".");
-        if (s === e.name && e.dimensions[a]) {
-          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
-          if (t.granularity) {
-            const m = `DATE_TRUNC('${t.granularity}', ${o})`;
-            i.push(`${m} as "${t.dimension}"`);
-          } else
-            i.push(`${o} as "${t.dimension}"`);
+    if (t.timeDimensions)
+      for (const o of t.timeDimensions) {
+        const [l, a] = o.dimension.split(".");
+        if (l === e.name && e.dimensions[a]) {
+          const m = e.dimensions[a], d = this.buildTimeDimensionExpression(
+            m.sql,
+            o.granularity,
+            s
+          );
+          i[o.dimension] = d;
         }
       }
-    return i.length > 0 ? i : ["1"];
+    return Object.keys(i).length === 0 && (i.count = Y()), i;
   }
-  buildMeasureSQL(e, n) {
-    const i = typeof e.sql == "string" ? e.sql : e.sql.toString();
+  /**
+   * Build measure expression with aggregation and filters for Cube
+   */
+  buildMeasureExpression(e, t) {
+    let s = v(e.sql, t);
+    if (e.filters && e.filters.length > 0) {
+      const i = e.filters.map((o) => o(t));
+      s = y`CASE WHEN ${B(...i)} THEN ${s} END`;
+    }
     switch (e.type) {
       case "count":
-        return `COUNT(${i})`;
+        return Y(s);
       case "countDistinct":
-        return `COUNT(DISTINCT ${i})`;
+        return ro(s);
       case "sum":
-        return `SUM(${i})`;
+        return io(s);
       case "avg":
-        return `AVG(${i})`;
+        return so(s);
       case "min":
-        return `MIN(${i})`;
+        return no(s);
       case "max":
-        return `MAX(${i})`;
+        return to(s);
       case "number":
-        return i;
+        return s;
+      default:
+        return Y(s);
+    }
+  }
+  /**
+   * Build time dimension expression with granularity
+   */
+  buildTimeDimensionExpression(e, t, s) {
+    const i = v(e, s);
+    if (!t)
+      return i;
+    switch (t) {
+      case "year":
+        return y`DATE_TRUNC('year', ${i}::timestamptz)`;
+      case "quarter":
+        return y`DATE_TRUNC('quarter', ${i}::timestamptz)`;
+      case "month":
+        return y`DATE_TRUNC('month', ${i}::timestamptz)`;
+      case "week":
+        return y`DATE_TRUNC('week', ${i}::timestamptz)`;
+      case "day":
+        return y`DATE_TRUNC('day', ${i}::timestamptz)`;
+      case "hour":
+        return y`DATE_TRUNC('hour', ${i}::timestamptz)`;
+      case "minute":
+        return y`DATE_TRUNC('minute', ${i}::timestamptz)`;
+      case "second":
+        return y`DATE_TRUNC('second', ${i}::timestamptz)`;
       default:
-        return `COUNT(${i})`;
+        return i;
     }
   }
-  buildWhereClause(e, n) {
-    if (!n.filters || n.filters.length === 0)
-      return null;
+  /**
+   * Build WHERE conditions from semantic query filters (Cube)
+   */
+  buildWhereConditions(e, t, s) {
+    if (!t.filters || t.filters.length === 0)
+      return [];
     const i = [];
-    for (const t of n.filters) {
-      const [s, a] = t.member.split(".");
-      if (s !== e.name) continue;
-      const r = e.dimensions[a] || e.measures[a];
-      if (!r) continue;
-      const o = typeof r.sql == "string" ? r.sql : r.sql.toString(), m = this.buildFilterCondition(o, t.operator, t.values);
-      m && i.push(m);
-    }
-    return i.length > 0 ? i.join(" AND ") : null;
-  }
-  buildFilterCondition(e, n, i) {
-    const t = i[0], s = typeof t == "string" ? `'${t.replace(/'/g, "''")}'` : t;
-    switch (n) {
+    for (const o of t.filters) {
+      const l = this.processFilter(o, e, s);
+      l && i.push(l);
+    }
+    return i;
+  }
+  /**
+   * Process a single filter for Cube (basic or logical)
+   */
+  processFilter(e, t, s) {
+    if ("and" in e || "or" in e) {
+      const d = e;
+      if (d.and) {
+        const u = d.and.map((f) => this.processFilter(f, t, s)).filter((f) => f !== null);
+        return u.length > 0 ? B(...u) : null;
+      }
+      if (d.or) {
+        const u = d.or.map((f) => this.processFilter(f, t, s)).filter((f) => f !== null);
+        return u.length > 0 ? oo(...u) : null;
+      }
+    }
+    const i = e, [o, l] = i.member.split(".");
+    if (o !== t.name) return null;
+    const a = t.dimensions[l] || t.measures[l];
+    if (!a) return null;
+    const m = v(a.sql, s);
+    return this.buildFilterCondition(m, i.operator, i.values);
+  }
+  /**
+   * Build filter condition using Drizzle operators
+   */
+  buildFilterCondition(e, t, s) {
+    const i = s[0];
+    switch (t) {
       case "equals":
-        return `${e} = ${s}`;
+        return s.length > 1 ? y`${e} IN ${s}` : di(e, i);
       case "notEquals":
-        return `${e} != ${s}`;
+        return s.length > 1 ? y`${e} NOT IN ${s}` : co(e, i);
       case "contains":
-        return `${e} ILIKE '%${t}%'`;
+        return y`${e} ILIKE ${"%" + i + "%"}`;
       case "notContains":
-        return `${e} NOT ILIKE '%${t}%'`;
+        return y`${e} NOT ILIKE ${"%" + i + "%"}`;
       case "startsWith":
-        return `${e} ILIKE '${t}%'`;
+        return y`${e} ILIKE ${i + "%"}`;
       case "endsWith":
-        return `${e} ILIKE '%${t}'`;
+        return y`${e} ILIKE ${"%" + i}`;
       case "gt":
-        return `${e} > ${s}`;
+        return re(e, i);
       case "gte":
-        return `${e} >= ${s}`;
+        return ae(e, i);
       case "lt":
-        return `${e} < ${s}`;
+        return oe(e, i);
       case "lte":
-        return `${e} <= ${s}`;
+        return ue(e, i);
       case "set":
-        return `${e} IS NOT NULL`;
+        return uo(e);
       case "notSet":
-        return `${e} IS NULL`;
+        return ao(e);
       case "inDateRange":
-        return i.length >= 2 ? `${e} BETWEEN '${i[0]}' AND '${i[1]}'` : null;
+        return s.length >= 2 ? B(
+          ae(e, s[0]),
+          ue(e, s[1])
+        ) : null;
       case "beforeDate":
-        return `${e} < '${t}'`;
+        return oe(e, i);
       case "afterDate":
-        return `${e} > '${t}'`;
+        return re(e, i);
       default:
         return null;
     }
   }
-  buildGroupByClause(e, n) {
+  /**
+   * Build GROUP BY fields from dimensions and time dimensions (Cube)
+   */
+  buildGroupByFields(e, t, s) {
     const i = [];
-    if (n.dimensions)
-      for (const t of n.dimensions) {
-        const [s, a] = t.split(".");
-        if (s === e.name && e.dimensions[a]) {
-          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
-          i.push(o);
+    if (t.dimensions)
+      for (const o of t.dimensions) {
+        const [l, a] = o.split(".");
+        if (l === e.name && e.dimensions[a]) {
+          const m = e.dimensions[a], d = v(m.sql, s);
+          i.push(d);
         }
       }
-    if (n.timeDimensions)
-      for (const t of n.timeDimensions) {
-        const [s, a] = t.dimension.split(".");
-        if (s === e.name && e.dimensions[a]) {
-          const r = e.dimensions[a], o = typeof r.sql == "string" ? r.sql : r.sql.toString();
-          t.granularity ? i.push(`DATE_TRUNC('${t.granularity}', ${o})`) : i.push(o);
+    if (t.timeDimensions)
+      for (const o of t.timeDimensions) {
+        const [l, a] = o.dimension.split(".");
+        if (l === e.name && e.dimensions[a]) {
+          const m = e.dimensions[a], d = this.buildTimeDimensionExpression(
+            m.sql,
+            o.granularity,
+            s
+          );
+          i.push(d);
         }
       }
-    return i.length > 0 ? i.join(", ") : null;
+    return i;
   }
-  buildOrderByClause(e) {
+  /**
+   * Build ORDER BY clause
+   */
+  buildOrderBy(e) {
     if (!e.order || Object.keys(e.order).length === 0)
-      return null;
-    const n = [];
-    for (const [i, t] of Object.entries(e.order))
-      n.push(`"${i}" ${t.toUpperCase()}`);
-    return n.join(", ");
-  }
-  buildLimitClause(e) {
-    if (!e.limit)
-      return null;
-    let n = `LIMIT ${e.limit}`;
-    return e.offset && (n += ` OFFSET ${e.offset}`), n;
-  }
-  generateAnnotations(e, n) {
-    const i = {}, t = {}, s = {};
-    if (n.measures)
-      for (const a of n.measures) {
-        const [r, o] = a.split(".");
-        if (r === e.name && e.measures[o]) {
-          const m = e.measures[o];
-          i[a] = {
-            title: m.title || o,
-            shortTitle: m.title || o,
-            type: m.type,
-            format: m.format
+      return [];
+    const t = [];
+    for (const [s, i] of Object.entries(e.order)) {
+      const o = y.identifier(s), l = i === "desc" ? y`DESC` : y`ASC`;
+      t.push(y`${o} ${l}`);
+    }
+    return t;
+  }
+  /**
+   * Generate annotations for UI metadata
+   */
+  generateAnnotations(e, t) {
+    const s = {}, i = {}, o = {};
+    if (t.measures)
+      for (const l of t.measures) {
+        const [a, m] = l.split(".");
+        if (a === e.name && e.measures[m]) {
+          const d = e.measures[m];
+          s[l] = {
+            title: d.title || m,
+            shortTitle: d.title || m,
+            type: d.type
+          };
+        }
+      }
+    if (t.dimensions)
+      for (const l of t.dimensions) {
+        const [a, m] = l.split(".");
+        if (a === e.name && e.dimensions[m]) {
+          const d = e.dimensions[m];
+          i[l] = {
+            title: d.title || m,
+            shortTitle: d.title || m,
+            type: d.type
+          };
+        }
+      }
+    if (t.timeDimensions)
+      for (const l of t.timeDimensions) {
+        const [a, m] = l.dimension.split(".");
+        if (a === e.name && e.dimensions[m]) {
+          const d = e.dimensions[m];
+          o[l.dimension] = {
+            title: d.title || m,
+            shortTitle: d.title || m,
+            type: d.type,
+            granularity: l.granularity
+          };
+        }
+      }
+    return {
+      measures: s,
+      dimensions: i,
+      segments: {},
+      timeDimensions: o
+    };
+  }
+  /**
+   * Generate annotations for multi-cube queries
+   */
+  generateMultiCubeAnnotations(e, t) {
+    const s = {}, i = {}, o = {}, l = [e.primaryCube];
+    if (e.joinCubes && l.push(...e.joinCubes.map((a) => a.cube)), t.measures)
+      for (const a of t.measures) {
+        const [m, d] = a.split("."), u = l.find((f) => f.name === m);
+        if (u && u.measures[d]) {
+          const f = u.measures[d];
+          s[a] = {
+            title: f.title || d,
+            shortTitle: f.title || d,
+            type: f.type
           };
         }
       }
-    if (n.dimensions)
-      for (const a of n.dimensions) {
-        const [r, o] = a.split(".");
-        if (r === e.name && e.dimensions[o]) {
-          const m = e.dimensions[o];
-          t[a] = {
-            title: m.title || o,
-            shortTitle: m.title || o,
-            type: m.type,
-            format: m.format
+    if (t.dimensions)
+      for (const a of t.dimensions) {
+        const [m, d] = a.split("."), u = l.find((f) => f.name === m);
+        if (u && u.dimensions[d]) {
+          const f = u.dimensions[d];
+          i[a] = {
+            title: f.title || d,
+            shortTitle: f.title || d,
+            type: f.type
           };
         }
       }
-    if (n.timeDimensions)
-      for (const a of n.timeDimensions) {
-        const [r, o] = a.dimension.split(".");
-        if (r === e.name && e.dimensions[o]) {
-          const m = e.dimensions[o];
-          s[a.dimension] = {
-            title: m.title || o,
-            shortTitle: m.title || o,
-            type: m.type,
+    if (t.timeDimensions)
+      for (const a of t.timeDimensions) {
+        const [m, d] = a.dimension.split("."), u = l.find((f) => f.name === m);
+        if (u && u.dimensions && u.dimensions[d]) {
+          const f = u.dimensions[d];
+          o[a.dimension] = {
+            title: f.title || d,
+            shortTitle: f.title || d,
+            type: f.type,
             granularity: a.granularity
           };
         }
       }
     return {
-      measures: i,
-      dimensions: t,
+      measures: s,
+      dimensions: i,
       segments: {},
-      timeDimensions: s
+      timeDimensions: o
     };
   }
 }
-class d {
+class te {
   constructor(e) {
-    c(this, "cubes", /* @__PURE__ */ new Map());
-    c(this, "dbExecutor");
-    this.dbExecutor = e;
+    r(this, "cubes", /* @__PURE__ */ new Map());
+    r(this, "dbExecutor");
+    e != null && e.databaseExecutor ? this.dbExecutor = e.databaseExecutor : e != null && e.drizzle && (this.dbExecutor = me(
+      e.drizzle,
+      e.schema,
+      e.engineType
+    ));
   }
+  /**
+   * Set or update the database executor
+   */
   setDatabaseExecutor(e) {
     this.dbExecutor = e;
   }
+  /**
+   * Set Drizzle instance and schema directly
+   */
+  setDrizzle(e, t, s) {
+    this.dbExecutor = me(e, t, s);
+  }
+  /**
+   * Check if database executor is configured
+   */
+  hasExecutor() {
+    return !!this.dbExecutor;
+  }
+  /**
+   * Register a simplified cube with dynamic query building
+   */
   registerCube(e) {
-    this.validateCube(e);
-    const n = this.compileCube(e);
-    this.cubes.set(e.name, n);
+    this.cubes.set(e.name, e);
   }
+  /**
+   * Get a cube by name
+   */
   getCube(e) {
     return this.cubes.get(e);
   }
+  /**
+   * Get all registered cubes
+   */
   getAllCubes() {
     return Array.from(this.cubes.values());
   }
-  getMetadata() {
-    return Array.from(this.cubes.values()).map((e) => this.generateCubeMetadata(e));
+  /**
+   * Get all cubes as a Map for multi-cube queries
+   */
+  getAllCubesMap() {
+    return this.cubes;
+  }
+  /**
+   * Unified query execution method that handles both single and multi-cube queries
+   */
+  async execute(e, t) {
+    if (!this.dbExecutor)
+      throw new Error("Database executor not configured");
+    return new de(this.dbExecutor).execute(this.cubes, e, t);
   }
-  validateCube(e) {
-    if (!e.name)
-      throw new Error("Cube must have a name");
-    if (!e.sql)
-      throw new Error(`Cube ${e.name} must have SQL definition`);
-    if (!e.measures || Object.keys(e.measures).length === 0)
-      throw new Error(`Cube ${e.name} must have at least one measure`);
+  /**
+   * Execute a multi-cube query
+   */
+  async executeMultiCubeQuery(e, t) {
+    return this.execute(e, t);
   }
-  compileCube(e) {
-    return {
-      ...e,
-      queryFn: async (i, t) => {
-        if (!this.dbExecutor)
-          throw new Error("Database executor not configured. Call setDatabaseExecutor() first.");
-        return new f(this.dbExecutor).executeQuery(e, i, t);
-      }
-    };
+  /**
+   * Execute a single cube query
+   */
+  async executeQuery(e, t, s) {
+    if (!this.cubes.get(e))
+      throw new Error(`Cube '${e}' not found`);
+    return this.execute(t, s);
+  }
+  /**
+   * Get metadata for all cubes (for API responses)
+   */
+  getMetadata() {
+    return Array.from(this.cubes.values()).map((e) => this.generateCubeMetadata(e));
   }
+  /**
+   * Generate cube metadata for API responses from cubes
+   */
   generateCubeMetadata(e) {
-    const n = Object.entries(e.measures).map(([t, s]) => ({
-      name: `${e.name}.${t}`,
-      title: s.title || t,
-      shortTitle: s.title || t,
-      type: s.type,
-      format: s.format,
-      description: s.description
-    })), i = Object.entries(e.dimensions).map(([t, s]) => ({
-      name: `${e.name}.${t}`,
-      title: s.title || t,
-      shortTitle: s.title || t,
-      type: s.type,
-      format: s.format,
-      description: s.description
+    const t = Object.entries(e.measures).map(([i, o]) => ({
+      name: `${e.name}.${i}`,
+      title: o.title || i,
+      shortTitle: o.title || i,
+      type: o.type,
+      format: void 0,
+      // Measure doesn't have format field
+      description: o.description
+    })), s = Object.entries(e.dimensions).map(([i, o]) => ({
+      name: `${e.name}.${i}`,
+      title: o.title || i,
+      shortTitle: o.title || i,
+      type: o.type,
+      format: void 0,
+      // Dimension doesn't have format field
+      description: o.description
     }));
     return {
       name: e.name,
       title: e.title || e.name,
       description: e.description,
-      measures: n,
-      dimensions: i,
+      measures: t,
+      dimensions: s,
       segments: []
       // Add segments support later if needed
     };
   }
-}
-const E = new d(), g = {
-  name: "Employees",
-  title: "Employee Analytics",
-  description: "Employee data for workforce analysis",
-  sql: `
-    SELECT 
-      e.id,
-      e.name,
-      e.email,
-      e.active,
-      e.fte_basis,
-      e.start_date,
-      e.end_date,
-      d.name as department_name,
-      s.name as supplier_name,
-      s.internal as supplier_internal
-    FROM employees e
-    LEFT JOIN departments d ON e.department = d.id
-    LEFT JOIN suppliers s ON e.supplier = s.id
-    WHERE e.organisation = \${SECURITY_CONTEXT.organisation}
-  `,
-  dimensions: {
-    id: {
-      name: "id",
-      title: "Employee ID",
-      type: "string",
-      sql: "id",
-      primaryKey: !0
-    },
-    name: {
-      name: "name",
-      title: "Employee Name",
-      type: "string",
-      sql: "name"
-    },
-    email: {
-      name: "email",
-      title: "Email",
-      type: "string",
-      sql: "email"
-    },
-    active: {
-      name: "active",
-      title: "Active Status",
-      type: "boolean",
-      sql: "active"
-    },
-    departmentName: {
-      name: "departmentName",
-      title: "Department",
-      type: "string",
-      sql: "department_name"
-    },
-    supplierName: {
-      name: "supplierName",
-      title: "Supplier",
-      type: "string",
-      sql: "supplier_name"
-    },
-    supplierType: {
-      name: "supplierType",
-      title: "Supplier Type",
-      type: "string",
-      sql: "CASE WHEN supplier_internal THEN 'Internal' ELSE 'External' END"
-    },
-    startDate: {
-      name: "startDate",
-      title: "Start Date",
-      type: "time",
-      sql: "start_date"
-    }
-  },
-  measures: {
-    count: {
-      name: "count",
-      title: "Employee Count",
-      type: "count",
-      sql: "id"
-    },
-    activeCount: {
-      name: "activeCount",
-      title: "Active Employees",
-      type: "count",
-      sql: "id",
-      filters: [{ sql: "active = true" }]
-    },
-    totalFte: {
-      name: "totalFte",
-      title: "Total FTE",
-      type: "sum",
-      sql: "fte_basis",
-      format: "number"
-    },
-    averageFte: {
-      name: "averageFte",
-      title: "Average FTE",
-      type: "avg",
-      sql: "fte_basis",
-      format: "number"
-    }
-  }
-}, C = {
-  name: "Departments",
-  title: "Department Analytics",
-  description: "Organizational department data",
-  sql: `
-    SELECT 
-      d.id,
-      d.name,
-      d.description,
-      COUNT(e.id) as employee_count
-    FROM departments d
-    LEFT JOIN employees e ON d.id = e.department AND e.active = true
-    WHERE d.organisation = \${SECURITY_CONTEXT.organisation}
-    GROUP BY d.id, d.name, d.description
-  `,
-  dimensions: {
-    id: {
-      name: "id",
-      title: "Department ID",
-      type: "string",
-      sql: "id",
-      primaryKey: !0
-    },
-    name: {
-      name: "name",
-      title: "Department Name",
-      type: "string",
-      sql: "name"
-    },
-    description: {
-      name: "description",
-      title: "Description",
-      type: "string",
-      sql: "description"
-    }
-  },
-  measures: {
-    count: {
-      name: "count",
-      title: "Department Count",
-      type: "count",
-      sql: "id"
-    },
-    employeeCount: {
-      name: "employeeCount",
-      title: "Employee Count",
-      type: "sum",
-      sql: "employee_count"
-    }
-  }
-}, $ = {
-  name: "EmployeeDepartments",
-  title: "Employee Department Analysis",
-  description: "Combined employee and department analytics",
-  sql: `
-    SELECT 
-      e.id as employee_id,
-      e.name as employee_name,
-      e.active,
-      e.fte_basis,
-      d.id as department_id,
-      d.name as department_name
-    FROM employees e
-    LEFT JOIN departments d ON e.department = d.id
-    WHERE e.organisation = \${SECURITY_CONTEXT.organisation}
-  `,
-  dimensions: {
-    employeeName: {
-      name: "employeeName",
-      title: "Employee Name",
-      type: "string",
-      sql: "employee_name"
-    },
-    departmentName: {
-      name: "departmentName",
-      title: "Department Name",
-      type: "string",
-      sql: "department_name"
-    },
-    active: {
-      name: "active",
-      title: "Active",
-      type: "boolean",
-      sql: "active"
-    }
-  },
-  measures: {
-    employeeCount: {
-      name: "employeeCount",
-      title: "Employee Count",
-      type: "count",
-      sql: "employee_id"
-    },
-    activeEmployeeCount: {
-      name: "activeEmployeeCount",
-      title: "Active Employee Count",
-      type: "count",
-      sql: "employee_id",
-      filters: [{ sql: "active = true" }]
-    },
-    totalFte: {
-      name: "totalFte",
-      title: "Total FTE",
-      type: "sum",
-      sql: "fte_basis"
-    }
-  }
-}, T = [
-  g,
-  C,
-  $
-], v = E;
-function q(l) {
-  return new d(l);
-}
-const D = {
   /**
-   * Create a simple query builder
+   * Get SQL for a query without executing it (debugging)
    */
-  query: (l) => {
-    const e = (n, i = [], t = [], s = [], a, r) => ({
-      measures: n,
-      dimensions: i,
-      filters: t,
-      timeDimensions: s,
-      limit: a,
-      order: r
+  async generateSQL(e, t, s) {
+    const i = this.getCube(e);
+    if (!i)
+      throw new Error(`Cube '${e}' not found`);
+    if (!this.dbExecutor)
+      throw new Error("Database executor not configured");
+    return new de(this.dbExecutor).generateSQL(i, t, s);
+  }
+  /**
+   * Check if a cube exists
+   */
+  hasCube(e) {
+    return this.cubes.has(e);
+  }
+  /**
+   * Remove a cube
+   */
+  removeCube(e) {
+    return this.cubes.delete(e);
+  }
+  /**
+   * Clear all cubes
+   */
+  clearCubes() {
+    this.cubes.clear();
+  }
+  /**
+   * Get cube names
+   */
+  getCubeNames() {
+    return Array.from(this.cubes.keys());
+  }
+}
+function Da(n) {
+  return new te(n);
+}
+const wo = new te();
+function xo(n) {
+  const e = {
+    valid: !0,
+    errors: [],
+    warnings: [],
+    cubes: []
+  };
+  try {
+    const t = lo(n);
+    if (!t)
+      return e.valid = !1, e.errors.push("Invalid YAML: empty or malformed content"), e;
+    if (t.cubes && Array.isArray(t.cubes))
+      e.cubes = t.cubes;
+    else if (t.name)
+      e.cubes = [t];
+    else
+      return e.valid = !1, e.errors.push('YAML must contain either a "cubes" array or cube properties at root level'), e;
+    for (const s of e.cubes) {
+      const i = No(s);
+      e.errors.push(...i);
+    }
+    e.valid = e.errors.length === 0;
+  } catch (t) {
+    e.valid = !1, e.errors.push(`YAML parsing error: ${t instanceof Error ? t.message : String(t)}`);
+  }
+  return e;
+}
+function No(n) {
+  const e = [];
+  return n.name || e.push("Cube name is required"), !n.sql && !n.sql_table && !n.sqlTable && e.push('Cube must have either "sql", "sql_table", or "sqlTable" property'), n.dimensions && n.dimensions.forEach((t, s) => {
+    t.name || e.push(`Dimension at index ${s} is missing name`), t.type || e.push(`Dimension "${t.name}" is missing type`), t.sql || e.push(`Dimension "${t.name}" is missing sql`);
+  }), n.measures && n.measures.forEach((t, s) => {
+    t.name || e.push(`Measure at index ${s} is missing name`), t.type || e.push(`Measure "${t.name}" is missing type`), t.sql || e.push(`Measure "${t.name}" is missing sql`);
+  }), n.joins && n.joins.forEach((t, s) => {
+    t.name || e.push(`Join at index ${s} is missing name`), t.relationship || e.push(`Join "${t.name}" is missing relationship`), t.sql || e.push(`Join "${t.name}" is missing sql`);
+  }), e;
+}
+function To(n) {
+  const e = {};
+  n.dimensions && n.dimensions.forEach((a) => {
+    e[a.name] = Co(a);
+  });
+  const t = {};
+  n.measures && n.measures.forEach((a) => {
+    t[a.name] = So(a);
+  });
+  const s = {};
+  n.joins && n.joins.forEach((a) => {
+    s[a.name] = vo(a);
+  });
+  const i = {};
+  (n.pre_aggregations || n.preAggregations) && (n.pre_aggregations || n.preAggregations || []).forEach((m) => {
+    i[m.name] = Eo(m);
+  });
+  let o = n.sql;
+  !o && (n.sql_table || n.sqlTable) && (o = `SELECT * FROM ${n.sql_table || n.sqlTable}`);
+  const l = n.refresh_key || n.refreshKey;
+  return {
+    name: n.name,
+    title: n.title,
+    description: n.description,
+    sql: o || "",
+    sqlAlias: n.sql_alias || n.sqlAlias,
+    dataSource: n.data_source || n.dataSource,
+    refreshKey: l ? {
+      every: l.every,
+      sql: l.sql
+    } : void 0,
+    dimensions: e,
+    measures: t,
+    joins: Object.keys(s).length > 0 ? s : void 0,
+    preAggregations: Object.keys(i).length > 0 ? i : void 0,
+    meta: n.meta
+  };
+}
+function Co(n) {
+  return {
+    name: n.name,
+    title: n.title,
+    description: n.description,
+    type: n.type,
+    sql: n.sql,
+    primaryKey: n.primary_key || n.primaryKey,
+    shown: n.shown,
+    format: n.format,
+    meta: n.meta
+  };
+}
+function So(n) {
+  var s;
+  const e = (s = n.filters) == null ? void 0 : s.map((i) => ({
+    sql: i.sql
+  })), t = n.rolling_window || n.rollingWindow;
+  return {
+    name: n.name,
+    title: n.title,
+    description: n.description,
+    type: n.type,
+    sql: n.sql,
+    format: n.format,
+    shown: n.shown,
+    filters: e,
+    rollingWindow: t,
+    meta: n.meta
+  };
+}
+function Po(n) {
+  switch (n) {
+    case "one_to_one":
+      return "hasOne";
+    case "one_to_many":
+      return "hasMany";
+    case "many_to_one":
+      return "belongsTo";
+    default:
+      return "belongsTo";
+  }
+}
+function Do(n) {
+  switch (n) {
+    case "hasOne":
+      return "one_to_one";
+    case "hasMany":
+      return "one_to_many";
+    case "belongsTo":
+      return "many_to_one";
+    default:
+      return "many_to_one";
+  }
+}
+function vo(n) {
+  return {
+    name: n.name,
+    type: n.type,
+    relationship: Po(n.relationship),
+    sql: n.sql
+  };
+}
+function Eo(n) {
+  const e = n.time_dimension || n.timeDimension, t = n.refresh_key || n.refreshKey;
+  return {
+    name: n.name,
+    measures: n.measures,
+    dimensions: n.dimensions,
+    timeDimension: e,
+    refreshKey: t,
+    indexes: n.indexes
+  };
+}
+async function $o() {
+  try {
+    const { promises: n } = await import("fs"), e = await n.readFile("non-existent-file.txt", "utf-8").catch((t) => t.message);
+    return !(typeof e == "string" && e.includes("not implemented"));
+  } catch {
+    return !1;
+  }
+}
+function Bo(n) {
+  const e = xo(n);
+  if (!e.valid)
+    throw new Error(`Invalid YAML cube definition:
+${e.errors.join(`
+`)}`);
+  return e.cubes.map((t) => To(t));
+}
+async function va(n) {
+  if (!await $o())
+    return console.log("ℹ️ YAML file loading not supported in this environment (Cloudflare Workers/Edge Runtime). Use inline YAML strings or build-time transformations instead."), [];
+  try {
+    const { promises: t } = await import("fs"), s = await t.readFile(n, "utf-8");
+    return Bo(s);
+  } catch (t) {
+    return console.log(`ℹ️ Could not load YAML file ${n}:`, t instanceof Error ? t.message : t), [];
+  }
+}
+function Ea(n) {
+  let e = n;
+  return e = e.replace(/\{CUBE\}/g, "${CUBE}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\$\$\{/g, "${"), e;
+}
+function $a(n) {
+  const e = {
+    name: n.name,
+    title: n.title,
+    description: n.description,
+    sql: typeof n.sql == "string" ? n.sql : void 0,
+    dimensions: Object.values(n.dimensions).map((t) => ({
+      name: t.name,
+      title: t.title,
+      description: t.description,
+      type: t.type,
+      sql: typeof t.sql == "string" ? t.sql : "",
+      primary_key: t.primaryKey,
+      shown: t.shown,
+      format: t.format,
+      meta: t.meta
+    })),
+    measures: Object.values(n.measures).map((t) => {
+      var s;
+      return {
+        name: t.name,
+        title: t.title,
+        description: t.description,
+        type: t.type,
+        sql: typeof t.sql == "string" ? t.sql : "",
+        format: t.format,
+        shown: t.shown,
+        filters: (s = t.filters) == null ? void 0 : s.map((i) => ({
+          sql: typeof i.sql == "string" ? i.sql : ""
+        })),
+        rolling_window: t.rollingWindow,
+        meta: t.meta
+      };
+    }),
+    joins: n.joins ? Object.values(n.joins).map((t) => ({
+      name: t.name || "",
+      type: t.type,
+      relationship: Do(t.relationship),
+      sql: typeof t.sql == "string" ? t.sql : ""
+    })) : void 0,
+    meta: n.meta
+  };
+  return mo(e, {
+    indent: 2,
+    lineWidth: 120,
+    minContentWidth: 40
+  });
+}
+const c = Symbol.for("drizzle:entityKind");
+function T(n, e) {
+  if (!n || typeof n != "object")
+    return !1;
+  if (n instanceof e)
+    return !0;
+  if (!Object.prototype.hasOwnProperty.call(e, c))
+    throw new Error(
+      `Class "${e.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  let t = Object.getPrototypeOf(n).constructor;
+  if (t)
+    for (; t; ) {
+      if (c in t && t[c] === e[c])
+        return !0;
+      t = Object.getPrototypeOf(t);
+    }
+  return !1;
+}
+var xe;
+xe = c;
+class K {
+  constructor(e, t) {
+    r(this, "name");
+    r(this, "keyAsName");
+    r(this, "primary");
+    r(this, "notNull");
+    r(this, "default");
+    r(this, "defaultFn");
+    r(this, "onUpdateFn");
+    r(this, "hasDefault");
+    r(this, "isUnique");
+    r(this, "uniqueName");
+    r(this, "uniqueType");
+    r(this, "dataType");
+    r(this, "columnType");
+    r(this, "enumValues");
+    r(this, "generated");
+    r(this, "generatedIdentity");
+    r(this, "config");
+    this.table = e, this.config = t, this.name = t.name, this.keyAsName = t.keyAsName, this.notNull = t.notNull, this.default = t.default, this.defaultFn = t.defaultFn, this.onUpdateFn = t.onUpdateFn, this.hasDefault = t.hasDefault, this.primary = t.primaryKey, this.isUnique = t.isUnique, this.uniqueName = t.uniqueName, this.uniqueType = t.uniqueType, this.dataType = t.dataType, this.columnType = t.columnType, this.generated = t.generated, this.generatedIdentity = t.generatedIdentity;
+  }
+  mapFromDriverValue(e) {
+    return e;
+  }
+  mapToDriverValue(e) {
+    return e;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+}
+r(K, xe, "Column");
+var Ne;
+Ne = c;
+class fi {
+  constructor(e, t, s) {
+    r(this, "config");
+    /**
+     * Alias for {@link $defaultFn}.
+     */
+    r(this, "$default", this.$defaultFn);
+    /**
+     * Alias for {@link $onUpdateFn}.
+     */
+    r(this, "$onUpdate", this.$onUpdateFn);
+    this.config = {
+      name: e,
+      keyAsName: e === "",
+      notNull: !1,
+      default: void 0,
+      hasDefault: !1,
+      primaryKey: !1,
+      isUnique: !1,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType: t,
+      columnType: s,
+      generated: void 0
+    };
+  }
+  /**
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
+   */
+  $type() {
+    return this;
+  }
+  /**
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+   */
+  notNull() {
+    return this.config.notNull = !0, this;
+  }
+  /**
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+   */
+  default(e) {
+    return this.config.default = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $defaultFn(e) {
+    return this.config.defaultFn = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(e) {
+    return this.config.onUpdateFn = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    return this.config.primaryKey = !0, this.config.notNull = !0, this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(e) {
+    this.config.name === "" && (this.config.name = e);
+  }
+}
+r(fi, Ne, "ColumnBuilder");
+const Q = Symbol.for("drizzle:Name");
+var Te;
+Te = c;
+class pi {
+  constructor(e, t) {
+    /** @internal */
+    r(this, "reference");
+    /** @internal */
+    r(this, "_onUpdate", "no action");
+    /** @internal */
+    r(this, "_onDelete", "no action");
+    this.reference = () => {
+      const { name: s, columns: i, foreignColumns: o } = e();
+      return { name: s, columns: i, foreignTable: o[0].table, foreignColumns: o };
+    }, t && (this._onUpdate = t.onUpdate, this._onDelete = t.onDelete);
+  }
+  onUpdate(e) {
+    return this._onUpdate = e === void 0 ? "no action" : e, this;
+  }
+  onDelete(e) {
+    return this._onDelete = e === void 0 ? "no action" : e, this;
+  }
+  /** @internal */
+  build(e) {
+    return new hi(e, this);
+  }
+}
+r(pi, Te, "PgForeignKeyBuilder");
+var Ce;
+Ce = c;
+class hi {
+  constructor(e, t) {
+    r(this, "reference");
+    r(this, "onUpdate");
+    r(this, "onDelete");
+    this.table = e, this.reference = t.reference, this.onUpdate = t._onUpdate, this.onDelete = t._onDelete;
+  }
+  getName() {
+    const { name: e, columns: t, foreignColumns: s } = this.reference(), i = t.map((a) => a.name), o = s.map((a) => a.name), l = [
+      this.table[Q],
+      ...i,
+      s[0].table[Q],
+      ...o
+    ];
+    return e ?? `${l.join("_")}_fk`;
+  }
+}
+r(hi, Ce, "PgForeignKey");
+function zo(n, ...e) {
+  return n(...e);
+}
+function Fo(n, e) {
+  return `${n[Q]}_${e.join("_")}_unique`;
+}
+function fe(n, e, t) {
+  for (let s = e; s < n.length; s++) {
+    const i = n[s];
+    if (i === "\\") {
+      s++;
+      continue;
+    }
+    if (i === '"')
+      return [n.slice(e, s).replace(/\\/g, ""), s + 1];
+    if (!t && (i === "," || i === "}"))
+      return [n.slice(e, s).replace(/\\/g, ""), s];
+  }
+  return [n.slice(e).replace(/\\/g, ""), n.length];
+}
+function gi(n, e = 0) {
+  const t = [];
+  let s = e, i = !1;
+  for (; s < n.length; ) {
+    const o = n[s];
+    if (o === ",") {
+      (i || s === e) && t.push(""), i = !0, s++;
+      continue;
+    }
+    if (i = !1, o === "\\") {
+      s += 2;
+      continue;
+    }
+    if (o === '"') {
+      const [m, d] = fe(n, s + 1, !0);
+      t.push(m), s = d;
+      continue;
+    }
+    if (o === "}")
+      return [t, s + 1];
+    if (o === "{") {
+      const [m, d] = gi(n, s + 1);
+      t.push(m), s = d;
+      continue;
+    }
+    const [l, a] = fe(n, s, !1);
+    t.push(l), s = a;
+  }
+  return [t, s];
+}
+function Lo(n) {
+  const [e] = gi(n, 1);
+  return e;
+}
+function bi(n) {
+  return `{${n.map((e) => Array.isArray(e) ? bi(e) : typeof e == "string" ? `"${e.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : `${e}`).join(",")}}`;
+}
+var Se, Pe;
+class b extends (Pe = fi, Se = c, Pe) {
+  constructor() {
+    super(...arguments);
+    r(this, "foreignKeyConfigs", []);
+  }
+  array(t) {
+    return new wi(this.config.name, this, t);
+  }
+  references(t, s = {}) {
+    return this.foreignKeyConfigs.push({ ref: t, actions: s }), this;
+  }
+  unique(t, s) {
+    return this.config.isUnique = !0, this.config.uniqueName = t, this.config.uniqueType = s == null ? void 0 : s.nulls, this;
+  }
+  generatedAlwaysAs(t) {
+    return this.config.generated = {
+      as: t,
+      type: "always",
+      mode: "stored"
+    }, this;
+  }
+  /** @internal */
+  buildForeignKeys(t, s) {
+    return this.foreignKeyConfigs.map(({ ref: i, actions: o }) => zo(
+      (l, a) => {
+        const m = new pi(() => {
+          const d = l();
+          return { columns: [t], foreignColumns: [d] };
+        });
+        return a.onUpdate && m.onUpdate(a.onUpdate), a.onDelete && m.onDelete(a.onDelete), m.build(s);
+      },
+      i,
+      o
+    ));
+  }
+  /** @internal */
+  buildExtraConfigColumn(t) {
+    return new yi(t, this.config);
+  }
+}
+r(b, Se, "PgColumnBuilder");
+var De, ve;
+class g extends (ve = K, De = c, ve) {
+  constructor(e, t) {
+    t.uniqueName || (t.uniqueName = Fo(e, [t.name])), super(e, t), this.table = e;
+  }
+}
+r(g, De, "PgColumn");
+var Ee, $e;
+class yi extends ($e = g, Ee = c, $e) {
+  constructor() {
+    super(...arguments);
+    r(this, "indexConfig", {
+      order: this.config.order ?? "asc",
+      nulls: this.config.nulls ?? "last",
+      opClass: this.config.opClass
+    });
+    r(this, "defaultConfig", {
+      order: "asc",
+      nulls: "last",
+      opClass: void 0
+    });
+  }
+  getSQLType() {
+    return this.getSQLType();
+  }
+  asc() {
+    return this.indexConfig.order = "asc", this;
+  }
+  desc() {
+    return this.indexConfig.order = "desc", this;
+  }
+  nullsFirst() {
+    return this.indexConfig.nulls = "first", this;
+  }
+  nullsLast() {
+    return this.indexConfig.nulls = "last", this;
+  }
+  /**
+   * ### PostgreSQL documentation quote
+   *
+   * > An operator class with optional parameters can be specified for each column of an index.
+   * The operator class identifies the operators to be used by the index for that column.
+   * For example, a B-tree index on four-byte integers would use the int4_ops class;
+   * this operator class includes comparison functions for four-byte integers.
+   * In practice the default operator class for the column's data type is usually sufficient.
+   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
+   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+   * More information about operator classes check:
+   *
+   * ### Useful links
+   * https://www.postgresql.org/docs/current/sql-createindex.html
+   *
+   * https://www.postgresql.org/docs/current/indexes-opclass.html
+   *
+   * https://www.postgresql.org/docs/current/xindex.html
+   *
+   * ### Additional types
+   * If you have the `pg_vector` extension installed in your database, you can use the
+   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+   *
+   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+   *
+   * @param opClass
+   * @returns
+   */
+  op(t) {
+    return this.indexConfig.opClass = t, this;
+  }
+}
+r(yi, Ee, "ExtraConfigColumn");
+var Be, ze;
+class wi extends (ze = b, Be = c, ze) {
+  constructor(e, t, s) {
+    super(e, "array", "PgArray"), this.config.baseBuilder = t, this.config.size = s;
+  }
+  /** @internal */
+  build(e) {
+    const t = this.config.baseBuilder.build(e);
+    return new X(
+      e,
+      this.config,
+      t
+    );
+  }
+}
+r(wi, Be, "PgArrayBuilder");
+var Fe, Le;
+const R = class R extends (Le = g, Fe = c, Le) {
+  constructor(t, s, i, o) {
+    super(t, s);
+    r(this, "size");
+    this.baseColumn = i, this.range = o, this.size = s.size;
+  }
+  getSQLType() {
+    return `${this.baseColumn.getSQLType()}[${typeof this.size == "number" ? this.size : ""}]`;
+  }
+  mapFromDriverValue(t) {
+    return typeof t == "string" && (t = Lo(t)), t.map((s) => this.baseColumn.mapFromDriverValue(s));
+  }
+  mapToDriverValue(t, s = !1) {
+    const i = t.map(
+      (o) => o === null ? null : T(this.baseColumn, R) ? this.baseColumn.mapToDriverValue(o, !0) : this.baseColumn.mapToDriverValue(o)
+    );
+    return s ? i : bi(i);
+  }
+};
+r(R, Fe, "PgArray");
+let X = R;
+const pe = Symbol.for("drizzle:isPgEnum");
+function Ao(n) {
+  return !!n && typeof n == "function" && pe in n && n[pe] === !0;
+}
+var Ae;
+Ae = c;
+class ne {
+  constructor(e, t, s, i = !1, o = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: e,
+      selectedFields: t,
+      alias: s,
+      isWith: i,
+      usedTables: o
+    };
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+}
+r(ne, Ae, "Subquery");
+const Qo = {
+  startActiveSpan(n, e) {
+    return e();
+  }
+}, I = Symbol.for("drizzle:ViewBaseConfig"), G = Symbol.for("drizzle:Schema"), he = Symbol.for("drizzle:Columns"), ge = Symbol.for("drizzle:ExtraConfigColumns"), H = Symbol.for("drizzle:OriginalName"), Z = Symbol.for("drizzle:BaseName"), _ = Symbol.for("drizzle:IsAlias"), be = Symbol.for("drizzle:ExtraConfigBuilder"), Vo = Symbol.for("drizzle:IsDrizzleTable");
+var Qe, Ve, Ie, je, _e, Ue, qe, Oe, Me, Re;
+Re = c, Me = Q, Oe = H, qe = G, Ue = he, _e = ge, je = Z, Ie = _, Ve = Vo, Qe = be;
+class w {
+  constructor(e, t, s) {
+    /**
+     * @internal
+     * Can be changed if the table is aliased.
+     */
+    r(this, Me);
+    /**
+     * @internal
+     * Used to store the original name of the table, before any aliasing.
+     */
+    r(this, Oe);
+    /** @internal */
+    r(this, qe);
+    /** @internal */
+    r(this, Ue);
+    /** @internal */
+    r(this, _e);
+    /**
+     *  @internal
+     * Used to store the table name before the transformation via the `tableCreator` functions.
+     */
+    r(this, je);
+    /** @internal */
+    r(this, Ie, !1);
+    /** @internal */
+    r(this, Ve, !0);
+    /** @internal */
+    r(this, Qe);
+    this[Q] = this[H] = e, this[G] = t, this[Z] = s;
+  }
+}
+r(w, Re, "Table"), /** @internal */
+r(w, "Symbol", {
+  Name: Q,
+  Schema: G,
+  OriginalName: H,
+  Columns: he,
+  ExtraConfigColumns: ge,
+  BaseName: Z,
+  IsAlias: _,
+  ExtraConfigBuilder: be
+});
+function Io(n) {
+  return n != null && typeof n.getSQL == "function";
+}
+function jo(n) {
+  var t;
+  const e = { sql: "", params: [] };
+  for (const s of n)
+    e.sql += s.sql, e.params.push(...s.params), (t = s.typings) != null && t.length && (e.typings || (e.typings = []), e.typings.push(...s.typings));
+  return e;
+}
+var Je;
+Je = c;
+class C {
+  constructor(e) {
+    r(this, "value");
+    this.value = Array.isArray(e) ? e : [e];
+  }
+  getSQL() {
+    return new N([this]);
+  }
+}
+r(C, Je, "StringChunk");
+var Ke;
+Ke = c;
+const z = class z {
+  constructor(e) {
+    /** @internal */
+    r(this, "decoder", xi);
+    r(this, "shouldInlineParams", !1);
+    /** @internal */
+    r(this, "usedTables", []);
+    this.queryChunks = e;
+    for (const t of e)
+      if (T(t, w)) {
+        const s = t[w.Symbol.Schema];
+        this.usedTables.push(
+          s === void 0 ? t[w.Symbol.Name] : s + "." + t[w.Symbol.Name]
+        );
+      }
+  }
+  append(e) {
+    return this.queryChunks.push(...e.queryChunks), this;
+  }
+  toQuery(e) {
+    return Qo.startActiveSpan("drizzle.buildSQL", (t) => {
+      const s = this.buildQueryFromSourceParams(this.queryChunks, e);
+      return t == null || t.setAttributes({
+        "drizzle.query.text": s.sql,
+        "drizzle.query.params": JSON.stringify(s.params)
+      }), s;
+    });
+  }
+  buildQueryFromSourceParams(e, t) {
+    const s = Object.assign({}, t, {
+      inlineParams: t.inlineParams || this.shouldInlineParams,
+      paramStartIndex: t.paramStartIndex || { value: 0 }
+    }), {
+      casing: i,
+      escapeName: o,
+      escapeParam: l,
+      prepareTyping: a,
+      inlineParams: m,
+      paramStartIndex: d
+    } = s;
+    return jo(e.map((u) => {
+      var f;
+      if (T(u, C))
+        return { sql: u.value.join(""), params: [] };
+      if (T(u, U))
+        return { sql: o(u.value), params: [] };
+      if (u === void 0)
+        return { sql: "", params: [] };
+      if (Array.isArray(u)) {
+        const p = [new C("(")];
+        for (const [h, A] of u.entries())
+          p.push(A), h < u.length - 1 && p.push(new C(", "));
+        return p.push(new C(")")), this.buildQueryFromSourceParams(p, s);
+      }
+      if (T(u, z))
+        return this.buildQueryFromSourceParams(u.queryChunks, {
+          ...s,
+          inlineParams: m || u.shouldInlineParams
+        });
+      if (T(u, w)) {
+        const p = u[w.Symbol.Schema], h = u[w.Symbol.Name];
+        return {
+          sql: p === void 0 || u[_] ? o(h) : o(p) + "." + o(h),
+          params: []
+        };
+      }
+      if (T(u, K)) {
+        const p = i.getColumnCasing(u);
+        if (t.invokeSource === "indexes")
+          return { sql: o(p), params: [] };
+        const h = u.table[w.Symbol.Schema];
+        return {
+          sql: u.table[_] || h === void 0 ? o(u.table[w.Symbol.Name]) + "." + o(p) : o(h) + "." + o(u.table[w.Symbol.Name]) + "." + o(p),
+          params: []
+        };
+      }
+      if (T(u, Ti)) {
+        const p = u[I].schema, h = u[I].name;
+        return {
+          sql: p === void 0 || u[I].isAlias ? o(h) : o(p) + "." + o(h),
+          params: []
+        };
+      }
+      if (T(u, se)) {
+        if (T(u.value, O))
+          return { sql: l(d.value++, u), params: [u], typings: ["none"] };
+        const p = u.value === null ? null : u.encoder.mapToDriverValue(u.value);
+        if (T(p, z))
+          return this.buildQueryFromSourceParams([p], s);
+        if (m)
+          return { sql: this.mapInlineParam(p, s), params: [] };
+        let h = ["none"];
+        return a && (h = [a(u.encoder)]), { sql: l(d.value++, p), params: [p], typings: h };
+      }
+      return T(u, O) ? { sql: l(d.value++, u), params: [u], typings: ["none"] } : T(u, z.Aliased) && u.fieldAlias !== void 0 ? { sql: o(u.fieldAlias), params: [] } : T(u, ne) ? u._.isWith ? { sql: o(u._.alias), params: [] } : this.buildQueryFromSourceParams([
+        new C("("),
+        u._.sql,
+        new C(") "),
+        new U(u._.alias)
+      ], s) : Ao(u) ? u.schema ? { sql: o(u.schema) + "." + o(u.enumName), params: [] } : { sql: o(u.enumName), params: [] } : Io(u) ? (f = u.shouldOmitSQLParens) != null && f.call(u) ? this.buildQueryFromSourceParams([u.getSQL()], s) : this.buildQueryFromSourceParams([
+        new C("("),
+        u.getSQL(),
+        new C(")")
+      ], s) : m ? { sql: this.mapInlineParam(u, s), params: [] } : { sql: l(d.value++, u), params: [u], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(e, { escapeString: t }) {
+    if (e === null)
+      return "null";
+    if (typeof e == "number" || typeof e == "boolean")
+      return e.toString();
+    if (typeof e == "string")
+      return t(e);
+    if (typeof e == "object") {
+      const s = e.toString();
+      return t(s === "[object Object]" ? JSON.stringify(e) : s);
+    }
+    throw new Error("Unexpected param value: " + e);
+  }
+  getSQL() {
+    return this;
+  }
+  as(e) {
+    return e === void 0 ? this : new z.Aliased(this, e);
+  }
+  mapWith(e) {
+    return this.decoder = typeof e == "function" ? { mapFromDriverValue: e } : e, this;
+  }
+  inlineParams() {
+    return this.shouldInlineParams = !0, this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(e) {
+    return e ? this : void 0;
+  }
+};
+r(z, Ke, "SQL");
+let N = z;
+var We;
+We = c;
+class U {
+  constructor(e) {
+    r(this, "brand");
+    this.value = e;
+  }
+  getSQL() {
+    return new N([this]);
+  }
+}
+r(U, We, "Name");
+const xi = {
+  mapFromDriverValue: (n) => n
+}, Ni = {
+  mapToDriverValue: (n) => n
+};
+({
+  ...xi,
+  ...Ni
+});
+var Ye;
+Ye = c;
+class se {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(e, t = Ni) {
+    r(this, "brand");
+    this.value = e, this.encoder = t;
+  }
+  getSQL() {
+    return new N([this]);
+  }
+}
+r(se, Ye, "Param");
+function q(n, ...e) {
+  const t = [];
+  (e.length > 0 || n.length > 0 && n[0] !== "") && t.push(new C(n[0]));
+  for (const [s, i] of e.entries())
+    t.push(i, new C(n[s + 1]));
+  return new N(t);
+}
+((n) => {
+  function e() {
+    return new N([]);
+  }
+  n.empty = e;
+  function t(m) {
+    return new N(m);
+  }
+  n.fromList = t;
+  function s(m) {
+    return new N([new C(m)]);
+  }
+  n.raw = s;
+  function i(m, d) {
+    const u = [];
+    for (const [f, p] of m.entries())
+      f > 0 && d !== void 0 && u.push(d), u.push(p);
+    return new N(u);
+  }
+  n.join = i;
+  function o(m) {
+    return new U(m);
+  }
+  n.identifier = o;
+  function l(m) {
+    return new O(m);
+  }
+  n.placeholder = l;
+  function a(m, d) {
+    return new se(m, d);
+  }
+  n.param = a;
+})(q || (q = {}));
+((n) => {
+  var t;
+  t = c;
+  const s = class s {
+    constructor(o, l) {
+      /** @internal */
+      r(this, "isSelectionField", !1);
+      this.sql = o, this.fieldAlias = l;
+    }
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new s(this.sql, this.fieldAlias);
+    }
+  };
+  r(s, t, "SQL.Aliased");
+  let e = s;
+  n.Aliased = e;
+})(N || (N = {}));
+var Ge;
+Ge = c;
+class O {
+  constructor(e) {
+    this.name = e;
+  }
+  getSQL() {
+    return new N([this]);
+  }
+}
+r(O, Ge, "Placeholder");
+const _o = Symbol.for("drizzle:IsDrizzleView");
+var He, Ze, Xe;
+Xe = c, Ze = I, He = _o;
+class Ti {
+  constructor({ name: e, schema: t, selectedFields: s, query: i }) {
+    /** @internal */
+    r(this, Ze);
+    /** @internal */
+    r(this, He, !0);
+    this[I] = {
+      name: e,
+      originalName: e,
+      schema: t,
+      selectedFields: s,
+      query: i,
+      isExisting: !i,
+      isAlias: !1
+    };
+  }
+  getSQL() {
+    return new N([this]);
+  }
+}
+r(Ti, Xe, "View");
+K.prototype.getSQL = function() {
+  return new N([this]);
+};
+w.prototype.getSQL = function() {
+  return new N([this]);
+};
+ne.prototype.getSQL = function() {
+  return new N([this]);
+};
+function x(n, e) {
+  return {
+    name: typeof n == "string" && n.length > 0 ? n : "",
+    config: typeof n == "object" ? n : e
+  };
+}
+var ke, et;
+class j extends (et = b, ke = c, et) {
+  generatedAlwaysAsIdentity(e) {
+    if (e) {
+      const { name: t, ...s } = e;
+      this.config.generatedIdentity = {
+        type: "always",
+        sequenceName: t,
+        sequenceOptions: s
+      };
+    } else
+      this.config.generatedIdentity = {
+        type: "always"
+      };
+    return this.config.hasDefault = !0, this.config.notNull = !0, this;
+  }
+  generatedByDefaultAsIdentity(e) {
+    if (e) {
+      const { name: t, ...s } = e;
+      this.config.generatedIdentity = {
+        type: "byDefault",
+        sequenceName: t,
+        sequenceOptions: s
+      };
+    } else
+      this.config.generatedIdentity = {
+        type: "byDefault"
+      };
+    return this.config.hasDefault = !0, this.config.notNull = !0, this;
+  }
+}
+r(j, ke, "PgIntColumnBaseBuilder");
+var tt, nt;
+class Ci extends (nt = j, tt = c, nt) {
+  constructor(e) {
+    super(e, "number", "PgBigInt53");
+  }
+  /** @internal */
+  build(e) {
+    return new Si(e, this.config);
+  }
+}
+r(Ci, tt, "PgBigInt53Builder");
+var st, it;
+class Si extends (it = g, st = c, it) {
+  getSQLType() {
+    return "bigint";
+  }
+  mapFromDriverValue(e) {
+    return typeof e == "number" ? e : Number(e);
+  }
+}
+r(Si, st, "PgBigInt53");
+var rt, ot;
+class Pi extends (ot = j, rt = c, ot) {
+  constructor(e) {
+    super(e, "bigint", "PgBigInt64");
+  }
+  /** @internal */
+  build(e) {
+    return new Di(
+      e,
+      this.config
+    );
+  }
+}
+r(Pi, rt, "PgBigInt64Builder");
+var at, ut;
+class Di extends (ut = g, at = c, ut) {
+  getSQLType() {
+    return "bigint";
+  }
+  // eslint-disable-next-line unicorn/prefer-native-coercion-functions
+  mapFromDriverValue(e) {
+    return BigInt(e);
+  }
+}
+r(Di, at, "PgBigInt64");
+function Uo(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return s.mode === "number" ? new Ci(t) : new Pi(t);
+}
+var ct, lt;
+class vi extends (lt = b, ct = c, lt) {
+  constructor(e) {
+    super(e, "number", "PgBigSerial53"), this.config.hasDefault = !0, this.config.notNull = !0;
+  }
+  /** @internal */
+  build(e) {
+    return new Ei(
+      e,
+      this.config
+    );
+  }
+}
+r(vi, ct, "PgBigSerial53Builder");
+var mt, dt;
+class Ei extends (dt = g, mt = c, dt) {
+  getSQLType() {
+    return "bigserial";
+  }
+  mapFromDriverValue(e) {
+    return typeof e == "number" ? e : Number(e);
+  }
+}
+r(Ei, mt, "PgBigSerial53");
+var ft, pt;
+class $i extends (pt = b, ft = c, pt) {
+  constructor(e) {
+    super(e, "bigint", "PgBigSerial64"), this.config.hasDefault = !0;
+  }
+  /** @internal */
+  build(e) {
+    return new Bi(
+      e,
+      this.config
+    );
+  }
+}
+r($i, ft, "PgBigSerial64Builder");
+var ht, gt;
+class Bi extends (gt = g, ht = c, gt) {
+  getSQLType() {
+    return "bigserial";
+  }
+  // eslint-disable-next-line unicorn/prefer-native-coercion-functions
+  mapFromDriverValue(e) {
+    return BigInt(e);
+  }
+}
+r(Bi, ht, "PgBigSerial64");
+function qo(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return s.mode === "number" ? new vi(t) : new $i(t);
+}
+var bt, yt;
+class zi extends (yt = b, bt = c, yt) {
+  constructor(e) {
+    super(e, "boolean", "PgBoolean");
+  }
+  /** @internal */
+  build(e) {
+    return new Fi(e, this.config);
+  }
+}
+r(zi, bt, "PgBooleanBuilder");
+var wt, xt;
+class Fi extends (xt = g, wt = c, xt) {
+  getSQLType() {
+    return "boolean";
+  }
+}
+r(Fi, wt, "PgBoolean");
+function ie(n) {
+  return new zi(n ?? "");
+}
+var Nt, Tt;
+class Li extends (Tt = b, Nt = c, Tt) {
+  constructor(e, t) {
+    super(e, "string", "PgChar"), this.config.length = t.length, this.config.enumValues = t.enum;
+  }
+  /** @internal */
+  build(e) {
+    return new Ai(
+      e,
+      this.config
+    );
+  }
+}
+r(Li, Nt, "PgCharBuilder");
+var Ct, St;
+class Ai extends (St = g, Ct = c, St) {
+  constructor() {
+    super(...arguments);
+    r(this, "length", this.config.length);
+    r(this, "enumValues", this.config.enumValues);
+  }
+  getSQLType() {
+    return this.length === void 0 ? "char" : `char(${this.length})`;
+  }
+}
+r(Ai, Ct, "PgChar");
+function Oo(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return new Li(t, s);
+}
+var Pt, Dt;
+class Qi extends (Dt = b, Pt = c, Dt) {
+  constructor(e) {
+    super(e, "string", "PgCidr");
+  }
+  /** @internal */
+  build(e) {
+    return new Vi(e, this.config);
+  }
+}
+r(Qi, Pt, "PgCidrBuilder");
+var vt, Et;
+class Vi extends (Et = g, vt = c, Et) {
+  getSQLType() {
+    return "cidr";
+  }
+}
+r(Vi, vt, "PgCidr");
+function Mo(n) {
+  return new Qi(n ?? "");
+}
+var $t, Bt;
+class Ii extends (Bt = b, $t = c, Bt) {
+  constructor(e, t, s) {
+    super(e, "custom", "PgCustomColumn"), this.config.fieldConfig = t, this.config.customTypeParams = s;
+  }
+  /** @internal */
+  build(e) {
+    return new ji(
+      e,
+      this.config
+    );
+  }
+}
+r(Ii, $t, "PgCustomColumnBuilder");
+var zt, Ft;
+class ji extends (Ft = g, zt = c, Ft) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "sqlName");
+    r(this, "mapTo");
+    r(this, "mapFrom");
+    this.sqlName = s.customTypeParams.dataType(s.fieldConfig), this.mapTo = s.customTypeParams.toDriver, this.mapFrom = s.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(t) {
+    return typeof this.mapFrom == "function" ? this.mapFrom(t) : t;
+  }
+  mapToDriverValue(t) {
+    return typeof this.mapTo == "function" ? this.mapTo(t) : t;
+  }
+}
+r(ji, zt, "PgCustomColumn");
+function Ro(n) {
+  return (e, t) => {
+    const { name: s, config: i } = x(e, t);
+    return new Ii(s, i, n);
+  };
+}
+var Lt, At;
+class V extends (At = b, Lt = c, At) {
+  defaultNow() {
+    return this.default(q`now()`);
+  }
+}
+r(V, Lt, "PgDateColumnBaseBuilder");
+var Qt, Vt;
+class _i extends (Vt = V, Qt = c, Vt) {
+  constructor(e) {
+    super(e, "date", "PgDate");
+  }
+  /** @internal */
+  build(e) {
+    return new Ui(e, this.config);
+  }
+}
+r(_i, Qt, "PgDateBuilder");
+var It, jt;
+class Ui extends (jt = g, It = c, jt) {
+  getSQLType() {
+    return "date";
+  }
+  mapFromDriverValue(e) {
+    return new Date(e);
+  }
+  mapToDriverValue(e) {
+    return e.toISOString();
+  }
+}
+r(Ui, It, "PgDate");
+var _t, Ut;
+class qi extends (Ut = V, _t = c, Ut) {
+  constructor(e) {
+    super(e, "string", "PgDateString");
+  }
+  /** @internal */
+  build(e) {
+    return new Oi(
+      e,
+      this.config
+    );
+  }
+}
+r(qi, _t, "PgDateStringBuilder");
+var qt, Ot;
+class Oi extends (Ot = g, qt = c, Ot) {
+  getSQLType() {
+    return "date";
+  }
+}
+r(Oi, qt, "PgDateString");
+function Jo(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return (s == null ? void 0 : s.mode) === "date" ? new _i(t) : new qi(t);
+}
+var Mt, Rt;
+class Mi extends (Rt = b, Mt = c, Rt) {
+  constructor(e) {
+    super(e, "number", "PgDoublePrecision");
+  }
+  /** @internal */
+  build(e) {
+    return new Ri(
+      e,
+      this.config
+    );
+  }
+}
+r(Mi, Mt, "PgDoublePrecisionBuilder");
+var Jt, Kt;
+class Ri extends (Kt = g, Jt = c, Kt) {
+  getSQLType() {
+    return "double precision";
+  }
+  mapFromDriverValue(e) {
+    return typeof e == "string" ? Number.parseFloat(e) : e;
+  }
+}
+r(Ri, Jt, "PgDoublePrecision");
+function Ko(n) {
+  return new Mi(n ?? "");
+}
+var Wt, Yt;
+class Ji extends (Yt = b, Wt = c, Yt) {
+  constructor(e) {
+    super(e, "string", "PgInet");
+  }
+  /** @internal */
+  build(e) {
+    return new Ki(e, this.config);
+  }
+}
+r(Ji, Wt, "PgInetBuilder");
+var Gt, Ht;
+class Ki extends (Ht = g, Gt = c, Ht) {
+  getSQLType() {
+    return "inet";
+  }
+}
+r(Ki, Gt, "PgInet");
+function Wo(n) {
+  return new Ji(n ?? "");
+}
+var Zt, Xt;
+class Wi extends (Xt = j, Zt = c, Xt) {
+  constructor(e) {
+    super(e, "number", "PgInteger");
+  }
+  /** @internal */
+  build(e) {
+    return new Yi(e, this.config);
+  }
+}
+r(Wi, Zt, "PgIntegerBuilder");
+var kt, en;
+class Yi extends (en = g, kt = c, en) {
+  getSQLType() {
+    return "integer";
+  }
+  mapFromDriverValue(e) {
+    return typeof e == "string" ? Number.parseInt(e) : e;
+  }
+}
+r(Yi, kt, "PgInteger");
+function D(n) {
+  return new Wi(n ?? "");
+}
+var tn, nn;
+class Gi extends (nn = b, tn = c, nn) {
+  constructor(e, t) {
+    super(e, "string", "PgInterval"), this.config.intervalConfig = t;
+  }
+  /** @internal */
+  build(e) {
+    return new Hi(e, this.config);
+  }
+}
+r(Gi, tn, "PgIntervalBuilder");
+var sn, rn;
+class Hi extends (rn = g, sn = c, rn) {
+  constructor() {
+    super(...arguments);
+    r(this, "fields", this.config.intervalConfig.fields);
+    r(this, "precision", this.config.intervalConfig.precision);
+  }
+  getSQLType() {
+    const t = this.fields ? ` ${this.fields}` : "", s = this.precision ? `(${this.precision})` : "";
+    return `interval${t}${s}`;
+  }
+}
+r(Hi, sn, "PgInterval");
+function Yo(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return new Gi(t, s);
+}
+var on, an;
+class Zi extends (an = b, on = c, an) {
+  constructor(e) {
+    super(e, "json", "PgJson");
+  }
+  /** @internal */
+  build(e) {
+    return new Xi(e, this.config);
+  }
+}
+r(Zi, on, "PgJsonBuilder");
+var un, cn;
+class Xi extends (cn = g, un = c, cn) {
+  constructor(e, t) {
+    super(e, t);
+  }
+  getSQLType() {
+    return "json";
+  }
+  mapToDriverValue(e) {
+    return JSON.stringify(e);
+  }
+  mapFromDriverValue(e) {
+    if (typeof e == "string")
+      try {
+        return JSON.parse(e);
+      } catch {
+        return e;
+      }
+    return e;
+  }
+}
+r(Xi, un, "PgJson");
+function Go(n) {
+  return new Zi(n ?? "");
+}
+var ln, mn;
+class ki extends (mn = b, ln = c, mn) {
+  constructor(e) {
+    super(e, "json", "PgJsonb");
+  }
+  /** @internal */
+  build(e) {
+    return new er(e, this.config);
+  }
+}
+r(ki, ln, "PgJsonbBuilder");
+var dn, fn;
+class er extends (fn = g, dn = c, fn) {
+  constructor(e, t) {
+    super(e, t);
+  }
+  getSQLType() {
+    return "jsonb";
+  }
+  mapToDriverValue(e) {
+    return JSON.stringify(e);
+  }
+  mapFromDriverValue(e) {
+    if (typeof e == "string")
+      try {
+        return JSON.parse(e);
+      } catch {
+        return e;
+      }
+    return e;
+  }
+}
+r(er, dn, "PgJsonb");
+function Ho(n) {
+  return new ki(n ?? "");
+}
+var pn, hn;
+class tr extends (hn = b, pn = c, hn) {
+  constructor(e) {
+    super(e, "array", "PgLine");
+  }
+  /** @internal */
+  build(e) {
+    return new nr(
+      e,
+      this.config
+    );
+  }
+}
+r(tr, pn, "PgLineBuilder");
+var gn, bn;
+class nr extends (bn = g, gn = c, bn) {
+  getSQLType() {
+    return "line";
+  }
+  mapFromDriverValue(e) {
+    const [t, s, i] = e.slice(1, -1).split(",");
+    return [Number.parseFloat(t), Number.parseFloat(s), Number.parseFloat(i)];
+  }
+  mapToDriverValue(e) {
+    return `{${e[0]},${e[1]},${e[2]}}`;
+  }
+}
+r(nr, gn, "PgLine");
+var yn, wn;
+class sr extends (wn = b, yn = c, wn) {
+  constructor(e) {
+    super(e, "json", "PgLineABC");
+  }
+  /** @internal */
+  build(e) {
+    return new ir(
+      e,
+      this.config
+    );
+  }
+}
+r(sr, yn, "PgLineABCBuilder");
+var xn, Nn;
+class ir extends (Nn = g, xn = c, Nn) {
+  getSQLType() {
+    return "line";
+  }
+  mapFromDriverValue(e) {
+    const [t, s, i] = e.slice(1, -1).split(",");
+    return { a: Number.parseFloat(t), b: Number.parseFloat(s), c: Number.parseFloat(i) };
+  }
+  mapToDriverValue(e) {
+    return `{${e.a},${e.b},${e.c}}`;
+  }
+}
+r(ir, xn, "PgLineABC");
+function Zo(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return !(s != null && s.mode) || s.mode === "tuple" ? new tr(t) : new sr(t);
+}
+var Tn, Cn;
+class rr extends (Cn = b, Tn = c, Cn) {
+  constructor(e) {
+    super(e, "string", "PgMacaddr");
+  }
+  /** @internal */
+  build(e) {
+    return new or(e, this.config);
+  }
+}
+r(rr, Tn, "PgMacaddrBuilder");
+var Sn, Pn;
+class or extends (Pn = g, Sn = c, Pn) {
+  getSQLType() {
+    return "macaddr";
+  }
+}
+r(or, Sn, "PgMacaddr");
+function Xo(n) {
+  return new rr(n ?? "");
+}
+var Dn, vn;
+class ar extends (vn = b, Dn = c, vn) {
+  constructor(e) {
+    super(e, "string", "PgMacaddr8");
+  }
+  /** @internal */
+  build(e) {
+    return new ur(e, this.config);
+  }
+}
+r(ar, Dn, "PgMacaddr8Builder");
+var En, $n;
+class ur extends ($n = g, En = c, $n) {
+  getSQLType() {
+    return "macaddr8";
+  }
+}
+r(ur, En, "PgMacaddr8");
+function ko(n) {
+  return new ar(n ?? "");
+}
+var Bn, zn;
+class cr extends (zn = b, Bn = c, zn) {
+  constructor(e, t, s) {
+    super(e, "string", "PgNumeric"), this.config.precision = t, this.config.scale = s;
+  }
+  /** @internal */
+  build(e) {
+    return new lr(e, this.config);
+  }
+}
+r(cr, Bn, "PgNumericBuilder");
+var Fn, Ln;
+class lr extends (Ln = g, Fn = c, Ln) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "precision");
+    r(this, "scale");
+    this.precision = s.precision, this.scale = s.scale;
+  }
+  mapFromDriverValue(t) {
+    return typeof t == "string" ? t : String(t);
+  }
+  getSQLType() {
+    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
+  }
+}
+r(lr, Fn, "PgNumeric");
+var An, Qn;
+class mr extends (Qn = b, An = c, Qn) {
+  constructor(e, t, s) {
+    super(e, "number", "PgNumericNumber"), this.config.precision = t, this.config.scale = s;
+  }
+  /** @internal */
+  build(e) {
+    return new dr(
+      e,
+      this.config
+    );
+  }
+}
+r(mr, An, "PgNumericNumberBuilder");
+var Vn, In;
+class dr extends (In = g, Vn = c, In) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "precision");
+    r(this, "scale");
+    r(this, "mapToDriverValue", String);
+    this.precision = s.precision, this.scale = s.scale;
+  }
+  mapFromDriverValue(t) {
+    return typeof t == "number" ? t : Number(t);
+  }
+  getSQLType() {
+    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
+  }
+}
+r(dr, Vn, "PgNumericNumber");
+var jn, _n;
+class fr extends (_n = b, jn = c, _n) {
+  constructor(e, t, s) {
+    super(e, "bigint", "PgNumericBigInt"), this.config.precision = t, this.config.scale = s;
+  }
+  /** @internal */
+  build(e) {
+    return new pr(
+      e,
+      this.config
+    );
+  }
+}
+r(fr, jn, "PgNumericBigIntBuilder");
+var Un, qn;
+class pr extends (qn = g, Un = c, qn) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "precision");
+    r(this, "scale");
+    r(this, "mapFromDriverValue", BigInt);
+    r(this, "mapToDriverValue", String);
+    this.precision = s.precision, this.scale = s.scale;
+  }
+  getSQLType() {
+    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
+  }
+}
+r(pr, Un, "PgNumericBigInt");
+function hr(n, e) {
+  const { name: t, config: s } = x(n, e), i = s == null ? void 0 : s.mode;
+  return i === "number" ? new mr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale) : i === "bigint" ? new fr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale) : new cr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale);
+}
+const ea = hr;
+var On, Mn;
+class gr extends (Mn = b, On = c, Mn) {
+  constructor(e) {
+    super(e, "array", "PgPointTuple");
+  }
+  /** @internal */
+  build(e) {
+    return new br(
+      e,
+      this.config
+    );
+  }
+}
+r(gr, On, "PgPointTupleBuilder");
+var Rn, Jn;
+class br extends (Jn = g, Rn = c, Jn) {
+  getSQLType() {
+    return "point";
+  }
+  mapFromDriverValue(e) {
+    if (typeof e == "string") {
+      const [t, s] = e.slice(1, -1).split(",");
+      return [Number.parseFloat(t), Number.parseFloat(s)];
+    }
+    return [e.x, e.y];
+  }
+  mapToDriverValue(e) {
+    return `(${e[0]},${e[1]})`;
+  }
+}
+r(br, Rn, "PgPointTuple");
+var Kn, Wn;
+class yr extends (Wn = b, Kn = c, Wn) {
+  constructor(e) {
+    super(e, "json", "PgPointObject");
+  }
+  /** @internal */
+  build(e) {
+    return new wr(
+      e,
+      this.config
+    );
+  }
+}
+r(yr, Kn, "PgPointObjectBuilder");
+var Yn, Gn;
+class wr extends (Gn = g, Yn = c, Gn) {
+  getSQLType() {
+    return "point";
+  }
+  mapFromDriverValue(e) {
+    if (typeof e == "string") {
+      const [t, s] = e.slice(1, -1).split(",");
+      return { x: Number.parseFloat(t), y: Number.parseFloat(s) };
+    }
+    return e;
+  }
+  mapToDriverValue(e) {
+    return `(${e.x},${e.y})`;
+  }
+}
+r(wr, Yn, "PgPointObject");
+function ta(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return !(s != null && s.mode) || s.mode === "tuple" ? new gr(t) : new yr(t);
+}
+function na(n) {
+  const e = [];
+  for (let t = 0; t < n.length; t += 2)
+    e.push(Number.parseInt(n.slice(t, t + 2), 16));
+  return new Uint8Array(e);
+}
+function ye(n, e) {
+  const t = new ArrayBuffer(8), s = new DataView(t);
+  for (let i = 0; i < 8; i++)
+    s.setUint8(i, n[e + i]);
+  return s.getFloat64(0, !0);
+}
+function xr(n) {
+  const e = na(n);
+  let t = 0;
+  const s = e[t];
+  t += 1;
+  const i = new DataView(e.buffer), o = i.getUint32(t, s === 1);
+  if (t += 4, o & 536870912 && (i.getUint32(t, s === 1), t += 4), (o & 65535) === 1) {
+    const l = ye(e, t);
+    t += 8;
+    const a = ye(e, t);
+    return t += 8, [l, a];
+  }
+  throw new Error("Unsupported geometry type");
+}
+var Hn, Zn;
+class Nr extends (Zn = b, Hn = c, Zn) {
+  constructor(e) {
+    super(e, "array", "PgGeometry");
+  }
+  /** @internal */
+  build(e) {
+    return new Tr(
+      e,
+      this.config
+    );
+  }
+}
+r(Nr, Hn, "PgGeometryBuilder");
+var Xn, kn;
+class Tr extends (kn = g, Xn = c, kn) {
+  getSQLType() {
+    return "geometry(point)";
+  }
+  mapFromDriverValue(e) {
+    return xr(e);
+  }
+  mapToDriverValue(e) {
+    return `point(${e[0]} ${e[1]})`;
+  }
+}
+r(Tr, Xn, "PgGeometry");
+var es, ts;
+class Cr extends (ts = b, es = c, ts) {
+  constructor(e) {
+    super(e, "json", "PgGeometryObject");
+  }
+  /** @internal */
+  build(e) {
+    return new Sr(
+      e,
+      this.config
+    );
+  }
+}
+r(Cr, es, "PgGeometryObjectBuilder");
+var ns, ss;
+class Sr extends (ss = g, ns = c, ss) {
+  getSQLType() {
+    return "geometry(point)";
+  }
+  mapFromDriverValue(e) {
+    const t = xr(e);
+    return { x: t[0], y: t[1] };
+  }
+  mapToDriverValue(e) {
+    return `point(${e.x} ${e.y})`;
+  }
+}
+r(Sr, ns, "PgGeometryObject");
+function sa(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return !(s != null && s.mode) || s.mode === "tuple" ? new Nr(t) : new Cr(t);
+}
+var is, rs;
+class Pr extends (rs = b, is = c, rs) {
+  constructor(e, t) {
+    super(e, "number", "PgReal"), this.config.length = t;
+  }
+  /** @internal */
+  build(e) {
+    return new Dr(e, this.config);
+  }
+}
+r(Pr, is, "PgRealBuilder");
+var os, as;
+class Dr extends (as = g, os = c, as) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "mapFromDriverValue", (t) => typeof t == "string" ? Number.parseFloat(t) : t);
+  }
+  getSQLType() {
+    return "real";
+  }
+}
+r(Dr, os, "PgReal");
+function ia(n) {
+  return new Pr(n ?? "");
+}
+var us, cs;
+class vr extends (cs = b, us = c, cs) {
+  constructor(e) {
+    super(e, "number", "PgSerial"), this.config.hasDefault = !0, this.config.notNull = !0;
+  }
+  /** @internal */
+  build(e) {
+    return new Er(e, this.config);
+  }
+}
+r(vr, us, "PgSerialBuilder");
+var ls, ms;
+class Er extends (ms = g, ls = c, ms) {
+  getSQLType() {
+    return "serial";
+  }
+}
+r(Er, ls, "PgSerial");
+function ra(n) {
+  return new vr(n ?? "");
+}
+var ds, fs;
+class $r extends (fs = j, ds = c, fs) {
+  constructor(e) {
+    super(e, "number", "PgSmallInt");
+  }
+  /** @internal */
+  build(e) {
+    return new Br(e, this.config);
+  }
+}
+r($r, ds, "PgSmallIntBuilder");
+var ps, hs;
+class Br extends (hs = g, ps = c, hs) {
+  constructor() {
+    super(...arguments);
+    r(this, "mapFromDriverValue", (t) => typeof t == "string" ? Number(t) : t);
+  }
+  getSQLType() {
+    return "smallint";
+  }
+}
+r(Br, ps, "PgSmallInt");
+function oa(n) {
+  return new $r(n ?? "");
+}
+var gs, bs;
+class zr extends (bs = b, gs = c, bs) {
+  constructor(e) {
+    super(e, "number", "PgSmallSerial"), this.config.hasDefault = !0, this.config.notNull = !0;
+  }
+  /** @internal */
+  build(e) {
+    return new Fr(
+      e,
+      this.config
+    );
+  }
+}
+r(zr, gs, "PgSmallSerialBuilder");
+var ys, ws;
+class Fr extends (ws = g, ys = c, ws) {
+  getSQLType() {
+    return "smallserial";
+  }
+}
+r(Fr, ys, "PgSmallSerial");
+function aa(n) {
+  return new zr(n ?? "");
+}
+var xs, Ns;
+class Lr extends (Ns = b, xs = c, Ns) {
+  constructor(e, t) {
+    super(e, "string", "PgText"), this.config.enumValues = t.enum;
+  }
+  /** @internal */
+  build(e) {
+    return new Ar(e, this.config);
+  }
+}
+r(Lr, xs, "PgTextBuilder");
+var Ts, Cs;
+class Ar extends (Cs = g, Ts = c, Cs) {
+  constructor() {
+    super(...arguments);
+    r(this, "enumValues", this.config.enumValues);
+  }
+  getSQLType() {
+    return "text";
+  }
+}
+r(Ar, Ts, "PgText");
+function E(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return new Lr(t, s);
+}
+var Ss, Ps;
+class Qr extends (Ps = V, Ss = c, Ps) {
+  constructor(e, t, s) {
+    super(e, "string", "PgTime"), this.withTimezone = t, this.precision = s, this.config.withTimezone = t, this.config.precision = s;
+  }
+  /** @internal */
+  build(e) {
+    return new Vr(e, this.config);
+  }
+}
+r(Qr, Ss, "PgTimeBuilder");
+var Ds, vs;
+class Vr extends (vs = g, Ds = c, vs) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "withTimezone");
+    r(this, "precision");
+    this.withTimezone = s.withTimezone, this.precision = s.precision;
+  }
+  getSQLType() {
+    return `time${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+  }
+}
+r(Vr, Ds, "PgTime");
+function ua(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return new Qr(t, s.withTimezone ?? !1, s.precision);
+}
+var Es, $s;
+class Ir extends ($s = V, Es = c, $s) {
+  constructor(e, t, s) {
+    super(e, "date", "PgTimestamp"), this.config.withTimezone = t, this.config.precision = s;
+  }
+  /** @internal */
+  build(e) {
+    return new jr(e, this.config);
+  }
+}
+r(Ir, Es, "PgTimestampBuilder");
+var Bs, zs;
+class jr extends (zs = g, Bs = c, zs) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "withTimezone");
+    r(this, "precision");
+    r(this, "mapFromDriverValue", (t) => new Date(this.withTimezone ? t : t + "+0000"));
+    r(this, "mapToDriverValue", (t) => t.toISOString());
+    this.withTimezone = s.withTimezone, this.precision = s.precision;
+  }
+  getSQLType() {
+    return `timestamp${this.precision === void 0 ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+  }
+}
+r(jr, Bs, "PgTimestamp");
+var Fs, Ls;
+class _r extends (Ls = V, Fs = c, Ls) {
+  constructor(e, t, s) {
+    super(e, "string", "PgTimestampString"), this.config.withTimezone = t, this.config.precision = s;
+  }
+  /** @internal */
+  build(e) {
+    return new Ur(
+      e,
+      this.config
+    );
+  }
+}
+r(_r, Fs, "PgTimestampStringBuilder");
+var As, Qs;
+class Ur extends (Qs = g, As = c, Qs) {
+  constructor(t, s) {
+    super(t, s);
+    r(this, "withTimezone");
+    r(this, "precision");
+    this.withTimezone = s.withTimezone, this.precision = s.precision;
+  }
+  getSQLType() {
+    return `timestamp${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+  }
+}
+r(Ur, As, "PgTimestampString");
+function S(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return (s == null ? void 0 : s.mode) === "string" ? new _r(t, s.withTimezone ?? !1, s.precision) : new Ir(t, (s == null ? void 0 : s.withTimezone) ?? !1, s == null ? void 0 : s.precision);
+}
+var Vs, Is;
+class qr extends (Is = b, Vs = c, Is) {
+  constructor(e) {
+    super(e, "string", "PgUUID");
+  }
+  /**
+   * Adds `default gen_random_uuid()` to the column definition.
+   */
+  defaultRandom() {
+    return this.default(q`gen_random_uuid()`);
+  }
+  /** @internal */
+  build(e) {
+    return new Or(e, this.config);
+  }
+}
+r(qr, Vs, "PgUUIDBuilder");
+var js, _s;
+class Or extends (_s = g, js = c, _s) {
+  getSQLType() {
+    return "uuid";
+  }
+}
+r(Or, js, "PgUUID");
+function ca(n) {
+  return new qr(n ?? "");
+}
+var Us, qs;
+class Mr extends (qs = b, Us = c, qs) {
+  constructor(e, t) {
+    super(e, "string", "PgVarchar"), this.config.length = t.length, this.config.enumValues = t.enum;
+  }
+  /** @internal */
+  build(e) {
+    return new Rr(
+      e,
+      this.config
+    );
+  }
+}
+r(Mr, Us, "PgVarcharBuilder");
+var Os, Ms;
+class Rr extends (Ms = g, Os = c, Ms) {
+  constructor() {
+    super(...arguments);
+    r(this, "length", this.config.length);
+    r(this, "enumValues", this.config.enumValues);
+  }
+  getSQLType() {
+    return this.length === void 0 ? "varchar" : `varchar(${this.length})`;
+  }
+}
+r(Rr, Os, "PgVarchar");
+function la(n, e = {}) {
+  const { name: t, config: s } = x(n, e);
+  return new Mr(t, s);
+}
+var Rs, Js;
+class Jr extends (Js = b, Rs = c, Js) {
+  constructor(e, t) {
+    super(e, "string", "PgBinaryVector"), this.config.dimensions = t.dimensions;
+  }
+  /** @internal */
+  build(e) {
+    return new Kr(
+      e,
+      this.config
+    );
+  }
+}
+r(Jr, Rs, "PgBinaryVectorBuilder");
+var Ks, Ws;
+class Kr extends (Ws = g, Ks = c, Ws) {
+  constructor() {
+    super(...arguments);
+    r(this, "dimensions", this.config.dimensions);
+  }
+  getSQLType() {
+    return `bit(${this.dimensions})`;
+  }
+}
+r(Kr, Ks, "PgBinaryVector");
+function ma(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return new Jr(t, s);
+}
+var Ys, Gs;
+class Wr extends (Gs = b, Ys = c, Gs) {
+  constructor(e, t) {
+    super(e, "array", "PgHalfVector"), this.config.dimensions = t.dimensions;
+  }
+  /** @internal */
+  build(e) {
+    return new Yr(
+      e,
+      this.config
+    );
+  }
+}
+r(Wr, Ys, "PgHalfVectorBuilder");
+var Hs, Zs;
+class Yr extends (Zs = g, Hs = c, Zs) {
+  constructor() {
+    super(...arguments);
+    r(this, "dimensions", this.config.dimensions);
+  }
+  getSQLType() {
+    return `halfvec(${this.dimensions})`;
+  }
+  mapToDriverValue(t) {
+    return JSON.stringify(t);
+  }
+  mapFromDriverValue(t) {
+    return t.slice(1, -1).split(",").map((s) => Number.parseFloat(s));
+  }
+}
+r(Yr, Hs, "PgHalfVector");
+function da(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return new Wr(t, s);
+}
+var Xs, ks;
+class Gr extends (ks = b, Xs = c, ks) {
+  constructor(e, t) {
+    super(e, "string", "PgSparseVector"), this.config.dimensions = t.dimensions;
+  }
+  /** @internal */
+  build(e) {
+    return new Hr(
+      e,
+      this.config
+    );
+  }
+}
+r(Gr, Xs, "PgSparseVectorBuilder");
+var ei, ti;
+class Hr extends (ti = g, ei = c, ti) {
+  constructor() {
+    super(...arguments);
+    r(this, "dimensions", this.config.dimensions);
+  }
+  getSQLType() {
+    return `sparsevec(${this.dimensions})`;
+  }
+}
+r(Hr, ei, "PgSparseVector");
+function fa(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return new Gr(t, s);
+}
+var ni, si;
+class Zr extends (si = b, ni = c, si) {
+  constructor(e, t) {
+    super(e, "array", "PgVector"), this.config.dimensions = t.dimensions;
+  }
+  /** @internal */
+  build(e) {
+    return new Xr(
+      e,
+      this.config
+    );
+  }
+}
+r(Zr, ni, "PgVectorBuilder");
+var ii, ri;
+class Xr extends (ri = g, ii = c, ri) {
+  constructor() {
+    super(...arguments);
+    r(this, "dimensions", this.config.dimensions);
+  }
+  getSQLType() {
+    return `vector(${this.dimensions})`;
+  }
+  mapToDriverValue(t) {
+    return JSON.stringify(t);
+  }
+  mapFromDriverValue(t) {
+    return t.slice(1, -1).split(",").map((s) => Number.parseFloat(s));
+  }
+}
+r(Xr, ii, "PgVector");
+function pa(n, e) {
+  const { name: t, config: s } = x(n, e);
+  return new Zr(t, s);
+}
+function ha() {
+  return {
+    bigint: Uo,
+    bigserial: qo,
+    boolean: ie,
+    char: Oo,
+    cidr: Mo,
+    customType: Ro,
+    date: Jo,
+    doublePrecision: Ko,
+    inet: Wo,
+    integer: D,
+    interval: Yo,
+    json: Go,
+    jsonb: Ho,
+    line: Zo,
+    macaddr: Xo,
+    macaddr8: ko,
+    numeric: hr,
+    point: ta,
+    geometry: sa,
+    real: ia,
+    serial: ra,
+    smallint: oa,
+    smallserial: aa,
+    text: E,
+    time: ua,
+    timestamp: S,
+    uuid: ca,
+    varchar: la,
+    bit: ma,
+    halfvec: da,
+    sparsevec: fa,
+    vector: pa
+  };
+}
+const k = Symbol.for("drizzle:PgInlineForeignKeys"), we = Symbol.for("drizzle:EnableRLS");
+var oi, ai, ui, ci, li, mi;
+class M extends (mi = w, li = c, ci = k, ui = we, ai = w.Symbol.ExtraConfigBuilder, oi = w.Symbol.ExtraConfigColumns, mi) {
+  constructor() {
+    super(...arguments);
+    /**@internal */
+    r(this, ci, []);
+    /** @internal */
+    r(this, ui, !1);
+    /** @internal */
+    r(this, ai);
+    /** @internal */
+    r(this, oi, {});
+  }
+}
+r(M, li, "PgTable"), /** @internal */
+r(M, "Symbol", Object.assign({}, w.Symbol, {
+  InlineForeignKeys: k,
+  EnableRLS: we
+}));
+function ga(n, e, t, s, i = n) {
+  const o = new M(n, s, i), l = typeof e == "function" ? e(ha()) : e, a = Object.fromEntries(
+    Object.entries(l).map(([u, f]) => {
+      const p = f;
+      p.setName(u);
+      const h = p.build(o);
+      return o[k].push(...p.buildForeignKeys(h, o)), [u, h];
+    })
+  ), m = Object.fromEntries(
+    Object.entries(l).map(([u, f]) => {
+      const p = f;
+      p.setName(u);
+      const h = p.buildExtraConfigColumn(o);
+      return [u, h];
+    })
+  ), d = Object.assign(o, a);
+  return d[w.Symbol.Columns] = a, d[w.Symbol.ExtraConfigColumns] = m, Object.assign(d, {
+    enableRLS: () => (d[M.Symbol.EnableRLS] = !0, d)
+  });
+}
+const W = (n, e, t) => ga(n, e, t, void 0), P = W("organisations", {
+  id: D("id").primaryKey(),
+  name: E("name").notNull(),
+  description: E("description"),
+  createdAt: S("created_at").defaultNow(),
+  updatedAt: S("updated_at").defaultNow()
+}), F = W("departments", {
+  id: D("id").primaryKey(),
+  name: E("name").notNull(),
+  description: E("description"),
+  organisation: D("organisation").notNull().references(() => P.id),
+  createdAt: S("created_at").defaultNow(),
+  updatedAt: S("updated_at").defaultNow()
+}), L = W("suppliers", {
+  id: D("id").primaryKey(),
+  name: E("name").notNull(),
+  description: E("description"),
+  internal: ie("internal").default(!1),
+  organisation: D("organisation").notNull().references(() => P.id),
+  createdAt: S("created_at").defaultNow(),
+  updatedAt: S("updated_at").defaultNow()
+}), $ = W("employees", {
+  id: D("id").primaryKey(),
+  name: E("name").notNull(),
+  email: E("email").notNull(),
+  active: ie("active").default(!0),
+  fteBasis: ea("fte_basis", { precision: 3, scale: 2 }).default("1.00"),
+  startDate: S("start_date"),
+  endDate: S("end_date"),
+  department: D("department").references(() => F.id),
+  supplier: D("supplier").references(() => L.id),
+  organisation: D("organisation").notNull().references(() => P.id),
+  createdAt: S("created_at").defaultNow(),
+  updatedAt: S("updated_at").defaultNow()
+}), ba = J(P, ({ many: n }) => ({
+  departments: n(F),
+  suppliers: n(L),
+  employees: n($)
+})), ya = J(F, ({ one: n, many: e }) => ({
+  organisation: n(P, {
+    fields: [F.organisation],
+    references: [P.id]
+  }),
+  employees: e($)
+})), wa = J(L, ({ one: n, many: e }) => ({
+  organisation: n(P, {
+    fields: [L.organisation],
+    references: [P.id]
+  }),
+  employees: e($)
+})), xa = J($, ({ one: n }) => ({
+  organisation: n(P, {
+    fields: [$.organisation],
+    references: [P.id]
+  }),
+  department: n(F, {
+    fields: [$.department],
+    references: [F.id]
+  }),
+  supplier: n(L, {
+    fields: [$.supplier],
+    references: [L.id]
+  })
+})), Ba = {
+  organisations: P,
+  departments: F,
+  suppliers: L,
+  employees: $,
+  organisationsRelations: ba,
+  departmentsRelations: ya,
+  suppliersRelations: wa,
+  employeesRelations: xa
+}, za = wo;
+function Fa(n) {
+  return new te({
+    drizzle: n.drizzle,
+    schema: n.schema
+  });
+}
+const La = {
+  /**
+   * Create a simple query builder
+   */
+  query: () => {
+    const n = (e, t = [], s = [], i = [], o, l) => ({
+      measures: e,
+      dimensions: t,
+      filters: s,
+      timeDimensions: i,
+      limit: o,
+      order: l
     });
     return {
-      measures: (n) => ({
-        dimensions: (i = []) => ({
-          filters: (t = []) => ({
-            timeDimensions: (s = []) => ({
-              limit: (a) => ({
-                order: (r) => e(n, i, t, s, a, r)
+      measures: (e) => ({
+        dimensions: (t = []) => ({
+          filters: (s = []) => ({
+            timeDimensions: (i = []) => ({
+              limit: (o) => ({
+                order: (l) => n(e, t, s, i, o, l)
               }),
-              order: (a) => e(n, i, t, s, void 0, a)
+              order: (o) => n(e, t, s, i, void 0, o)
             }),
-            limit: (s) => ({
-              order: (a) => e(n, i, t, [], s, a)
+            limit: (i) => ({
+              order: (o) => n(e, t, s, [], i, o)
             }),
-            order: (s) => e(n, i, t, [], void 0, s)
+            order: (i) => n(e, t, s, [], void 0, i)
           }),
-          timeDimensions: (t = []) => ({
-            filters: (s = []) => ({
-              limit: (a) => ({
-                order: (r) => e(n, i, s, t, a, r)
+          timeDimensions: (s = []) => ({
+            filters: (i = []) => ({
+              limit: (o) => ({
+                order: (l) => n(e, t, i, s, o, l)
               }),
-              order: (a) => e(n, i, s, t, void 0, a)
+              order: (o) => n(e, t, i, s, void 0, o)
             }),
-            limit: (s) => ({
-              order: (a) => e(n, i, [], t, s, a)
+            limit: (i) => ({
+              order: (o) => n(e, t, [], s, i, o)
             }),
-            order: (s) => e(n, i, [], t, void 0, s)
+            order: (i) => n(e, t, [], s, void 0, i)
           }),
-          limit: (t) => ({
-            order: (s) => e(n, i, [], [], t, s)
+          limit: (s) => ({
+            order: (i) => n(e, t, [], [], s, i)
           }),
-          order: (t) => e(n, i, [], [], void 0, t)
+          order: (s) => n(e, t, [], [], void 0, s)
         }),
-        filters: (i = []) => ({
-          dimensions: (t = []) => ({
-            timeDimensions: (s = []) => ({
-              limit: (a) => ({
-                order: (r) => e(n, t, i, s, a, r)
+        filters: (t = []) => ({
+          dimensions: (s = []) => ({
+            timeDimensions: (i = []) => ({
+              limit: (o) => ({
+                order: (l) => n(e, s, t, i, o, l)
               }),
-              order: (a) => e(n, t, i, s, void 0, a)
+              order: (o) => n(e, s, t, i, void 0, o)
             }),
-            limit: (s) => ({
-              order: (a) => e(n, t, i, [], s, a)
+            limit: (i) => ({
+              order: (o) => n(e, s, t, [], i, o)
             }),
-            order: (s) => e(n, t, i, [], void 0, s)
+            order: (i) => n(e, s, t, [], void 0, i)
           }),
-          timeDimensions: (t = []) => ({
-            dimensions: (s = []) => ({
-              limit: (a) => ({
-                order: (r) => e(n, s, i, t, a, r)
+          timeDimensions: (s = []) => ({
+            dimensions: (i = []) => ({
+              limit: (o) => ({
+                order: (l) => n(e, i, t, s, o, l)
               }),
-              order: (a) => e(n, s, i, t, void 0, a)
+              order: (o) => n(e, i, t, s, void 0, o)
             }),
-            limit: (s) => ({
-              order: (a) => e(n, [], i, t, s, a)
+            limit: (i) => ({
+              order: (o) => n(e, [], t, s, i, o)
             }),
-            order: (s) => e(n, [], i, t, void 0, s)
+            order: (i) => n(e, [], t, s, void 0, i)
           }),
-          limit: (t) => ({
-            order: (s) => e(n, [], i, [], t, s)
+          limit: (s) => ({
+            order: (i) => n(e, [], t, [], s, i)
           }),
-          order: (t) => e(n, [], i, [], void 0, t)
+          order: (s) => n(e, [], t, [], void 0, s)
         })
       })
     };
@@ -586,39 +3490,64 @@ const D = {
    * Create filters
    */
   filters: {
-    equals: (l, e) => ({ member: l, operator: "equals", values: [e] }),
-    notEquals: (l, e) => ({ member: l, operator: "notEquals", values: [e] }),
-    contains: (l, e) => ({ member: l, operator: "contains", values: [e] }),
-    greaterThan: (l, e) => ({ member: l, operator: "gt", values: [e] }),
-    lessThan: (l, e) => ({ member: l, operator: "lt", values: [e] }),
-    inDateRange: (l, e, n) => ({
-      member: l,
+    equals: (n, e) => ({ member: n, operator: "equals", values: [e] }),
+    notEquals: (n, e) => ({ member: n, operator: "notEquals", values: [e] }),
+    contains: (n, e) => ({ member: n, operator: "contains", values: [e] }),
+    greaterThan: (n, e) => ({ member: n, operator: "gt", values: [e] }),
+    lessThan: (n, e) => ({ member: n, operator: "lt", values: [e] }),
+    inDateRange: (n, e, t) => ({
+      member: n,
       operator: "inDateRange",
-      values: [e, n]
+      values: [e, t]
     }),
-    set: (l) => ({ member: l, operator: "set", values: [] }),
-    notSet: (l) => ({ member: l, operator: "notSet", values: [] })
+    set: (n) => ({ member: n, operator: "set", values: [] }),
+    notSet: (n) => ({ member: n, operator: "notSet", values: [] })
   },
   /**
    * Create time dimensions
    */
   timeDimensions: {
-    create: (l, e, n) => ({
-      dimension: l,
+    create: (n, e, t) => ({
+      dimension: n,
       granularity: e,
-      dateRange: n
+      dateRange: t
     })
   }
 };
 export {
-  d as SemanticLayerCompiler,
-  D as SemanticLayerUtils,
-  f as SemanticQueryExecutor,
-  q as createSemanticLayer,
-  v as defaultSemanticLayer,
-  C as departmentsCube,
-  $ as employeeDepartmentsCube,
-  g as employeesCube,
-  T as exampleCubes,
-  E as semanticLayer
+  ee as BaseDatabaseExecutor,
+  yo as MultiCubeBuilder,
+  ho as MySQLExecutor,
+  fo as PostgresExecutor,
+  de as QueryExecutor,
+  po as SQLiteExecutor,
+  te as SemanticLayerCompiler,
+  La as SemanticLayerUtils,
+  Ea as convertCubeReferences,
+  me as createDatabaseExecutor,
+  Fa as createDrizzleSemanticLayer,
+  bo as createMultiCubeContext,
+  go as createMySQLExecutor,
+  ce as createPostgresExecutor,
+  le as createSQLiteExecutor,
+  Da as createSemanticLayer,
+  za as defaultSemanticLayer,
+  Pa as defineCube,
+  Sa as defineLegacyCube,
+  F as departments,
+  ya as departmentsRelations,
+  $ as employees,
+  xa as employeesRelations,
+  Ba as exampleSchema,
+  Bo as loadYamlCubes,
+  va as loadYamlCubesFromFile,
+  P as organisations,
+  ba as organisationsRelations,
+  xo as parseYamlCubes,
+  v as resolveSqlExpression,
+  $a as semanticCubeToYaml,
+  wo as semanticLayer,
+  L as suppliers,
+  wa as suppliersRelations,
+  To as yamlCubeToSemanticCube
 };