@saasicat/ui-vue 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,2395 @@
+import { RouteRecordRaw, NavigationGuardWithThis, RouterHistory, Router } from 'vue-router';
+import { PublicBootResponse, AdminManifest, StandardPageKey, TenantActionDef, TenantColumnDef, TenantListFilter, TenantDto, AuditQuery, AuditEntry, FeatureUiRegistry, PromoPreviewResponse, OnboardingSelectionRequest, PublicMarketingBundle, FeatureDef, FeatureKey, DiscoverySnapshot, CapabilityCatalogEntryRow, FeatureCatalogEntryRow, QuotaCatalogEntryRow, ReviewCatalogEntryData, CatalogEntryI18n, UpdateCatalogEntryBaseData, SyncDiscoveryResult, BundleVersionRow, CreateBundleVersionDraftData, BundleVersionMutationResult, UpdateBundleVersionDraftData, BundleRow, CreateBundleData, UpdateBundleData, SubscriptionBundleRecord, BusinessTypeVersionRow, CreateBusinessTypeVersionDraftData, BusinessTypeVersionMutationResult, UpdateBusinessTypeVersionDraftData, BusinessTypeRow, CreateBusinessTypeData, UpdateBusinessTypeData, MarketingProjectionFilter, MarketingProjectionRow, CreateMarketingProjectionData, UpdateMarketingProjectionData, PromotionRow, CreatePromotionData, UpdatePromotionData, PlanVersionRow as PlanVersionRow$1, CreatePlanVersionDraftData, PlanVersionMutationResult, UpdatePlanVersionDraftData, PlanRow, CreatePlanData, UpdatePlanData, ActionKey, ComponentKey } from '@saasicat/types';
+import * as vue from 'vue';
+import { Ref, InjectionKey, App, ComputedRef, Component } from 'vue';
+import { QuasarPluginOptions } from 'quasar';
+import { Pinia, StoreDefinition } from 'pinia';
+
+declare const ADMIN_UI_VERSION = "1.2.0";
+
+/**
+ * Minimal abstraction over `fetch`. Consumers may pass their own
+ * implementation (e.g. an axios wrapper that already injects auth headers
+ * and tenant headers).
+ */
+type HttpClient = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+}) => Promise<HttpResponse>;
+interface HttpResponse {
+    status: number;
+    headers: {
+        get(name: string): string | null;
+    };
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+/** Simple persistence adapter; default is `localStorage`. */
+interface KvStore {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    remove(key: string): void;
+}
+/**
+ * Returns a `KvStore` wrapper around `localStorage` (or `null` under SSR).
+ * Tests may pass an in-memory stub.
+ */
+declare function defaultKvStore(): KvStore;
+/**
+ * Default `HttpClient` over `fetch`. Consumers pass their own variant
+ * through when they need auth headers / tenant headers / retry logic.
+ */
+declare function defaultHttpClient(): HttpClient;
+
+/**
+ * Error for non-2xx responses. `code` is the machine-readable error code
+ * from the JSON body (`{ code }`), if present — callers map it to
+ * a message (e.g. via `SETUP_ERROR_CODES`).
+ */
+declare class HttpJsonError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    constructor(status: number, code?: string | undefined);
+}
+/**
+ * Removes trailing slashes so an API prefix can be concatenated with paths
+ * that start with `/`. Deliberately index-based instead of
+ * `replace(/\/+$/, '')`: the regex backtracks quadratically on inputs that
+ * end in many slashes.
+ */
+declare function trimTrailingSlashes(url: string): string;
+declare function getJson<T>(http: HttpClient, url: string): Promise<T>;
+declare function postJson<T>(http: HttpClient, url: string, body: unknown): Promise<T>;
+
+/** Eager or lazy component loader (`() => import(...)`). */
+type RouteComponent = NonNullable<RouteRecordRaw['component']>;
+interface CreateAdminRoutesOptions {
+    /**
+     * Loader for the shared login page. The app passes it through as a
+     * package-path import (resolved by the app bundler):
+     * `() => import('@saasicat/ui-vue/pages-standard/SuperAdminLoginPage.vue')`.
+     */
+    loginPage: RouteComponent;
+    /** Layout component for `/admin` (e.g. `() => import('@/layouts/AdminLayout.vue')`). */
+    adminLayout: RouteComponent;
+    /** Fail-closed error page for `manifestGuard.errorRoute` (`/admin-error`, public). */
+    adminErrorPage: RouteComponent;
+    /**
+     * App-specific pages under `/admin` (without the `→ dashboard` redirect and
+     * the `ProjectPageHost` catch-all — those the factory adds). Exactly the
+     * `children` entries that are duplicated per app today.
+     */
+    children: RouteRecordRaw[];
+    /** Default target of the `/admin` index redirect. Default `/admin/dashboard`. */
+    dashboardPath?: string;
+}
+declare function createAdminRoutes(options: CreateAdminRoutesOptions): RouteRecordRaw[];
+
+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;
+    /**
+     * Auth header for `Authorization: Bearer <token>`. Sent with every
+     * request. The consumer supplies a function that pulls the
+     * current token from the auth store.
+     */
+    getAuthToken?: () => string | null;
+}
+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;
+    private readonly getAuthToken?;
+    constructor(options: ManifestLoaderOptions);
+    /**
+     * Loads the current manifest. On a cache hit (304) the cached
+     * body is returned — otherwise the fresh server body.
+     */
+    load(): Promise<AdminManifest>;
+    /** 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 {
+    /**
+     * Optional: overrides the default routes for certain standard pages.
+     * Consumers set this if they want an alternative URL structure.
+     */
+    standardPageRoutes?: Partial<Record<StandardPageKey, string>>;
+    /**
+     * Default labels for standard pages — consumers may localize.
+     */
+    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>;
+}
+declare const DEFAULT_SECTION_ORDER: 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;
+
+/** Consumer implementation; receives the action inputs as a generic object. */
+type ActionHandler<TInput = unknown, TResult = unknown> = (input: TInput) => Promise<TResult>;
+interface ResolvedAction<TInput = unknown, TResult = unknown> {
+    def: TenantActionDef;
+    handler: ActionHandler<TInput, TResult>;
+}
+declare class MissingHandlerError extends Error {
+    constructor(actionKey: string);
+}
+declare class ActionDefNotInManifestError extends Error {
+    constructor(actionKey: string);
+}
+declare class ActionRegistry {
+    private readonly defs;
+    private readonly handlers;
+    constructor(manifest: AdminManifest, handlers?: Record<string, ActionHandler>);
+    /**
+     * Registers a handler after the fact (e.g. when consumer code loads
+     * lazily). Throws `ActionDefNotInManifestError` if the `actionKey` is not
+     * declared in the manifest — prevents dead registrations.
+     */
+    register<TInput, TResult>(actionKey: string, handler: ActionHandler<TInput, TResult>): void;
+    /**
+     * Returns the `{def, handler}` pair. Throws if the key is missing from
+     * the manifest or no handler is registered. The shell's UI layer calls
+     * the method, checks `def.requiresMfa` / `def.confirmType` for the
+     * pre-flow, and then calls `handler(input)`.
+     */
+    get<TInput = unknown, TResult = unknown>(actionKey: string): ResolvedAction<TInput, TResult>;
+    /**
+     * Convenience: `get(key).handler(input)`. UI convenience for actions
+     * that need neither MFA nor confirm.
+     */
+    dispatch<TInput, TResult>(actionKey: string, input: TInput): Promise<TResult>;
+    /**
+     * List of actionKeys that are declared in the manifest but have no
+     * handler. Consumers use this in a doctor check to detect drift between
+     * the manifest and the shell build.
+     */
+    listOrphanedDefs(): string[];
+    /**
+     * List of registered handlers that are missing from the manifest. Drift
+     * in the other direction.
+     */
+    listOrphanedHandlers(): string[];
+}
+
+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;
+    /**
+     * Auth-token provider for `Authorization: Bearer <token>`. The consumer
+     * supplies a function that pulls the current token from the auth store.
+     */
+    getAuthToken?: () => string | null;
+}
+declare class BatchColumnDriftError extends Error {
+    readonly column: TenantColumnDef;
+    constructor(column: TenantColumnDef, reason: string);
+}
+declare class BatchColumnFetcher {
+    private readonly http;
+    private readonly paramStyle;
+    private readonly getAuthToken?;
+    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;
+}
+
+interface ApiListResponse<T> {
+    items: T[];
+    page?: number;
+    pageSize?: number;
+    total?: number;
+}
+interface UseApiListOptions<TFilter> {
+    endpoint: string;
+    /**
+     * Reactive filter object. The composable serializes it into `?key=value`
+     * pairs (with URL encoding); empty/null values are omitted.
+     */
+    filter?: Ref<TFilter>;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /**
+     * When `true`, loads automatically on mount. Defaults to `true`.
+     * Set to `false` when the consumer wants to trigger the first load
+     * explicitly (e.g. after auth-state init).
+     */
+    autoLoad?: boolean;
+}
+interface UseApiListResult<T> {
+    items: Ref<T[]>;
+    page: Ref<number>;
+    pageSize: Ref<number>;
+    total: Ref<number>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Reloads fresh (e.g. after a mutation). */
+    reload: () => Promise<void>;
+    /** Jumps to a specific page (1-based) and loads. */
+    goToPage: (page: number) => Promise<void>;
+    /** Changes the page size and jumps to page 1. */
+    setPageSize: (size: number) => Promise<void>;
+}
+declare function useApiList<T, TFilter extends Record<string, unknown> = Record<string, unknown>>(options: UseApiListOptions<TFilter>): UseApiListResult<T>;
+
+interface UseTenantsOptions {
+    /**
+     * Fully qualified tenants-list endpoint including the app globalPrefix
+     * (`/api/admin/tenants`, `/api/v1/admin/tenants`, …). Mandatory — the
+     * platform has no uniform default, because apps mount differently
+     * (see header comment).
+     */
+    endpoint: string;
+    /** Reactive filter; default is an empty object. */
+    filter?: Ref<TenantListFilter>;
+    http?: UseApiListOptions<Record<string, unknown>>['http'];
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface UseTenantsResult<T extends TenantDto = TenantDto> extends UseApiListResult<T> {
+    filter: Ref<TenantListFilter>;
+}
+/**
+ * Composable for the tenants list. Generic over the row shape:
+ * consumer apps with extended backend responses (plan/usage/pilot/…)
+ * specialize via `useTenants<MyRow>()`.
+ */
+declare function useTenants<T extends TenantDto = TenantDto>(options: UseTenantsOptions): UseTenantsResult<T>;
+
+interface UseAuditEntriesOptions {
+    /**
+     * Fully-qualified audit endpoint including the app's globalPrefix
+     * (`/api/admin/audit`, `/api/v1/admin/audit`, …). Mandatory.
+     */
+    endpoint: string;
+    filter?: Ref<AuditQuery>;
+    http?: UseApiListOptions<Record<string, unknown>>['http'];
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface UseAuditEntriesResult extends UseApiListResult<AuditEntry> {
+    filter: Ref<AuditQuery>;
+}
+declare function useAuditEntries(options: UseAuditEntriesOptions): UseAuditEntriesResult;
+
+interface EntitlementSnapshotShape {
+    plan: string;
+    quotas: Record<string, number>;
+    features: string[];
+}
+interface UseEntitlementOptions {
+    /**
+     * Fully-qualified entitlement endpoint including the app globalPrefix
+     * (`/api/billing/entitlement`, `/api/v1/billing/entitlement`, …). Mandatory.
+     */
+    endpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Default `true`. */
+    autoLoad?: boolean;
+}
+interface UseEntitlementResult {
+    entitlement: Ref<EntitlementSnapshotShape | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    /** Convenience: checks whether a FeatureKey is in the set. */
+    hasFeature: (key: string) => boolean;
+}
+declare function useEntitlement(options: UseEntitlementOptions): UseEntitlementResult;
+
+interface TenantManifestNavItem {
+    id: string;
+    label: string;
+    path: string;
+    icon?: string;
+    order?: number;
+}
+interface TenantManifestShape {
+    schemaVersion: 1;
+    tenant: {
+        id: string;
+    };
+    planId: string | null;
+    features: string[];
+    quotas: Record<string, number>;
+    navigation: TenantManifestNavItem[];
+}
+interface UseTenantManifestOptions {
+    /** e.g. `/api/tenant/manifest` (mandatory). */
+    endpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Defaults to `true`. */
+    autoLoad?: boolean;
+}
+interface UseTenantManifestResult {
+    manifest: Ref<TenantManifestShape | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    hasFeature: (key: string) => boolean;
+    /** Quota limit (`null` if the Quota is not in the Plan). */
+    quotaLimit: (key: string) => number | null;
+}
+declare function useTenantManifest(options: UseTenantManifestOptions): UseTenantManifestResult;
+
+declare const ENTITLEMENT_INJECTION_KEY: InjectionKey<UseEntitlementResult>;
+/**
+ * Binds a `useEntitlement(...)` result for the whole app so that
+ * `<FeatureGate>` and router guards can inject it.
+ */
+declare function provideEntitlement(app: App, entitlement: UseEntitlementResult): void;
+/**
+ * Fetches the bound entitlement result. Returns `null` when the
+ * consumer did not call `provideEntitlement(...)` — `<FeatureGate>`
+ * then falls back to "everything allowed" (with a dev warning).
+ */
+declare function useInjectedEntitlement(): UseEntitlementResult | null;
+
+interface FeatureRouterGuardOptions {
+    /**
+     * Returns the current entitlement. Deliberately a factory (instead of
+     * passing a ref directly), so the app can lazy-load the entitlement and
+     * re-bind it — e.g. after a plan change or logout/re-login.
+     */
+    getEntitlement: () => UseEntitlementResult | null;
+    /**
+     * Where to redirect when a feature is missing. Default: no redirect, but
+     * `next(false)` (route blocks). Apps with an upgrade page set
+     * `'/upgrade'`.
+     */
+    redirectTo?: string;
+    /**
+     * `true` (default): entitlement not yet loaded → let through,
+     * so the first render doesn't hang. `false`: blocks until the entitlement
+     * is there (user sees a white screen if the endpoint is slow — only
+     * sensible in apps with pre-login load).
+     */
+    allowWhileLoading?: boolean;
+}
+declare function buildFeatureRouterGuard(options: FeatureRouterGuardOptions): NavigationGuardWithThis<undefined>;
+
+interface CatalogPlan {
+    id: string;
+    name: string;
+    tagline: string;
+    monthlyNet: number | null;
+    yearlyNet: number | null;
+    popular: boolean;
+    quotas: Record<string, number>;
+    features: string[];
+}
+/**
+ * Bookable catalog bundle (wire form of `PublicBundleEntry` from
+ * `GET /billing/bundles`) — standalone catalog bundles
+ * (`bundle_versions`) with their own purchase flow `/billing/subscription-bundles`.
+ * Prices arrive as a decimal string on the wire and become `number` here.
+ */
+interface CatalogBundle {
+    bundleVersionId: string;
+    bundleKey: string;
+    label: string;
+    description: string | null;
+    features: string[];
+    quotas: Record<string, number>;
+    monthlyNet: number | null;
+    yearlyNet: number | null;
+    /**
+     * Uncovered feature dependencies (#35): union of the `requires` of the
+     * contained features minus those contained in the bundle itself. The UI
+     * grays out the bundle if these keys are neither in the plan nor in the
+     * active bundles. Empty without requires data (graceful).
+     */
+    requiresFeatures: string[];
+    /** Marketing price label (e.g. "from 19 €/month") — null = auto-format. */
+    priceTag: string | null;
+}
+interface UseTenantBillingCatalogOptions {
+    /**
+     * URL prefix before `/plans`, `/feature-registry`, `/bundles`.
+     * Default `'/billing'`. **Convention**: `apiPrefix` is the sub-path
+     * UNDER the app API base URL that the HTTP adapter itself holds.
+     * Example: HTTP adapter baseURL `/api` + apiPrefix `/billing` →
+     * `/api/billing/...`. Do NOT set `'/api/billing'` if the HTTP adapter
+     * already has `/api` as baseURL (→ `/api/api/...` 404).
+     */
+    apiPrefix?: string;
+    http?: HttpClient;
+    /**
+     * Default `true`. Set to `false` if the consumer wants to trigger
+     * `load()` itself (e.g. after login).
+     */
+    autoLoad?: boolean;
+}
+interface UseTenantBillingCatalogResult {
+    plans: Ref<CatalogPlan[] | null>;
+    featureRegistry: Ref<FeatureUiRegistry | null>;
+    /**
+     * Bookable catalog bundles (`/billing/bundles`). `null` while not yet
+     * loaded; `[]` if the endpoint is missing/empty (non-fatal).
+     */
+    bundles: Ref<CatalogBundle[] | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Loads plans/feature-registry in parallel + bundles (non-fatal). */
+    load: () => Promise<void>;
+}
+declare function useTenantBillingCatalog(options?: UseTenantBillingCatalogOptions): UseTenantBillingCatalogResult;
+
+type BillingCycleStr = 'MONTHLY' | 'YEARLY';
+interface UsageSnapshotShape {
+    plan: string;
+    effectivePlan: string;
+    billingCycle: BillingCycleStr;
+    status: string;
+    isPilot: boolean;
+    pilotEndsAt: string | null;
+    trialEndsAt: string | null;
+    startedAt: string | null;
+    currentPeriodStart: string | null;
+    currentPeriodEnd: string | null;
+    pendingPlan: string | null;
+    pendingBillingCycle: BillingCycleStr | null;
+    pendingEffectiveAt: string | null;
+    planVersion: {
+        id: string;
+        planId: string;
+        version: number;
+        publishedAt: string | null;
+        supersededAt: string | null;
+        changeNote: string | null;
+    };
+    pendingPlanVersion: {
+        id: string;
+        planId: string;
+        version: number;
+        nonRegressive: boolean;
+        changeNote: string | null;
+        publishedChanges: unknown;
+    } | null;
+    pendingPlanVersionEffectiveAt: string | null;
+    pendingPlanVersionAccepted: boolean;
+    pendingPlanVersionAcceptedAt: string | null;
+    limits: {
+        plan: string;
+        quotas: Record<string, number>;
+        features: string[];
+    };
+    usage: Record<string, number>;
+    /**
+     * P11.4 (METAMODELL §17a): Read-only package snapshot from the
+     * original CheckoutOffer. `null` for subscriptions without a
+     * CheckoutOffer origin. The JSON structure matches the Offer
+     * schema; the UI can read `bundleVersionIds`, `currency`,
+     * `priceTotal` and more from it.
+     */
+    packageSnapshot: PackageSnapshotShape | null;
+    /** P11.4: Optional reference to the original CheckoutOffer. */
+    checkoutOfferId: string | null;
+}
+/**
+ * Self-contained package snapshot (shape of `CheckoutOffer.snapshot`).
+ * All fields are optional because the snapshot schema may grow and older
+ * subscriptions can carry leaner snapshots. The UI must stay defensive
+ * against missing fields.
+ */
+interface PackageSnapshotShape {
+    planId?: string;
+    planVersionId?: string;
+    billingCycle?: BillingCycleStr;
+    bundleVersionIds?: string[];
+    currency?: string;
+    priceMonthlyNet?: number | null;
+    priceYearlyNet?: number | null;
+    priceTotalNet?: number | null;
+    label?: string;
+    capturedAt?: string;
+    [key: string]: unknown;
+}
+interface PlanChangePreviewShape {
+    changeType: 'UPGRADE' | 'DOWNGRADE' | 'CYCLE_CHANGE' | 'NOOP';
+    current: {
+        plan: PlanSnapshotShape;
+        billingCycle: BillingCycleStr;
+    };
+    target: {
+        plan: PlanSnapshotShape;
+        billingCycle: BillingCycleStr;
+    };
+    effectiveAt: string | null;
+    isImmediate: boolean;
+    /** Projected new trial end (ISO) after the change, otherwise null. */
+    projectedTrialEndsAt: string | null;
+    proration: {
+        daysRemainingInPeriod: number;
+        daysInPeriod: number;
+        periodStart: string;
+        periodEnd: string;
+        currentPriceNet: number;
+        targetPriceNet: number;
+        prorataDeltaNet: number;
+    } | null;
+    limitsCheck: Record<string, {
+        used: number;
+        currentMax: number;
+        targetMax: number;
+        exceeded: boolean;
+    }>;
+    featuresLost: string[];
+    featuresGained: string[];
+    blockers: Array<{
+        code: string;
+        message: string;
+    }>;
+    warnings: Array<{
+        code: string;
+        message: string;
+    }>;
+}
+interface PlanSnapshotShape {
+    id: string;
+    name: string;
+    monthlyNet: number | null;
+    yearlyNet: number | null;
+    quotas: Record<string, number>;
+    features: string[];
+}
+/**
+ * Booked catalog bundle (wire shape of `SubscriptionBundleRecord`, dates
+ * as ISO strings). Source: `GET /billing/subscription-bundles`. The label/
+ * price is joined by the consumer via `bundleVersionId` against the bundle
+ * catalog (`GET /billing/bundles`) — the record itself carries only the
+ * version reference.
+ */
+interface SubscriptionBundleShape {
+    id: string;
+    subscriptionId: string;
+    bundleVersionId: string;
+    /** Denormalized (server-side from the booked bundleVersion): label/
+     *  key/price, so that booked bundles can be shown without a catalog join. */
+    bundleKey?: string | null;
+    label?: string | null;
+    monthlyNet?: string | null;
+    startedAt: string;
+    minimumTermEndsAt: string | null;
+    canceledAt: string | null;
+    canceledEffectiveAt: string | null;
+}
+interface BundlePreviewIssueShape {
+    code: string;
+    message: string;
+}
+interface BundlePreviewSnapshotShape {
+    bundleKey: string;
+    label: string;
+    bundleVersionId: string;
+    features: string[];
+    quotas: Record<string, number>;
+}
+/** AK-13: Feature is already paid for elsewhere — double-payment hint. */
+interface RedundantFeatureHintShape {
+    featureKey: string;
+    coveredBy: 'PLAN' | 'BUNDLE';
+    coveredByKey: string;
+}
+/**
+ * Wire shape of `SubscriptionBundleAddPreviewDto` (#37,
+ * `POST /billing/subscription-bundles/preview` with `bundleVersionId`).
+ * `proration` is `null` during TRIAL or without a maintained list price.
+ */
+interface BundleAddPreviewShape {
+    action: 'add';
+    bundle: BundlePreviewSnapshotShape;
+    billingCycle: string;
+    proration: {
+        daysRemainingInPeriod: number;
+        daysInPeriod: number;
+        periodStart: string;
+        periodEnd: string;
+        currentPriceNet: number;
+        targetPriceNet: number;
+        prorataDeltaNet: number;
+    } | null;
+    nextPeriodPriceNet: number | null;
+    minimumTermMonths: number;
+    minimumTermEndsAt: string | null;
+    redundantFeatures: RedundantFeatureHintShape[];
+    missingRequires: string[];
+    blockers: BundlePreviewIssueShape[];
+    warnings: BundlePreviewIssueShape[];
+}
+/**
+ * Wire shape of `SubscriptionBundleCancelPreviewDto` (#37, preview with
+ * `subscriptionBundleId`). `effectiveAt` = max(period end, minimum term).
+ */
+interface BundleCancelPreviewShape {
+    action: 'cancel';
+    subscriptionBundleId: string;
+    bundle: BundlePreviewSnapshotShape;
+    billingCycle: string;
+    effectiveAt: string;
+    nextPeriodSavingsNet: number | null;
+    blockers: BundlePreviewIssueShape[];
+    warnings: BundlePreviewIssueShape[];
+}
+type BundlePreviewShape = BundleAddPreviewShape | BundleCancelPreviewShape;
+interface UseTenantBillingOptions {
+    /**
+     * Default `'/billing'`. The app HTTP adapter sets the API base URL
+     * (e.g. `/api` or `/api/v1`); `apiPrefix` is
+     * the sub-path below it. A doubled `/api` prefix leads to HTTP 404.
+     */
+    apiPrefix?: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Default `true`. */
+    autoLoad?: boolean;
+}
+interface UseTenantBillingResult {
+    usage: Ref<UsageSnapshotShape | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    reload: () => Promise<void>;
+    previewPlanChange: (plan: string, billingCycle: BillingCycleStr) => Promise<PlanChangePreviewShape>;
+    changePlan: (plan: string, billingCycle: BillingCycleStr, effectiveImmediately: boolean) => Promise<void>;
+    acceptPendingPlanVersion: () => Promise<void>;
+    cancelSubscription: (immediately: boolean) => Promise<void>;
+    /** True if `usage.value.features` contains the FeatureKey. */
+    hasFeature: (key: string) => boolean;
+    /**
+     * The tenant's booked catalog bundles (`/billing/subscription-bundles`).
+     * Loaded along with `reload()`. If the endpoint is missing (consumer
+     * without `SubscriptionBundleModule`), the list stays empty without
+     * setting the main `error` — the page degrades gracefully.
+     */
+    subscriptionBundles: Ref<SubscriptionBundleShape[]>;
+    /** Reloads only the booked bundles (non-fatal). */
+    loadBundles: () => Promise<void>;
+    /** Books a bundle via `bundleVersionId` + reloads the list. */
+    addBundle: (bundleVersionId: string, minimumTermMonths?: number) => Promise<void>;
+    /** Cancels a booked bundle via SubscriptionBundle PK + reloads. */
+    cancelBundle: (subscriptionBundleId: string) => Promise<void>;
+    /** Reverses a cancellation that has not yet taken effect + reloads. */
+    reactivateBundle: (subscriptionBundleId: string) => Promise<void>;
+    /**
+     * Add preview (#37): proration, next-period price, redundancy hint,
+     * requires check and blockers — show BEFORE booking.
+     */
+    previewAddBundle: (bundleVersionId: string, minimumTermMonths?: number) => Promise<BundleAddPreviewShape>;
+    /** Cancel preview (#37): effective date + savings from the next period on. */
+    previewCancelBundle: (subscriptionBundleId: string) => Promise<BundleCancelPreviewShape>;
+}
+declare function useTenantBilling(options?: UseTenantBillingOptions): UseTenantBillingResult;
+
+declare const DEFAULT_YEARLY_FACTOR = 10;
+type PromoStatus = 'idle' | 'checking' | 'valid' | 'invalid' | 'restricted';
+interface PromoState {
+    status: PromoStatus;
+    /** Backend response (only set when status === 'valid' or 'restricted'). */
+    preview: PromoPreviewResponse | null;
+    /** Display text for the UI (confirmation or error message). */
+    message: string;
+}
+interface UseSubscriptionDraftOptions {
+    plans: Ref<CatalogPlan[] | null> | ComputedRef<CatalogPlan[] | null>;
+    subscriptionBundles?: Ref<PublicMarketingBundle[] | null> | ComputedRef<PublicMarketingBundle[] | null>;
+    initialPlan?: string | null;
+    initialCycle?: BillingCycleStr;
+    initialBundleVersionIds?: ReadonlyArray<string>;
+    /** Override for the `yearlyNet` fallback if the catalog provides no yearlyNet. */
+    yearlyFactor?: number;
+}
+interface PriceLineItem {
+    /** Stable key for UI `v-for`. */
+    key: string;
+    label: string;
+    /** Raw catalog value in the selected cycle unit. */
+    net: number;
+    /** Optional: additional text. */
+    sublabel?: string;
+}
+interface DraftPricing {
+    cycle: BillingCycleStr;
+    /** Plan base without bundles. */
+    planNet: number;
+    /** Sum of all selected catalog bundles. */
+    bundlesNet: number;
+    /** Plan + Bundles. */
+    subtotalNet: number;
+    /** Discount derived from the promo preview (on subtotalNet, not plan-only). */
+    discountNet: number;
+    /** subtotalNet - discountNet. */
+    totalNet: number;
+    /** Savings per year vs. monthly payment. */
+    yearSavings: number;
+    /** Structured breakdown for the sticky sidebar. */
+    breakdown: {
+        plan: PriceLineItem | null;
+        bundles: PriceLineItem[];
+    };
+}
+interface SubscriptionDraft {
+    plan: Ref<string | null>;
+    cycle: Ref<BillingCycleStr>;
+    selectedBundleVersionIds: Ref<Set<string>>;
+    promoCode: Ref<string>;
+    promoState: Ref<PromoState>;
+    selectedPlan: ComputedRef<CatalogPlan | null>;
+    /** Plan-included ∪ features of the selected catalog bundles. */
+    activeFeatures: ComputedRef<Set<string>>;
+    pricing: ComputedRef<DraftPricing>;
+    isDirty: ComputedRef<boolean>;
+    setPlan(planId: string): void;
+    setCycle(c: BillingCycleStr): void;
+    toggleSubscriptionBundle(bundleVersionId: string): void;
+    setPromoCode(code: string): void;
+    setPromoState(state: PromoState): void;
+    clearPromo(): void;
+    toApiPayload(): OnboardingSelectionRequest;
+}
+declare function useSubscriptionDraft(options: UseSubscriptionDraftOptions): SubscriptionDraft;
+
+interface TenantPlanSectionI18n {
+    sectionTitle: string;
+    sectionSubtitle: string;
+    loading: string;
+    noSubscription: string;
+    activePlan: string;
+    cycleMonthly: string;
+    cycleYearly: string;
+    statusActive: string;
+    statusTrial: string;
+    statusPastDue: string;
+    statusCanceled: string;
+    statusPendingSales: string;
+    trialEndsAt: string;
+    pilotEndsAt: string;
+    nextBillingDate: string;
+    pendingChange: string;
+    changeFromTo: string;
+    changeEffectiveAt: string;
+    changePlanButton: string;
+    cancelSubscriptionButton: string;
+    usageTitle: string;
+    /** #18 — feature / scope-of-services matrix (included + locked). */
+    featuresOverviewTitle: string;
+    featuresActive: string;
+    featuresLocked: string;
+    /** #15 — bundle store (booked + available bundles). */
+    bundlesStoreTitle: string;
+    bundlesBookedTitle: string;
+    bundlesAvailableTitle: string;
+    bundlesAvailableEmpty: string;
+    bundlesPerMonth: string;
+    bundleBookAction: string;
+    bundleBookInProgress: string;
+    bundleCancelAction: string;
+    bundleReactivateAction: string;
+    bundleReactivateConfirmTitle: string;
+    bundleReactivateConfirmBody: string;
+    bundleCanceledAt: string;
+    bundleMinimumTermUntil: string;
+    bundleIncludesLabel: string;
+    bundleAlreadyBooked: string;
+    bundleIncompatible: string;
+    /** #37/#61 — requires graying-out + booking/cancellation preview. */
+    bundleMissingRequires: string;
+    bundlePreviewAddTitle: string;
+    bundlePreviewCancelTitle: string;
+    bundlePreviewLoading: string;
+    bundlePreviewProrationTitle: string;
+    bundlePreviewProratedNow: string;
+    bundlePreviewProrationDays: string;
+    bundlePreviewNextPeriod: string;
+    bundlePreviewTrialNote: string;
+    bundlePreviewNoPrice: string;
+    bundlePreviewMinimumTermLabel: string;
+    bundlePreviewMinimumTermMonths: string;
+    bundlePreviewMinimumTermNone: string;
+    bundlePreviewRedundantTitle: string;
+    bundlePreviewRedundantCoveredByPlan: string;
+    bundlePreviewRedundantCoveredByBundle: string;
+    bundlePreviewMissingRequiresTitle: string;
+    bundlePreviewBlockersTitle: string;
+    bundlePreviewWarningsTitle: string;
+    bundlePreviewEffectiveAt: string;
+    bundlePreviewSavings: string;
+    bundlePreviewConfirmAdd: string;
+    bundlePreviewConfirmCancel: string;
+    bundlePreviewInProgress: string;
+    bundlePreviewClose: string;
+    pendingVersionTitle: string;
+    pendingVersionChipNonRegressive: string;
+    pendingVersionChipRegressive: string;
+    pendingVersionEffectiveAt: string;
+    pendingVersionAcceptAction: string;
+    pendingVersionAcceptInProgress: string;
+    pendingVersionAcceptedAt: string;
+    wizardTitle: string;
+    wizardClose: string;
+    wizardCurrent: string;
+    wizardBadgeCurrent: string;
+    wizardBadgePopular: string;
+    wizardPriceUnitMonthly: string;
+    wizardPriceUnitYearly: string;
+    wizardPriceOnRequest: string;
+    wizardStepChoose: string;
+    wizardStepChooseIntro: string;
+    wizardStepPreview: string;
+    wizardStepConfirm: string;
+    wizardNext: string;
+    wizardBack: string;
+    wizardPreviewLoading: string;
+    wizardEffectiveAtLabel: string;
+    wizardEffectiveImmediate: string;
+    wizardProrationTitle: string;
+    wizardProrationLine: string;
+    wizardProrationDays: string;
+    wizardLimitsTitle: string;
+    wizardLimitsUsed: string;
+    wizardLimitsCurrent: string;
+    wizardLimitsTarget: string;
+    wizardFeaturesGained: string;
+    wizardFeaturesLost: string;
+    wizardBlockersTitle: string;
+    wizardConfirmImmediate: string;
+    wizardConfirmScheduled: string;
+    wizardConfirmAction: string;
+    wizardConfirmInProgress: string;
+    /** #17 — price overview in the confirm step. */
+    wizardConfirmPriceTitle: string;
+    wizardConfirmProratedNow: string;
+    wizardConfirmRecurringNext: string;
+    wizardConfirmRecurringFrom: string;
+    wizardConfirmPerCycleMonthly: string;
+    wizardConfirmPerCycleYearly: string;
+    /** #17 — trial case in the confirm step (nothing due during the trial). */
+    wizardConfirmTrialNote: string;
+    wizardConfirmRecurringTrialEnd: string;
+    wizardChangeTypeUpgrade: string;
+    wizardChangeTypeDowngrade: string;
+    wizardChangeTypeCycle: string;
+    wizardChangeTypeNoop: string;
+    /** P11.4: read-only display of the package snapshot. */
+    packageSnapshotTitle: string;
+    packageSnapshotSubtitle: string;
+    packageSnapshotCapturedAt: string;
+    packageSnapshotOfferRef: string;
+    packageSnapshotPlanLabel: string;
+    packageSnapshotPlanVersionLabel: string;
+    packageSnapshotCycleLabel: string;
+    packageSnapshotBundlesLabel: string;
+    packageSnapshotBundlesEmpty: string;
+    packageSnapshotPriceMonthly: string;
+    packageSnapshotPriceYearly: string;
+    packageSnapshotPriceTotal: string;
+    packageSnapshotNone: string;
+    packageSnapshotShowRaw: string;
+    packageSnapshotHideRaw: string;
+}
+/** German default strings — apps can override them selectively. */
+declare const DEFAULT_I18N_DE: TenantPlanSectionI18n;
+
+/**
+ * Generic filter shape for versions lists.
+ * `state`: 'draft' (publishedAt null), 'live' (publishedAt set, supersededAt null),
+ *          'superseded' (supersededAt set), 'all' (default).
+ */
+interface PlanVersionListFilter {
+    state?: 'draft' | 'live' | 'superseded' | 'all';
+    /** PlanId (`'BASIC'`, `'STANDARD'`, …). */
+    planId?: string;
+}
+/**
+ * Generic versions row shape. Depending on the endpoint, the consumer backend
+ * returns slightly different fields; the platform composable takes the universal ones.
+ */
+interface PlanVersionRow {
+    id: string;
+    version: number;
+    publishedAt: string | null;
+    supersededAt: string | null;
+    nonRegressive: boolean;
+    changeNote?: string;
+    [extra: string]: unknown;
+}
+interface VersionsOptions {
+    /**
+     * Fully qualified versions-list endpoint including the app globalPrefix
+     * (`/api/admin/plan-versions`, `/api/v1/admin/plan-versions`, …). Mandatory.
+     */
+    endpoint: string;
+    filter?: Ref<PlanVersionListFilter>;
+    http?: UseApiListOptions<Record<string, unknown>>['http'];
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface VersionsResult extends UseApiListResult<PlanVersionRow> {
+    filter: Ref<PlanVersionListFilter>;
+}
+/**
+ * Read-only catalog view for PlanVersions (lift-and-shift from a
+ * consumer admin).
+ * Called `usePlanVersionsCatalog` since M6 Pack 2a, because `usePlanVersions`
+ * from `use-plans.ts` is now the lifecycle editor (createDraft/publish).
+ */
+declare const usePlanVersionsCatalog: (options: VersionsOptions) => VersionsResult;
+
+type BulkItemKind = 'plan';
+type BulkItemStatus = 'pending' | 'publishing' | 'published' | 'failed';
+interface BulkPublishItem {
+    /** Composite ID: `<kind>:<draftId>`. Unique within the bulk set. */
+    key: string;
+    kind: BulkItemKind;
+    draftId: string;
+    /** Display label in the modal (e.g. "STANDARD v3"). */
+    label: string;
+    status: BulkItemStatus;
+    error?: string;
+    /** Server response when status='published'. */
+    result?: unknown;
+}
+interface UseBulkPublishOptions {
+    /**
+     * Endpoint mapping per kind. **Required** — the platform does not know
+     * the app's globalPrefix (e.g. `/api/admin/...` or
+     * `/api/v1/admin/...`), so consumers supply the full URL per kind.
+     */
+    endpoints: Record<BulkItemKind, (draftId: string) => string>;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+}
+interface UseBulkPublishResult {
+    items: Ref<BulkPublishItem[]>;
+    /** Fraction of items already completed (0..1). */
+    progress: ComputedRef<number>;
+    /** Returns `true` once all items are either `published` or `failed`. */
+    done: ComputedRef<boolean>;
+    /** Number of successful publishes. */
+    successCount: ComputedRef<number>;
+    /** Number of failed publishes. */
+    failureCount: ComputedRef<number>;
+    /** Resets the bulk set — e.g. after modal open. */
+    setItems: (items: Array<Omit<BulkPublishItem, 'status'>>) => void;
+    /**
+     * Triggers the bulk publish. `changeNote` is required for all
+     * drafts; `mfaCode` is optional and is sent in the `X-Mfa-Code`
+     * header when present.
+     */
+    run: (input: {
+        changeNote: string;
+        mfaCode?: string;
+    }) => Promise<void>;
+}
+declare function useBulkPublish(options: UseBulkPublishOptions): UseBulkPublishResult;
+
+declare class PlannedOnlyFeatureError extends Error {
+    readonly violations: FeatureKey[];
+    constructor(violations: FeatureKey[]);
+}
+interface FeatureRowMarkers {
+    /** Catalog definition (label, icon, tier, marker). */
+    def: FeatureDef;
+    /** Currently selected in the draft. */
+    isSelected: boolean;
+    /** Catalog marker `plannedOnly: true` — the UI shows it as roadmap, not bookable. */
+    isPlannedOnly: boolean;
+    /** In the base plan (inherited) — not removable on nonRegressive drafts. */
+    isInherited: boolean;
+    /** Computed: is the user allowed to toggle the feature? */
+    canToggle: boolean;
+}
+interface UsePlanEditorOptions {
+    /** Initial selection — typically `draft.features` from PATCH preparation. */
+    initialFeatures?: FeatureKey[];
+    /** Features the base plan already contained; not removable under nonRegressive. */
+    baseFeatures?: FeatureKey[];
+    /** If `true`: base features are locked (default `true`, platform convention). */
+    nonRegressive?: boolean;
+}
+interface UsePlanEditorResult {
+    /** Feature keys currently selected in the draft (Set for O(1) lookup). */
+    selectedFeatures: Ref<Set<FeatureKey>>;
+    /** Ordered list of all catalog features with UI markers. */
+    availableFeatures: ComputedRef<FeatureRowMarkers[]>;
+    /** Tier grouping for drawer sections (CORE, ADVANCED, PRO, …). */
+    featuresByTier: ComputedRef<Array<{
+        tier: string;
+        rows: FeatureRowMarkers[];
+    }>>;
+    /** Toggle without throwing: `plannedOnly` and locked features are ignored. */
+    toggleFeature: (key: FeatureKey) => void;
+    /** Pre-save validation. Throws `PlannedOnlyFeatureError` if disallowed keys are present. */
+    validateDraft: () => void;
+    /** Snapshot of the current selection for the PATCH body. */
+    snapshot: () => FeatureKey[];
+}
+/**
+ * Plan-editor discovery + validation. The manifest provides the source of
+ * truth (catalog snapshot including the `plannedOnly` marker). The consumer
+ * builds the Vue component and uses this composable for state + filter.
+ */
+declare function usePlanEditor(manifest: AdminManifest, options?: UsePlanEditorOptions): UsePlanEditorResult;
+
+interface UsePublicBootResult {
+    boot: Ref<PublicBootResponse | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+}
+declare function usePublicBoot(options: BootLoaderOptions): UsePublicBootResult;
+
+interface UseDiscoveryOptions {
+    /**
+     * Fully qualified discovery endpoint including the app globalPrefix
+     * (`/api/admin/discovery`, `/api/v1/admin/discovery`, …). Mandatory.
+     */
+    endpoint: string;
+    http?: HttpClient;
+    /**
+     * Auth header for `Authorization: Bearer <token>`. Sent along with every
+     * request. The consumer supplies a function that pulls the current token
+     * from the auth store.
+     */
+    getAuthToken?: () => string | null;
+    /**
+     * When `true`, loads automatically on composable init. Default
+     * `false` — the consumer triggers `load()` itself (e.g. after page mount).
+     */
+    autoLoad?: boolean;
+}
+declare class DiscoveryLoadError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+interface UseDiscoveryResult {
+    snapshot: Ref<DiscoverySnapshot | null>;
+    /** ETag header of the last 200 response, or null. */
+    etag: Ref<string | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /**
+     * Loads fresh. On a cache hit (HTTP 304) `snapshot` stays unchanged,
+     * as does `etag`.
+     */
+    load: () => Promise<void>;
+    /**
+     * Discards the cache (etag = null) and loads without If-None-Match. Useful
+     * after code deploys, when a new snapshot is expected.
+     */
+    reload: () => Promise<void>;
+    /**
+     * `POST <endpoint>/rescan` — forces a fresh code scan in the backend
+     * (new `scannedAt`) and adopts the snapshot.
+     */
+    rescan: () => Promise<void>;
+}
+declare function useDiscovery(options: UseDiscoveryOptions): UseDiscoveryResult;
+
+interface UseCatalogEntriesOptions {
+    /** Admin endpoint prefix incl. globalPrefix (`/api/admin`, `/api/v1/admin`). */
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** projectKey the catalog entries are filtered against. */
+    projectKey: string;
+    autoLoad?: boolean;
+}
+declare class CatalogEntriesApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UseCatalogEntriesResult {
+    capabilities: Ref<CapabilityCatalogEntryRow[]>;
+    features: Ref<FeatureCatalogEntryRow[]>;
+    quotas: Ref<QuotaCatalogEntryRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    /** Approval transition of a feature (#20): PATCH …/features/:key/review. */
+    reviewFeature: (featureKey: string, data: ReviewCatalogEntryData) => Promise<FeatureCatalogEntryRow>;
+    /** Approval transition of a quota (#20): PATCH …/quotas/:key/review. */
+    reviewQuota: (quotaKey: string, data: ReviewCatalogEntryData) => Promise<QuotaCatalogEntryRow>;
+    setFeatureI18n: (featureKey: string, i18n: CatalogEntryI18n) => Promise<FeatureCatalogEntryRow>;
+    setQuotaI18n: (quotaKey: string, i18n: CatalogEntryI18n) => Promise<QuotaCatalogEntryRow>;
+    /** Sets the editable default-locale label/description of a feature. */
+    setFeatureBase: (featureKey: string, data: UpdateCatalogEntryBaseData) => Promise<FeatureCatalogEntryRow>;
+    /** Sets the editable default-locale label/description of a quota. */
+    setQuotaBase: (quotaKey: string, data: UpdateCatalogEntryBaseData) => Promise<QuotaCatalogEntryRow>;
+    /** Upserts the catalog entries from a discovery snapshot and reloads. */
+    syncDiscovery: (snapshot: DiscoverySnapshot) => Promise<SyncDiscoveryResult>;
+}
+declare function useCatalogEntries(options: UseCatalogEntriesOptions): UseCatalogEntriesResult;
+
+interface UseBundlesOptions {
+    /**
+     * Fully-qualified admin endpoint prefix including the app globalPrefix
+     * (`/api/admin`, `/api/v1/admin`, …). Required. The composable appends
+     * the catalog paths itself (`/catalog/bundles`).
+     */
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Required: projectKey the list is filtered against. */
+    projectKey: string;
+    /** When `true`, loads on composable init. Default `false`. */
+    autoLoad?: boolean;
+}
+declare class BundlesApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UseBundlesResult {
+    bundles: Ref<BundleRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    create: (data: CreateBundleData) => Promise<BundleRow>;
+    update: (bundleId: string, data: UpdateBundleData) => Promise<BundleRow>;
+    softDelete: (bundleId: string) => Promise<void>;
+}
+declare function useBundles(options: UseBundlesOptions): UseBundlesResult;
+interface UseBundleVersionsOptions {
+    adminEndpoint: string;
+    bundleId: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface UseBundleVersionsResult {
+    versions: Ref<BundleVersionRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    /** Returns {row, warnings} — warnings should be shown to the user as a banner. */
+    createDraft: (data: Omit<CreateBundleVersionDraftData, 'bundleId'>) => Promise<BundleVersionMutationResult>;
+    updateDraft: (versionId: string, data: UpdateBundleVersionDraftData) => Promise<BundleVersionMutationResult>;
+    publish: (versionId: string, opts?: {
+        forceRegressive?: boolean;
+        allowZeroPrice?: boolean;
+        validFrom?: string | null;
+        validUntil?: string | null;
+    }) => Promise<BundleVersionMutationResult>;
+    /**
+     * Discards a draft (`DELETE /admin/catalog/bundle-versions/:id`).
+     * Published versions cannot be discarded — the API responds
+     * with 422 `BUNDLE_VERSION_ALREADY_PUBLISHED`.
+     */
+    discardDraft: (versionId: string) => Promise<void>;
+}
+declare function useBundleVersions(options: UseBundleVersionsOptions): UseBundleVersionsResult;
+
+interface UseBundleVersionsMapOptions {
+    adminEndpoint: string;
+    /** Reactive list of bundle roots; the watcher reloads when the IDs change. */
+    bundles: Ref<BundleRow[]>;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+}
+interface UseBundleVersionsMapResult {
+    /** `bundleId → BundleVersionRow[]`. Empty list for bundles without versions. */
+    versionsByBundle: Ref<Record<string, BundleVersionRow[]>>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Forces a reload of all bundle versions. */
+    refresh: () => Promise<void>;
+    /** Refresh only a single bundle (e.g. after an inline-editor save). */
+    refreshOne: (bundleId: string) => Promise<void>;
+}
+declare function useBundleVersionsMap(options: UseBundleVersionsMapOptions): UseBundleVersionsMapResult;
+
+interface UseTenantSubscriptionBundlesOptions {
+    /** App-global API prefix incl. `/billing` (e.g. `/api/v1`). */
+    billingEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** With `true`, loads on mount. Default `false`. */
+    autoLoad?: boolean;
+}
+interface UseTenantSubscriptionBundlesResult {
+    bundles: Ref<SubscriptionBundleRecord[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    add: (data: {
+        bundleVersionId: string;
+        minimumTermMonths?: number;
+    }) => Promise<SubscriptionBundleRecord>;
+    cancel: (subscriptionBundleId: string, opts?: {
+        canceledAt?: string;
+    }) => Promise<SubscriptionBundleRecord>;
+}
+declare class TenantSubscriptionBundlesApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+declare function useTenantSubscriptionBundles(options: UseTenantSubscriptionBundlesOptions): UseTenantSubscriptionBundlesResult;
+
+interface UseBusinessTypesOptions {
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    projectKey: string;
+    autoLoad?: boolean;
+}
+declare class BusinessTypesApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UseBusinessTypesResult {
+    businessTypes: Ref<BusinessTypeRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    create: (data: CreateBusinessTypeData) => Promise<BusinessTypeRow>;
+    update: (businessTypeId: string, data: UpdateBusinessTypeData) => Promise<BusinessTypeRow>;
+    softDelete: (businessTypeId: string) => Promise<void>;
+}
+declare function useBusinessTypes(options: UseBusinessTypesOptions): UseBusinessTypesResult;
+interface UseBusinessTypeVersionsOptions {
+    adminEndpoint: string;
+    businessTypeId: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface UseBusinessTypeVersionsResult {
+    versions: Ref<BusinessTypeVersionRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    createDraft: (data: Omit<CreateBusinessTypeVersionDraftData, 'businessTypeId'>) => Promise<BusinessTypeVersionMutationResult>;
+    updateDraft: (versionId: string, data: UpdateBusinessTypeVersionDraftData) => Promise<BusinessTypeVersionMutationResult>;
+    publish: (versionId: string, opts?: {
+        forceRegressive?: boolean;
+    }) => Promise<BusinessTypeVersionMutationResult>;
+}
+declare function useBusinessTypeVersions(options: UseBusinessTypeVersionsOptions): UseBusinessTypeVersionsResult;
+
+interface UseMarketingProjectionsOptions {
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Filter that is active on `load()`. Can be changed via `setFilter()`. */
+    filter: MarketingProjectionFilter;
+    autoLoad?: boolean;
+}
+declare class MarketingProjectionsApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UseMarketingProjectionsResult {
+    projections: Ref<MarketingProjectionRow[]>;
+    filter: Ref<MarketingProjectionFilter>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Changes the filter and reloads fresh. */
+    setFilter: (next: MarketingProjectionFilter) => Promise<void>;
+    load: () => Promise<void>;
+    create: (data: CreateMarketingProjectionData) => Promise<MarketingProjectionRow>;
+    update: (id: string, data: UpdateMarketingProjectionData) => Promise<MarketingProjectionRow>;
+    remove: (id: string) => Promise<void>;
+}
+declare function useMarketingProjections(options: UseMarketingProjectionsOptions): UseMarketingProjectionsResult;
+
+interface UsePromotionsOptions {
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    projectKey: string;
+    autoLoad?: boolean;
+}
+declare class PromotionsApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UsePromotionsResult {
+    promotions: Ref<PromotionRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    create: (data: CreatePromotionData) => Promise<PromotionRow>;
+    update: (id: string, data: UpdatePromotionData) => Promise<PromotionRow>;
+    remove: (id: string) => Promise<void>;
+}
+declare function usePromotions(options: UsePromotionsOptions): UsePromotionsResult;
+
+interface UsePlansOptions {
+    /**
+     * Fully-qualified admin endpoint prefix incl. the app globalPrefix
+     * (`/api/admin`, `/api/v1/admin`, …). Required.
+     */
+    adminEndpoint: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    /** Required: projectKey the list is filtered against. */
+    projectKey: string;
+    /** With `true`, loads on composable init. Default `false`. */
+    autoLoad?: boolean;
+}
+declare class PlansApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string);
+}
+interface UsePlansResult {
+    plans: Ref<PlanRow[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /**
+     * planKey → number of active (ACTIVE/TRIAL) subscriptions, across
+     * versions and tenants. Plans without a subscription are absent from the
+     * map (default 0 on read). Populated by `loadTenantCounts()`.
+     */
+    tenantCountsByPlanKey: Ref<Record<string, number>>;
+    load: () => Promise<void>;
+    /**
+     * Loads the platform-wide tenant counters
+     * (`GET /admin/catalog/plans/tenant-counts?projectKey=…`) and writes them
+     * into `tenantCountsByPlanKey`. Best-effort: errors are swallowed
+     * (empty map), since the counters are only decorative in the plan overview.
+     */
+    loadTenantCounts: () => Promise<void>;
+    create: (data: CreatePlanData) => Promise<PlanRow>;
+    update: (planId: string, data: UpdatePlanData) => Promise<PlanRow>;
+    softDelete: (planId: string) => Promise<void>;
+    /**
+     * Hard delete (`DELETE /admin/catalog/plans/:id/purge`). Only allowed
+     * for plans without PlanVersions — otherwise the backend responds with
+     * 422 `PLAN_HAS_VERSIONS`. Also removes the plan from `plans`.
+     */
+    hardDelete: (planId: string) => Promise<void>;
+}
+declare function usePlans(options: UsePlansOptions): UsePlansResult;
+interface UsePlanVersionsOptions {
+    adminEndpoint: string;
+    /** UUID of the plan root (Plan.id), not the planKey. */
+    planId: string;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+    autoLoad?: boolean;
+}
+interface UsePlanVersionsResult {
+    versions: Ref<PlanVersionRow$1[]>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    load: () => Promise<void>;
+    /**
+     * The caller does not need to set `data.planId` — it comes from the
+     * composable options (`adminEndpoint/catalog/plans/:id/versions`).
+     */
+    createDraft: (data: Omit<CreatePlanVersionDraftData, 'planId'>) => Promise<PlanVersionMutationResult>;
+    updateDraft: (versionId: string, data: UpdatePlanVersionDraftData) => Promise<PlanVersionMutationResult>;
+    publish: (versionId: string, opts?: {
+        forceRegressive?: boolean;
+        allowZeroPrice?: boolean;
+        validFrom?: string | null;
+        validUntil?: string | null;
+    }) => Promise<PlanVersionMutationResult>;
+    /**
+     * Discards a draft (`DELETE /admin/catalog/plan-versions/:id`).
+     * Published versions cannot be discarded — the API responds with
+     * 422 and code `PLAN_VERSION_ALREADY_PUBLISHED`.
+     */
+    discardDraft: (versionId: string) => Promise<void>;
+    /**
+     * Terminates a live PlanVersion with `endsAt` (without a successor
+     * version). Idempotent — a second call with a different date overwrites.
+     */
+    terminateVersion: (versionId: string, endsAt: string) => Promise<PlanVersionRow$1>;
+}
+declare function usePlanVersions(options: UsePlanVersionsOptions): UsePlanVersionsResult;
+
+interface UseLivePlanVersionsOptions {
+    adminEndpoint: string;
+    /** Reactive list of plan stems — the watcher reloads when the list changes. */
+    plans: Ref<PlanRow[]>;
+    http?: HttpClient;
+    getAuthToken?: () => string | null;
+}
+interface UseLivePlanVersionsResult {
+    /** `planKey → live PlanVersion` (or null when the plan has no live version). */
+    livePlanVersions: Ref<Record<string, PlanVersionRow$1 | null>>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Forces a reload of all live versions. */
+    refresh: () => Promise<void>;
+}
+declare function useLivePlanVersions(options: UseLivePlanVersionsOptions): UseLivePlanVersionsResult;
+
+interface UseManifestResult {
+    manifest: Ref<AdminManifest | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Loads once (or returns the cache); does not abort on re-call. */
+    load: () => Promise<void>;
+    /** Discards the cache and loads fresh (e.g. after manifest/reload). */
+    reload: () => Promise<void>;
+    /** Clears the cache — e.g. on logout. */
+    clearCache: () => void;
+}
+declare function useManifest(options: ManifestLoaderOptions): UseManifestResult;
+
+interface UseNavResult {
+    /** List of all routes available via the manifest — filtered by capabilities. */
+    routes: ComputedRef<BuildRouteEntry[]>;
+    /** Drawer items, grouped by navSection. */
+    sidebar: ComputedRef<SidebarSection[]>;
+}
+declare function useNav(manifest: Ref<AdminManifest | null>, options?: NavBuilderOptions): UseNavResult;
+
+interface UseActionsResult {
+    registry: ComputedRef<ActionRegistry | null>;
+}
+declare function useActions(manifest: Ref<AdminManifest | null>, actions: Record<string, ActionHandler>): UseActionsResult;
+
+/**
+ * Input the app-side handler receives. `mfaCode` is populated when
+ * `def.requiresMfa === true` AND the provider supplies a code.
+ * `reason` comes from the confirm provider (typed-slug / typed-production
+ * typically confirm a slug entry as a safety check).
+ */
+interface TenantActionInput<TRow extends TenantDto = TenantDto> {
+    row: TRow;
+    mfaCode: string | null;
+    reason: string | null;
+    /**
+     * App-specific extra inputs that the confirm provider captures and
+     * passes through to the handler (e.g. `until` for `pilots.extend` with
+     * `confirmType: 'date'`). If the confirm provider supplies no `extras`,
+     * this is an empty object.
+     */
+    extras: Record<string, unknown>;
+}
+/** Provider contract for UI dialogs — apps supply the Quasar/headless implementation. */
+interface TenantActionFlowProviders<TRow extends TenantDto = TenantDto> {
+    /**
+     * App-specific confirm UI. Invoked when `def.confirmType !== 'none'`.
+     * Returns `{ ok: false }` when the user cancels. Optionally `extras`
+     * may be returned — that ends up in the handler's
+     * `TenantActionInput.extras` (e.g. `{ until: ISO }` for
+     * `confirmType: 'date'`).
+     */
+    confirm?: (def: TenantActionDef, ctx: {
+        row: TRow;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string | null;
+        extras?: Record<string, unknown>;
+    }>;
+    /**
+     * App-specific MFA UI. Invoked when `def.requiresMfa`. Returns `null`
+     * when the user cancels. Otherwise the TOTP code that must be attached
+     * to the backend via the `X-Mfa-Code` header.
+     */
+    mfa?: (def: TenantActionDef, ctx: {
+        row: TRow;
+    }) => Promise<string | null>;
+    /** Optional: success/error notify (toast/snackbar). */
+    notify?: (kind: 'positive' | 'negative', message: string) => void;
+    /** Optional: hook after a successful dispatch (e.g. reload the list). */
+    onSuccess?: (def: TenantActionDef, ctx: {
+        row: TRow;
+    }) => void;
+    /**
+     * Optional: row-specific visibility. Evaluated after the capability and
+     * handler checks — `false` hides the action for this row (e.g.
+     * `tenants.suspend` only for active tenants).
+     * Default: `true` (do not hide).
+     */
+    visibleForRow?: (def: TenantActionDef, row: TRow) => boolean;
+}
+interface ResolvedTenantAction<TRow extends TenantDto = TenantDto> {
+    def: TenantActionDef;
+    /**
+     * Starts the flow: confirm → MFA → handler. Returns the handler result
+     * or `undefined` when the user cancelled the flow.
+     */
+    invoke: (row: TRow) => Promise<unknown>;
+}
+interface UseTenantActionFlowResult<TRow extends TenantDto = TenantDto> {
+    registry: ComputedRef<ActionRegistry | null>;
+    /**
+     * Row-independent action list, filtered by **static** criteria:
+     *   1. Capability gate: `requiredCapability` must not be explicitly
+     *      `false` in the manifest.
+     *   2. Handler gate: for every `actionKey` a handler must be registered
+     *      in the `actions:` map (otherwise a ghost button).
+     *
+     * `visibleForRow` is NOT evaluated here — the list is the basis from
+     * which pages derive their action descriptors. Row-specific visibility
+     * only comes in via `actionsForRow(row)` or via the `condition()` of the
+     * platform page buttons.
+     *
+     * This makes sample-row-based UI constructions work again: a page can
+     * walk `availableActions.value` and prepare buttons without
+     * `tenants.reactivate` disappearing for `isActive: true` sample rows.
+     */
+    availableActions: ComputedRef<TenantActionDef[]>;
+    /**
+     * Returns the actions visible for `row`. In addition to the
+     * capability/handler checks (see `availableActions`), it runs the
+     * `visibleForRow` provider — i.e. everything that depends on the row
+     * (e.g. `tenants.suspend` only for active tenants).
+     */
+    actionsForRow: (row: TRow) => ResolvedTenantAction<TRow>[];
+    /** Drift diagnostics: declared actions without a registered handler. */
+    orphanedDefs: ComputedRef<string[]>;
+}
+/**
+ * Vue composable. Uses:
+ *   1. `useSuperAdminActions()` as the source of the handler map (the app
+ *      supplies it via `createSuperAdminApp({ actions: { [actionKey]: handler } })`).
+ *   2. The provided manifest ref, to react to manifest reloads.
+ *
+ * Returns an `actionsForRow(row)` function that is rendered directly in the
+ * page inside `<button v-for="...">`. The `invoke` call orchestrates
+ * confirm + MFA + dispatch automatically.
+ */
+declare function useTenantActionFlow<TRow extends TenantDto = TenantDto>(manifest: Ref<AdminManifest | null>, providers?: TenantActionFlowProviders<TRow>): UseTenantActionFlowResult<TRow>;
+
+type TenantRowLike = TenantDto & Record<string, unknown>;
+interface PlatformTenantActionTone {
+    tone: 'positive' | 'negative' | 'primary' | 'warning' | 'accent';
+}
+interface PlatformTenantActionRow<TRow extends TenantRowLike> {
+    id: string;
+    label: string;
+    icon: string;
+    tone: PlatformTenantActionTone['tone'];
+    actionKey: string;
+    condition: (row: TRow) => boolean;
+    handler: (row: TRow) => void;
+}
+interface PlatformTenantActionsOptions<TRow extends TenantRowLike> {
+    /** Reactive manifest source — usually `storeToRefs(useManifestStore()).manifest`. */
+    manifest: Ref<AdminManifest | null>;
+    /** Notify provider (toast/snackbar). */
+    notify: (kind: 'positive' | 'negative', message: string) => void;
+    /** Success hook after a successful dispatch (e.g. reload the list). */
+    onSuccess: () => Promise<void> | void;
+    /** Row-specific visibility. Default: suspend only for active, reactivate only for inactive tenants. */
+    visibleForRow?: (def: TenantActionDef, row: TRow) => boolean;
+    /** MFA dialog description. Default: `"{def.label} — Tenant „{row.name}". TOTP-Code aus Authenticator eingeben."`. */
+    mfaDescription?: (def: TenantActionDef, row: TRow) => string;
+    /** Manifest action → icon. Default: suspend→block, reactivate→play_arrow, grant→star, revoke→star_outline, impersonate→switch_account, export→download, otherwise→bolt. */
+    iconForActionKey?: (actionKey: string) => string;
+    /** Manifest action → tone. Default: suspend/revoke→negative, reactivate/grant→positive, otherwise→primary. */
+    toneForActionKey?: (actionKey: string) => PlatformTenantActionTone['tone'];
+}
+interface MfaDialogState {
+    show: boolean;
+    description: string;
+    error: string;
+}
+interface ConfirmDialogState<TRow extends TenantRowLike> {
+    show: boolean;
+    def: TenantActionDef | null;
+    row: TRow | null;
+}
+interface PlatformTenantActionsResult<TRow extends TenantRowLike> {
+    /** Reactive list of fully configured row actions — pass straight to the page action renderer. */
+    manifestActions: ComputedRef<PlatformTenantActionRow<TRow>[]>;
+    /** Manifest drift: declared actions without a handler (Capability=false filtered out). */
+    realOrphans: ComputedRef<string[]>;
+    mfa: Ref<MfaDialogState>;
+    onMfaConfirm: (code: string) => void;
+    onMfaDialogVisibility: (open: boolean) => void;
+    confirmDialog: Ref<ConfirmDialogState<TRow>>;
+    onConfirmSubmit: (payload: {
+        reason: string | null;
+        extras?: Record<string, unknown>;
+    }) => void;
+    onConfirmCancel: () => void;
+    onConfirmDialogVisibility: (open: boolean) => void;
+}
+/**
+ * Default helper for apps that want to override `iconForActionKey`
+ * themselves but use the platform defaults as a fallback.
+ */
+declare function defaultIconForActionKey(actionKey: string): string;
+/**
+ * Default helper for apps that want to override `toneForActionKey`
+ * themselves but use the platform defaults as a fallback.
+ */
+declare function defaultToneForActionKey(actionKey: string): PlatformTenantActionTone['tone'];
+declare function usePlatformTenantActions<TRow extends TenantRowLike>(options: PlatformTenantActionsOptions<TRow>): PlatformTenantActionsResult<TRow>;
+
+interface UseBatchColumnsResult {
+    /** Data per column key (`columnKey → tenantId → value`). */
+    data: Ref<BatchColumnData>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    /** Manual re-fetch (e.g. after a mutation). */
+    reload: () => Promise<void>;
+}
+declare function useBatchColumns(manifest: Ref<AdminManifest | null>, tenantIds: Ref<string[]>, options?: BatchColumnFetcherOptions): UseBatchColumnsResult;
+
+type SnapshotKind = 'drafts' | 'active' | 'historical';
+interface CatalogSnapshot<P extends PlanVersionRow$1 = PlanVersionRow$1> {
+    id: string;
+    kind: SnapshotKind;
+    status: 'DRAFT' | 'ACTIVE' | 'ARCHIVED';
+    label: string;
+    title: string;
+    description: string;
+    asOf: string | null;
+    createdAt: string | null;
+    publishedAt: string | null;
+    authorEmail: string | null;
+    plans: ResolvedPlan<P>[];
+    /** Number of open drafts for the `drafts` snapshot, otherwise 0. */
+    draftCount: number;
+    /** Number of entities in this snapshot whose publication flagged at least
+     *  one regression (`nonRegressive === false`). */
+    regressionCount: number;
+}
+interface ResolvedPlan<P extends PlanVersionRow$1 = PlanVersionRow$1> {
+    /** Which PlanVersionRow was selected to represent this slot. */
+    source: P;
+    /** Live predecessor (only set when `source` is a DRAFT; otherwise null). */
+    liveBase: P | null;
+    isDraft: boolean;
+    planId: string;
+    features: string[];
+    /** Quota map (from `source.quotas` or legacy fields; empty if none). */
+    quotas: Record<string, number>;
+    monthlyNet: number;
+    yearlyNet: number;
+    marketed: boolean;
+    version: number;
+    /** @deprecated Read from `quotas['users']`. */
+    maxUsers?: number;
+    /** @deprecated Legacy field; read from `quotas['vehicles']`. */
+    maxVehicles?: number;
+    /** @deprecated Read from `quotas['storageGb']`. */
+    maxStorageGb?: number;
+}
+interface RawCatalogData<P extends PlanVersionRow$1 = PlanVersionRow$1> {
+    planVersions: P[];
+}
+interface BuildSnapshotsOptions {
+    /**
+     * App-specific plan order, e.g. `['BASIC', 'STANDARD',
+     * 'PROFESSIONAL', 'BUSINESS', 'ENTERPRISE']`. Plan IDs outside the list
+     * end up sorted alphabetically at the back.
+     */
+    planSortOrder?: readonly string[];
+}
+declare function buildSnapshots<P extends PlanVersionRow$1>(data: RawCatalogData<P>, options?: BuildSnapshotsOptions): CatalogSnapshot<P>[];
+declare function listOpenDrafts<P extends PlanVersionRow$1>(data: RawCatalogData<P>): {
+    plans: P[];
+};
+
+interface PilotCreatePayload {
+    tenant: {
+        name: string;
+        slug?: string;
+        legalForm?: string;
+        vatId?: string;
+    };
+    admin: {
+        email: string;
+        firstName: string;
+        lastName: string;
+        initialPassword?: string;
+    };
+    pilot: {
+        plan: string;
+        note?: string;
+        endsAt?: string;
+    };
+}
+interface PilotCreateResult {
+    slug: string;
+    /** If the server generated an initial password, include it here. */
+    initialPassword?: string;
+}
+/** Edit an existing pilot subscription (plan, end date, note). */
+interface PilotEditPayload {
+    /** Optional — only the fields that are set get changed. */
+    plan?: string;
+    /** `null` clears the end date (open-ended pilot phase). */
+    endsAt?: string | null;
+    /** `null` or empty clears the note. */
+    note?: string | null;
+}
+interface PilotEditResult {
+    slug: string;
+    changed?: string[];
+}
+/**
+ * Tenant-specific vocabulary for the pilot dialogs. The platform
+ * provides neutral defaults ("Mandant"); consumers override with
+ * their domain language (e.g. "Verein" or "Händler").
+ */
+interface PilotCopy {
+    /** Subtitle of the tenant section in the create dialog. */
+    tenantSubtitle?: string;
+    /** Label of the name field, e.g. "Vereinsname" / "Firmenname". */
+    tenantNameLabel?: string;
+    /** Placeholder for the tenant name. */
+    tenantNamePlaceholder?: string;
+    /** Placeholder for the slug. */
+    slugPlaceholder?: string;
+    /** Placeholder for the initial admin email. */
+    adminEmailPlaceholder?: string;
+    /** Placeholder for the internal note (create + edit). */
+    notePlaceholder?: string;
+}
+/** Neutral, tenant-agnostic defaults for {@link PilotCopy}. */
+declare const DEFAULT_PILOT_COPY: Required<PilotCopy>;
+type PromoCodeValueType = 'PERCENT' | 'ABSOLUTE';
+type PromoCodeDurationType = 'ONCE' | 'MONTHS' | 'BILLING_CYCLES';
+interface PromoCodeCreatePayload {
+    code: string;
+    valueType: PromoCodeValueType;
+    value: number;
+    durationType: PromoCodeDurationType;
+    durationValue: number | null;
+    maxRedemptions: number | null;
+    validFrom: string | null;
+    validUntil: string | null;
+    /** Plan keys the code applies to. Empty = all plans. */
+    appliesToPlans?: string[];
+    /** Optional: filter on MONTHLY/YEARLY subscriptions. */
+    appliesToBilling?: 'MONTHLY' | 'YEARLY';
+    /** Only redeemable by new customers. */
+    firstTimeCustomersOnly?: boolean;
+    /** Minimum gross plan amount from which the code takes effect. */
+    minimumPlanAmountGross?: number;
+    /** Allows €0 invoices (otherwise the discount is capped at 100% of the amount). */
+    allowZeroInvoice?: boolean;
+    /** Ledger account for discount revenue reduction (app-specific). */
+    revenueDeductionAccount?: string;
+    campaignTag?: string;
+    description?: string;
+}
+/** Plan option for the plan picker in PromoCodeCreateDialog. */
+interface PromoCodePlanOption {
+    /** Plan key as sent to the backend (e.g. 'BASIC'). */
+    key: string;
+    /** Display label (e.g. 'Basic'). */
+    label: string;
+    /** Optional accent for the plan chip; fallback neutral gray. */
+    color?: string;
+}
+/**
+ * PATCH payload — all fields optional, only the explicitly set ones
+ * are sent to the backend (whitelist on the server side). `code` is
+ * not in the list because it stays stable after creation.
+ */
+interface PromoCodeUpdatePayload {
+    status?: 'ACTIVE' | 'PAUSED';
+    valueType?: PromoCodeValueType;
+    value?: number;
+    durationType?: PromoCodeDurationType;
+    durationValue?: number | null;
+    maxRedemptions?: number | null;
+    validFrom?: string | null;
+    validUntil?: string | null;
+    appliesToPlans?: string[];
+    appliesToBilling?: 'MONTHLY' | 'YEARLY' | null;
+    firstTimeCustomersOnly?: boolean;
+    minimumPlanAmountGross?: number | null;
+    allowZeroInvoice?: boolean;
+    description?: string | null;
+    campaignTag?: string | null;
+    revenueDeductionAccount?: string | null;
+}
+
+declare const CATALOG_DEFAULT_LOCALE = "de";
+/** Display mapping per feature key (compatible with `FeatureMeta`). */
+interface FeatureRegistryEntry {
+    label?: string;
+    group?: string;
+    core?: boolean;
+}
+/** Display mapping per quota key. */
+interface QuotaMeta {
+    label?: string;
+    unit?: string;
+}
+/**
+ * Builds the `featureRegistry` for the bundle editors from the feature catalog
+ * entries. Keys without a resolvable label are omitted — the editor then falls
+ * back to the feature key.
+ */
+declare function buildFeatureRegistry(featureCatalog: FeatureCatalogEntryRow[], locale: string): Record<string, FeatureRegistryEntry>;
+/**
+ * Builds the `quotaRegistry` for the bundle editors from the quota catalog
+ * entries. Label and unit are resolved independently; if a translation is
+ * missing, the editor falls back to the Discovery value or the quota key.
+ */
+declare function buildQuotaRegistry(quotaCatalog: QuotaCatalogEntryRow[], locale: string): Record<string, QuotaMeta>;
+
+interface PlatformEmailProvider {
+    id: string;
+    name: string;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser: string;
+    encryption: string;
+    autoTls?: boolean;
+    fromEmail: string;
+    fromName?: string | null;
+    isDefault: boolean;
+    active: boolean;
+    [extra: string]: unknown;
+}
+interface PlatformEmailWriteInput {
+    name: string;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser: string;
+    smtpPassword?: string;
+    encryption: string;
+    fromEmail: string;
+    fromName?: string;
+    active?: boolean;
+}
+interface PlatformEmailTestInput {
+    toEmail: string;
+    subject?: string;
+}
+interface PlatformEmailTestResult {
+    success: boolean;
+    message: string;
+}
+
+type EmailHistoryStatus = 'PENDING' | 'SENT' | 'FAILED' | 'BOUNCED';
+/** List projection — deliberately without body (loaded only in the detail view). */
+interface EmailHistoryRow {
+    id: string;
+    fromEmail: string;
+    toEmail: string;
+    subject: string;
+    status: EmailHistoryStatus;
+    sentAt?: string | null;
+    createdAt: string;
+}
+/** Complete entry including content, headers, SMTP response and errors. */
+interface EmailHistoryDetail extends EmailHistoryRow {
+    ccEmail?: string | null;
+    bccEmail?: string | null;
+    bodyHtml?: string | null;
+    bodyText?: string | null;
+    errorMessage?: string | null;
+    smtpResponse?: string | null;
+}
+/** Search/filter/pagination input — field names as in the backend (QueryEmailLogDto). */
+interface EmailHistoryFilter {
+    search?: string;
+    status?: EmailHistoryStatus;
+    from?: string;
+    to?: string;
+    page?: number;
+    limit?: number;
+}
+interface EmailHistoryListResult {
+    rows: EmailHistoryRow[];
+    total: number;
+}
+interface EmailHistoryResendResult {
+    success: boolean;
+    message?: string;
+}
+
+/**
+ * App-specific branding data that the platform `AdminLayout` and other
+ * consumers read via `useSuperAdminBrand()`.
+ */
+interface SuperAdminBrand {
+    /** 2-letter abbreviation in the logo badge (`'ma'`, `'da'`, …). */
+    logoText: string;
+    /** Full display name (`'DemoApp'`, `'ClubApp'`, …). */
+    name: string;
+    /** Optional: tag to the right of the name, default `'SuperAdmin'`. */
+    tag?: string;
+}
+/**
+ * Endpoint configuration. `apiBase` is the shared prefix under which
+ * `/manifest`, `/boot` and extra routes live.
+ */
+interface SuperAdminEndpoints {
+    /** Shared prefix, e.g. `'/api/admin'` or `'/api/v1/admin'`. */
+    apiBase: string;
+    /** Pre-login branding endpoint, default `${apiBase}/boot`. */
+    publicBootEndpoint?: string;
+    /** Post-login full-manifest endpoint, default `${apiBase}/manifest`. */
+    manifestEndpoint?: string;
+}
+type ExtensionLoader = () => Promise<Component | {
+    default: Component;
+}>;
+type ExtensionsMap = Record<ComponentKey, ExtensionLoader>;
+type ActionsMap = Record<ActionKey, ActionHandler>;
+interface SuperAdminAuthGuardOptions {
+    /** App provides: is the user currently logged in? */
+    isAuthenticated: () => boolean;
+    /** App provides: does the user have the SuperAdmin role? Default: only check `isAuthenticated`. */
+    isSuperAdmin?: () => boolean;
+    /** App provides: redirect path for unauthenticated calls (e.g. `'/login'`). */
+    onUnauthenticated: () => string;
+}
+/**
+ * Result of a login attempt. Apps pass this back from their auth store to the
+ * platform LoginPage; the page renders an appropriate error message.
+ *
+ * `ok: true` → login succeeded, page redirects to `redirectAfterLogin`.
+ * `ok: false` → page shows `message` or a translation derived from `code`.
+ *
+ * Known codes:
+ *   - `BAD_CREDENTIALS` — wrong email/password combination.
+ *   - `NOT_SUPER_ADMIN` — account does not have the SuperAdmin role.
+ *   - otherwise          — app-specific; `message` is displayed directly.
+ */
+type SuperAdminLoginResult = {
+    ok: true;
+} | {
+    ok: false;
+    code?: 'BAD_CREDENTIALS' | 'NOT_SUPER_ADMIN' | string;
+    message?: string;
+};
+/**
+ * Login adapter. The app passes its auth-store call through here. The platform
+ * LoginPage consumes it via `useSuperAdminLoginAdapter()`, without knowledge
+ * of app-specific stores (Pinia, auth API routes, MFA hooks).
+ */
+interface SuperAdminLoginAdapter {
+    /**
+     * Performs the login. The app store encapsulates the API call, token
+     * storage, MFA hops etc.
+     */
+    login(email: string, password: string): Promise<SuperAdminLoginResult>;
+    /**
+     * Target route after a successful login. Default: `/admin/dashboard`
+     * (platform convention for the standard pages — apps with a different
+     * default mount override this here).
+     */
+    redirectAfterLogin?: string;
+    /**
+     * Optional: dev hint (test account), shown below the form. Deliberately
+     * rendered only when `environment !== 'production'`.
+     */
+    devHint?: {
+        email: string;
+        password: string;
+    };
+}
+interface SuperAdminManifestGuardOptions {
+    /**
+     * App provides: loads the manifest into the app store. The router guard
+     * `await`s the promise before the route is resolved.
+     *
+     * **On loader error:** the promise REJECTS. The router guard catches the
+     * rejection and decides depending on `errorRoute`:
+     *   - `errorRoute` set → redirect to this route (fail-closed).
+     *   - `errorRoute` not set → `console.error` + render allowed
+     *     (defensive default behavior; the app must render the manifest gap
+     *     itself).
+     */
+    ensureLoaded: () => Promise<void>;
+    /**
+     * Optional: read accessor on the loaded manifest. When set, it is exposed
+     * via `provide(SUPER_ADMIN_MANIFEST_KEY)` — the `<ProjectPageHost>`
+     * resolves manifest `projectPages` through it against the
+     * `extensions:` map.
+     */
+    getManifest?: () => AdminManifest | null;
+    /**
+     * Optional: path that the router guard redirects to on a manifest load
+     * error (fail-closed mode). The app must register the route in `appRoutes`
+     * and mark it as `meta.public = true`, otherwise it runs through the
+     * manifest guard again and produces a redirect loop.
+     */
+    errorRoute?: string;
+}
+interface CreateSuperAdminAppOptions {
+    /** App root component (`App.vue`). */
+    rootComponent: Component;
+    /** App branding (logo, name). */
+    brand: SuperAdminBrand;
+    /** Endpoint configuration. */
+    endpoints: SuperAdminEndpoints;
+    /** App's own routes (login, standard pages, bundle pages, …). */
+    appRoutes: RouteRecordRaw[];
+    /**
+     * Static `extensions:` map. Manifest `projectPages[].componentKey` is
+     * looked up in it (see Spec §4.4).
+     */
+    extensions?: ExtensionsMap;
+    /**
+     * Static `actions:` map. Manifest `tenants.actions[].actionKey` is looked
+     * up in it.
+     */
+    actions?: ActionsMap;
+    /**
+     * Optional: auth guard. When set, `router.beforeEach` is wired up
+     * automatically — `to.meta.public === true` bypasses the guard.
+     */
+    authGuard?: SuperAdminAuthGuardOptions;
+    /**
+     * Optional: manifest guard. Runs after a successful auth guard, blocks the
+     * render until the manifest is loaded (prevents sidebar flicker).
+     */
+    manifestGuard?: SuperAdminManifestGuardOptions;
+    /**
+     * Optional: login adapter. When set, it is exposed via `provide()` for the
+     * shared `<SuperAdminLoginPage>` (from `pages-standard/`) — the app no
+     * longer needs to hold its own LoginPage Vue component.
+     */
+    loginAdapter?: SuperAdminLoginAdapter;
+    /**
+     * Optional: router history variant, default `createWebHistory()`.
+     * Apps with a subpath mount override this.
+     */
+    routerHistory?: RouterHistory;
+    /**
+     * Optional: Quasar configuration. Default loads `Notify`/`Dialog`/`Loading`
+     * with the established consumer convention (`top-right`, 3 s).
+     */
+    quasarOptions?: Partial<QuasarPluginOptions>;
+    /**
+     * Optional: additional Vue plugins (e.g. an app's own NotificationCenter)
+     * that are installed after the platform setup, before the mount.
+     */
+    installPlugins?: Array<(app: App) => void>;
+    /**
+     * Optional: `HttpClient` for all pre-login calls (boot, first-run setup).
+     * Default `defaultHttpClient()` (= `fetch`). Consumers pass their own
+     * variant through (auth header, baseURL, retry) — it then applies uniformly,
+     * including for the setup wizard. Consumed via `useSuperAdminHttp()`.
+     */
+    http?: HttpClient;
+}
+interface SuperAdminAppHandle {
+    app: App;
+    router: Router;
+    pinia: Pinia;
+    /** Mounts the app on a selector. Returns the root component instance. */
+    mount: (selector: string | Element) => ReturnType<App['mount']>;
+}
+/** Vue inject key for `useSuperAdminBrand()`. */
+declare const SUPER_ADMIN_BRAND_KEY: InjectionKey<SuperAdminBrand>;
+/** Vue inject key for `useSuperAdminEndpoints()`. */
+declare const SUPER_ADMIN_ENDPOINTS_KEY: InjectionKey<Required<SuperAdminEndpoints>>;
+/** Vue inject key for `useSuperAdminExtensions()`. */
+declare const SUPER_ADMIN_EXTENSIONS_KEY: InjectionKey<ExtensionsMap>;
+/** Vue inject key for `useSuperAdminActions()`. */
+declare const SUPER_ADMIN_ACTIONS_KEY: InjectionKey<ActionsMap>;
+/**
+ * Vue inject key for the manifest accessor. Only provided when
+ * `manifestGuard.getManifest` was passed to `createSuperAdminApp()` — the
+ * `<ProjectPageHost>` needs it to resolve project pages.
+ */
+declare const SUPER_ADMIN_MANIFEST_KEY: InjectionKey<() => AdminManifest | null>;
+/** Vue inject key for `useSuperAdminLoginAdapter()`. */
+declare const SUPER_ADMIN_LOGIN_ADAPTER_KEY: InjectionKey<SuperAdminLoginAdapter>;
+/** Vue inject key for `useSuperAdminHttp()` (pre-login HttpClient). */
+declare const SUPER_ADMIN_HTTP_KEY: InjectionKey<HttpClient>;
+/**
+ * Universal bootstrap function for SuperAdmin apps. Replaces the `main.ts`
+ * boilerplate duplicated per app today (Quasar + Pinia + Router + manifest
+ * guard) and exposes the platform maps via `provide()` for downstream
+ * components.
+ */
+declare function createSuperAdminApp(options: CreateSuperAdminAppOptions): SuperAdminAppHandle;
+/**
+ * Internal helper, exported for isolated unit tests of the navigation
+ * behavior (auth redirect, manifest fail-closed path). Consumers should call
+ * `createSuperAdminApp()`, not this helper directly.
+ */
+declare function buildNavigationGuard(options: Pick<CreateSuperAdminAppOptions, 'authGuard' | 'manifestGuard'>): NavigationGuardWithThis<undefined> | null;
+
+/** Returns the `extensions:` map registered in `createSuperAdminApp()`. */
+declare function useSuperAdminExtensions(): ExtensionsMap;
+/** Returns the `actions:` map registered in `createSuperAdminApp()`. */
+declare function useSuperAdminActions(): ActionsMap;
+/**
+ * Returns the app branding. Throws when the component is rendered outside a
+ * `createSuperAdminApp()` shell — that is a setup bug, not a runtime
+ * problem.
+ */
+declare function useSuperAdminBrand(): SuperAdminBrand;
+/** Returns the app endpoints (apiBase, publicBootEndpoint, manifestEndpoint). */
+declare function useSuperAdminEndpoints(): Required<SuperAdminEndpoints>;
+/**
+ * Returns the manifest accessor that was provided via
+ * `createSuperAdminApp({ manifestGuard: { getManifest } })`.
+ * Returns `null` if the app did not pass an accessor — components
+ * (e.g. `<ProjectPageHost>`) must handle the null case cleanly, because
+ * the accessor is optional.
+ */
+declare function useSuperAdminManifest(): AdminManifest | null;
+/**
+ * Returns the login adapter the app registered via
+ * `createSuperAdminApp({ loginAdapter })`. Throws when none was
+ * set — the shared `<SuperAdminLoginPage>` needs it.
+ */
+declare function useSuperAdminLoginAdapter(): SuperAdminLoginAdapter;
+/**
+ * Returns the pre-login `HttpClient` (boot, first-run setup) the app registered
+ * via `createSuperAdminApp({ http })`. Falls back to `defaultHttpClient()`
+ * if none was provided (e.g. in isolated tests).
+ */
+declare function useSuperAdminHttp(): HttpClient;
+
+interface CreatePlatformLoadersOptions {
+    /**
+     * Same endpoint configuration as for `createSuperAdminApp()`.
+     * `publicBootEndpoint` / `manifestEndpoint` are derived from `apiBase`
+     * when not set explicitly.
+     */
+    endpoints: SuperAdminEndpoints;
+    /** HTTP adapter. App-specific, because auth-header / base-URL conventions vary. */
+    http: HttpClient;
+    /** Storage for the `ManifestLoader` ETag cache. Defaults to `defaultKvStore()`. */
+    storage?: KvStore;
+    /**
+     * Storage key prefix — consumers with multiple apps under one domain
+     * set this to e.g. `'ma:'` or `'da:'` so the caches stay separate.
+     * Only forwarded to the `ManifestLoader`.
+     */
+    storageKeyPrefix?: string;
+    /** Auth-token provider for `Authorization: Bearer …` (ManifestLoader only). */
+    getAuthToken?: () => string | null;
+}
+interface PlatformLoaders {
+    bootLoader: BootLoader;
+    manifestLoader: ManifestLoader;
+}
+/**
+ * Builds `BootLoader` + `ManifestLoader` from a single endpoint constant.
+ * Apps use the same constant for `createSuperAdminApp({ endpoints })`.
+ */
+declare function createPlatformLoaders(options: CreatePlatformLoadersOptions): PlatformLoaders;
+
+declare const ProjectPageHost: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/**
+ * Returns a Vue Router child route that is registered as a catch-all under
+ * the app's `/admin` layout. Children defined statically in the app router
+ * (e.g. `/admin/dashboard`) win, because
+ * Vue Router 4 matches specific routes before wildcard children.
+ *
+ * Example (simplified):
+ *
+ *     {
+ *         path: '/admin',
+ *         component: AdminLayout,
+ *         children: [
+ *             { path: '', redirect: '/admin/dashboard' },
+ *             { path: 'dashboard', component: DashboardPage },
+ *             // ...more static children
+ *             createProjectPageHostRoute(),
+ *         ],
+ *     }
+ */
+declare function createProjectPageHostRoute(options?: {
+    /**
+     * Path pattern of the catch-all route. Default `:projectPagePath(.+)`, so
+     * that `/admin` and `/admin/` are not swallowed by the ProjectPageHost,
+     * but the dashboard redirect child can take effect.
+     */
+    path?: string;
+}): RouteRecordRaw;
+
+interface ManifestStoreState {
+    manifest: Ref<AdminManifest | null>;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+    loaded: Ref<boolean>;
+}
+interface ManifestStoreActions {
+    /**
+     * Loads once per session. Concurrent calls share the promise.
+     *
+     * **Behavior on loader error:** the store caches the error in
+     * `error.value` and resets `loaded = false`/`manifest = null`, and the
+     * promise REJECTS with the original error. Callers must either
+     * call `.catch(...)` (defensive behavior) or let the rejection
+     * propagate. The platform router guard
+     * (`createSuperAdminApp({ manifestGuard.errorRoute })`) provides a
+     * fail-closed path with a redirect to a dedicated error route.
+     */
+    ensureLoaded: () => Promise<void>;
+    /** Discards cache + state (logout path). */
+    clearCache: () => void;
+    /** Forces a server refresh (e.g. after `manifest reload`). */
+    reload: () => Promise<void>;
+}
+interface CreateManifestStoreOptions {
+    /** Platform `ManifestLoader` instance (typically via `createPlatformLoaders()`). */
+    loader: ManifestLoader;
+    /** Pinia store ID. Default `admin-manifest`. */
+    id?: string;
+}
+type ManifestStoreDefinition = StoreDefinition<string, ManifestStoreState, Record<string, never>, ManifestStoreActions>;
+/**
+ * Returns a `useStore` function for the manifest store. Apps call the
+ * factory once at module top level and export the result as
+ * `useManifestStore`.
+ */
+declare function createManifestStore(options: CreateManifestStoreOptions): ManifestStoreDefinition;
+
+export { ADMIN_UI_VERSION, ActionDefNotInManifestError, type ActionHandler, ActionRegistry, type ActionsMap, type ApiListResponse, type BatchColumnData, BatchColumnDriftError, BatchColumnFetcher, type BatchColumnFetcherOptions, type BatchColumnRow, type BatchColumnValue, type BillingCycleStr, BootLoadError, BootLoader, type BootLoaderOptions, type BuildRouteEntry, type BuildSnapshotsOptions, type BulkItemKind, type BulkItemStatus, type BulkPublishItem, type BundleAddPreviewShape, type BundleCancelPreviewShape, type BundlePreviewIssueShape, type BundlePreviewShape, type BundlePreviewSnapshotShape, BundlesApiError, BusinessTypesApiError, CATALOG_DEFAULT_LOCALE, type CachedManifestEntry, type CatalogBundle, CatalogEntriesApiError, type CatalogPlan, type CatalogSnapshot, type ConfirmDialogState, type CreateAdminRoutesOptions, type CreateManifestStoreOptions, type CreatePlatformLoadersOptions, type CreateSuperAdminAppOptions, DEFAULT_I18N_DE, DEFAULT_PILOT_COPY, DEFAULT_SECTION_ORDER, DEFAULT_STANDARD_PAGE_ROUTES, DEFAULT_YEARLY_FACTOR, DiscoveryLoadError, type DraftPricing, ENTITLEMENT_INJECTION_KEY, type EmailHistoryDetail, type EmailHistoryFilter, type EmailHistoryListResult, type EmailHistoryResendResult, type EmailHistoryRow, type EmailHistoryStatus, type EntitlementSnapshotShape, type ExtensionLoader, type ExtensionsMap, type FeatureRegistryEntry, type FeatureRouterGuardOptions, type FeatureRowMarkers, type HttpClient, HttpJsonError, type HttpResponse, type KvStore, ManifestLoadError, ManifestLoader, type ManifestLoaderOptions, type ManifestStoreActions, type ManifestStoreDefinition, type ManifestStoreState, MarketingProjectionsApiError, type MfaDialogState, MissingHandlerError, type NavBuilderOptions, type PackageSnapshotShape, type ParamStyle, type PilotCopy, type PilotCreatePayload, type PilotCreateResult, type PilotEditPayload, type PilotEditResult, type PlanChangePreviewShape, type PlanSnapshotShape, type PlanVersionListFilter, type PlanVersionRow, PlannedOnlyFeatureError, PlansApiError, type PlatformEmailProvider, type PlatformEmailTestInput, type PlatformEmailTestResult, type PlatformEmailWriteInput, type PlatformLoaders, type PlatformTenantActionRow, type PlatformTenantActionTone, type PlatformTenantActionsOptions, type PlatformTenantActionsResult, type PriceLineItem, ProjectPageHost, type PromoCodeCreatePayload, type PromoCodeDurationType, type PromoCodePlanOption, type PromoCodeUpdatePayload, type PromoCodeValueType, type PromoState, type PromoStatus, PromotionsApiError, type QuotaMeta, type RawCatalogData, type RedundantFeatureHintShape, type ResolvedAction, type ResolvedPlan, type ResolvedTenantAction, SUPER_ADMIN_ACTIONS_KEY, SUPER_ADMIN_BRAND_KEY, SUPER_ADMIN_ENDPOINTS_KEY, SUPER_ADMIN_EXTENSIONS_KEY, SUPER_ADMIN_HTTP_KEY, SUPER_ADMIN_LOGIN_ADAPTER_KEY, SUPER_ADMIN_MANIFEST_KEY, type SidebarItem, type SidebarSection, type SnapshotKind, type SubscriptionBundleShape, type SubscriptionDraft, type SuperAdminAppHandle, type SuperAdminAuthGuardOptions, type SuperAdminBrand, type SuperAdminEndpoints, type SuperAdminLoginAdapter, type SuperAdminLoginResult, type SuperAdminManifestGuardOptions, type TenantActionFlowProviders, type TenantActionInput, type TenantManifestNavItem, type TenantManifestShape, type TenantPlanSectionI18n, type TenantRowLike, TenantSubscriptionBundlesApiError, type UsageSnapshotShape, type UseActionsResult, type UseApiListOptions, type UseApiListResult, type UseAuditEntriesOptions, type UseAuditEntriesResult, type UseBatchColumnsResult, type UseBulkPublishOptions, type UseBulkPublishResult, type UseBundleVersionsMapOptions, type UseBundleVersionsMapResult, type UseBundleVersionsOptions, type UseBundleVersionsResult, type UseBundlesOptions, type UseBundlesResult, type UseBusinessTypeVersionsOptions, type UseBusinessTypeVersionsResult, type UseBusinessTypesOptions, type UseBusinessTypesResult, type UseCatalogEntriesOptions, type UseCatalogEntriesResult, type UseDiscoveryOptions, type UseDiscoveryResult, type UseEntitlementOptions, type UseEntitlementResult, type UseLivePlanVersionsOptions, type UseLivePlanVersionsResult, type UseManifestResult, type UseMarketingProjectionsOptions, type UseMarketingProjectionsResult, type UseNavResult, type UsePlanEditorOptions, type UsePlanEditorResult, type UsePlanVersionsOptions, type UsePlanVersionsResult, type UsePlansOptions, type UsePlansResult, type UsePromotionsOptions, type UsePromotionsResult, type UsePublicBootResult, type UseSubscriptionDraftOptions, type UseTenantActionFlowResult, type UseTenantBillingCatalogOptions, type UseTenantBillingCatalogResult, type UseTenantBillingOptions, type UseTenantBillingResult, type UseTenantManifestOptions, type UseTenantManifestResult, type UseTenantSubscriptionBundlesOptions, type UseTenantSubscriptionBundlesResult, type UseTenantsOptions, type UseTenantsResult, type VersionsOptions, type VersionsResult, buildFeatureRegistry, buildFeatureRouterGuard, buildNavigationGuard, buildQuotaRegistry, buildRoutes, buildSidebar, buildSnapshots, createAdminRoutes, createManifestStore, createPlatformLoaders, createProjectPageHostRoute, createSuperAdminApp, defaultHttpClient, defaultIconForActionKey, defaultKvStore, defaultToneForActionKey, getJson, listOpenDrafts, postJson, provideEntitlement, resolveExtension, trimTrailingSlashes, useActions, useApiList, useAuditEntries, useBatchColumns, useBulkPublish, useBundleVersions, useBundleVersionsMap, useBundles, useBusinessTypeVersions, useBusinessTypes, useCatalogEntries, useDiscovery, useEntitlement, useInjectedEntitlement, useLivePlanVersions, useManifest, useMarketingProjections, useNav, usePlanEditor, usePlanVersions, usePlanVersionsCatalog, usePlans, usePlatformTenantActions, usePromotions, usePublicBoot, useSubscriptionDraft, useSuperAdminActions, useSuperAdminBrand, useSuperAdminEndpoints, useSuperAdminExtensions, useSuperAdminHttp, useSuperAdminLoginAdapter, useSuperAdminManifest, useTenantActionFlow, useTenantBilling, useTenantBillingCatalog, useTenantManifest, useTenantSubscriptionBundles, useTenants };