@saasicat/ui-vue 0.27.0 → 1.0.0-rc.0

package/README.md

@@ -15,12 +15,12 @@ The package is layered so that each entry only loads what it names.
 Lower layers never import upward; ESLint (`no-restricted-imports`, repo
 root config) enforces the boundaries in CI.
 
-| Entry                                                                   | Source                           | May import                               | Contents                                                                                                                                                                                                                                                         |
-| ----------------------------------------------------------------------- | -------------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@saasicat/ui-vue/client`                                               | `src/client/`                    | `@saasicat/types` only                   | Framework-free core: `BootLoader`, `ManifestLoader` (ETag cache), nav builder, action registry, batch column fetcher, the `HttpClient`/`KvStore` contract with its `fetch` and axios adapters, `AdminError`. Usable from any framework or plain Node/TypeScript. |
-| `@saasicat/ui-vue` (main)                                               | `src/vue/` (+ client re-exports) | Vue, `vue-router`, Pinia — **no Quasar** | Composables (`useTenants`, `usePlanEditor`, …), router guards, injection keys + shell contract, notify-port type, optional Pinia store factory.                                                                                                                  |
-| `@saasicat/ui-vue/quasar`                                               | `src/quasar/`                    | everything above + Quasar                | `createSuperAdminApp()` bootstrap and the Quasar notify-port implementation.                                                                                                                                                                                     |
-| `@saasicat/ui-vue/pages-standard/*`, `/pages-tenant/*`, `/components/*` | SFC directories                  | everything                               | The Quasar reference UI, shipped as raw `.vue` from `src/` (compiled by the consumer's Vite).                                                                                                                                                                    |
+| Entry                                                                                           | Source                           | May import                               | Contents                                                                                                                                                                                                                                                         |
+| ----------------------------------------------------------------------------------------------- | -------------------------------- | ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@saasicat/ui-vue/client`                                                                       | `src/client/`                    | `@saasicat/types` only                   | Framework-free core: `BootLoader`, `ManifestLoader` (ETag cache), nav builder, action registry, batch column fetcher, the `HttpClient`/`KvStore` contract with its `fetch` and axios adapters, `AdminError`. Usable from any framework or plain Node/TypeScript. |
+| `@saasicat/ui-vue` (main)                                                                       | `src/vue/` (+ client re-exports) | Vue, `vue-router`, Pinia — **no Quasar** | Composables (`useTenants`, `usePlanEditor`, …), router guards, injection keys + shell contract, notify-port type, optional Pinia store factory.                                                                                                                  |
+| `@saasicat/ui-vue/quasar`                                                                       | `src/quasar/`                    | everything above + Quasar                | `createSuperAdminApp()` bootstrap and the Quasar notify-port implementation.                                                                                                                                                                                     |
+| `@saasicat/ui-vue/pages/*.vue`, `/layouts/*.vue`, `/auth/*.vue`, `/ui/*.vue`, `/pages-tenant/*` | SFC directories                  | everything                               | The Quasar reference UI, shipped as raw `.vue` from `src/` (compiled by the consumer's Vite).                                                                                                                                                                    |
 
 ### The shipped source has a language floor
 
@@ -52,8 +52,8 @@ Rules of thumb when contributing:
 - Quasar imports in `.ts` files are only allowed under `src/quasar/`.
 - A few framework-free type/i18n modules stay co-located with their SFCs
   (`components/dialogs/types.ts`, `components/bundle-editor/catalog-i18n.ts`,
-  `pages-standard/platform-email.types.ts`,
-  `pages-standard/email-history.types.ts`, `pages-tenant/default-i18n.ts`)
+  `internal/platform-email/platform-email.types.ts`,
+  `internal/email-history/email-history.types.ts`, `pages-tenant/default-i18n.ts`)
   and are whitelisted in the ESLint rules — they must not grow framework
   imports.
 

package/dist/.build-stamp

@@ -0,0 +1 @@
+c0ad4bfbe61ec2533f28d5a963436a4c73dd8f8c82d3c138e9138b98cc34d5a8

package/dist/batch-column-fetcher-BlRPjUST.d.cts

@@ -0,0 +1,482 @@
+import { a5 as SaMessages, H as HttpClient, l as KvStore, a2 as SaLocale, aA as SaNavMessages } from './catalog-Q7RPiOHD.cjs';
+import { PublicBootResponse, AdminManifest, StandardPageKey, TenantColumnDef } from '@saasicat/types';
+
+/**
+ * Marks an error as one this package raised. Called by the package's own error
+ * classes in their constructors; nothing else should call it.
+ */
+declare function markPlatformError(error: Error): void;
+/** Whether an error came from this package, across bundle copies. */
+declare function isPlatformError(value: unknown): boolean;
+/**
+ * Marks an error as the empty-body sentinel: the call reached the server, the
+ * server answered, and the body the caller needed was not in it. Returns the
+ * error so a throw site stays one expression.
+ *
+ * Called at those throw sites only — never in a constructor, because the class
+ * is also raised for calls that failed outright.
+ */
+declare function markEmptyResponse<E extends Error>(error: E): E;
+/** Whether an error is that sentinel, across bundle copies. */
+declare function isEmptyResponse(value: unknown): boolean;
+/**
+ * Marks an error as one the request did not survive: no connection, DNS
+ * failure, CORS rejection, abort, or a client that reported the same by
+ * resolving without an HTTP status. Returns the error so a throw site stays one
+ * expression.
+ */
+declare function markTransportFailure<E>(error: E): E;
+/** Whether an error is a declared transport failure, across bundle copies. */
+declare function isTransportFailure(value: unknown): boolean;
+interface AdminErrorInit {
+    /** HTTP status. `0` means the request never produced one. */
+    status?: number;
+    /** Machine-readable code from the response body (`{ code }`). */
+    code?: string;
+    /** Parsed response body, when there was one. */
+    body?: unknown;
+    /** Requested URL, when known. */
+    url?: string;
+    /** Request method, when known. */
+    method?: string;
+    /**
+     * Text the failing side supplied. Never invent one — its absence is the
+     * signal that only a translated fallback can be shown.
+     */
+    detail?: string;
+    /**
+     * The request completed and the answer was unusable — a 2xx that carried
+     * no body where one was required.
+     *
+     * Its own state because the model could not otherwise tell it from a
+     * transport failure: both have no HTTP status to report, and both were
+     * therefore `status: 0`. They need opposite words. A request that never
+     * left says "check your connection"; one the server accepted and answered
+     * with nothing says "check whether the change was applied", because it may
+     * well have been.
+     */
+    emptyResponse?: boolean;
+    /**
+     * The request never reached the server.
+     *
+     * Its own state for the same reason as `emptyResponse`: neither has an HTTP
+     * status to reason from, so a status of `0` cannot tell them apart — and
+     * neither can it tell either of them from an error that simply carries no
+     * status, such as a bug in page code. Only the seam that made the request
+     * knows, and it says so with `markTransportFailure`.
+     */
+    transportFailure?: boolean;
+    /** Diagnostic message. Derived from the fields above when omitted. */
+    message?: string;
+    /** The error this one was built from. */
+    cause?: unknown;
+}
+/** A failed admin API call, in the one shape the package works with. */
+declare class AdminError extends Error {
+    /** HTTP status. `0` means the request never produced one. */
+    readonly status: number;
+    /** Machine-readable code from the response body, when it carried one. */
+    readonly code?: string;
+    /** Parsed response body, when there was one. */
+    readonly body?: unknown;
+    /** Requested URL, when known. */
+    readonly url?: string;
+    /** Request method, when known. */
+    readonly method?: string;
+    /**
+     * Text the failing side supplied — the only candidate for user-facing
+     * output. `undefined` when nothing was supplied.
+     */
+    readonly detail?: string;
+    /** The request completed but the answer was unusable. See `AdminErrorInit`. */
+    readonly emptyResponse: boolean;
+    /** The request never reached the server. See `AdminErrorInit`. */
+    readonly transportFailure: boolean;
+    /**
+     * The error this one was raised from, when `AdminErrorInit` carried one.
+     *
+     * `declare` because the property is real but not emitted here: `attachCause`
+     * defines it, exactly as the ES2022 `Error` constructor would. The
+     * declaration is what makes it *readable* — `Error.cause` lives in
+     * `lib.es2022.error.d.ts`, and this package supports consumers on ES2021,
+     * where taking a cause in and never being able to read it out would be a
+     * one-way public API.
+     *
+     * Not `readonly`, unlike its siblings: the inherited `Error.cause` is
+     * writable, and narrowing that in a patch release would reject assignments
+     * a consumer can make today on ES2022.
+     */
+    cause?: unknown;
+    constructor(init?: AdminErrorInit);
+}
+/** Whether `err` is an `AdminError`, including one from another bundle copy. */
+/**
+ * The HTTP status an error carries, whichever shape carries it.
+ *
+ * An `AdminError` has it at `status`; an axios rejection has it at
+ * `response.status`. The pages used to read only the second, which was right
+ * while they called axios themselves — since they ask the resource registry,
+ * every failure is an `AdminError`, and a 401 read as `undefined` turned the
+ * MFA prompt's "try the code again" into "close and start over".
+ */
+declare function httpStatusOf(err: unknown): number | undefined;
+declare function isAdminError(err: unknown): err is AdminError;
+/**
+ * Whether an error is axios saying, in its own words, that the request was made
+ * and no response ever arrived.
+ *
+ * This is the one transport failure read rather than branded, because a library
+ * cannot be asked to mark itself. What it reads is axios's own three-way split,
+ * documented under "Handling errors" in its README and visible in the
+ * `AxiosError` constructor: `response` is set only when the server answered,
+ * `request` only once one was actually made, and an error with neither happened
+ * while the request was still being set up.
+ *
+ * Measured against axios 1.18.1 driven at a real `node:http` server, and the
+ * groups came out disjoint:
+ *
+ * | rejection                                       | `isAxiosError` | `request` | `response` |
+ * | ----------------------------------------------- | -------------- | --------- | ---------- |
+ * | connection refused / reset, DNS, timeout, abort  | `true`         | yes       | no         |
+ * | the same, rethrown by a rejection interceptor    | `true`         | yes       | no         |
+ * | a 401 or 500 the server really sent              | `true`         | yes       | yes        |
+ * | interceptor rejects with `new Error(…)`          | absent         | no        | no         |
+ * | …the same, but copying `error.config` across     | absent         | no        | no         |
+ * | …the same, copying `config` and `request`        | absent         | yes       | no         |
+ * | unsupported protocol, signal aborted before call | `true`         | no        | no         |
+ * | request interceptor throws, malformed URL        | absent         | no        | no         |
+ *
+ * Three readings follow from that table, and only the first is free of choice:
+ *
+ * - `response` present means the server answered, whatever else is set.
+ * - `request` present without it is axios's "made, nothing came back". The
+ *   browser and `fetch` adapters attach it too — an `XMLHttpRequest` and a
+ *   `Request` respectively — so the reading is not Node-only.
+ * - Requiring `isAxiosError` on top of that is the decision. It removes the
+ *   ordinary interceptor that copies `config` and `request` onto a hand-built
+ *   `new Error`, which is shape-wise axios's no-response form after the server
+ *   had answered.
+ *
+ * The previous reading was `config` without `response`, which is not axios's
+ * statement about anything: `config` is echoed on every axios error including
+ * the ones carrying a 401, and it is the field an interceptor is most likely to
+ * carry over when it replaces the rejection. It matched three rows above that
+ * mean the opposite of a transport failure.
+ *
+ * ## What this cannot decide, and which way it errs
+ *
+ * This is read *after* the consumer's interceptors have run — after the one
+ * place that can set or delete any field on the rejection. Both readings are
+ * therefore forgeable, in both directions, and each was reproduced:
+ *
+ * - An interceptor that **drops** `request` — `AxiosError.from(err, code,
+ *   config)` without its fourth argument, `err.toJSON()`, or a `delete
+ *   err.request` before logging — leaves a genuine `ECONNREFUSED` unbranded.
+ *   The operator then reads `connect ECONNREFUSED 127.0.0.1:44947` instead of
+ *   the localized sentence.
+ * - An interceptor that **builds** one — `AxiosError.from(msg, code,
+ *   error.config, error.request)` after an answered 401 — is branded. Nothing
+ *   distinguishes it: `AxiosError.from` is public API, so `isAxiosError` is
+ *   available to user code as well.
+ *
+ * Neither is closable by a better predicate; the fields simply do not carry the
+ * fact by then. So the reading errs deliberately toward *not* branding, because
+ * the two mistakes do not cost the same: an unbranded transport failure shows a
+ * true sentence in the wrong register, while a branded application failure tells
+ * the operator to check a connection that is fine. Saying less beats saying
+ * something false.
+ *
+ * An interceptor that rewrites rejections should say what it means with
+ * `markTransportFailure`, which is exported for exactly this. It is checked
+ * first and settles the case.
+ */
+declare function isAxiosNoResponseError(value: unknown): boolean;
+/**
+ * Reads the human-readable message out of a response body.
+ *
+ * Covers the two shapes the platform and its host produce: a coded platform
+ * error (`{ code, message }`) carries a string, while a NestJS
+ * `ValidationPipe` rejection carries `message: string[]` — one entry per
+ * failed constraint. Joining them is what keeps a validation error readable
+ * instead of rendering as `[object Object]`.
+ *
+ * Exported because every place that builds an `AdminError` from a response
+ * needs the same answer. It had two implementations for one release and they
+ * disagreed: the one in `http-json.ts` accepted only a string, so a validation
+ * rejection arriving through `getJson`/`postJson` lost its constraints
+ * entirely and the operator was shown the generic fallback.
+ */
+declare function readErrorDetail(body: unknown): string | undefined;
+/** Reads the machine-readable code out of a response body, if it carries one. */
+declare function readErrorCode(body: unknown): string | undefined;
+/**
+ * Turns anything that was caught into an `AdminError`.
+ *
+ * Recognises, in order: an `AdminError` (from any bundle copy), an axios-style
+ * rejection, an error carrying a numeric `status` — which is every one of the
+ * package's own `*ApiError` classes — and finally any `Error`, string or
+ * unknown value.
+ */
+declare function toAdminError(err: unknown): AdminError;
+/**
+ * Turns anything that was caught into text for a user.
+ *
+ * What the failing side said outranks anything this package could guess, so a
+ * `detail` wins whenever there is one. After that come the two facts a seam
+ * declared about a request with no HTTP status — they need opposite sentences
+ * and no number can tell them apart — and only then the status.
+ *
+ * The last line is the honest one. An error with no status, no text and no
+ * declaration is an error nothing knows anything about; "check your connection"
+ * used to be the answer, and it sent an operator after their router for a null
+ * dereference in a page. Whoever knows better says so with
+ * `markTransportFailure` or `markEmptyResponse`.
+ *
+ * `useAsyncAction` and `AdminErrorBanner` call this for you, and a page that
+ * reaches the platform through either should not need it. The five pages that
+ * do call it directly still notify from their own catch blocks; each had grown
+ * its own copy of this function, and one decision reached from five places
+ * beats five decisions.
+ */
+declare function adminErrorMessage(err: unknown, msgs: SaMessages['errors']): string;
+
+interface BootLoaderOptions {
+    /**
+     * Fully-qualified boot endpoint incl. app globalPrefix
+     * (`/api/admin/boot`, `/api/v1/admin/boot`, …). Mandatory.
+     */
+    endpoint: string;
+    /** Defaults to `defaultHttpClient()` (= `fetch`). */
+    http?: HttpClient;
+}
+declare class BootLoadError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+declare class BootLoader {
+    private readonly endpoint;
+    private readonly http;
+    constructor(options: BootLoaderOptions);
+    load(): Promise<PublicBootResponse>;
+}
+
+interface ManifestLoaderOptions {
+    /**
+     * Fully-qualified manifest endpoint incl. app globalPrefix
+     * (`/api/admin/manifest`, `/api/v1/admin/manifest`, …). Mandatory.
+     */
+    endpoint: string;
+    http?: HttpClient;
+    storage?: KvStore;
+    /**
+     * Storage key prefix — consumers with multiple apps under one domain
+     * set this to e.g. `'ma:'` or `'da:'`, so that the caches
+     * are separated.
+     */
+    storageKeyPrefix?: string;
+}
+/**
+ * The manifest could not be loaded. Its `message` is a diagnostic for the log,
+ * never text for a screen — `markPlatformError` is what tells `toAdminError`
+ * so, and it is a promise this class has to keep at every throw site.
+ */
+declare class ManifestLoadError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+interface CachedManifestEntry {
+    etag: string;
+    body: AdminManifest;
+}
+declare class ManifestLoader {
+    private readonly endpoint;
+    private readonly http;
+    private readonly storage;
+    private readonly bodyKey;
+    private readonly etagKey;
+    constructor(options: ManifestLoaderOptions);
+    /**
+     * Loads the current manifest. On a cache hit (304) the cached
+     * body is returned — otherwise the fresh server body.
+     *
+     * A 304 with no usable cached body is not a failure to report but one to
+     * undo: the request only carried `If-None-Match` because this loader put
+     * the ETag there, and the cache it validated against is this loader's own.
+     * So it drops the pair and asks once more without the header, which is the
+     * same recovery a person would have had to trigger by hand — except that
+     * the person reading an admin screen has neither this loader nor a
+     * console. Exactly one retry: a 304 to a request that asked nothing
+     * conditional is a server fault, and no repetition fixes it.
+     */
+    load(): Promise<AdminManifest>;
+    /** Sends the manifest GET, conditional when an ETag is supplied. */
+    private request;
+    /** Takes a non-304 response as the current manifest and caches it. */
+    private acceptFresh;
+    /** Reads the cached manifest body from storage; null if absent. */
+    readCachedBody(): CachedManifestEntry | null;
+    /** Clears the cache — e.g. on logout or after `manifest reload`. */
+    clearCache(): void;
+}
+
+/**
+ * Default routes for the platform standard pages. Consumers may override this
+ * via the `standardPageRoutes` option (e.g. `/admin/users` →
+ * `/admin/team`).
+ */
+declare const DEFAULT_STANDARD_PAGE_ROUTES: Record<StandardPageKey, string>;
+interface BuildRouteEntry {
+    /** Stable identifier — the key for standard pages, the `id` for project pages. */
+    id: string;
+    /** Route path (`/admin/...`). */
+    path: string;
+    /** Visible for the UI. */
+    label: string;
+    icon?: string;
+    /** Sort key for drawer groups. */
+    navSection?: string;
+    /** Lookup key in the `extensions:` map (project) or the platform standard map. */
+    componentKey: string;
+    /** Required capability or null. */
+    requiredCapability: string | null;
+    /** Platform standard page (`true`) or project page (`false`). */
+    isStandard: boolean;
+    /** Hint for anticipatory lazy loading. */
+    prefetchOnIdle?: boolean;
+}
+interface NavBuilderOptions {
+    /**
+     * UI locale for the default labels and section names, default `'de'`.
+     * Pass the same locale to `buildSidebar()`'s `sectionOrder` (via
+     * `defaultSectionOrder(locale)`) — section names are compared as strings.
+     *
+     * Only resolves the two catalogs the platform ships. Prefer `nav`, which
+     * carries app overrides and app-supplied languages as well.
+     */
+    locale?: SaLocale;
+    /**
+     * Resolved `nav` namespace, as `useSuperAdminI18n().messages.value.nav`
+     * hands it out. Wins over `locale`, and is the only way the sidebar sees
+     * `i18n.overrides` or a language the app added itself.
+     */
+    nav?: SaNavMessages;
+    /**
+     * Optional: overrides the default routes for certain standard pages.
+     * Consumers set this if they want an alternative URL structure.
+     */
+    standardPageRoutes?: Partial<Record<StandardPageKey, string>>;
+    /**
+     * Per-page label overrides layered over the locale defaults.
+     */
+    standardPageLabels?: Partial<Record<StandardPageKey, string>>;
+    /** Default icons for standard pages. */
+    standardPageIcons?: Partial<Record<StandardPageKey, string>>;
+    /** Default `navSection` for standard pages. */
+    standardPageNavSection?: Partial<Record<StandardPageKey, string>>;
+    /**
+     * Optional: set of known `componentKey`s from the shell's `extensions:`
+     * map. ProjectPages whose `componentKey` is not contained here
+     * are filtered out — they would otherwise appear in the sidebar but on
+     * click be redirected by the catch-all (silent dead link).
+     * Consumers without an `extensions:` map omit the field → as before.
+     */
+    availableExtensions?: Set<string>;
+}
+/**
+ * Localized default section names in drawer order (Übersicht → Produktkatalog
+ * → Kunden → System). Pass the result to `buildSidebar()` when building routes
+ * with a non-default locale, or hand it the resolved `nav` catalog directly —
+ * section names are compared as strings, so both sides must come from the same
+ * source.
+ */
+declare function defaultSectionOrder(locale?: SaLocale | SaNavMessages): readonly string[];
+/**
+ * Returns the list of all routes defined by the current manifest —
+ * filtered to the capabilities that the logged-in user has.
+ *
+ * The consumer shell then builds its Vue router configuration and its
+ * sidebar drawer from it.
+ */
+declare function buildRoutes(manifest: AdminManifest, options?: NavBuilderOptions): BuildRouteEntry[];
+interface SidebarItem {
+    id: string;
+    path: string;
+    label: string;
+    icon?: string;
+}
+interface SidebarSection {
+    /** `null` for the default section (items without `navSection`). */
+    section: string | null;
+    items: SidebarItem[];
+}
+/**
+ * Groups the routes by `navSection` for the drawer.
+ *
+ * Section order:
+ *   1. Default section (`null`) — items without `navSection`.
+ *   2. Sections from `sectionOrder` in exactly this order.
+ *   3. Remaining sections alphabetically.
+ *
+ * The default order matches the plan simulation layout (Übersicht →
+ * Produktkatalog → Kunden → System); consumers can override it.
+ */
+declare function buildSidebar(routes: BuildRouteEntry[], sectionOrder?: readonly string[]): SidebarSection[];
+/**
+ * Returns the Vue component registered for the given `componentKey`.
+ * The consumer shell calls this function with its own `extensions:` map.
+ * For unknown keys → `null` (the UI then renders a fallback
+ * component, e.g. "Component not found in shell build").
+ *
+ * `extensions` is `Record<string, T>` — `T` is typically a
+ * Vue component (either imported directly or as a
+ * `defineAsyncComponent` wrapper).
+ */
+declare function resolveExtension<T>(componentKey: string, extensions: Record<string, T>): T | null;
+
+type BatchColumnValue = unknown;
+/** One value per `tenantId` (freely structured). */
+type BatchColumnRow = Record<string, BatchColumnValue>;
+/** One `tenantId → value` map per column key. */
+type BatchColumnData = Record<string, BatchColumnRow>;
+type ParamStyle = 'comma' | 'repeat';
+interface BatchColumnFetcherOptions {
+    http?: HttpClient;
+    /**
+     * How the `tenantIds` are passed to the endpoint. Default `'comma'` →
+     * `?tenantIds=t1,t2,t3`. `'repeat'` → `?tenantIds=t1&tenantIds=t2`.
+     * Consumer backends decide based on their framework (NestJS accepts
+     * comma-separated strings by default, or via `@Query() ids: string[]`).
+     */
+    paramStyle?: ParamStyle;
+}
+declare class BatchColumnDriftError extends Error {
+    readonly column: TenantColumnDef;
+    constructor(column: TenantColumnDef, reason: string);
+}
+declare class BatchColumnFetcher {
+    private readonly http;
+    private readonly paramStyle;
+    constructor(options?: BatchColumnFetcherOptions);
+    /**
+     * Loads the data for all columns declared in the manifest in parallel
+     * (one request per column, all `tenantIds` in the batch). Columns without
+     * a satisfied capability are ignored.
+     */
+    fetchAll(manifest: AdminManifest, tenantIds: string[]): Promise<BatchColumnData>;
+    /** Fetch a single column (consumers may also use this directly). */
+    fetchOne(column: TenantColumnDef, tenantIds: string[]): Promise<BatchColumnRow>;
+    /**
+     * Column drift against the manifest. Consumers use this for CI smoke
+     * tests of the manifest-vs-shell build.
+     */
+    listDriftIssues(manifest: AdminManifest): BatchColumnDriftError[];
+    /**
+     * Which columns have a satisfied `requiredCapability`? Manifest =
+     * discovery, so a local check is enough.
+     */
+    eligibleColumns(manifest: AdminManifest): TenantColumnDef[];
+    private validateBatchEndpoint;
+    private buildUrl;
+}
+
+export { AdminError as A, type BatchColumnData as B, type CachedManifestEntry as C, DEFAULT_STANDARD_PAGE_ROUTES as D, readErrorCode as E, readErrorDetail as F, resolveExtension as G, toAdminError as H, ManifestLoadError as M, type NavBuilderOptions as N, type ParamStyle as P, type SidebarItem as S, type AdminErrorInit as a, BatchColumnDriftError as b, BatchColumnFetcher as c, type BatchColumnFetcherOptions as d, type BatchColumnRow as e, type BatchColumnValue as f, BootLoadError as g, BootLoader as h, type BootLoaderOptions as i, type BuildRouteEntry as j, ManifestLoader as k, type ManifestLoaderOptions as l, type SidebarSection as m, adminErrorMessage as n, buildRoutes as o, buildSidebar as p, defaultSectionOrder as q, httpStatusOf as r, isAdminError as s, isAxiosNoResponseError as t, isEmptyResponse as u, isPlatformError as v, isTransportFailure as w, markEmptyResponse as x, markPlatformError as y, markTransportFailure as z };