@dbx-tools/appkit-generator 0.0.0-stage → 0.9.138

package/lib/src/assets.js

@@ -0,0 +1,224 @@
+/**
+ * Deterministic brand-asset discovery from an official page.
+ *
+ * @module
+ */
+import { object } from "@dbx-tools/shared-core";
+import { load } from "cheerio";
+/** Normalize a page-relative asset reference to a public HTTPS URL. */
+function assetUrl(value, baseUrl) {
+    if (!value?.trim())
+        return undefined;
+    try {
+        const resolved = new URL(value.trim(), baseUrl);
+        return resolved.protocol === "https:" ? resolved.toString() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Add a normalized URL to a candidate list once. */
+function appendCandidate(candidates, value, baseUrl) {
+    const resolved = assetUrl(value, baseUrl);
+    if (resolved && !candidates.includes(resolved))
+        candidates.push(resolved);
+}
+/** Collapse CDN size and format variants of the same mobile artwork. */
+function mobileImageIdentity(value) {
+    const url = new URL(value);
+    if (/googleusercontent\.com$/i.test(url.hostname)) {
+        return `${url.origin}${url.pathname.replace(/=[^/]+$/, "")}`;
+    }
+    if (/mzstatic\.com$/i.test(url.hostname)) {
+        return `${url.origin}${url.pathname.replace(/\/[^/]+$/, "")}`;
+    }
+    return url.toString();
+}
+/**
+ * Find logo-like URLs nested in JSON-LD organization metadata.
+ *
+ * JSON-LD permits `logo` and `image` to be a URL, an object with a `url` or
+ * `contentUrl`, or an array. The bounded recursive walk accepts those forms
+ * without treating unrelated strings elsewhere in the document as assets.
+ */
+function jsonLdAssetUrls(value, depth = 0, assetContext = false) {
+    if (depth > 8 || value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return assetContext ? [value] : [];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => jsonLdAssetUrls(entry, depth + 1, assetContext));
+    }
+    if (!object.isRecord(value))
+        return [];
+    const direct = assetContext
+        ? [value.url, value.contentUrl].flatMap((entry) => (typeof entry === "string" ? [entry] : []))
+        : [];
+    return [
+        ...direct,
+        ...jsonLdAssetUrls(value.logo, depth + 1, true),
+        ...jsonLdAssetUrls(value.image, depth + 1, true),
+        ...jsonLdAssetUrls(value["@graph"], depth + 1, false),
+    ];
+}
+/** Collect mobile screenshots and image objects from JSON-LD. */
+function jsonLdMobileImageUrls(value, depth = 0, imageContext = false) {
+    if (depth > 10 || value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return imageContext ? [value] : [];
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => jsonLdMobileImageUrls(entry, depth + 1, imageContext));
+    }
+    if (!object.isRecord(value))
+        return [];
+    const direct = imageContext
+        ? [value.url, value.contentUrl].flatMap((entry) => (typeof entry === "string" ? [entry] : []))
+        : [];
+    return [
+        ...direct,
+        ...jsonLdMobileImageUrls(value.screenshot, depth + 1, true),
+        ...jsonLdMobileImageUrls(value.image, depth + 1, true),
+        ...jsonLdMobileImageUrls(value.thumbnailUrl, depth + 1, true),
+        ...jsonLdMobileImageUrls(value["@graph"], depth + 1, false),
+    ];
+}
+/**
+ * Discover icon, logo, and favicon URLs from an official page.
+ *
+ * The function only returns URLs present in page metadata or markup. When the
+ * page omits an icon, it uses the conventional `/favicon.ico` URL on the same
+ * origin. The logo falls back to that icon so a generated context never points
+ * at the dbx-tools default artwork.
+ */
+export function discoverBrandAssets(html, pageUrl) {
+    const $ = load(html);
+    const icons = [];
+    const logos = [];
+    $("link[rel]").each((_index, element) => {
+        const rel = ($(element).attr("rel") ?? "").toLowerCase();
+        if (rel.split(/\s+/).some((part) => part === "icon" || part === "apple-touch-icon")) {
+            appendCandidate(icons, $(element).attr("href"), pageUrl);
+        }
+    });
+    for (const selector of [
+        'meta[property="og:image"]',
+        'meta[property="og:logo"]',
+        'meta[name="twitter:image"]',
+    ]) {
+        $(selector).each((_index, element) => {
+            appendCandidate(logos, $(element).attr("content"), pageUrl);
+        });
+    }
+    $("img").each((_index, element) => {
+        const descriptor = [
+            $(element).attr("alt"),
+            $(element).attr("class"),
+            $(element).attr("id"),
+            $(element).attr("data-testid"),
+        ]
+            .filter(Boolean)
+            .join(" ");
+        if (/\b(?:brand|logo|wordmark)\b/i.test(descriptor)) {
+            appendCandidate(logos, $(element).attr("src"), pageUrl);
+        }
+    });
+    $('script[type="application/ld+json"]').each((_index, element) => {
+        try {
+            const value = JSON.parse($(element).text());
+            for (const candidate of jsonLdAssetUrls(value)) {
+                appendCandidate(logos, candidate, pageUrl);
+            }
+        }
+        catch {
+            return;
+        }
+    });
+    const fallbackIcon = new URL("/favicon.ico", pageUrl).toString();
+    const icon = icons[0] ?? logos[0] ?? fallbackIcon;
+    const logo = logos[0] ?? icons[0] ?? fallbackIcon;
+    return {
+        icon: { light: icon },
+        logo: { light: logo },
+        favicon: icon,
+    };
+}
+/** Extract an app name plus representative screenshots/icons from a store page. */
+export function discoverMobileAppVisuals(html, pageUrl) {
+    const $ = load(html);
+    const metadataImages = [];
+    const structuredImages = [];
+    const screenshotImages = [];
+    const iconImages = [];
+    const otherStoreImages = [];
+    for (const selector of ['meta[property="og:image"]', 'meta[name="twitter:image"]']) {
+        $(selector).each((_index, element) => {
+            appendCandidate(metadataImages, $(element).attr("content"), pageUrl);
+        });
+    }
+    $('script[type="application/ld+json"]').each((_index, element) => {
+        try {
+            const value = JSON.parse($(element).text());
+            for (const candidate of jsonLdMobileImageUrls(value)) {
+                appendCandidate(structuredImages, candidate, pageUrl);
+            }
+        }
+        catch {
+            return;
+        }
+    });
+    $("img").each((_index, element) => {
+        const descriptor = [
+            $(element).attr("alt"),
+            $(element).attr("class"),
+            $(element).attr("aria-label"),
+        ]
+            .filter(Boolean)
+            .join(" ");
+        const source = $(element).attr("src") ?? $(element).attr("data-src");
+        const isStoreImageHost = /(?:mzstatic|ggpht|googleusercontent)\./i.test(source ?? "");
+        const target = /\b(?:phone|screen|screenshot|tablet)\b/i.test(descriptor)
+            ? screenshotImages
+            : /\b(?:app|icon)\b/i.test(descriptor)
+                ? iconImages
+                : isStoreImageHost
+                    ? otherStoreImages
+                    : undefined;
+        if (target) {
+            appendCandidate(target, source, pageUrl);
+            const srcset = ($(element).attr("srcset") ?? $(element).attr("data-srcset"))
+                ?.split(",")
+                .at(-1)
+                ?.trim()
+                .split(/\s+/)[0];
+            appendCandidate(target, srcset, pageUrl);
+        }
+    });
+    $("picture source[srcset]").each((_index, element) => {
+        const srcset = $(element).attr("srcset")?.split(",").at(-1)?.trim().split(/\s+/)[0];
+        appendCandidate(screenshotImages, srcset, pageUrl);
+    });
+    const images = [];
+    const seenImages = new Set();
+    for (const candidate of [
+        ...metadataImages.slice(0, 1),
+        ...screenshotImages,
+        ...iconImages,
+        ...structuredImages,
+        ...otherStoreImages,
+    ]) {
+        const resolved = assetUrl(candidate, pageUrl);
+        if (!resolved)
+            continue;
+        const identity = mobileImageIdentity(resolved);
+        if (seenImages.has(identity))
+            continue;
+        seenImages.add(identity);
+        images.push(resolved);
+    }
+    const rawName = $('meta[property="og:title"]').attr("content") ?? $("h1").first().text() ?? $("title").text();
+    const appName = rawName.replace(/\s+(?:on the App Store|- Apps on Google Play).*$/i, "").trim() ||
+        new URL(pageUrl).hostname;
+    return { appName, imageUrls: images.slice(0, 6) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../src/assets.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Deterministic brand-asset discovery from an official page.\n *\n * @module\n */\n\nimport { object } from \"@dbx-tools/shared-core\";\nimport type { BrandAssetSet } from \"@dbx-tools/shared-core/brand-utils\";\nimport { load } from \"cheerio\";\n\n/** Asset references extracted from one official HTML page. */\nexport interface DiscoveredBrandAssets {\n  /** Theme-aware icon reference. */\n  icon: BrandAssetSet;\n  /** Theme-aware logo reference. */\n  logo: BrandAssetSet;\n  /** Browser favicon reference. */\n  favicon: string;\n}\n\n/** Visual references extracted from an official mobile-store page. */\nexport interface DiscoveredMobileAppVisuals {\n  /** Store listing application name. */\n  appName: string;\n  /** App icon and screenshot URLs in page order. */\n  imageUrls: string[];\n}\n\n/** Normalize a page-relative asset reference to a public HTTPS URL. */\nfunction assetUrl(value: string | undefined, baseUrl: string): string | undefined {\n  if (!value?.trim()) return undefined;\n  try {\n    const resolved = new URL(value.trim(), baseUrl);\n    return resolved.protocol === \"https:\" ? resolved.toString() : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Add a normalized URL to a candidate list once. */\nfunction appendCandidate(candidates: string[], value: string | undefined, baseUrl: string): void {\n  const resolved = assetUrl(value, baseUrl);\n  if (resolved && !candidates.includes(resolved)) candidates.push(resolved);\n}\n\n/** Collapse CDN size and format variants of the same mobile artwork. */\nfunction mobileImageIdentity(value: string): string {\n  const url = new URL(value);\n  if (/googleusercontent\\.com$/i.test(url.hostname)) {\n    return `${url.origin}${url.pathname.replace(/=[^/]+$/, \"\")}`;\n  }\n  if (/mzstatic\\.com$/i.test(url.hostname)) {\n    return `${url.origin}${url.pathname.replace(/\\/[^/]+$/, \"\")}`;\n  }\n  return url.toString();\n}\n\n/**\n * Find logo-like URLs nested in JSON-LD organization metadata.\n *\n * JSON-LD permits `logo` and `image` to be a URL, an object with a `url` or\n * `contentUrl`, or an array. The bounded recursive walk accepts those forms\n * without treating unrelated strings elsewhere in the document as assets.\n */\nfunction jsonLdAssetUrls(value: unknown, depth = 0, assetContext = false): string[] {\n  if (depth > 8 || value === null || value === undefined) return [];\n  if (typeof value === \"string\") return assetContext ? [value] : [];\n  if (Array.isArray(value)) {\n    return value.flatMap((entry) => jsonLdAssetUrls(entry, depth + 1, assetContext));\n  }\n  if (!object.isRecord(value)) return [];\n\n  const direct = assetContext\n    ? [value.url, value.contentUrl].flatMap((entry) => (typeof entry === \"string\" ? [entry] : []))\n    : [];\n  return [\n    ...direct,\n    ...jsonLdAssetUrls(value.logo, depth + 1, true),\n    ...jsonLdAssetUrls(value.image, depth + 1, true),\n    ...jsonLdAssetUrls(value[\"@graph\"], depth + 1, false),\n  ];\n}\n\n/** Collect mobile screenshots and image objects from JSON-LD. */\nfunction jsonLdMobileImageUrls(value: unknown, depth = 0, imageContext = false): string[] {\n  if (depth > 10 || value === null || value === undefined) return [];\n  if (typeof value === \"string\") return imageContext ? [value] : [];\n  if (Array.isArray(value)) {\n    return value.flatMap((entry) => jsonLdMobileImageUrls(entry, depth + 1, imageContext));\n  }\n  if (!object.isRecord(value)) return [];\n  const direct = imageContext\n    ? [value.url, value.contentUrl].flatMap((entry) => (typeof entry === \"string\" ? [entry] : []))\n    : [];\n  return [\n    ...direct,\n    ...jsonLdMobileImageUrls(value.screenshot, depth + 1, true),\n    ...jsonLdMobileImageUrls(value.image, depth + 1, true),\n    ...jsonLdMobileImageUrls(value.thumbnailUrl, depth + 1, true),\n    ...jsonLdMobileImageUrls(value[\"@graph\"], depth + 1, false),\n  ];\n}\n\n/**\n * Discover icon, logo, and favicon URLs from an official page.\n *\n * The function only returns URLs present in page metadata or markup. When the\n * page omits an icon, it uses the conventional `/favicon.ico` URL on the same\n * origin. The logo falls back to that icon so a generated context never points\n * at the dbx-tools default artwork.\n */\nexport function discoverBrandAssets(html: string, pageUrl: string): DiscoveredBrandAssets {\n  const $ = load(html);\n  const icons: string[] = [];\n  const logos: string[] = [];\n\n  $(\"link[rel]\").each((_index, element) => {\n    const rel = ($(element).attr(\"rel\") ?? \"\").toLowerCase();\n    if (rel.split(/\\s+/).some((part) => part === \"icon\" || part === \"apple-touch-icon\")) {\n      appendCandidate(icons, $(element).attr(\"href\"), pageUrl);\n    }\n  });\n\n  for (const selector of [\n    'meta[property=\"og:image\"]',\n    'meta[property=\"og:logo\"]',\n    'meta[name=\"twitter:image\"]',\n  ]) {\n    $(selector).each((_index, element) => {\n      appendCandidate(logos, $(element).attr(\"content\"), pageUrl);\n    });\n  }\n\n  $(\"img\").each((_index, element) => {\n    const descriptor = [\n      $(element).attr(\"alt\"),\n      $(element).attr(\"class\"),\n      $(element).attr(\"id\"),\n      $(element).attr(\"data-testid\"),\n    ]\n      .filter(Boolean)\n      .join(\" \");\n    if (/\\b(?:brand|logo|wordmark)\\b/i.test(descriptor)) {\n      appendCandidate(logos, $(element).attr(\"src\"), pageUrl);\n    }\n  });\n\n  $('script[type=\"application/ld+json\"]').each((_index, element) => {\n    try {\n      const value: unknown = JSON.parse($(element).text());\n      for (const candidate of jsonLdAssetUrls(value)) {\n        appendCandidate(logos, candidate, pageUrl);\n      }\n    } catch {\n      return;\n    }\n  });\n\n  const fallbackIcon = new URL(\"/favicon.ico\", pageUrl).toString();\n  const icon = icons[0] ?? logos[0] ?? fallbackIcon;\n  const logo = logos[0] ?? icons[0] ?? fallbackIcon;\n  return {\n    icon: { light: icon },\n    logo: { light: logo },\n    favicon: icon,\n  };\n}\n\n/** Extract an app name plus representative screenshots/icons from a store page. */\nexport function discoverMobileAppVisuals(\n  html: string,\n  pageUrl: string,\n): DiscoveredMobileAppVisuals {\n  const $ = load(html);\n  const metadataImages: string[] = [];\n  const structuredImages: string[] = [];\n  const screenshotImages: string[] = [];\n  const iconImages: string[] = [];\n  const otherStoreImages: string[] = [];\n  for (const selector of ['meta[property=\"og:image\"]', 'meta[name=\"twitter:image\"]']) {\n    $(selector).each((_index, element) => {\n      appendCandidate(metadataImages, $(element).attr(\"content\"), pageUrl);\n    });\n  }\n  $('script[type=\"application/ld+json\"]').each((_index, element) => {\n    try {\n      const value: unknown = JSON.parse($(element).text());\n      for (const candidate of jsonLdMobileImageUrls(value)) {\n        appendCandidate(structuredImages, candidate, pageUrl);\n      }\n    } catch {\n      return;\n    }\n  });\n  $(\"img\").each((_index, element) => {\n    const descriptor = [\n      $(element).attr(\"alt\"),\n      $(element).attr(\"class\"),\n      $(element).attr(\"aria-label\"),\n    ]\n      .filter(Boolean)\n      .join(\" \");\n    const source = $(element).attr(\"src\") ?? $(element).attr(\"data-src\");\n    const isStoreImageHost = /(?:mzstatic|ggpht|googleusercontent)\\./i.test(source ?? \"\");\n    const target = /\\b(?:phone|screen|screenshot|tablet)\\b/i.test(descriptor)\n      ? screenshotImages\n      : /\\b(?:app|icon)\\b/i.test(descriptor)\n        ? iconImages\n        : isStoreImageHost\n          ? otherStoreImages\n          : undefined;\n    if (target) {\n      appendCandidate(target, source, pageUrl);\n      const srcset = ($(element).attr(\"srcset\") ?? $(element).attr(\"data-srcset\"))\n        ?.split(\",\")\n        .at(-1)\n        ?.trim()\n        .split(/\\s+/)[0];\n      appendCandidate(target, srcset, pageUrl);\n    }\n  });\n  $(\"picture source[srcset]\").each((_index, element) => {\n    const srcset = $(element).attr(\"srcset\")?.split(\",\").at(-1)?.trim().split(/\\s+/)[0];\n    appendCandidate(screenshotImages, srcset, pageUrl);\n  });\n  const images: string[] = [];\n  const seenImages = new Set<string>();\n  for (const candidate of [\n    ...metadataImages.slice(0, 1),\n    ...screenshotImages,\n    ...iconImages,\n    ...structuredImages,\n    ...otherStoreImages,\n  ]) {\n    const resolved = assetUrl(candidate, pageUrl);\n    if (!resolved) continue;\n    const identity = mobileImageIdentity(resolved);\n    if (seenImages.has(identity)) continue;\n    seenImages.add(identity);\n    images.push(resolved);\n  }\n  const rawName =\n    $('meta[property=\"og:title\"]').attr(\"content\") ?? $(\"h1\").first().text() ?? $(\"title\").text();\n  const appName =\n    rawName.replace(/\\s+(?:on the App Store|- Apps on Google Play).*$/i, \"\").trim() ||\n    new URL(pageUrl).hostname;\n  return { appName, imageUrls: images.slice(0, 6) };\n}\n"]}

package/lib/src/config.d.ts

@@ -0,0 +1,75 @@
+/**
+ * AppKit generator-plugin configuration and environment resolution.
+ *
+ * @module
+ */
+import type { BasePluginConfig } from "@databricks/appkit";
+/** Default ceiling for one complete generator operation. */
+export declare const DEFAULT_GENERATOR_TIMEOUT_MS = 240000;
+/** AppKit configuration accepted by the generator plugin. */
+export interface GeneratorPluginConfig extends BasePluginConfig {
+    /** Model endpoint or loose model name used for structured synthesis. */
+    model?: string;
+    /** Maximum cited pages fetched per research operation. */
+    maxSources?: number;
+    /** Maximum readable characters retained from each fetched page. */
+    sourceMaxLength?: number;
+    /** Overall operation timeout in milliseconds. */
+    timeoutMs?: number;
+    /** Unity Catalog containing all generated per-user schemas. */
+    catalog?: string;
+    /** SQL warehouse used for data generation and validation. */
+    warehouseId?: string;
+}
+/** Fully resolved generator configuration. */
+export interface ResolvedGeneratorConfig {
+    /** Optional pinned synthesis model. */
+    model?: string;
+    /** Bounded cited-page count. */
+    maxSources: number;
+    /** Character cap per fetched source. */
+    sourceMaxLength: number;
+    /** Overall operation timeout in milliseconds. */
+    timeoutMs: number;
+    /** Unity Catalog containing generated schemas, when configured. */
+    catalog?: string;
+    /** SQL warehouse used for mutations, when configured. */
+    warehouseId?: string;
+}
+/** JSON Schema published by the generator plugin manifest. */
+export declare const GENERATOR_CONFIG_SCHEMA: {
+    type: string;
+    properties: {
+        model: {
+            type: string;
+            description: string;
+        };
+        maxSources: {
+            type: string;
+            minimum: number;
+            maximum: number;
+            description: string;
+        };
+        sourceMaxLength: {
+            type: string;
+            minimum: number;
+            maximum: number;
+            description: string;
+        };
+        timeoutMs: {
+            type: string;
+            minimum: number;
+            description: string;
+        };
+        catalog: {
+            type: string;
+            description: string;
+        };
+        warehouseId: {
+            type: string;
+            description: string;
+        };
+    };
+};
+/** Resolve explicit plugin values over environment values and defaults. */
+export declare function resolveGeneratorConfig(config?: GeneratorPluginConfig): ResolvedGeneratorConfig;

package/lib/src/config.js

@@ -0,0 +1,31 @@
+/**
+ * AppKit generator-plugin configuration and environment resolution.
+ *
+ * @module
+ */
+import { configUtils } from "@dbx-tools/core";
+import { stringUtils } from "@dbx-tools/shared-core";
+import manifest from "./manifest.json" with { type: "json" };
+import { DEFAULT_MAX_SOURCES, DEFAULT_SOURCE_MAX_LENGTH, MAX_SOURCES, MAX_SOURCE_MAX_LENGTH, } from "./research.js";
+/** Default ceiling for one complete generator operation. */
+export const DEFAULT_GENERATOR_TIMEOUT_MS = 240_000;
+/** JSON Schema published by the generator plugin manifest. */
+export const GENERATOR_CONFIG_SCHEMA = manifest.config.schema;
+/** Resolve explicit plugin values over environment values and defaults. */
+export function resolveGeneratorConfig(config = {}) {
+    const model = stringUtils.trimToNull(config.model) ??
+        configUtils.text("GENERATOR_MODEL", configUtils.ENV_ONLY);
+    const catalog = stringUtils.trimToNull(config.catalog) ??
+        configUtils.text("GENERATOR_CATALOG", configUtils.ENV_ONLY);
+    const warehouseId = stringUtils.trimToNull(config.warehouseId) ??
+        configUtils.text("DATABRICKS_WAREHOUSE_ID", configUtils.ENV_ONLY);
+    return {
+        ...(model ? { model } : {}),
+        ...(catalog ? { catalog } : {}),
+        ...(warehouseId ? { warehouseId } : {}),
+        maxSources: Math.min(configUtils.positiveInt(config.maxSources, "GENERATOR_MAX_SOURCES", DEFAULT_MAX_SOURCES, configUtils.ENV_ONLY), MAX_SOURCES),
+        sourceMaxLength: Math.min(configUtils.positiveInt(config.sourceMaxLength, "GENERATOR_SOURCE_MAX_LENGTH", DEFAULT_SOURCE_MAX_LENGTH, configUtils.ENV_ONLY), MAX_SOURCE_MAX_LENGTH),
+        timeoutMs: configUtils.positiveInt(config.timeoutMs, "GENERATOR_TIMEOUT_MS", DEFAULT_GENERATOR_TIMEOUT_MS, configUtils.ENV_ONLY),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/dashboard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deterministic AI/BI dashboard assembly and OBO publication.
+ *
+ * @module
+ */
+import type { BrandContext } from "@dbx-tools/shared-core/brand-utils";
+import { type GeneratedDashboard, type GeneratedSchema, type GeneratorPlan } from "@dbx-tools/shared-generator/workflow";
+/** Inputs for dashboard assembly and publication. */
+export interface CreateGeneratorDashboardInput {
+    /** Generated schema containing the fact table. */
+    location: GeneratedSchema;
+    /** Validated data and metric plan. */
+    plan: GeneratorPlan;
+    /** Brand applied to the dashboard theme. */
+    brand: BrandContext;
+    /** SQL warehouse used by the dashboard. */
+    warehouseId: string;
+    /** Company display name. */
+    company: string;
+    /** Demo purpose. */
+    purpose: string;
+}
+/** Build one complete dashboard with automatic companion Genie enabled. */
+export declare function buildGeneratorDashboard(input: CreateGeneratorDashboardInput): {
+    datasets: Record<string, unknown>[];
+    pages: Record<string, unknown>[];
+    uiSettings: Record<string, unknown>;
+};
+/** Create and publish a dashboard as the active OBO user. */
+export declare function createGeneratorDashboard(input: CreateGeneratorDashboardInput, signal?: AbortSignal): Promise<GeneratedDashboard>;