drizzle-cube 0.1.3 → 0.1.5

package/README.md

@@ -4,6 +4,8 @@
 
 Transform your Drizzle schema into a powerful, type-safe analytics platform with SQL injection protection and full TypeScript support.
 
+📖 **[Documentation](https://www.drizzle-cube.dev/)** • 🚀 **[Try the Sandbox](https://try.drizzle-cube.dev/)**
+
 > **⚠️ DEVELOPMENT WARNING**  
 > **This project is under active development and is not yet fully functional. I will update here when we reach an alpha/working version!**  
 > Feel free to star ⭐ the repo to stay updated on progress.
@@ -318,11 +320,31 @@ Supports all Cube.js filter operators with Drizzle safety:
 
 ## Documentation
 
-Coming soon! 📚
+📚 **[Full Documentation](https://drizzle-cube.dev/help)** - Complete guides and API reference
+
+### Quick Links
+- [Getting Started](https://drizzle-cube.dev/help/getting-started) - Installation and first steps
+- [Core Concepts](https://drizzle-cube.dev/help/getting-started/concepts) - Cubes, dimensions, and measures
+- [Semantic Layer](https://drizzle-cube.dev/help/semantic-layer) - Advanced semantic layer features
+- [React Client](https://drizzle-cube.dev/help/client) - Dashboard and chart components
+- [Hono Adapter](https://drizzle-cube.dev/help/adapters/hono) - Web framework integration
+- [Security](https://drizzle-cube.dev/help/semantic-layer/security) - Multi-tenant security patterns
+
+### Local Development
+```bash
+# Run documentation site locally
+npm run dev:help
+
+# Build documentation site
+npm run build:help
+```
 
 ## Examples
 
-Coming soon! Check the test files for usage patterns in the meantime.
+🚀 **[Live Examples](https://github.com/cliftonc/drizzle-cube/tree/main/examples)**
+
+- **[Basic Example](https://github.com/cliftonc/drizzle-cube/tree/main/examples/basic)** - Simple semantic layer setup
+- **[Hono Example](https://github.com/cliftonc/drizzle-cube/tree/main/examples/hono)** - Full-featured dashboard with Cloudflare Workers
 
 ## Contributing
 

package/dist/adapters/hono/index.d.ts

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
 import { SemanticLayerCompiler, SemanticQuery, SecurityContext, DatabaseExecutor, DrizzleDatabase } from '../../server';
+import { PostgresJsDatabase } from 'drizzle-orm/postgres-js';
+import { MySql2Database } from 'drizzle-orm/mysql2';
+import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
 export interface HonoAdapterOptions<TSchema extends Record<string, any> = Record<string, any>> {
     /**
      * The semantic layer instance to use
@@ -8,8 +11,9 @@ export interface HonoAdapterOptions<TSchema extends Record<string, any> = Record
     /**
      * Drizzle database instance (REQUIRED)
      * This is the core of drizzle-cube - Drizzle ORM integration
+     * Accepts PostgreSQL, MySQL, or SQLite database instances
      */
-    drizzle: DrizzleDatabase<TSchema>;
+    drizzle: PostgresJsDatabase<TSchema> | MySql2Database<TSchema> | BetterSQLite3Database<TSchema> | DrizzleDatabase<TSchema>;
     /**
      * Database schema for type inference (RECOMMENDED)
      * Provides full type safety for cube definitions

package/dist/adapters/hono/index.js

@@ -1,64 +1,79 @@
-import { Hono as w } from "hono";
-var j = (f) => {
-  const u = {
+import { Hono as D } from "hono";
+var S = (q) => {
+  const d = {
     ...{
       origin: "*",
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
       allowHeaders: [],
       exposeHeaders: []
     },
-    ...f
-  }, q = /* @__PURE__ */ ((a) => typeof a == "string" ? a === "*" ? () => a : (t) => a === t ? t : null : typeof a == "function" ? a : (t) => a.includes(t) ? t : null)(u.origin), m = ((a) => typeof a == "function" ? a : Array.isArray(a) ? () => a : () => [])(u.allowMethods);
-  return async function(t, d) {
-    var i;
-    function e(r, n) {
-      t.res.headers.set(r, n);
+    ...q
+  }, A = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(d.origin), j = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(d.allowMethods);
+  return async function(n, m) {
+    var x;
+    function p(h, f) {
+      n.res.headers.set(h, f);
     }
-    const o = q(t.req.header("origin") || "", t);
-    if (o && e("Access-Control-Allow-Origin", o), u.origin !== "*") {
-      const r = t.req.header("Vary");
-      r ? e("Vary", r) : e("Vary", "Origin");
+    const b = A(n.req.header("origin") || "", n);
+    if (b && p("Access-Control-Allow-Origin", b), d.origin !== "*") {
+      const h = n.req.header("Vary");
+      h ? p("Vary", h) : p("Vary", "Origin");
     }
-    if (u.credentials && e("Access-Control-Allow-Credentials", "true"), (i = u.exposeHeaders) != null && i.length && e("Access-Control-Expose-Headers", u.exposeHeaders.join(",")), t.req.method === "OPTIONS") {
-      u.maxAge != null && e("Access-Control-Max-Age", u.maxAge.toString());
-      const r = m(t.req.header("origin") || "", t);
-      r.length && e("Access-Control-Allow-Methods", r.join(","));
-      let n = u.allowHeaders;
-      if (!(n != null && n.length)) {
-        const s = t.req.header("Access-Control-Request-Headers");
-        s && (n = s.split(/\s*,\s*/));
+    if (d.credentials && p("Access-Control-Allow-Credentials", "true"), (x = d.exposeHeaders) != null && x.length && p("Access-Control-Expose-Headers", d.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
+      d.maxAge != null && p("Access-Control-Max-Age", d.maxAge.toString());
+      const h = j(n.req.header("origin") || "", n);
+      h.length && p("Access-Control-Allow-Methods", h.join(","));
+      let f = d.allowHeaders;
+      if (!(f != null && f.length)) {
+        const e = n.req.header("Access-Control-Request-Headers");
+        e && (f = e.split(/\s*,\s*/));
       }
-      return n != null && n.length && (e("Access-Control-Allow-Headers", n.join(",")), t.res.headers.append("Vary", "Access-Control-Request-Headers")), t.res.headers.delete("Content-Length"), t.res.headers.delete("Content-Type"), new Response(null, {
-        headers: t.res.headers,
+      return f != null && f.length && (p("Access-Control-Allow-Headers", f.join(",")), n.res.headers.append("Vary", "Access-Control-Request-Headers")), n.res.headers.delete("Content-Length"), n.res.headers.delete("Content-Type"), new Response(null, {
+        headers: n.res.headers,
         status: 204,
         statusText: "No Content"
       });
     }
-    await d();
+    await m();
   };
 };
-function C(f) {
+function E(q) {
   const {
-    semanticLayer: l,
-    drizzle: u,
-    schema: q,
-    getSecurityContext: m,
-    cors: a,
-    basePath: t = "/cubejs-api/v1"
-  } = f, d = new w();
-  return a && d.use("/*", j(a)), l.hasExecutor() || l.setDrizzle(u, q), d.post(`${t}/load`, async (e) => {
-    var o, i;
+    semanticLayer: a,
+    drizzle: d,
+    schema: A,
+    getSecurityContext: j,
+    cors: u,
+    basePath: n = "/cubejs-api/v1"
+  } = q, m = new D();
+  u && m.use("/*", S(u)), a.hasExecutor() || a.setDrizzle(d, A), m.post(`${n}/load`, async (e) => {
     try {
-      const r = await e.req.json(), n = await m(e);
-      if (!((o = r.measures) != null && o.length) && !((i = r.dimensions) != null && i.length))
+      const r = await e.req.json(), s = r.query || r, t = await j(e), o = a.validateQuery(s);
+      if (!o.isValid)
         return e.json({
-          error: "Query must specify at least one measure or dimension"
+          error: `Query validation failed: ${o.errors.join(", ")}`
         }, 400);
-      const s = await l.executeMultiCubeQuery(r, n);
+      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
       return e.json({
-        data: s.data,
-        annotation: s.annotation,
-        query: r,
+        queryType: "regularQuery",
+        results: [{
+          query: s,
+          lastRefreshTime: g,
+          usedPreAggregations: {},
+          transformedQuery: Q,
+          requestId: y,
+          annotation: i.annotation,
+          dataSource: "default",
+          dbType: l,
+          extDbType: l,
+          external: !1,
+          slowQuery: !1,
+          data: i.data
+        }],
+        pivotQuery: {
+          ...s,
+          queryType: "regularQuery"
+        },
         slowQuery: !1
       });
     } catch (r) {
@@ -66,24 +81,39 @@ function C(f) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${t}/load`, async (e) => {
-    var o, i;
+  }), m.get(`${n}/load`, async (e) => {
     try {
       const r = e.req.query("query");
       if (!r)
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const n = JSON.parse(r), s = await m(e);
-      if (!((o = n.measures) != null && o.length) && !((i = n.dimensions) != null && i.length))
+      const s = JSON.parse(r), t = await j(e), o = a.validateQuery(s);
+      if (!o.isValid)
         return e.json({
-          error: "Query must specify at least one measure or dimension"
+          error: `Query validation failed: ${o.errors.join(", ")}`
         }, 400);
-      const c = await l.executeMultiCubeQuery(n, s);
+      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
       return e.json({
-        data: c.data,
-        annotation: c.annotation,
-        query: n,
+        queryType: "regularQuery",
+        results: [{
+          query: s,
+          lastRefreshTime: g,
+          usedPreAggregations: {},
+          transformedQuery: Q,
+          requestId: y,
+          annotation: i.annotation,
+          dataSource: "default",
+          dbType: l,
+          extDbType: l,
+          external: !1,
+          slowQuery: !1,
+          data: i.data
+        }],
+        pivotQuery: {
+          ...s,
+          queryType: "regularQuery"
+        },
         slowQuery: !1
       });
     } catch (r) {
@@ -91,82 +121,215 @@ function C(f) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${t}/meta`, async (e) => {
+  }), m.get(`${n}/meta`, (e) => {
     try {
-      const o = l.getMetadata();
+      const r = a.getMetadata();
       return e.json({
-        cubes: o
+        cubes: r
       });
-    } catch (o) {
-      return console.error("Metadata error:", o), e.json({
-        error: o instanceof Error ? o.message : "Failed to fetch metadata"
+    } catch (r) {
+      return console.error("Metadata error:", r), e.json({
+        error: r instanceof Error ? r.message : "Failed to fetch metadata"
       }, 500);
     }
-  }), d.post(`${t}/sql`, async (e) => {
-    var o, i, r, n;
+  }), m.post(`${n}/sql`, async (e) => {
+    var r, s;
     try {
-      const s = await e.req.json(), c = await m(e);
-      if (!((o = s.measures) != null && o.length) && !((i = s.dimensions) != null && i.length))
+      const t = await e.req.json(), o = await j(e), i = a.validateQuery(t);
+      if (!i.isValid)
         return e.json({
-          error: "Query must specify at least one measure or dimension"
+          error: `Query validation failed: ${i.errors.join(", ")}`
         }, 400);
-      const y = ((r = s.measures) == null ? void 0 : r[0]) || ((n = s.dimensions) == null ? void 0 : n[0]);
-      if (!y)
+      const l = ((r = t.measures) == null ? void 0 : r[0]) || ((s = t.dimensions) == null ? void 0 : s[0]);
+      if (!l)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const g = y.split(".")[0], h = await l.generateSQL(g, s, c);
+      const y = l.split(".")[0], g = await a.generateSQL(y, t, o);
       return e.json({
-        sql: h.sql,
-        params: h.params || [],
-        query: s
+        sql: g.sql,
+        params: g.params || [],
+        query: t
       });
-    } catch (s) {
-      return console.error("SQL generation error:", s), e.json({
-        error: s instanceof Error ? s.message : "SQL generation failed"
+    } catch (t) {
+      return console.error("SQL generation error:", t), e.json({
+        error: t instanceof Error ? t.message : "SQL generation failed"
       }, 500);
     }
-  }), d.get(`${t}/sql`, async (e) => {
-    var o, i, r, n;
+  }), m.get(`${n}/sql`, async (e) => {
+    var r, s;
     try {
-      const s = e.req.query("query");
-      if (!s)
+      const t = e.req.query("query");
+      if (!t)
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const c = JSON.parse(s), y = await m(e);
-      if (!((o = c.measures) != null && o.length) && !((i = c.dimensions) != null && i.length))
+      const o = JSON.parse(t), i = await j(e), l = a.validateQuery(o);
+      if (!l.isValid)
         return e.json({
-          error: "Query must specify at least one measure or dimension"
+          error: `Query validation failed: ${l.errors.join(", ")}`
         }, 400);
-      const g = ((r = c.measures) == null ? void 0 : r[0]) || ((n = c.dimensions) == null ? void 0 : n[0]);
-      if (!g)
+      const y = ((r = o.measures) == null ? void 0 : r[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
+      if (!y)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const h = g.split(".")[0], p = await l.generateSQL(h, c, y);
+      const g = y.split(".")[0], Q = await a.generateSQL(g, o, i);
       return e.json({
-        sql: p.sql,
-        params: p.params || [],
-        query: c
+        sql: Q.sql,
+        params: Q.params || [],
+        query: o
       });
-    } catch (s) {
-      return console.error("SQL generation error:", s), e.json({
-        error: s instanceof Error ? s.message : "SQL generation failed"
+    } catch (t) {
+      return console.error("SQL generation error:", t), e.json({
+        error: t instanceof Error ? t.message : "SQL generation failed"
       }, 500);
     }
-  }), d;
+  });
+  function p(e) {
+    var s, t, o, i;
+    let r = 0;
+    return r += (((s = e.measures) == null ? void 0 : s.length) || 0) * 1, r += (((t = e.dimensions) == null ? void 0 : t.length) || 0) * 1, r += (((o = e.filters) == null ? void 0 : o.length) || 0) * 2, r += (((i = e.timeDimensions) == null ? void 0 : i.length) || 0) * 3, r <= 5 ? "low" : r <= 15 ? "medium" : "high";
+  }
+  function b() {
+    const e = Date.now(), r = Math.random().toString(36).substring(2, 9);
+    return `${e}-${r}`;
+  }
+  function x(e) {
+    const r = e.dimensions || [], s = e.timeDimensions || [], t = e.measures || [];
+    return {
+      sortedDimensions: r,
+      sortedTimeDimensions: s,
+      timeDimensions: s,
+      measures: t,
+      leafMeasureAdditive: !0,
+      leafMeasures: t,
+      measureToLeafMeasures: {},
+      hasNoTimeDimensionsWithoutGranularity: !0,
+      allFiltersWithinSelectedDimensions: !0,
+      isAdditive: !0,
+      granularityHierarchies: {},
+      hasMultipliedMeasures: !1,
+      hasCumulativeMeasures: !1,
+      windowGranularity: null,
+      filterDimensionsSingleValueEqual: {},
+      ownedDimensions: r,
+      ownedTimeDimensionsWithRollupGranularity: [],
+      ownedTimeDimensionsAsIs: [],
+      allBackAliasMembers: {},
+      hasMultiStage: !1
+    };
+  }
+  function h(e) {
+    if (e.hasExecutor()) {
+      const r = e.databaseExecutor;
+      if (r != null && r.engineType)
+        return r.engineType;
+    }
+    return "postgres";
+  }
+  async function f(e, r) {
+    var y, g, Q, v;
+    const s = a.validateQuery(e);
+    if (!s.isValid)
+      throw new Error(`Query validation failed: ${s.errors.join(", ")}`);
+    const t = /* @__PURE__ */ new Set();
+    (y = e.measures) == null || y.forEach((c) => {
+      const w = c.split(".")[0];
+      t.add(w);
+    }), (g = e.dimensions) == null || g.forEach((c) => {
+      const w = c.split(".")[0];
+      t.add(w);
+    }), (Q = e.timeDimensions) == null || Q.forEach((c) => {
+      const w = c.dimension.split(".")[0];
+      t.add(w);
+    }), (v = e.filters) == null || v.forEach((c) => {
+      if ("member" in c) {
+        const w = c.member.split(".")[0];
+        t.add(w);
+      }
+    });
+    const o = t.size > 1;
+    let i;
+    if (o)
+      i = await a.generateMultiCubeSQL(e, r);
+    else {
+      const c = Array.from(t)[0];
+      i = await a.generateSQL(c, e, r);
+    }
+    const l = Array.from(t).map((c) => {
+      var w, T;
+      return {
+        cube: c,
+        query: {
+          measures: ((w = e.measures) == null ? void 0 : w.filter((C) => C.startsWith(c + "."))) || [],
+          dimensions: ((T = e.dimensions) == null ? void 0 : T.filter((C) => C.startsWith(c + "."))) || [],
+          filters: e.filters || [],
+          timeDimensions: e.timeDimensions || [],
+          order: e.order || {},
+          limit: e.limit,
+          offset: e.offset
+        }
+      };
+    });
+    return {
+      queryType: "regularQuery",
+      normalizedQueries: l,
+      queryOrder: Array.from(t),
+      transformedQueries: l,
+      pivotQuery: {
+        query: e,
+        cubes: Array.from(t)
+      },
+      sql: {
+        sql: [i.sql],
+        params: i.params || []
+      },
+      complexity: p(e),
+      valid: !0,
+      cubesUsed: Array.from(t),
+      joinType: o ? "multi_cube_join" : "single_cube",
+      query: e
+    };
+  }
+  return m.post(`${n}/dry-run`, async (e) => {
+    try {
+      const r = await e.req.json(), s = r.query || r, t = await j(e), o = await f(s, t);
+      return e.json(o);
+    } catch (r) {
+      return console.error("Dry-run error:", r), e.json({
+        error: r instanceof Error ? r.message : "Dry-run validation failed",
+        valid: !1
+      }, 400);
+    }
+  }), m.get(`${n}/dry-run`, async (e) => {
+    try {
+      const r = e.req.query("query");
+      if (!r)
+        return e.json({
+          error: "Query parameter is required",
+          valid: !1
+        }, 400);
+      const s = JSON.parse(r), t = await j(e), o = await f(s, t);
+      return e.json(o);
+    } catch (r) {
+      return console.error("Dry-run error:", r), e.json({
+        error: r instanceof Error ? r.message : "Dry-run validation failed",
+        valid: !1
+      }, 400);
+    }
+  }), m;
 }
-function x(f, l) {
-  const u = C(l);
-  return f.route("/", u), f;
+function M(q, a) {
+  const d = E(a);
+  return q.route("/", d), q;
 }
-function A(f) {
-  const l = new w();
-  return x(l, f);
+function R(q) {
+  const a = new D();
+  return M(a, q);
 }
 export {
-  A as createCubeApp,
-  C as createCubeRoutes,
-  x as mountCubeRoutes
+  R as createCubeApp,
+  E as createCubeRoutes,
+  M as mountCubeRoutes
 };

package/dist/client/client/CubeClient.d.ts

@@ -0,0 +1,15 @@
+import { CubeQuery, CubeApiOptions, CubeResultSet } from '../types';
+export declare class CubeClient {
+    private apiUrl;
+    private headers;
+    constructor(token?: string, options?: CubeApiOptions);
+    load(query: CubeQuery): Promise<CubeResultSet>;
+    meta(): Promise<any>;
+    sql(query: CubeQuery): Promise<any>;
+    dryRun(query: CubeQuery): Promise<any>;
+}
+/**
+ * Factory function to create a cube client
+ */
+export declare function createCubeClient(token?: string, options?: CubeApiOptions): CubeClient;
+export declare function cube(token?: string, options?: CubeApiOptions): CubeClient;

package/dist/client/components/AnalyticsDashboard.d.ts

@@ -0,0 +1,2 @@
+import { AnalyticsDashboardProps } from '../types';
+export default function AnalyticsDashboard({ config, apiUrl, apiOptions, editable, onConfigChange, onSave, onDirtyStateChange }: AnalyticsDashboardProps): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/AnalyticsPage.d.ts

@@ -0,0 +1 @@
+export declare function AnalyticsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/AnalyticsPortlet.d.ts

@@ -0,0 +1,6 @@
+import { AnalyticsPortletProps } from '../types';
+interface AnalyticsPortletRef {
+    refresh: () => void;
+}
+declare const AnalyticsPortlet: import('react').ForwardRefExoticComponent<AnalyticsPortletProps & import('react').RefAttributes<AnalyticsPortletRef>>;
+export default AnalyticsPortlet;

package/dist/client/components/ChartConfigEditor.d.ts

@@ -0,0 +1,8 @@
+import { ChartAxisConfig, ChartDisplayConfig } from '../types';
+interface ChartConfigEditorProps {
+    chartConfig: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    onConfigChange: (chartConfig: ChartAxisConfig, displayConfig: ChartDisplayConfig) => void;
+}
+export default function ChartConfigEditor({ chartConfig, displayConfig, onConfigChange }: ChartConfigEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/ChartErrorBoundary.d.ts

@@ -0,0 +1,21 @@
+import { default as React, Component, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+    portletTitle?: string;
+    portletConfig?: any;
+    cubeQuery?: string;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: string | null;
+}
+export default class ChartErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    handleReset: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/client/components/DashboardEditModal.d.ts

@@ -0,0 +1,14 @@
+interface DashboardEditModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (data: {
+        name: string;
+        description?: string;
+    }) => Promise<void> | void;
+    title: string;
+    submitText: string;
+    initialName?: string;
+    initialDescription?: string;
+}
+export default function DashboardEditModal({ isOpen, onClose, onSave, title, submitText, initialName, initialDescription }: DashboardEditModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/DashboardGrid.d.ts

@@ -0,0 +1,11 @@
+import { DashboardConfig } from '../types';
+interface DashboardGridProps {
+    config: DashboardConfig;
+    editable?: boolean;
+    onConfigChange?: (config: DashboardConfig) => void;
+    onPortletRefresh?: (portletId: string) => void;
+    onSave?: (config: DashboardConfig) => Promise<void> | void;
+    apiUrl?: string;
+}
+export default function DashboardGrid({ config, editable, onConfigChange, onPortletRefresh, onSave, apiUrl }: DashboardGridProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/Modal.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'fullscreen';
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    className?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    noPadding?: boolean;
+}
+declare const Modal: React.FC<ModalProps>;
+export default Modal;

package/dist/client/components/PortletContainer.d.ts

@@ -0,0 +1,10 @@
+import { PortletConfig } from '../types';
+interface PortletContainerProps {
+    portlet: PortletConfig;
+    editable?: boolean;
+    onEdit?: (portlet: PortletConfig) => void;
+    onDelete?: (portletId: string) => void;
+    onRefresh?: (portletId: string) => void;
+}
+export default function PortletContainer({ portlet, editable, onEdit, onDelete, onRefresh }: PortletContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/PortletEditModal.d.ts

@@ -0,0 +1,12 @@
+import { PortletConfig } from '../types';
+interface PortletEditModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (portlet: PortletConfig | Omit<PortletConfig, 'id' | 'x' | 'y'>) => void;
+    portlet?: PortletConfig | null;
+    title: string;
+    submitText: string;
+    apiUrl?: string;
+}
+export default function PortletEditModal({ isOpen, onClose, onSave, portlet, title, submitText, apiUrl }: PortletEditModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/client/components/QueryBuilder/CubeMetaExplorer.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { CubeMetaExplorerProps } from './types';
+declare const CubeMetaExplorer: React.FC<CubeMetaExplorerProps>;
+export default CubeMetaExplorer;

package/dist/client/components/QueryBuilder/QueryPanel.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { QueryPanelProps } from './types';
+declare const QueryPanel: React.FC<QueryPanelProps>;
+export default QueryPanel;

package/dist/client/components/QueryBuilder/ResultsPanel.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ResultsPanelProps } from './types';
+declare const ResultsPanel: React.FC<ResultsPanelProps>;
+export default ResultsPanel;