@withpotter/lib 0.13.0-next.101

package/dist/roster-label.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ONE WORD FOR THE BOOKABLE THINGS — the sidebar row and the page it opens
+ * must say the same one.
+ *
+ * They did not. The nav collapsed to a single row on 2026-08-24 (John: *"why
+ * have staffs and rooms in the sidenav, just merge and call the nav something
+ * general"*), so a club with courts AND coaches got a row reading "Resources".
+ * The title was still written for the world where that row was two rows, and
+ * joined the group names instead — so you pressed **Resources** and landed on
+ * a page headed **Courts & coaches**. Two names for one place, and neither of
+ * them is what you clicked.
+ *
+ * The ladder is `collapse-shared-nav`'s: the merchant's own noun while there
+ * is only one, the plain word once there are several.
+ *
+ *   no groups      the word the archetype declared — a merchant with nothing
+ *                  set up still needs the door that sets it up
+ *   one or more    the generic word, which is the module label so a merchant
+ *                  who renamed it gets their own
+ *
+ * The page adds one rung the nav cannot have: scoped to a group by `?group=`,
+ * the title is that group. Narrowing did not disappear with the rows.
+ */
+export declare function rosterLabel(categories: {
+    labelPlural: string;
+    kind?: string;
+}[], declared: string, generic: string): string;

package/dist/roster-label.js

@@ -0,0 +1,8 @@
+function rosterLabel(categories, declared, generic) {
+  if (categories.length === 0) return declared;
+  return generic;
+}
+export {
+  rosterLabel
+};
+//# sourceMappingURL=roster-label.js.map

package/dist/roster-label.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/roster-label.ts"],"sourcesContent":["/**\n * ONE WORD FOR THE BOOKABLE THINGS — the sidebar row and the page it opens\n * must say the same one.\n *\n * They did not. The nav collapsed to a single row on 2026-08-24 (John: *\"why\n * have staffs and rooms in the sidenav, just merge and call the nav something\n * general\"*), so a club with courts AND coaches got a row reading \"Resources\".\n * The title was still written for the world where that row was two rows, and\n * joined the group names instead — so you pressed **Resources** and landed on\n * a page headed **Courts & coaches**. Two names for one place, and neither of\n * them is what you clicked.\n *\n * The ladder is `collapse-shared-nav`'s: the merchant's own noun while there\n * is only one, the plain word once there are several.\n *\n *   no groups      the word the archetype declared — a merchant with nothing\n *                  set up still needs the door that sets it up\n *   one or more    the generic word, which is the module label so a merchant\n *                  who renamed it gets their own\n *\n * The page adds one rung the nav cannot have: scoped to a group by `?group=`,\n * the title is that group. Narrowing did not disappear with the rows.\n */\nexport function rosterLabel(\n  categories: { labelPlural: string; kind?: string }[],\n  declared: string,\n  generic: string,\n): string {\n  if (categories.length === 0) return declared;\n  return generic;\n}\n"],"mappings":"AAuBO,SAAS,YACd,YACA,UACA,SACQ;AACR,MAAI,WAAW,WAAW,EAAG,QAAO;AACpC,SAAO;AACT;","names":[]}

package/dist/route-pattern.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Matching a live pathname against Next's route patterns.
+ *
+ * Extracted because there are now two registries keyed by route — the mobile
+ * tier map and the page intros — and both need the same walk: exact match
+ * first, then segment-by-segment with `[param]` matching anything and
+ * `[...catchAll]` swallowing the rest. Written twice it would drift on the one
+ * case that is easy to get wrong (a catch-all must not require equal lengths),
+ * and the drift would be invisible: each registry would simply miss a route.
+ */
+export declare function matchRoutePattern(pathname: string, patterns: string[]): string | undefined;

package/dist/route-pattern.js

@@ -0,0 +1,20 @@
+function matchRoutePattern(pathname, patterns) {
+  if (patterns.includes(pathname)) return pathname;
+  const parts = pathname.split("/").filter(Boolean);
+  for (const pattern of patterns) {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const catchAll = patternParts.at(-1)?.startsWith("[...");
+    if (!catchAll && patternParts.length !== parts.length) continue;
+    const matches = patternParts.every((segment, i) => {
+      if (segment.startsWith("[...")) return true;
+      if (segment.startsWith("[")) return parts[i] !== void 0;
+      return segment === parts[i];
+    });
+    if (matches) return pattern;
+  }
+  return void 0;
+}
+export {
+  matchRoutePattern
+};
+//# sourceMappingURL=route-pattern.js.map

package/dist/route-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/route-pattern.ts"],"sourcesContent":["/**\n * Matching a live pathname against Next's route patterns.\n *\n * Extracted because there are now two registries keyed by route — the mobile\n * tier map and the page intros — and both need the same walk: exact match\n * first, then segment-by-segment with `[param]` matching anything and\n * `[...catchAll]` swallowing the rest. Written twice it would drift on the one\n * case that is easy to get wrong (a catch-all must not require equal lengths),\n * and the drift would be invisible: each registry would simply miss a route.\n */\nexport function matchRoutePattern(\n  pathname: string,\n  patterns: string[],\n): string | undefined {\n  if (patterns.includes(pathname)) return pathname;\n\n  const parts = pathname.split('/').filter(Boolean);\n  for (const pattern of patterns) {\n    const patternParts = pattern.split('/').filter(Boolean);\n    const catchAll = patternParts.at(-1)?.startsWith('[...');\n    if (!catchAll && patternParts.length !== parts.length) continue;\n\n    const matches = patternParts.every((segment, i) => {\n      if (segment.startsWith('[...')) return true;\n      if (segment.startsWith('[')) return parts[i] !== undefined;\n      return segment === parts[i];\n    });\n    if (matches) return pattern;\n  }\n  return undefined;\n}\n"],"mappings":"AAUO,SAAS,kBACd,UACA,UACoB;AACpB,MAAI,SAAS,SAAS,QAAQ,EAAG,QAAO;AAExC,QAAM,QAAQ,SAAS,MAAM,GAAG,EAAE,OAAO,OAAO;AAChD,aAAW,WAAW,UAAU;AAC9B,UAAM,eAAe,QAAQ,MAAM,GAAG,EAAE,OAAO,OAAO;AACtD,UAAM,WAAW,aAAa,GAAG,EAAE,GAAG,WAAW,MAAM;AACvD,QAAI,CAAC,YAAY,aAAa,WAAW,MAAM,OAAQ;AAEvD,UAAM,UAAU,aAAa,MAAM,CAAC,SAAS,MAAM;AACjD,UAAI,QAAQ,WAAW,MAAM,EAAG,QAAO;AACvC,UAAI,QAAQ,WAAW,GAAG,EAAG,QAAO,MAAM,CAAC,MAAM;AACjD,aAAO,YAAY,MAAM,CAAC;AAAA,IAC5B,CAAC;AACD,QAAI,QAAS,QAAO;AAAA,EACtB;AACA,SAAO;AACT;","names":[]}

package/dist/route-permission.d.ts

@@ -0,0 +1,60 @@
+import type { PermissionKey } from './use-permissions';
+/**
+ * Whether this person may be on this page at all.
+ *
+ * The nav has always known which grant each destination needs — every row
+ * carries `requiredPermission`, and the sidebar hides the ones you do not hold.
+ * Nothing enforced it at the page. A staff member who typed the address, kept a
+ * bookmark, followed a link in a handover note, or hit Back after being demoted
+ * landed on the screen itself: a hidden row is not a locked door.
+ *
+ * The api refuses the requests either way, so this is not what stops them
+ * acting. It is what stops the app showing somebody a page it will not fill,
+ * and then leaving them there to work out why it is empty.
+ *
+ * The rule reads the nav's own table rather than a second list beside it. A new
+ * screen gated in the sidebar is gated here on the same line, and there is no
+ * way for the two to disagree.
+ */
+export interface RouteRule {
+    href: string;
+    requiredPermission?: PermissionKey[];
+}
+/** Referrals uses the loyalty programme, not the discount permissions. */
+export declare function permissionPathForView(path: string | null, view: string | null): string | null;
+/**
+ * The grants that reach this path, or null when nothing claims it.
+ *
+ * Deepest match wins, so /dashboard/settings/team answers with Team's rule and
+ * not with the Settings row above it. Null is deliberately not "denied": detail
+ * routes, labs and one-off screens have no nav row, and a gate that treated an
+ * unlisted path as forbidden would lock people out of pages by omission — the
+ * opposite failure to the one it is here to fix, and a much louder one.
+ */
+export declare function requiredForPath(path: string | null | undefined, rules: RouteRule[]): PermissionKey[] | null;
+/** Any-of, matching how the sidebar reads the same field. */
+export declare function allowsPath(path: string | null | undefined, rules: RouteRule[], can: (permission: PermissionKey) => boolean): boolean;
+/**
+ * Whether the guard should move somebody off this page.
+ *
+ * Pure, and separate from the component, because the bug this exists to stop
+ * is a redirect fired on a verdict that had not arrived yet — and that is a
+ * question about state, not about React.
+ *
+ * `sessionReady` is the half that was missing. `usePermissions` answers
+ * `loading: false` the moment it has no tenant and no user to ask about, which
+ * is the state every cold load starts in: the guard read not-loading,
+ * not-owner, no grants, and threw the merchant off the page they had just
+ * opened. It only ever looked like a flaky nav row, because a second visit
+ * through the router — with the session already in hand — worked fine.
+ */
+export declare function shouldLeavePage(state: {
+    /** The session is known: auth has finished and named a user and a tenant. */
+    sessionReady: boolean;
+    permissionsLoading: boolean;
+    isOwner: boolean;
+    path: string | null | undefined;
+    staffHome: string;
+    rules: RouteRule[];
+    can: (permission: PermissionKey) => boolean;
+}): boolean;

package/dist/route-permission.js

@@ -0,0 +1,48 @@
+function permissionPathForView(path, view) {
+  return path?.replace(/\/+$/, "") === "/dashboard/marketing/promotions" && view === "referrals" ? "/dashboard/loyalty" : path;
+}
+const PERSONAL = [
+  "/dashboard/settings/profile",
+  "/dashboard/settings/account",
+  "/dashboard/help",
+  "/dashboard/workspaces"
+];
+function covers(href, path) {
+  return path === href || path.startsWith(`${href}/`);
+}
+function requiredForPath(path, rules) {
+  if (!path) return null;
+  const clean = path.replace(/\/+$/, "") || "/dashboard";
+  if (clean.startsWith("/dashboard/toolkit/connectors/") || clean.startsWith("/dashboard/toolkit/connections/")) {
+    return ["canManageSettings"];
+  }
+  if (PERSONAL.some((href) => covers(href, clean))) return null;
+  let best = null;
+  for (const rule of rules) {
+    if (!rule.requiredPermission?.length) continue;
+    if (!covers(rule.href, clean)) continue;
+    const depth = rule.href.split("/").length;
+    if (!best || depth > best.depth) {
+      best = { depth, needs: rule.requiredPermission };
+    }
+  }
+  return best?.needs ?? null;
+}
+function allowsPath(path, rules, can) {
+  const needs = requiredForPath(path, rules);
+  if (!needs) return true;
+  return needs.some((permission) => can(permission));
+}
+function shouldLeavePage(state) {
+  const { sessionReady, permissionsLoading, isOwner, path, staffHome } = state;
+  if (!sessionReady || permissionsLoading || isOwner) return false;
+  if (allowsPath(path, state.rules, state.can)) return false;
+  return path !== staffHome;
+}
+export {
+  allowsPath,
+  permissionPathForView,
+  requiredForPath,
+  shouldLeavePage
+};
+//# sourceMappingURL=route-permission.js.map

package/dist/route-permission.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/route-permission.ts"],"sourcesContent":["import type { PermissionKey } from './use-permissions';\n\n/**\n * Whether this person may be on this page at all.\n *\n * The nav has always known which grant each destination needs — every row\n * carries `requiredPermission`, and the sidebar hides the ones you do not hold.\n * Nothing enforced it at the page. A staff member who typed the address, kept a\n * bookmark, followed a link in a handover note, or hit Back after being demoted\n * landed on the screen itself: a hidden row is not a locked door.\n *\n * The api refuses the requests either way, so this is not what stops them\n * acting. It is what stops the app showing somebody a page it will not fill,\n * and then leaving them there to work out why it is empty.\n *\n * The rule reads the nav's own table rather than a second list beside it. A new\n * screen gated in the sidebar is gated here on the same line, and there is no\n * way for the two to disagree.\n */\n\nexport interface RouteRule {\n  href: string;\n  requiredPermission?: PermissionKey[];\n}\n\n/** Referrals uses the loyalty programme, not the discount permissions. */\nexport function permissionPathForView(\n  path: string | null,\n  view: string | null,\n): string | null {\n  return path?.replace(/\\/+$/, '') === '/dashboard/marketing/promotions' &&\n    view === 'referrals'\n    ? '/dashboard/loyalty'\n    : path;\n}\n\n/**\n * Pages that belong to the PERSON rather than to the business, and so are never\n * gated on a business grant: your own profile, the help desk, the list of\n * workspaces somebody removed from a business needs in order to leave.\n */\nconst PERSONAL = [\n  '/dashboard/settings/profile',\n  '/dashboard/settings/account',\n  '/dashboard/help',\n  '/dashboard/workspaces',\n];\n\nfunction covers(href: string, path: string): boolean {\n  return path === href || path.startsWith(`${href}/`);\n}\n\n/**\n * The grants that reach this path, or null when nothing claims it.\n *\n * Deepest match wins, so /dashboard/settings/team answers with Team's rule and\n * not with the Settings row above it. Null is deliberately not \"denied\": detail\n * routes, labs and one-off screens have no nav row, and a gate that treated an\n * unlisted path as forbidden would lock people out of pages by omission — the\n * opposite failure to the one it is here to fix, and a much louder one.\n */\nexport function requiredForPath(\n  path: string | null | undefined,\n  rules: RouteRule[],\n): PermissionKey[] | null {\n  if (!path) return null;\n  const clean = path.replace(/\\/+$/, '') || '/dashboard';\n  if (\n    clean.startsWith('/dashboard/toolkit/connectors/') ||\n    clean.startsWith('/dashboard/toolkit/connections/')\n  ) {\n    return ['canManageSettings'];\n  }\n  if (PERSONAL.some((href) => covers(href, clean))) return null;\n\n  let best: { depth: number; needs: PermissionKey[] } | null = null;\n  for (const rule of rules) {\n    if (!rule.requiredPermission?.length) continue;\n    if (!covers(rule.href, clean)) continue;\n    const depth = rule.href.split('/').length;\n    if (!best || depth > best.depth) {\n      best = { depth, needs: rule.requiredPermission };\n    }\n  }\n  return best?.needs ?? null;\n}\n\n/** Any-of, matching how the sidebar reads the same field. */\nexport function allowsPath(\n  path: string | null | undefined,\n  rules: RouteRule[],\n  can: (permission: PermissionKey) => boolean,\n): boolean {\n  const needs = requiredForPath(path, rules);\n  if (!needs) return true;\n  return needs.some((permission) => can(permission));\n}\n\n/**\n * Whether the guard should move somebody off this page.\n *\n * Pure, and separate from the component, because the bug this exists to stop\n * is a redirect fired on a verdict that had not arrived yet — and that is a\n * question about state, not about React.\n *\n * `sessionReady` is the half that was missing. `usePermissions` answers\n * `loading: false` the moment it has no tenant and no user to ask about, which\n * is the state every cold load starts in: the guard read not-loading,\n * not-owner, no grants, and threw the merchant off the page they had just\n * opened. It only ever looked like a flaky nav row, because a second visit\n * through the router — with the session already in hand — worked fine.\n */\nexport function shouldLeavePage(state: {\n  /** The session is known: auth has finished and named a user and a tenant. */\n  sessionReady: boolean;\n  permissionsLoading: boolean;\n  isOwner: boolean;\n  path: string | null | undefined;\n  staffHome: string;\n  rules: RouteRule[];\n  can: (permission: PermissionKey) => boolean;\n}): boolean {\n  const { sessionReady, permissionsLoading, isOwner, path, staffHome } = state;\n  if (!sessionReady || permissionsLoading || isOwner) return false;\n  if (allowsPath(path, state.rules, state.can)) return false;\n  // A home they also cannot reach would be a redirect loop.\n  return path !== staffHome;\n}\n"],"mappings":"AA0BO,SAAS,sBACd,MACA,MACe;AACf,SAAO,MAAM,QAAQ,QAAQ,EAAE,MAAM,qCACnC,SAAS,cACP,uBACA;AACN;AAOA,MAAM,WAAW;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,SAAS,OAAO,MAAc,MAAuB;AACnD,SAAO,SAAS,QAAQ,KAAK,WAAW,GAAG,IAAI,GAAG;AACpD;AAWO,SAAS,gBACd,MACA,OACwB;AACxB,MAAI,CAAC,KAAM,QAAO;AAClB,QAAM,QAAQ,KAAK,QAAQ,QAAQ,EAAE,KAAK;AAC1C,MACE,MAAM,WAAW,gCAAgC,KACjD,MAAM,WAAW,iCAAiC,GAClD;AACA,WAAO,CAAC,mBAAmB;AAAA,EAC7B;AACA,MAAI,SAAS,KAAK,CAAC,SAAS,OAAO,MAAM,KAAK,CAAC,EAAG,QAAO;AAEzD,MAAI,OAAyD;AAC7D,aAAW,QAAQ,OAAO;AACxB,QAAI,CAAC,KAAK,oBAAoB,OAAQ;AACtC,QAAI,CAAC,OAAO,KAAK,MAAM,KAAK,EAAG;AAC/B,UAAM,QAAQ,KAAK,KAAK,MAAM,GAAG,EAAE;AACnC,QAAI,CAAC,QAAQ,QAAQ,KAAK,OAAO;AAC/B,aAAO,EAAE,OAAO,OAAO,KAAK,mBAAmB;AAAA,IACjD;AAAA,EACF;AACA,SAAO,MAAM,SAAS;AACxB;AAGO,SAAS,WACd,MACA,OACA,KACS;AACT,QAAM,QAAQ,gBAAgB,MAAM,KAAK;AACzC,MAAI,CAAC,MAAO,QAAO;AACnB,SAAO,MAAM,KAAK,CAAC,eAAe,IAAI,UAAU,CAAC;AACnD;AAgBO,SAAS,gBAAgB,OASpB;AACV,QAAM,EAAE,cAAc,oBAAoB,SAAS,MAAM,UAAU,IAAI;AACvE,MAAI,CAAC,gBAAgB,sBAAsB,QAAS,QAAO;AAC3D,MAAI,WAAW,MAAM,MAAM,OAAO,MAAM,GAAG,EAAG,QAAO;AAErD,SAAO,SAAS;AAClB;","names":[]}

package/dist/runtime-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Runtime public configuration for the console.
+ *
+ * Per-box values like the storefront domain must reach the browser at RUNTIME,
+ * not be frozen at `next build`. `NEXT_PUBLIC_*` vars are inlined by the Next
+ * compiler, so baking a per-box value at build time forces a per-box image.
+ * Instead the console shell reads a plain (non-`NEXT_PUBLIC_`) runtime env
+ * server-side via `PublicConfigLoader`, and `PublicConfigProvider` publishes it
+ * into this module singleton on both SSR and client render — so
+ * `resolveStorefrontUrl` and friends read the same value everywhere.
+ *
+ * When nothing is injected (older shell / local dev), each field falls back to
+ * its build-time `NEXT_PUBLIC_*` env var, preserving prior behaviour.
+ *
+ * Client-safe: this module never touches `fs`, so client components may import
+ * it. Read config at CALL time (inside the function that needs it), never at
+ * module top level, so the injected runtime value is available.
+ */
+export interface PublicConfig {
+    /** Wildcard storefront base host, e.g. `"olive.dummywears.com"`. */
+    storefrontDomain: string | null;
+}
+/**
+ * Registers the runtime config resolved on the server. Called by
+ * `PublicConfigProvider` during both SSR and client render so the singleton is
+ * populated before any consumer reads it.
+ */
+export declare function setPublicConfig(config: PublicConfig): void;
+/**
+ * Client-safe accessor. Returns the injected runtime config if present,
+ * otherwise the build-time env fallback.
+ */
+export declare function readPublicConfig(): PublicConfig;

package/dist/runtime-config.js

@@ -0,0 +1,23 @@
+let runtimeConfig = null;
+function fromEnv() {
+  return {
+    storefrontDomain: process.env.NEXT_PUBLIC_STOREFRONT_DOMAIN?.trim() || null
+  };
+}
+function withEnvFallback(config) {
+  const env = fromEnv();
+  return {
+    storefrontDomain: config.storefrontDomain?.trim() || env.storefrontDomain
+  };
+}
+function setPublicConfig(config) {
+  runtimeConfig = withEnvFallback(config);
+}
+function readPublicConfig() {
+  return runtimeConfig ?? fromEnv();
+}
+export {
+  readPublicConfig,
+  setPublicConfig
+};
+//# sourceMappingURL=runtime-config.js.map

package/dist/runtime-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime-config.ts"],"sourcesContent":["/**\n * Runtime public configuration for the console.\n *\n * Per-box values like the storefront domain must reach the browser at RUNTIME,\n * not be frozen at `next build`. `NEXT_PUBLIC_*` vars are inlined by the Next\n * compiler, so baking a per-box value at build time forces a per-box image.\n * Instead the console shell reads a plain (non-`NEXT_PUBLIC_`) runtime env\n * server-side via `PublicConfigLoader`, and `PublicConfigProvider` publishes it\n * into this module singleton on both SSR and client render — so\n * `resolveStorefrontUrl` and friends read the same value everywhere.\n *\n * When nothing is injected (older shell / local dev), each field falls back to\n * its build-time `NEXT_PUBLIC_*` env var, preserving prior behaviour.\n *\n * Client-safe: this module never touches `fs`, so client components may import\n * it. Read config at CALL time (inside the function that needs it), never at\n * module top level, so the injected runtime value is available.\n */\nexport interface PublicConfig {\n  /** Wildcard storefront base host, e.g. `\"olive.dummywears.com\"`. */\n  storefrontDomain: string | null;\n}\n\nlet runtimeConfig: PublicConfig | null = null;\n\n/** Build-time `NEXT_PUBLIC_*` fallback, used when no runtime config is injected. */\nfunction fromEnv(): PublicConfig {\n  return {\n    storefrontDomain: process.env.NEXT_PUBLIC_STOREFRONT_DOMAIN?.trim() || null,\n  };\n}\n\n/** Overlay a runtime-resolved config onto the build-time env, field by field. */\nfunction withEnvFallback(config: PublicConfig): PublicConfig {\n  const env = fromEnv();\n  return {\n    storefrontDomain: config.storefrontDomain?.trim() || env.storefrontDomain,\n  };\n}\n\n/**\n * Registers the runtime config resolved on the server. Called by\n * `PublicConfigProvider` during both SSR and client render so the singleton is\n * populated before any consumer reads it.\n */\nexport function setPublicConfig(config: PublicConfig): void {\n  runtimeConfig = withEnvFallback(config);\n}\n\n/**\n * Client-safe accessor. Returns the injected runtime config if present,\n * otherwise the build-time env fallback.\n */\nexport function readPublicConfig(): PublicConfig {\n  return runtimeConfig ?? fromEnv();\n}\n"],"mappings":"AAuBA,IAAI,gBAAqC;AAGzC,SAAS,UAAwB;AAC/B,SAAO;AAAA,IACL,kBAAkB,QAAQ,IAAI,+BAA+B,KAAK,KAAK;AAAA,EACzE;AACF;AAGA,SAAS,gBAAgB,QAAoC;AAC3D,QAAM,MAAM,QAAQ;AACpB,SAAO;AAAA,IACL,kBAAkB,OAAO,kBAAkB,KAAK,KAAK,IAAI;AAAA,EAC3D;AACF;AAOO,SAAS,gBAAgB,QAA4B;AAC1D,kBAAgB,gBAAgB,MAAM;AACxC;AAMO,SAAS,mBAAiC;AAC/C,SAAO,iBAAiB,QAAQ;AAClC;","names":[]}

package/dist/schema-validation.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Dashboard Schema Validation
+ *
+ * Zod-based validation for dashboard-schema.json files.
+ * Validates the structural integrity of template configurations
+ * to prevent silent rendering failures and inaccessible platform modules.
+ *
+ * Used at:
+ * - Template load time (in template-context.tsx)
+ * - Build/CI time (can be imported by validation scripts)
+ */
+import { z } from 'zod';
+/**
+ * The complete Zod schema for dashboard-schema.json files.
+ *
+ * Required structure:
+ * - dashboardModules: array with ≥1 entry (must include overview)
+ * - Either contentTypes OR behaviors must be present (new-format schemas)
+ * - siteSettings: at least 1 section with fields
+ *
+ * Old-format schemas (serenity-spa, noteable) won't have contentTypes,
+ * but are still valid if they have dashboardModules + siteSettings.
+ */
+export declare const dashboardSchemaValidator: z.ZodObject<{
+    contentTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        singularName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        apiEndpoint: z.ZodString;
+        contentTypeKey: z.ZodOptional<z.ZodString>;
+        behaviors: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            sellable: "sellable";
+            bookable: "bookable";
+            ticketed: "ticketed";
+            shippable: "shippable";
+            rentable: "rentable";
+            downloadable: "downloadable";
+            subscribable: "subscribable";
+            billable: "billable";
+            leadCapture: "leadCapture";
+            giftable: "giftable";
+            publishable: "publishable";
+            showcase: "showcase";
+        }>>>;
+        bookingModel: z.ZodOptional<z.ZodEnum<{
+            "date-range": "date-range";
+            "time-slot": "time-slot";
+        }>>;
+        excludeGroups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        fields: z.ZodArray<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+        fieldGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            collapsed: z.ZodOptional<z.ZodBoolean>;
+            fields: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        listFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        searchFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        listView: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        defaultSort: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            direction: z.ZodEnum<{
+                desc: "desc";
+                asc: "asc";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>>;
+    behaviors: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        sellable: "sellable";
+        bookable: "bookable";
+        ticketed: "ticketed";
+        shippable: "shippable";
+        rentable: "rentable";
+        downloadable: "downloadable";
+        subscribable: "subscribable";
+        billable: "billable";
+        leadCapture: "leadCapture";
+        giftable: "giftable";
+        publishable: "publishable";
+        showcase: "showcase";
+    }>>>;
+    siteSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                phone: "phone";
+                email: "email";
+                currency: "currency";
+                text: "text";
+                select: "select";
+                multiselect: "multiselect";
+                image: "image";
+                tags: "tags";
+                duration: "duration";
+                gallery: "gallery";
+                url: "url";
+                date: "date";
+                toggle: "toggle";
+                color: "color";
+                textarea: "textarea";
+                time: "time";
+                richtext: "richtext";
+                categorySelect: "categorySelect";
+                resourceSelect: "resourceSelect";
+                contentSelect: "contentSelect";
+                datetime: "datetime";
+                icon: "icon";
+                array: "array";
+                json: "json";
+                relation: "relation";
+                component: "component";
+                repeatable: "repeatable";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+                icon: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$loose>>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    }, z.core.$loose>>>;
+    pageContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dashboardModules: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        badge: z.ZodOptional<z.ZodString>;
+        contentType: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface SchemaValidationError {
+    path: string;
+    message: string;
+}
+export interface SchemaValidationResult {
+    valid: boolean;
+    errors: SchemaValidationError[];
+    warnings: string[];
+}
+/**
+ * Validate a dashboard-schema.json object using the Zod schema.
+ *
+ * Returns structured errors (blocking) and warnings (non-blocking).
+ * - Errors: schema is structurally invalid and will cause rendering failures
+ * - Warnings: schema is valid but missing recommended sections
+ */
+export declare function validateDashboardSchema(schema: unknown): SchemaValidationResult;
+/**
+ * Validate a template API response (TemplateConfigAPI) structure.
+ *
+ * This is used at runtime when the dashboard fetches a template schema.
+ * It replaces the ad-hoc validateTemplateSchema in template-context.tsx
+ * with proper Zod-based validation.
+ */
+export declare function validateTemplateConfig(apiTemplate: Record<string, unknown>): SchemaValidationResult;