@querypanel/node-sdk 1.0.55 → 1.0.57

package/dist/index.js

@@ -326,29 +326,31 @@ var PostgresAdapter = class {
     }
   }
   /**
-   * Convert named params to positional array for PostgreSQL
-   * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3]
+   * Convert params to positional array for PostgreSQL.
+   * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3].
+   * When the record has numeric keys ("1", "2", "3") — e.g. from mapGeneratedParams —
+   * use only those in order so placeholder order matches SQL. Otherwise fall back to
+   * named keys in alphabetical order for backward compatibility.
    */
   convertNamedToPositionalParams(params) {
     const numericKeys = Object.keys(params).filter((k) => /^\d+$/.test(k)).map((k) => Number.parseInt(k, 10)).sort((a, b) => a - b);
-    const namedKeys = Object.keys(params).filter((k) => !/^\d+$/.test(k)).sort();
-    const positionalParams = [];
-    for (const key of numericKeys) {
-      let val = params[String(key)];
-      if (typeof val === "string") {
-        const match = val.match(/^<([a-zA-Z0-9_]+)>$/);
-        const namedKey = match?.[1];
-        if (namedKey && namedKey in params) {
-          val = params[namedKey];
+    if (numericKeys.length > 0) {
+      const positionalParams = [];
+      for (const key of numericKeys) {
+        let val = params[String(key)];
+        if (typeof val === "string") {
+          const match = val.match(/^<([a-zA-Z0-9_]+)>$/);
+          const namedKey = match?.[1];
+          if (namedKey && namedKey in params) {
+            val = params[namedKey];
+          }
         }
+        positionalParams.push(val);
       }
-      positionalParams.push(val);
-    }
-    for (const key of namedKeys) {
-      const val = params[key];
-      positionalParams.push(val);
+      return positionalParams;
     }
-    return positionalParams;
+    const namedKeys = Object.keys(params).filter((k) => !/^\d+$/.test(k)).sort();
+    return namedKeys.map((key) => params[key]);
   }
   async validate(sql, params) {
     let paramArray;
@@ -560,6 +562,13 @@ var ApiClient = class {
   getDefaultTenantId() {
     return this.defaultTenantId;
   }
+  /**
+   * Create a JWT for the given tenant (and optional userId, scopes).
+   * Use this when you need to pass a token to the embed (e.g. frontend or demo).
+   */
+  async createJwt(tenantId, userId, scopes) {
+    return await this.generateJWT(tenantId, userId, scopes);
+  }
   async get(path, tenantId, userId, scopes, signal, sessionId) {
     return await this.request(path, {
       method: "GET",
@@ -772,6 +781,111 @@ var ApiClient = class {
   }
 };
 
+// src/core/callback-client.ts
+var CallbackApiClient = class {
+  requestHandler;
+  defaultTenantId;
+  constructor(requestHandler, options) {
+    this.requestHandler = requestHandler;
+    this.defaultTenantId = options?.defaultTenantId;
+  }
+  getDefaultTenantId() {
+    return this.defaultTenantId;
+  }
+  async request(opts) {
+    const { data, headers } = await this.requestHandler({
+      method: opts.method,
+      path: opts.path,
+      body: opts.body,
+      tenantId: opts.tenantId,
+      userId: opts.userId,
+      scopes: opts.scopes,
+      signal: opts.signal,
+      sessionId: opts.sessionId
+    });
+    return { data, headers };
+  }
+  async get(path, tenantId, userId, scopes, signal, sessionId) {
+    const { data } = await this.request({
+      method: "GET",
+      path,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return data;
+  }
+  async post(path, body, tenantId, userId, scopes, signal, sessionId) {
+    const { data } = await this.request({
+      method: "POST",
+      path,
+      body,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return data;
+  }
+  async postWithHeaders(path, body, tenantId, userId, scopes, signal, sessionId) {
+    const { data, headers } = await this.request({
+      method: "POST",
+      path,
+      body,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return {
+      data,
+      headers: headers ?? new Headers()
+    };
+  }
+  async put(path, body, tenantId, userId, scopes, signal, sessionId) {
+    const { data } = await this.request({
+      method: "PUT",
+      path,
+      body,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return data;
+  }
+  async patch(path, body, tenantId, userId, scopes, signal, sessionId) {
+    const { data } = await this.request({
+      method: "PATCH",
+      path,
+      body,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return data;
+  }
+  async delete(path, tenantId, userId, scopes, signal, sessionId) {
+    const { data } = await this.request({
+      method: "DELETE",
+      path,
+      tenantId,
+      userId,
+      scopes,
+      signal,
+      sessionId
+    });
+    return data;
+  }
+};
+
 // src/core/query-engine.ts
 var QueryEngine = class {
   databases = /* @__PURE__ */ new Map();
@@ -834,6 +948,12 @@ var QueryEngine = class {
       return [];
     }
   }
+  /**
+   * Maps API params (array in SQL placeholder order $1, $2, $3) to ParamRecord.
+   * Sets both numeric keys ("1", "2", "3") and named keys so that:
+   * - Postgres adapter uses numeric order for positional params (matches SQL).
+   * - Named keys remain for tenant isolation / other lookups.
+   */
   mapGeneratedParams(params) {
     const record = {};
     params.forEach((param, index) => {
@@ -841,6 +961,7 @@ var QueryEngine = class {
       if (value === void 0) {
         return;
       }
+      record[String(index + 1)] = value;
       const nameCandidate = typeof param.name === "string" && param.name.trim() || typeof param.placeholder === "string" && param.placeholder.trim() || typeof param.position === "number" && String(param.position) || String(index + 1);
       const key = nameCandidate.replace(/[{}:$]/g, "").trim();
       record[key] = value;
@@ -1169,10 +1290,161 @@ function resolveTenantId2(client, tenantId) {
   return resolved;
 }
 
+// src/routes/dashboards.ts
+function resolveTenantId3(client, tenantId) {
+  const resolved = tenantId ?? client.getDefaultTenantId();
+  if (resolved === void 0) {
+    throw new Error("tenantId is required (option or client default)");
+  }
+  return resolved;
+}
+async function createDashboard(client, body, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.post(
+    "/dashboards",
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listDashboards(client, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  const params = new URLSearchParams();
+  if (options?.pagination?.page) {
+    params.set("page", options.pagination.page.toString());
+  }
+  if (options?.pagination?.limit) {
+    params.set("limit", options.pagination.limit.toString());
+  }
+  if (options?.status) {
+    params.set("status", options.status);
+  }
+  if (options?.sortBy) {
+    params.set("sort_by", options.sortBy);
+  }
+  if (options?.sortDir) {
+    params.set("sort_dir", options.sortDir);
+  }
+  return await client.get(
+    `/dashboards?${params.toString()}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function getDashboard(client, id, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.get(
+    `/dashboards/${id}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function getDashboardForTenant(client, id, tenantId, options, signal) {
+  const params = new URLSearchParams();
+  params.set("tenant_id", tenantId);
+  return await client.get(
+    `/dashboards/${id}/for-tenant?${params.toString()}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function updateDashboard(client, id, body, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.put(
+    `/dashboards/${id}`,
+    body,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function updateDashboardStatus(client, id, status, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.patch(
+    `/dashboards/${id}/status`,
+    { status },
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteDashboard(client, id, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  await client.delete(
+    `/dashboards/${id}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function forkDashboard(client, id, input, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.post(
+    `/dashboards/${id}/fork`,
+    input,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function updateFork(client, forkId, input, options, signal) {
+  const tenantId = resolveTenantId3(client, options?.tenantId);
+  return await client.put(
+    `/dashboards/forks/${forkId}`,
+    input,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function rollbackFork(client, forkId, tenantId, options, signal) {
+  return await client.post(
+    `/dashboards/forks/${forkId}/rollback`,
+    { tenant_id: tenantId },
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function deleteFork(client, forkId, tenantId, options, signal) {
+  const params = new URLSearchParams();
+  params.set("tenant_id", tenantId);
+  await client.delete(
+    `/dashboards/forks/${forkId}?${params.toString()}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+async function listForksForTenant(client, tenantId, options, signal) {
+  return await client.get(
+    `/dashboards/customer/${tenantId}`,
+    tenantId,
+    options?.userId,
+    options?.scopes,
+    signal
+  );
+}
+
 // src/routes/ingest.ts
 import crypto2 from "crypto";
 async function syncSchema(client, queryEngine, databaseName, options, signal) {
-  const tenantId = resolveTenantId3(client, options.tenantId);
+  const tenantId = resolveTenantId4(client, options.tenantId);
   const adapter = queryEngine.getDatabase(databaseName);
   const metadata = queryEngine.getDatabaseMetadata(databaseName);
   const introspection = await adapter.introspect(
@@ -1194,7 +1466,7 @@ async function syncSchema(client, queryEngine, databaseName, options, signal) {
   );
   return response;
 }
-function resolveTenantId3(client, tenantId) {
+function resolveTenantId4(client, tenantId) {
   const resolved = tenantId ?? client.getDefaultTenantId();
   if (!resolved) {
     throw new Error(
@@ -1236,7 +1508,7 @@ import crypto4 from "crypto";
 // src/routes/query.ts
 import crypto3 from "crypto";
 async function ask(client, queryEngine, question, options, signal) {
-  const tenantId = resolveTenantId4(client, options.tenantId);
+  const tenantId = resolveTenantId5(client, options.tenantId);
   const sessionId = crypto3.randomUUID();
   const querypanelSessionId = options.querypanelSessionId ?? sessionId;
   const maxRetry = options.maxRetry ?? 0;
@@ -1391,7 +1663,7 @@ async function ask(client, queryEngine, question, options, signal) {
   }
   throw new Error("Unexpected error in ask retry loop");
 }
-function resolveTenantId4(client, tenantId) {
+function resolveTenantId5(client, tenantId) {
   const resolved = tenantId ?? client.getDefaultTenantId();
   if (!resolved) {
     throw new Error(
@@ -1414,7 +1686,7 @@ function anonymizeResults(rows) {
 }
 
 // src/routes/modify.ts
-function buildModifiedQuestion(originalQuestion, modifications, pipeline) {
+function buildModifiedQuestion(originalQuestion, modifications, pipeline, hasSessionContext = false) {
   const hints = [];
   if (modifications.timeGranularity) {
     hints.push(`group results by ${modifications.timeGranularity}`);
@@ -1449,7 +1721,7 @@ function buildModifiedQuestion(originalQuestion, modifications, pipeline) {
   if (hints.length === 0) {
     return originalQuestion;
   }
-  if (pipeline === "v2") {
+  if (pipeline === "v2" && hasSessionContext) {
     return hints.join(", ");
   }
   return `${originalQuestion} (${hints.join(", ")})`;
@@ -1547,7 +1819,7 @@ function stripVizSpecOnlyHints(hints) {
   const { kind: _kind, ...rest } = hints;
   return rest;
 }
-function resolveTenantId5(client, tenantId) {
+function resolveTenantId6(client, tenantId) {
   const resolved = tenantId ?? client.getDefaultTenantId();
   if (!resolved) {
     throw new Error(
@@ -1557,9 +1829,10 @@ function resolveTenantId5(client, tenantId) {
   return resolved;
 }
 async function modifyChart(client, queryEngine, input, options, signal) {
-  const tenantId = resolveTenantId5(client, options?.tenantId);
+  const tenantId = resolveTenantId6(client, options?.tenantId);
   const sessionId = crypto4.randomUUID();
   const querypanelSessionId = options?.querypanelSessionId ?? sessionId;
+  const hasQuerypanelSessionContext = !!options?.querypanelSessionId;
   const chartType = options?.chartType ?? "vega-lite";
   const hasSqlMods = !!input.sqlModifications;
   const hasVizMods = !!input.vizModifications;
@@ -1596,7 +1869,8 @@ async function modifyChart(client, queryEngine, input, options, signal) {
     const modifiedQuestion = buildModifiedQuestion(
       input.question,
       input.sqlModifications,
-      options?.pipeline
+      options?.pipeline,
+      hasQuerypanelSessionContext
     );
     if (options?.pipeline === "v2") {
       finalQuestion = modifiedQuestion;
@@ -1723,7 +1997,7 @@ async function modifyChart(client, queryEngine, input, options, signal) {
 
 // src/routes/sessions.ts
 async function listSessions(client, options, signal) {
-  const tenantId = resolveTenantId6(client, options?.tenantId);
+  const tenantId = resolveTenantId7(client, options?.tenantId);
   const params = new URLSearchParams();
   if (options?.pagination?.page)
     params.set("page", `${options.pagination.page}`);
@@ -1746,7 +2020,7 @@ async function listSessions(client, options, signal) {
   );
 }
 async function getSession(client, sessionId, options, signal) {
-  const tenantId = resolveTenantId6(client, options?.tenantId);
+  const tenantId = resolveTenantId7(client, options?.tenantId);
   const params = new URLSearchParams();
   if (options?.includeTurns !== void 0) {
     params.set("include_turns", `${options.includeTurns}`);
@@ -1760,7 +2034,7 @@ async function getSession(client, sessionId, options, signal) {
   );
 }
 async function updateSession(client, sessionId, body, options, signal) {
-  const tenantId = resolveTenantId6(client, options?.tenantId);
+  const tenantId = resolveTenantId7(client, options?.tenantId);
   return await client.patch(
     `/sessions/${encodeURIComponent(sessionId)}`,
     body,
@@ -1771,7 +2045,7 @@ async function updateSession(client, sessionId, body, options, signal) {
   );
 }
 async function deleteSession(client, sessionId, options, signal) {
-  const tenantId = resolveTenantId6(client, options?.tenantId);
+  const tenantId = resolveTenantId7(client, options?.tenantId);
   await client.delete(
     `/sessions/${encodeURIComponent(sessionId)}`,
     tenantId,
@@ -1780,7 +2054,7 @@ async function deleteSession(client, sessionId, options, signal) {
     signal
   );
 }
-function resolveTenantId6(client, tenantId) {
+function resolveTenantId7(client, tenantId) {
   const resolved = tenantId ?? client.getDefaultTenantId();
   if (!resolved) {
     throw new Error(
@@ -1793,7 +2067,7 @@ function resolveTenantId6(client, tenantId) {
 // src/routes/vizspec.ts
 import crypto5 from "crypto";
 async function generateVizSpec(client, input, options, signal) {
-  const tenantId = resolveTenantId7(client, options?.tenantId);
+  const tenantId = resolveTenantId8(client, options?.tenantId);
   const sessionId = crypto5.randomUUID();
   const response = await client.post(
     "/vizspec",
@@ -1815,7 +2089,7 @@ async function generateVizSpec(client, input, options, signal) {
   );
   return response;
 }
-function resolveTenantId7(client, tenantId) {
+function resolveTenantId8(client, tenantId) {
   const resolved = tenantId ?? client.getDefaultTenantId();
   if (!resolved) {
     throw new Error(
@@ -1826,13 +2100,62 @@ function resolveTenantId7(client, tenantId) {
 }
 
 // src/index.ts
-var QueryPanelSdkAPI = class {
+var QueryPanelSdkAPI = class _QueryPanelSdkAPI {
   client;
   queryEngine;
   constructor(baseUrl, privateKey, organizationId, options) {
-    this.client = new ApiClient(baseUrl, privateKey, organizationId, options);
+    if (options?.api) {
+      this.client = options.api;
+    } else {
+      if (!baseUrl) throw new Error("Base URL is required");
+      if (!privateKey) throw new Error("Private key is required");
+      if (!organizationId) throw new Error("Organization ID is required");
+      this.client = new ApiClient(baseUrl, privateKey, organizationId, {
+        defaultTenantId: options?.defaultTenantId,
+        additionalHeaders: options?.additionalHeaders,
+        fetch: options?.fetch
+      });
+    }
+    if (!organizationId) throw new Error("Organization ID is required");
     this.queryEngine = new QueryEngine();
   }
+  /**
+   * Create an SDK instance that uses a request callback instead of HTTP.
+   * Use this when calling the SDK from within your own API so that "API" calls
+   * are handled in-process (e.g. by invoking querypanel-sdk services directly)
+   * and do not cause recursion.
+   *
+   * @param organizationId - Organization identifier
+   * @param requestHandler - Callback invoked for each logical API request (method, path, body, tenantId, etc.)
+   * @param options - Optional defaultTenantId
+   * @returns QueryPanelSdkAPI instance; attach databases and call ask(), syncSchema(), etc. as usual
+   *
+   * @example
+   * ```ts
+   * const qp = QueryPanelSdkAPI.withCallbacks(
+   *   process.env.ORGANIZATION_ID!,
+   *   async (opts) => {
+   *     // Call your in-process services (e.g. querypanel-sdk logic) instead of HTTP
+   *     if (opts.path === '/query' || opts.path === '/v2/query') {
+   *       const result = await yourSqlGenerator.generate(opts.body, opts.tenantId);
+   *       return { data: result, headers: new Headers({ 'x-querypanel-session-id': result.sessionId }) };
+   *     }
+   *     if (opts.path === '/chart') return { data: await yourChartService.generate(opts.body) };
+   *     // ... other paths
+   *     return { data: await yourProxy(opts) };
+   *   },
+   *   { defaultTenantId: process.env.DEFAULT_TENANT_ID }
+   * );
+   * qp.attachPostgres('db', createClient, { tenantFieldName: 'tenant_id' });
+   * const result = await qp.ask('Top 10 orders', { tenantId: 't1', database: 'db' });
+   * ```
+   */
+  static withCallbacks(organizationId, requestHandler, options) {
+    const api = new CallbackApiClient(requestHandler, {
+      defaultTenantId: options?.defaultTenantId
+    });
+    return new _QueryPanelSdkAPI("", "", organizationId, { api });
+  }
   // Database attachment methods
   attachClickhouse(name, clientFn, options) {
     const adapter = new ClickHouseAdapter(clientFn, options);
@@ -1946,6 +2269,48 @@ var QueryPanelSdkAPI = class {
       signal
     );
   }
+  // Embedded dashboard / JWT
+  /**
+   * Creates a JWT for the given tenant (and optional userId, scopes).
+   * Use this when you need to pass a token to the embed (e.g. frontend or demo).
+   * Only available when using the HTTP client (ApiClient); not available when using withCallbacks.
+   */
+  async createJwt(options) {
+    const tenantId = options.tenantId?.trim();
+    if (!tenantId) {
+      throw new Error("tenantId is required");
+    }
+    if (!(this.client instanceof ApiClient)) {
+      throw new Error(
+        "createJwt is not available when using withCallbacks. Use the SDK with baseUrl + privateKey to create JWTs."
+      );
+    }
+    return await this.client.createJwt(
+      tenantId,
+      options.userId,
+      options.scopes
+    );
+  }
+  /**
+   * Runs SQL against an attached database with tenant isolation applied.
+   * Used by embed run-sql (e.g. dashboard chart execution). Requires a database
+   * to be attached (e.g. via attachPostgres) and options.tenantId.
+   */
+  async runSqlForDashboard(input, options) {
+    const tenantId = options.tenantId?.trim();
+    if (!tenantId) {
+      throw new Error("tenantId is required");
+    }
+    const databaseName = input.database ?? "db";
+    const params = input.params ?? {};
+    const result = await this.queryEngine.validateAndExecute(
+      input.sql,
+      params,
+      databaseName,
+      tenantId
+    );
+    return { rows: result.rows, fields: result.fields };
+  }
   // VizSpec generation
   /**
    * Generates a VizSpec visualization specification from query results.
@@ -2389,8 +2754,296 @@ var QueryPanelSdkAPI = class {
   async deleteActiveChart(id, options, signal) {
     await deleteActiveChart(this.client, id, options, signal);
   }
+  // Dashboard CRUD operations
+  /**
+   * Creates a new dashboard with BlockNote content.
+   *
+   * @param body - Dashboard configuration including name and BlockNote content
+   * @param options - Tenant, user, and scope options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Created dashboard
+   *
+   * @example
+   * ```typescript
+   * const dashboard = await qp.createDashboard({
+   *   name: "Sales Dashboard",
+   *   description: "Monthly sales metrics",
+   *   content_json: blockNoteContent,
+   *   editor_type: "blocknote",
+   * }, { tenantId: "tenant_123" });
+   * ```
+   */
+  async createDashboard(body, options, signal) {
+    return await createDashboard(
+      this.client,
+      body,
+      options,
+      signal
+    );
+  }
+  /**
+   * Lists dashboards with pagination and filtering.
+   *
+   * @param options - Filtering and pagination options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Paginated list of dashboards
+   *
+   * @example
+   * ```typescript
+   * const dashboards = await qp.listDashboards({
+   *   tenantId: "tenant_123",
+   *   status: "deployed",
+   *   pagination: { page: 1, limit: 10 },
+   * });
+   * ```
+   */
+  async listDashboards(options, signal) {
+    return await listDashboards(this.client, options, signal);
+  }
+  /**
+   * Gets a dashboard by ID.
+   *
+   * @param id - Dashboard ID
+   * @param options - Tenant, user, and scope options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Dashboard details
+   *
+   * @example
+   * ```typescript
+   * const dashboard = await qp.getDashboard("dash_123", {
+   *   tenantId: "tenant_123",
+   * });
+   * ```
+   */
+  async getDashboard(id, options, signal) {
+    return await getDashboard(
+      this.client,
+      id,
+      options,
+      signal
+    );
+  }
+  /**
+   * Gets a dashboard for a specific tenant.
+   * Returns customer fork if exists, otherwise returns the original dashboard.
+   *
+   * @param id - Dashboard ID
+   * @param tenantId - Tenant ID to check for fork
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Dashboard (fork if exists, original otherwise)
+   *
+   * @example
+   * ```typescript
+   * const dashboard = await qp.getDashboardForTenant(
+   *   "dash_123",
+   *   "tenant_456",
+   * );
+   * ```
+   */
+  async getDashboardForTenant(id, tenantId, options, signal) {
+    return await getDashboardForTenant(
+      this.client,
+      id,
+      tenantId,
+      options,
+      signal
+    );
+  }
+  /**
+   * Updates a dashboard.
+   *
+   * @param id - Dashboard ID to update
+   * @param body - Fields to update
+   * @param options - Tenant, user, and scope options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Updated dashboard
+   *
+   * @example
+   * ```typescript
+   * const updated = await qp.updateDashboard("dash_123", {
+   *   name: "Updated Dashboard",
+   *   content_json: newBlockNoteContent,
+   * }, { tenantId: "tenant_123" });
+   * ```
+   */
+  async updateDashboard(id, body, options, signal) {
+    return await updateDashboard(
+      this.client,
+      id,
+      body,
+      options,
+      signal
+    );
+  }
+  /**
+   * Updates dashboard status (deploy/undeploy).
+   *
+   * @param id - Dashboard ID
+   * @param status - New status
+   * @param options - Tenant, user, and scope options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Updated dashboard
+   *
+   * @example
+   * ```typescript
+   * const deployed = await qp.updateDashboardStatus(
+   *   "dash_123",
+   *   "deployed",
+   *   { tenantId: "tenant_123" },
+   * );
+   * ```
+   */
+  async updateDashboardStatus(id, status, options, signal) {
+    return await updateDashboardStatus(
+      this.client,
+      id,
+      status,
+      options,
+      signal
+    );
+  }
+  /**
+   * Deletes a dashboard.
+   *
+   * @param id - Dashboard ID to delete
+   * @param options - Tenant, user, and scope options
+   * @param signal - Optional AbortSignal for cancellation
+   *
+   * @example
+   * ```typescript
+   * await qp.deleteDashboard("dash_123", { tenantId: "tenant_123" });
+   * ```
+   */
+  async deleteDashboard(id, options, signal) {
+    await deleteDashboard(this.client, id, options, signal);
+  }
+  // Dashboard Fork operations (Customer Customization)
+  /**
+   * Forks a dashboard for customer customization (copy-on-write).
+   *
+   * Creates a full copy of the dashboard that the customer can edit independently.
+   * The original dashboard remains unchanged.
+   *
+   * @param id - Dashboard ID to fork
+   * @param input - Fork configuration with tenant_id
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Forked dashboard
+   *
+   * @example
+   * ```typescript
+   * const fork = await qp.forkDashboard("dash_123", {
+   *   tenant_id: "tenant_456",
+   *   name: "Customer's Custom Dashboard",
+   * });
+   * ```
+   */
+  async forkDashboard(id, input, options, signal) {
+    return await forkDashboard(
+      this.client,
+      id,
+      input,
+      options,
+      signal
+    );
+  }
+  /**
+   * Updates a customer fork.
+   *
+   * @param forkId - Fork ID to update
+   * @param input - Update data including tenant_id
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Updated fork
+   *
+   * @example
+   * ```typescript
+   * const updated = await qp.updateFork("fork_123", {
+   *   tenant_id: "tenant_456",
+   *   content_json: newBlockNoteContent,
+   * });
+   * ```
+   */
+  async updateFork(forkId, input, options, signal) {
+    return await updateFork(
+      this.client,
+      forkId,
+      input,
+      options,
+      signal
+    );
+  }
+  /**
+   * Rollbacks a fork to the original dashboard.
+   * This deletes the fork and the customer will see the original again.
+   *
+   * @param forkId - Fork ID to rollback
+   * @param tenantId - Tenant ID
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Original dashboard
+   *
+   * @example
+   * ```typescript
+   * const original = await qp.rollbackFork("fork_123", "tenant_456");
+   * ```
+   */
+  async rollbackFork(forkId, tenantId, options, signal) {
+    return await rollbackFork(
+      this.client,
+      forkId,
+      tenantId,
+      options,
+      signal
+    );
+  }
+  /**
+   * Deletes a customer fork.
+   *
+   * @param forkId - Fork ID to delete
+   * @param tenantId - Tenant ID
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   *
+   * @example
+   * ```typescript
+   * await qp.deleteFork("fork_123", "tenant_456");
+   * ```
+   */
+  async deleteFork(forkId, tenantId, options, signal) {
+    await deleteFork(
+      this.client,
+      forkId,
+      tenantId,
+      options,
+      signal
+    );
+  }
+  /**
+   * Lists all customer forks for a tenant.
+   *
+   * @param tenantId - Tenant ID
+   * @param options - Additional auth options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Array of forks
+   *
+   * @example
+   * ```typescript
+   * const forks = await qp.listForksForTenant("tenant_456");
+   * ```
+   */
+  async listForksForTenant(tenantId, options, signal) {
+    return await listForksForTenant(
+      this.client,
+      tenantId,
+      options,
+      signal
+    );
+  }
 };
 export {
+  CallbackApiClient,
   ClickHouseAdapter,
   PostgresAdapter,
   QueryErrorCode,