drizzle-cube 0.1.2 → 0.1.4

package/README.md

@@ -4,6 +4,12 @@
 
 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.
+
 [![NPM Version](https://img.shields.io/npm/v/drizzle-cube)](https://www.npmjs.com/package/drizzle-cube)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue)](https://www.typescriptlang.org/)
 [![Drizzle ORM](https://img.shields.io/badge/Drizzle%20ORM-0.33+-green)](https://orm.drizzle.team/)
@@ -240,56 +246,6 @@ Works with multiple frameworks via adapter pattern:
 
 ## Advanced Usage
 
-### Complex Queries with CTEs
-
-```typescript
-import { sql } from 'drizzle-orm'
-
-const advancedCube = defineCube('DepartmentAnalytics', {
-  title: 'Department Analytics',
-  
-  // For complex queries, you can use raw SQL
-  sql: (ctx) => sql`
-    WITH department_stats AS (
-      SELECT 
-        d.id,
-        d.name,
-        COUNT(e.id) as employee_count,
-        AVG(e.salary) as avg_salary
-      FROM ${schema.departments} d
-      LEFT JOIN ${schema.employees} e ON d.id = e.department_id
-      WHERE d.organisation_id = ${ctx.securityContext.organisationId}
-      GROUP BY d.id, d.name
-    )
-    SELECT * FROM department_stats
-  `,
-  
-  dimensions: {
-    name: {
-      name: 'name',
-      title: 'Department Name',
-      sql: sql`name`,
-      type: 'string'
-    }
-  },
-  
-  measures: {
-    employeeCount: {
-      name: 'employeeCount',
-      title: 'Employee Count',
-      sql: sql`employee_count`,
-      type: 'number'
-    },
-    avgSalary: {
-      name: 'avgSalary',
-      title: 'Average Salary',
-      sql: sql`avg_salary`,
-      type: 'number',
-      format: 'currency'
-    }
-  }
-})
-```
 
 ### Advanced Security with Row-Level Security
 
@@ -330,21 +286,6 @@ const secureCube = defineCube('SecureEmployees', {
 })
 ```
 
-### Multiple Database Support
-
-```typescript
-// PostgreSQL
-import { drizzle } from 'drizzle-orm/postgres-js'
-import postgres from 'postgres'
-
-// MySQL  
-import { drizzle } from 'drizzle-orm/mysql2'
-import mysql from 'mysql2/promise'
-
-// SQLite
-import { drizzle } from 'drizzle-orm/better-sqlite3'
-import Database from 'better-sqlite3'
-```
 
 ## API Reference
 
@@ -379,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,35 +1,35 @@
-import { Hono as w } from "hono";
-var j = (f) => {
-  const u = {
+import { Hono as v } from "hono";
+var A = (y) => {
+  const c = {
     ...{
       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);
+    ...y
+  }, q = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(c.origin), g = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(c.allowMethods);
+  return async function(n, d) {
+    var e;
+    function f(r, s) {
+      n.res.headers.set(r, s);
     }
-    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 w = q(n.req.header("origin") || "", n);
+    if (w && f("Access-Control-Allow-Origin", w), c.origin !== "*") {
+      const r = n.req.header("Vary");
+      r ? f("Vary", r) : f("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 (c.credentials && f("Access-Control-Allow-Credentials", "true"), (e = c.exposeHeaders) != null && e.length && f("Access-Control-Expose-Headers", c.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
+      c.maxAge != null && f("Access-Control-Max-Age", c.maxAge.toString());
+      const r = g(n.req.header("origin") || "", n);
+      r.length && f("Access-Control-Allow-Methods", r.join(","));
+      let s = c.allowHeaders;
+      if (!(s != null && s.length)) {
+        const t = n.req.header("Access-Control-Request-Headers");
+        t && (s = t.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 s != null && s.length && (f("Access-Control-Allow-Headers", s.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"
       });
@@ -37,28 +37,27 @@ var j = (f) => {
     await d();
   };
 };
-function C(f) {
+function E(y) {
   const {
-    semanticLayer: l,
-    drizzle: u,
+    semanticLayer: a,
+    drizzle: c,
     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;
+    getSecurityContext: g,
+    cors: u,
+    basePath: n = "/cubejs-api/v1"
+  } = y, d = new v();
+  u && d.use("/*", A(u)), a.hasExecutor() || a.setDrizzle(c, q), d.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 g(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);
       return e.json({
-        data: s.data,
-        annotation: s.annotation,
-        query: r,
+        data: i.data,
+        annotation: i.annotation,
+        query: s,
         slowQuery: !1
       });
     } catch (r) {
@@ -66,24 +65,23 @@ function C(f) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${t}/load`, async (e) => {
-    var o, i;
+  }), d.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 g(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);
       return e.json({
-        data: c.data,
-        annotation: c.annotation,
-        query: n,
+        data: i.data,
+        annotation: i.annotation,
+        query: s,
         slowQuery: !1
       });
     } catch (r) {
@@ -91,82 +89,178 @@ function C(f) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${t}/meta`, async (e) => {
+  }), d.get(`${n}/meta`, async (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;
+  }), d.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 g(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 p = ((r = t.measures) == null ? void 0 : r[0]) || ((s = t.dimensions) == null ? void 0 : s[0]);
+      if (!p)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const g = y.split(".")[0], h = await l.generateSQL(g, s, c);
+      const h = p.split(".")[0], j = await a.generateSQL(h, t, o);
       return e.json({
-        sql: h.sql,
-        params: h.params || [],
-        query: s
+        sql: j.sql,
+        params: j.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;
+  }), d.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 g(e), p = a.validateQuery(o);
+      if (!p.isValid)
         return e.json({
-          error: "Query must specify at least one measure or dimension"
+          error: `Query validation failed: ${p.errors.join(", ")}`
         }, 400);
-      const g = ((r = c.measures) == null ? void 0 : r[0]) || ((n = c.dimensions) == null ? void 0 : n[0]);
-      if (!g)
+      const h = ((r = o.measures) == null ? void 0 : r[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
+      if (!h)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const h = g.split(".")[0], p = await l.generateSQL(h, c, y);
+      const j = h.split(".")[0], Q = await a.generateSQL(j, 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);
     }
+  });
+  function f(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";
+  }
+  async function w(e, r) {
+    var h, j, Q, b;
+    const s = a.validateQuery(e);
+    if (!s.isValid)
+      throw new Error(`Query validation failed: ${s.errors.join(", ")}`);
+    const t = /* @__PURE__ */ new Set();
+    (h = e.measures) == null || h.forEach((l) => {
+      const m = l.split(".")[0];
+      t.add(m);
+    }), (j = e.dimensions) == null || j.forEach((l) => {
+      const m = l.split(".")[0];
+      t.add(m);
+    }), (Q = e.timeDimensions) == null || Q.forEach((l) => {
+      const m = l.dimension.split(".")[0];
+      t.add(m);
+    }), (b = e.filters) == null || b.forEach((l) => {
+      if ("member" in l) {
+        const m = l.member.split(".")[0];
+        t.add(m);
+      }
+    });
+    const o = t.size > 1;
+    let i;
+    if (o)
+      i = await a.generateMultiCubeSQL(e, r);
+    else {
+      const l = Array.from(t)[0];
+      i = await a.generateSQL(l, e, r);
+    }
+    const p = Array.from(t).map((l) => {
+      var m, x;
+      return {
+        cube: l,
+        query: {
+          measures: ((m = e.measures) == null ? void 0 : m.filter((C) => C.startsWith(l + "."))) || [],
+          dimensions: ((x = e.dimensions) == null ? void 0 : x.filter((C) => C.startsWith(l + "."))) || [],
+          filters: e.filters || [],
+          timeDimensions: e.timeDimensions || [],
+          order: e.order || {},
+          limit: e.limit,
+          offset: e.offset
+        }
+      };
+    });
+    return {
+      queryType: "regularQuery",
+      normalizedQueries: p,
+      queryOrder: Array.from(t),
+      transformedQueries: p,
+      pivotQuery: {
+        query: e,
+        cubes: Array.from(t)
+      },
+      sql: {
+        sql: [i.sql],
+        params: i.params || []
+      },
+      complexity: f(e),
+      valid: !0,
+      cubesUsed: Array.from(t),
+      joinType: o ? "multi_cube_join" : "single_cube",
+      query: e
+    };
+  }
+  return d.post(`${n}/dry-run`, async (e) => {
+    try {
+      const r = await e.req.json(), s = r.query || r, t = await g(e), o = await w(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);
+    }
+  }), d.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 g(e), o = await w(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);
+    }
   }), d;
 }
-function x(f, l) {
-  const u = C(l);
-  return f.route("/", u), f;
+function S(y, a) {
+  const c = E(a);
+  return y.route("/", c), y;
 }
-function A(f) {
-  const l = new w();
-  return x(l, f);
+function D(y) {
+  const a = new v();
+  return S(a, y);
 }
 export {
-  A as createCubeApp,
-  C as createCubeRoutes,
-  x as mountCubeRoutes
+  D as createCubeApp,
+  E as createCubeRoutes,
+  S as mountCubeRoutes
 };

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

@@ -0,0 +1,14 @@
+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>;
+}
+/**
+ * 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,15 @@
+import { default as React } from 'react';
+export interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    className?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+}
+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/charts/AreaChart.d.ts

@@ -0,0 +1,2 @@
+import { ChartProps } from '../../types';
+export default function AreaChart({ data, chartConfig, displayConfig, queryObject, height }: ChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/charts/BarChart.d.ts

@@ -0,0 +1,2 @@
+import { ChartProps } from '../../types';
+export default function BarChart({ data, chartConfig, displayConfig, queryObject, height }: ChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/client/components/charts/ChartContainer.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+interface ChartContainerProps {
+    children: ReactElement;
+    height?: string | number;
+}
+export default function ChartContainer({ children, height }: ChartContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};