@navette-js/panels 1.0.0-beta.4 → 1.0.0-beta.5

package/lib/index.d.ts

@@ -1,13 +1,20 @@
+export { Throttle } from './throttle.ts';
 import { type Mailer, type MailMessage } from './auth.ts';
-export { consoleMailer, fileMailer, hashPassword, knexAuthProvider, knexTenantProvider, mailText, verifyPassword, type Mailer, type MailMessage, type TableQuery } from './auth.ts';
+export { consoleMailer, fileMailer, hashPassword, knexAuthProvider, knexTenantProvider, mailText, multiFactorAuthenticationSchema, verifyPassword, type Mailer, type MailMessage, type TableQuery } from './auth.ts';
 import { type Request, type Response, type Router } from 'express';
 import { Action } from '@navette-js/actions';
 import { Step, Wizard } from '@navette-js/forms';
 import { Component as SchemaComponent, Schema, type SchemaHost } from '@navette-js/schemas';
 export { Notification, Notifications } from './notifications.ts';
+import { MultiFactorChallenge, type MultiFactorAuthenticationProvider, type SecurityKey } from './multi-factor.ts';
+export { AppAuthentication, EmailAuthentication, EmailCodeInput, type EmailAuthenticationStore, decryptSecret, encryptSecret, MemoryCacheStore, MultiFactorChallenge, SecurityKeyAuthentication, SecurityKeyInput, useMultiFactorCacheStore, type AppAuthenticationStore, type MultiFactorAuthenticationProvider, type MultiFactorCacheStore, type SecurityKey, type SecurityKeyStore } from './multi-factor.ts';
+export { base32Decode, base32Encode, generateTotpSecret, hotp, totpCode, totpTimestep, totpUri, verifyTotp, type TotpAlgorithm, type TotpOptions } from './totp.ts';
+export { qrCodeDataUri, qrCodeMatrix, qrCodeSvg, type QrCodeSvgOptions, type QrErrorCorrection } from './qr-code.ts';
+export { authenticationOptions, decodeCbor, generateChallenge, registrationOptions, verifyAuthentication, verifyRegistration, WebAuthnError, type AuthenticationResponseJSON, type RegistrationResponseJSON, type StoredCredential, type UserVerification } from './webauthn.ts';
 export { MemorySessionStore, type SessionStore } from './session-store.ts';
-export { csvCell, csvLine, DownloadStore, ExportAction, ExportBulkAction, ExportColumn, Exporter, ImportAction, ImportColumn, Importer, parseCsv, type ExportActionInstance, type ImportActionInstance } from './import-export.ts';
-import { DownloadStore } from './import-export.ts';
+export { csvCell, csvLine, DownloadStore, ExportAction, ExportBulkAction, ExportColumn, Exporter, ImportAction, ImportColumn, Importer, importExportSchema, knexImportExportHistory, parseCsv, readSpreadsheet, runInBackground, useBackgroundRunner, type BackgroundTask, type ExportActionInstance, type ImportActionInstance, type ImportExportHistory } from './import-export.ts';
+export { buildXlsx, readXlsx } from './xlsx.ts';
+import { DownloadStore, type ImportExportHistory } from './import-export.ts';
 import { type SessionStore } from './session-store.ts';
 import { type CalendarEvent, type CalendarLabels, type CalendarView } from './calendar.ts';
 export { addDays, addMonths, CALENDAR_LABELS, dayOf, daysBetween, eventsOn, renderCalendar, renderCalendarEvent, timeOf, visibleRange, type CalendarEvent, type CalendarLabels, type CalendarModel, type CalendarView } from './calendar.ts';
@@ -77,6 +84,27 @@ export interface AuthProvider {
     getPasswordFingerprint?(user: User): MaybePromise<string>;
     /** Can this user use this panel? Checked on every request and at login (`false`: 403, or "credentials do not match" at login). */
     canAccessPanel?(user: User, panel: Panel): MaybePromise<boolean>;
+    /** Stored authenticator app secret (encrypted by Navette), or `null`. */
+    getAppAuthenticationSecret?(user: User): MaybePromise<string | null>;
+    /** Saves the secret; `null` turns app authentication off. */
+    saveAppAuthenticationSecret?(user: User, secret: string | null): MaybePromise<void>;
+    /** Stored recovery codes (hashed by Navette), or `null`. */
+    getAppAuthenticationRecoveryCodes?(user: User): MaybePromise<string[] | null>;
+    saveAppAuthenticationRecoveryCodes?(user: User, codes: string[] | null): MaybePromise<void>;
+    /** Whether the user receives sign-in codes by email (`EmailAuthentication`). */
+    hasEmailAuthentication?(user: User): MaybePromise<boolean>;
+    saveEmailAuthentication?(user: User, enabled: boolean): MaybePromise<void>;
+    /** The user's security keys. */
+    getSecurityKeys?(user: User): MaybePromise<SecurityKey[]>;
+    createSecurityKey?(user: User, key: Omit<SecurityKey, 'id' | 'createdAt' | 'lastUsedAt'>): MaybePromise<void>;
+    /** Updates a key of this user (counter and last use after a sign-in). */
+    updateSecurityKey?(user: User, id: SecurityKey['id'], changes: {
+        signCount?: number;
+        lastUsedAt?: string;
+        name?: string;
+    }): MaybePromise<void>;
+    /** Deletes a key of this user. */
+    deleteSecurityKey?(user: User, id: SecurityKey['id']): MaybePromise<void>;
 }
 /**
  * Panel tenants (teams, organizations…). Every panel page then lives under
@@ -96,6 +124,15 @@ export interface TenantProvider<T = any> {
     /** Creates a tenant (tenant registration page); the user becomes a member. */
     create?(data: Record<string, unknown>, user: User): MaybePromise<T>;
     update?(tenant: T, data: Record<string, unknown>): MaybePromise<T>;
+    /** Tenant the user lands on after signing in (instead of their first one), or `null`. */
+    getDefaultTenant?(user: User): MaybePromise<T | null>;
+}
+/** Subscriptions of tenants (`panel.tenantBillingProvider()`): Stripe, Paddle, your own… */
+export interface TenantBillingProvider<T = any> {
+    /** The billing page of a tenant (`/<tenant>/billing`): usually a redirect to the payment provider's customer portal. */
+    handle(req: Request, res: Response, tenant: T): void | Promise<void>;
+    /** Whether the tenant has an active subscription; required by `panel.requiresTenantSubscription()`. */
+    isSubscribed?(tenant: T): MaybePromise<boolean>;
 }
 export type PanelContext = {
     req: Request;
@@ -143,8 +180,14 @@ export declare class NavigationItem {
     _isActive: ((path: string) => boolean) | null;
     _badge: string | number | null;
     _badgeColor: string;
+    _parentItem: string | null;
+    _childItems: NavigationItem[];
     constructor(label: string);
     static make(label: string): NavigationItem;
+    /** Shows the item below another item of its group, by that item's label. */
+    parentItem(label: string | null): this;
+    /** Items shown below this one, when it (or one of them) is active, or when it has no URL. */
+    childItems(items: NavigationItem[]): this;
     url(url: string): this;
     icon(icon: string | null): this;
     group(group: string | null): this;
@@ -176,6 +219,10 @@ export declare class Panel {
     private _downloads;
     /** Where files offered for download (exports, failed import rows) are kept: in memory by default. */
     downloads(store: DownloadStore): this;
+    private _importExportHistory;
+    /** Records each import and export run (`knexImportExportHistory(db)`): who, which file, how many rows, failed import rows. */
+    importExportHistory(store: ImportExportHistory | null): this;
+    getImportExportHistory(): ImportExportHistory | null;
     getDownloads(): DownloadStore;
     getDownloadUrl(token: string): string;
     private _pages;
@@ -239,6 +286,12 @@ export declare class Panel {
     pages(pages: (typeof Page)[]): this;
     /** Registers resources: their pages and navigation items. */
     resources(resources: (typeof Resource)[]): this;
+    /** A page or resource in a cluster is served under the cluster's slug; the cluster page is registered with it. */
+    private registerCluster;
+    /** Pages (resource list pages included) shown in a cluster's sub-navigation. */
+    getClusteredComponents(cluster: typeof Cluster): (typeof Page)[];
+    /** Sub-navigation of a cluster, for one of its pages: the components the user can open, sorted, with their groups. */
+    getClusterSubNavigation(cluster: typeof Cluster, current: Page, user: User | null): Promise<SubNavigationItem[]>;
     navigationItems(items: NavigationItem[]): this;
     /** Order of navigation groups. */
     /** Order of the navigation groups: labels, or `NavigationGroup.make('Shop').icon('o-shopping-cart').collapsible(false)`. */
@@ -268,7 +321,14 @@ export declare class Panel {
     private _authorizer;
     /** Plugs in your own permission system: consulted before any policy, for every ability, page and widget. */
     authorizeUsing(authorizer: Authorizer | null): this;
-    /** Authorization decision: the panel hook first, then the given rule. Always `false` without a user. */
+    private _guestAccess;
+    /**
+     * Lets visitors who are not signed in use the panel's pages. Policies, `canAccess()` and the authorization hook then receive
+     * a `null` user: return `true` there for what guests may see. Not available with tenancy.
+     */
+    guestAccess(condition?: boolean): this;
+    allowsGuests(): boolean;
+    /** Authorization decision: the panel hook first, then the given rule. Without a user: `false`, unless the panel allows guests. */
     authorize(user: User | null, ability: string, subject?: {
         resource?: unknown;
         record?: unknown;
@@ -376,6 +436,27 @@ export declare class Panel {
         page: typeof EditProfile;
         isSimple: boolean;
     };
+    /** Whether the profile page uses the simple layout (`profile(page, false)`: the full layout, with the navigation). */
+    isProfileSimple(): boolean;
+    private _multiFactor;
+    /**
+     * Multi-factor authentication: after the password, users with a provider set up must pass its challenge. They set providers
+     * up on their profile page (`profile()`). `isRequired`: users without any provider are sent to a setup page first.
+     */
+    multiFactorAuthentication(providers: MultiFactorAuthenticationProvider[], options?: {
+        isRequired?: boolean;
+        setUpPage?: typeof SetUpRequiredMultiFactorAuthentication;
+    }): this;
+    hasMultiFactorAuthentication(): boolean;
+    getMultiFactorAuthenticationProviders(): MultiFactorAuthenticationProvider[];
+    isMultiFactorAuthenticationRequired(): boolean;
+    getSetUpRequiredMultiFactorAuthenticationPage(): typeof SetUpRequiredMultiFactorAuthentication | null;
+    getSetUpRequiredMultiFactorAuthenticationUrl(): string;
+    /** The login challenge of this panel (enabled providers, rate limiting). */
+    getMultiFactorChallenge(): MultiFactorChallenge;
+    /** Whether the user must set up multi-factor authentication before using the panel. */
+    mustSetUpMultiFactorAuthentication(user: User | null): Promise<boolean>;
+    usesSecurityKeys(): boolean;
     /** Mailer for password reset and verification emails. Defaults to the console. */
     mailer(mailer: Mailer): this;
     sendMail(message: MailMessage): Promise<void>;
@@ -391,11 +472,29 @@ export declare class Panel {
     passwordResetRequestRouteSlug(slug: string): this;
     passwordResetRouteSlug(slug: string): this;
     /** Paths of the authentication pages, relative to the panel. */
+    /** URL segment of the logout route (`logout` by default). */
+    logoutRouteSlug(slug: string): this;
+    /** URL segments of email verification: `<prefix>/<prompt>` and `<prefix>/<verify>/…` (`email-verification/prompt`, `email-verification/verify`). */
+    emailVerificationRoutePrefix(prefix: string): this;
+    emailVerificationPromptRouteSlug(slug: string): this;
+    emailVerificationRouteSlug(slug: string): this;
+    /** URL segments of the email change links: `<prefix>/<verify>` and `<prefix>/block` (`email-change-verification/verify`). */
+    emailChangeVerificationRoutePrefix(prefix: string): this;
+    emailChangeVerificationRouteSlug(slug: string): this;
+    /** URL segments of the required multi-factor setup page (`multi-factor-authentication/set-up`). */
+    multiFactorAuthenticationRoutePrefix(prefix: string): this;
+    setUpRequiredMultiFactorAuthenticationRouteSlug(slug: string): this;
     getAuthPaths(): {
         login: string;
         registration: string;
         passwordResetRequest: string;
         passwordReset: string;
+        logout: string;
+        emailVerificationPrompt: string;
+        emailVerification: string;
+        emailChangeVerification: string;
+        blockEmailChange: string;
+        setUpRequiredMultiFactor: string;
     };
     /** First URL segments used by the panel itself (never page slugs or tenant keys). */
     getReservedSegments(): Set<string>;
@@ -410,6 +509,24 @@ export declare class Panel {
     getVerifyEmailUrl(user: User): string;
     checkVerifyEmailUrl(id: string, hash: string, expires: unknown, signature: unknown): boolean;
     getEmailVerificationPromptUrl(): string;
+    private _emailChangeVerification;
+    /**
+     * A new email address set on the profile page is only saved once confirmed: a link is sent to the new address, and a link
+     * to block the change to the old one. Both are valid for 60 minutes.
+     */
+    emailChangeVerification(condition?: boolean): this;
+    hasEmailChangeVerification(): boolean;
+    /** Links of an email change request: to confirm the new address, and to block the change. */
+    getEmailChangeUrls(user: User, newEmail: string): {
+        verify: string;
+        block: string;
+    };
+    readEmailChangeToken(kind: 'verify' | 'block', token: unknown): {
+        uid: string | number;
+        email: string;
+        from?: string;
+        nonce: string;
+    } | null;
     getProfileUrl(): string | null;
     /** Whether the user must still verify their email before using the panel. */
     mustVerifyEmail(user: User | null): Promise<boolean>;
@@ -438,6 +555,41 @@ export declare class Panel {
     getTenantProfilePage(): typeof EditTenantProfile | null;
     tenantMenu(condition?: boolean): this;
     hasTenantMenu(): boolean;
+    private _searchableTenantMenu;
+    /** A search field above the tenants of the menu. By default (`null`), it is shown from ten tenants to switch to. */
+    searchableTenantMenu(condition?: boolean | null): this;
+    isTenantMenuSearchable(): boolean | null;
+    private _tenantRoutePrefix;
+    /** A segment before the tenant key in URLs: `tenantRoutePrefix('team')` serves `/app/team/1/projects`. */
+    tenantRoutePrefix(prefix: string | null): this;
+    getTenantRoutePrefix(): string | null;
+    private _tenantDomain;
+    /**
+     * Identifies the tenant by the host instead of the path: `tenantDomain('{tenant}.example.com')` serves the tenant `acme` at
+     * `acme.example.com/app/projects`. A port may follow (`{tenant}.localhost:3000`).
+     */
+    tenantDomain(pattern: string | null): this;
+    getTenantDomain(): string | null;
+    /** Domain of a tenant, with its port if the pattern has one. */
+    getTenantDomainFor(tenant: unknown): string;
+    /** Key of the tenant designated by a request (its path, or its host with `tenantDomain()`), unchecked; `null` if none. */
+    getTenantKeyFromRequest(path: string, hostname: string): string | null;
+    private _tenantBilling;
+    private _tenantBillingRouteSlug;
+    private _requiresTenantSubscription;
+    /** Adds a "Manage subscription" link to the tenant menu, served by the provider at `/<tenant>/billing`. */
+    tenantBillingProvider(provider: TenantBillingProvider | null): this;
+    getTenantBillingProvider(): TenantBillingProvider | null;
+    hasTenantBilling(): boolean;
+    tenantBillingRouteSlug(slug: string): this;
+    getTenantBillingRouteSlug(): string;
+    getTenantBillingUrl(tenant?: unknown): string | null;
+    /** The pages of a tenant without an active subscription (`isSubscribed()`) redirect to its billing page. */
+    requiresTenantSubscription(condition?: boolean): this;
+    isTenantSubscriptionRequired(): boolean;
+    private _sessionCookieDomain;
+    /** Domain of the session cookie (`.example.com`): with `tenantDomain()`, a sign-in then holds on every tenant's host. */
+    sessionCookieDomain(domain: string | null): this;
     tenantMenuItems(items: Record<string, Action> | Action[]): this;
     getTenantMenuItems(): Record<string, Action>;
     /** Runs `fn` for a tenant: generated URLs (`getUrl`) and resource queries are scoped to it. */
@@ -470,9 +622,41 @@ export declare class Panel {
     /** Tenant avatar: from the tenant provider (`getAvatarUrl`), otherwise its initials. */
     getTenantAvatarUrl(tenant: unknown): string;
     private _spa;
-    /** SPA mode: navigate between panel pages without full reloads (`wire:navigate`). */
-    spa(condition?: boolean): this;
+    private _spaPrefetching;
+    /**
+     * SPA mode: navigate between panel pages without full reloads (`wire:navigate`). `{ prefetch: true }` loads a page as soon
+     * as its link is hovered (`wire:navigate.hover`).
+     */
+    spa(condition?: boolean, options?: {
+        prefetch?: boolean;
+    }): this;
     hasSpaMode(): boolean;
+    hasSpaPrefetching(): boolean;
+    private _domains;
+    /** Serves the panel on this domain only (`admin.example.com`): requests for other hosts go to the next routes. */
+    domain(host: string | null): this;
+    /** Serves the panel on these domains only. */
+    domains(hosts: string[]): this;
+    getDomains(): string[];
+    private _unsavedChangesAlerts;
+    /** Warns the user before leaving a create or edit page whose form has unsaved changes. */
+    unsavedChangesAlerts(condition?: boolean): this;
+    hasUnsavedChangesAlerts(): boolean;
+    private _databaseTransactions;
+    /**
+     * Wraps the creation and the saving of records (from `beforeCreate()` / `beforeSave()` to `afterCreate()` / `afterSave()`)
+     * in a database transaction, rolled back when anything throws. Pages can opt in or out with `static hasDatabaseTransactions`.
+     */
+    databaseTransactions(condition?: boolean): this;
+    hasDatabaseTransactions(): boolean;
+    private _strictAuthorization;
+    /** Throws when a resource is checked for an ability its policy does not define, instead of allowing it. */
+    strictAuthorization(condition?: boolean): this;
+    isAuthorizationStrict(): boolean;
+    private _bootCallbacks;
+    /** Runs on every request handled by the panel (its pages and their updates), before them. */
+    bootUsing(callback: (panel: Panel, req: Request) => void | Promise<void>): this;
+    boot(req: Request): Promise<void>;
     getAvatarUrlFor(name: string): string;
     /** Navigation groups: registered pages plus custom items, sorted, grouped in the declared order. */
     /** Computed navigation badges: page URL → value. */
@@ -483,14 +667,9 @@ export declare class Panel {
         label: string | null;
         itemsId: string;
         isActive: boolean;
-        items: {
-            label: string;
-            url: string;
-            icon: string | null;
-            isActive: boolean;
-            badge: string | number | null;
-            badgeColorClasses: string[];
-        }[];
+        icon: string | null;
+        collapsible: boolean;
+        items: NavigationItemView[];
     }[];
     private sign;
     logIn(res: Response, user: User, remember: boolean): void;
@@ -602,6 +781,63 @@ declare abstract class BasePage extends Component implements SchemaHost {
     contentSchema(schema: Schema): Schema;
     /** Render hook scopes of this page: its class (and its resource, for a resource page). */
     getRenderHookScopes(): unknown[];
+    /** Actions of the page header (full layout). */
+    getHeaderActions(): Action[];
+    static callable: string[];
+    loadedDeferredSchemas: Record<string, boolean>;
+    /** Whether a lazy schema is rendered: loaded already, or holding a field with a validation error (loaded so it shows). */
+    isDeferredSchemaLoaded(schema: Schema): Promise<boolean>;
+    /** Called by the loading indicator of a lazy schema: renders only that schema. */
+    loadDeferredSchema(schemaKey: unknown): Promise<void>;
+    mountedActions: {
+        name: string;
+        arguments: Record<string, unknown>;
+        context: Record<string, unknown>;
+        data?: Record<string, unknown>;
+    }[];
+    /** Files uploaded by rich editors (`componentFileAttachments.<state path>.<id>`), stored by the editor when it asks for their URL. */
+    componentFileAttachments: Record<string, unknown>;
+    getActionMountContext(): Record<string, unknown>;
+    protected getActionRecord(): unknown;
+    /** Record targeted by an action mounted in a given context (table row…). */
+    protected resolveActionRecord(_context: Record<string, unknown>): Promise<unknown>;
+    /** Actions that can be mounted in a given context (page header by default). */
+    protected getMountableActions(context: Record<string, unknown>): Action[] | Promise<Action[]>;
+    /**
+     * Actions owned by a schema component (Repeater: add, delete, move; Section: header actions).
+     * The key comes from the browser: it must match a real component of the schema, or the schema itself.
+     */
+    /** Visible component of a schema of this page (or of a mounted action's form) with this key. */
+    protected findSchemaComponent(key: string): Promise<any | null>;
+    protected getSchemaComponentActions(key: string): Promise<Action[]>;
+    /** Context kept for a mounted action: the server's, never the browser's as-is. */
+    protected resolveMountContext(clientContext: unknown): Record<string, unknown>;
+    private findMountableAction;
+    private actionContext;
+    /** Form schema of a mounted action: key `mountedActionSchema<n>`, state under `mountedActions.<n>.data`. */
+    getMountedActionSchema(index: number): Promise<Schema | null>;
+    private renderActionModal;
+    /** Cancels a partial modal render prepared by a live field when the same request then runs an action. */
+    private cancelModalPartialRender;
+    /** Live field in a mounted action's form: runs `afterStateUpdated`, then only returns the affected modal. */
+    updatedMountedActions(_value: unknown, key: string | null): Promise<void>;
+    /** Calls a method exposed by a field, from that field's JavaScript (e.g. Select search). Does not re-render. */
+    callSchemaComponentMethod(componentKey: unknown, method: unknown, args?: unknown): Promise<unknown>;
+    /** A hidden action can be neither mounted nor run, even through a call forged by the browser. */
+    private assertActionVisible;
+    private syncActionModals;
+    /** False for a table component: its modals are rendered inside the table. */
+    protected rendersActionModalsInPage(): boolean;
+    renderActionModals(): Promise<string>;
+    /** Mounts an action: without a modal it runs immediately; with one, only the modals fragment is returned. */
+    mountAction(name: unknown, args?: unknown, _context?: unknown): Promise<void>;
+    /**
+     * Replaces the action being run with another action of the same component, opened in its place (to show a result, as
+     * the new recovery codes). Call it from the running action; `name` must be mountable in the same context (it may be hidden).
+     */
+    replaceMountedAction(name: string, args?: Record<string, unknown>): Promise<void>;
+    unmountAction(_shouldCancelParentActions?: unknown): void;
+    callMountedAction(_args?: unknown): Promise<void>;
 }
 /** A panel page, in the full layout (sidebar, header). */
 export declare class Page extends BasePage {
@@ -615,9 +851,15 @@ export declare class Page extends BasePage {
     static navigationSort: number;
     static navigationBadge: string | number | null;
     static navigationBadgeColor: string;
+    /** Label of another menu item of the group, below which this page is shown. */
+    static navigationParentItem: string | null;
+    /** Cluster of the page: it is served under the cluster's URL and listed in its sub-navigation. */
+    static cluster: typeof Cluster | null;
     static shouldRegisterNavigation: boolean;
     /** Restricts the page to some users: returning `false` hides it from the menu and denies it (403). */
     static canAccess(_user: User): boolean | Promise<boolean>;
+    /** Whether the page needs the tenant's subscription (`panel.requiresTenantSubscription()`); `false` keeps it open. */
+    static isTenantSubscriptionRequired(panel: Panel): boolean;
     static getTitle(): string;
     static getNavigationLabel(): string;
     /** Every request, including browser updates, requires an authenticated user: a snapshot kept after logout is not enough. */
@@ -631,8 +873,13 @@ export declare class Page extends BasePage {
     }[];
     getHeaderActions(): Action[];
     getPageClasses(): string[];
-    /** Page sub-navigation; empty by default. */
+    /** Page sub-navigation: its cluster's pages, for a page in a cluster; empty otherwise. */
     getSubNavigation(): SubNavigationItem[] | Promise<SubNavigationItem[]>;
+    /** Breadcrumbs, preceded by the cluster's for a page in a cluster. */
+    protected getBreadcrumbsWithCluster(): {
+        label: string;
+        url: string | null;
+    }[];
     /** Sub-navigation position: `start` (column before the content), `end` (after) or `top` (tabs). Defaults to the resource's, then the panel's. */
     static subNavigationPosition: 'start' | 'end' | 'top' | null;
     getSubNavigationPosition(): 'start' | 'end' | 'top';
@@ -652,53 +899,33 @@ export declare class Page extends BasePage {
     /** Widget grid of a schema: each widget is a child component, lazy-loaded by default. */
     protected renderWidgetsGrid(widgets: (typeof Widget)[], columns: number | Record<string, number>, schemaKey: string): Promise<string>;
     /** Page content: its `content` schema by default. */
-    protected renderContent(): Promise<string>;
-    mountedActions: {
-        name: string;
-        arguments: Record<string, unknown>;
-        context: Record<string, unknown>;
-        data?: Record<string, unknown>;
-    }[];
-    /** Files uploaded by rich editors (`componentFileAttachments.<state path>.<id>`), stored by the editor when it asks for their URL. */
-    componentFileAttachments: Record<string, unknown>;
-    getActionMountContext(): Record<string, unknown>;
-    protected getActionRecord(): unknown;
-    /** Record targeted by an action mounted in a given context (table row…). */
-    protected resolveActionRecord(_context: Record<string, unknown>): Promise<unknown>;
-    /** Actions that can be mounted in a given context (page header by default). */
-    protected getMountableActions(context: Record<string, unknown>): Action[] | Promise<Action[]>;
     /**
-     * Actions owned by a schema component (Repeater: add, delete, move; Section: header actions).
-     * The key comes from the browser: it must match a real component of the schema, or the schema itself.
+     * Content rendered from an EJS view instead of the `content` schema: a namespaced view (`'app::pages.report'`), or a file
+     * (path or `new URL('./report.ejs', import.meta.url)`). The view receives `page` (this page) and `getViewData()`, and may use
+     * component tags (`<x-section>`, `<x-button>`…). Elements calling the server use `wire:click` on a method listed in `static callable`.
      */
-    /** Visible component of a schema of this page (or of a mounted action's form) with this key. */
-    protected findSchemaComponent(key: string): Promise<any | null>;
-    protected getSchemaComponentActions(key: string): Promise<Action[]>;
-    /** Context kept for a mounted action: the server's, never the browser's as-is. */
-    protected resolveMountContext(clientContext: unknown): Record<string, unknown>;
-    private findMountableAction;
-    private actionContext;
-    /** Form schema of a mounted action: key `mountedActionSchema<n>`, state under `mountedActions.<n>.data`. */
-    getMountedActionSchema(index: number): Promise<Schema | null>;
-    private renderActionModal;
-    /** Cancels a partial modal render prepared by a live field when the same request then runs an action. */
-    private cancelModalPartialRender;
-    /** Live field in a mounted action's form: runs `afterStateUpdated`, then only returns the affected modal. */
-    updatedMountedActions(_value: unknown, key: string | null): Promise<void>;
-    /** Calls a method exposed by a field, from that field's JavaScript (e.g. Select search). Does not re-render. */
-    callSchemaComponentMethod(componentKey: unknown, method: unknown, args?: unknown): Promise<unknown>;
-    /** A hidden action can be neither mounted nor run, even through a call forged by the browser. */
-    private assertActionVisible;
-    private syncActionModals;
-    /** False for a table component: its modals are rendered inside the table. */
-    protected rendersActionModalsInPage(): boolean;
-    renderActionModals(): Promise<string>;
-    /** Mounts an action: without a modal it runs immediately; with one, only the modals fragment is returned. */
-    mountAction(name: unknown, args?: unknown, _context?: unknown): Promise<void>;
-    unmountAction(_shouldCancelParentActions?: unknown): void;
-    callMountedAction(_args?: unknown): Promise<void>;
+    static view: string | URL | null;
+    /** Extra variables for the page view. */
+    getViewData(): Record<string, unknown> | Promise<Record<string, unknown>>;
+    protected renderContent(): Promise<string>;
     render(): Promise<string>;
 }
+/**
+ * Cluster: a menu item gathering pages and resources (`static cluster = Settings`), listed in its sub-navigation and served
+ * under its URL (`/settings/...`). Opening the cluster goes to its first page.
+ */
+export declare class Cluster extends Page {
+    /** Breadcrumb before those of its pages; defaults to the title. */
+    static clusterBreadcrumb: string | null;
+    /** `false`: the pages of the cluster have no sub-navigation. */
+    static shouldRegisterSubNavigation: boolean;
+    static getTitle(): string;
+    /** URL segment: `slug`, or the class name without "Cluster" in kebab case (`ProductsCluster` → `products`). */
+    static getSlug(): string;
+    static getClusterBreadcrumb(): string;
+    mount(): Promise<void>;
+    getSubNavigation(): SubNavigationItem[] | Promise<SubNavigationItem[]>;
+}
 /**
  * Dashboard: a widget grid, preceded by a filters form when the page defines `filtersFormSchema(schema)`.
  * The filters are passed to widgets as `pageFilters`.
@@ -721,16 +948,6 @@ export declare class Dashboard extends Page {
     getWidgetData(): Record<string, unknown>;
     protected renderContent(): Promise<string>;
 }
-/** In-memory rate limiter: `max` attempts per window, per key. Fine for a single instance; use a shared store when running several. */
-export declare class Throttle {
-    private hits;
-    private max;
-    private windowMs;
-    constructor(max?: number, windowMs?: number);
-    /** Records an attempt; returns 0 if allowed, otherwise the number of seconds to wait. */
-    hit(key: string, now?: number): number;
-    clear(key: string): void;
-}
 /** Page with the simple layout (login, registration…). */
 export declare abstract class SimplePage extends BasePage {
     abstract getTitle(): string;
@@ -805,8 +1022,17 @@ export declare class EditProfile extends SimplePage {
     boot(): Promise<void>;
     getTitle(): string;
     hasLogo(): boolean;
+    /** Whether the page uses the full layout (`panel.profile(EditProfile, false)`): its form is then split into sections. */
+    usesFullLayout(): boolean;
+    render(): Promise<string>;
     formSchema(schema: Schema): Schema;
+    /** Fields of the form: name, email, new password, its confirmation, current password. */
+    protected getFormComponents(): SchemaComponent[];
     contentSchema(schema: Schema): Schema;
+    /** Emails of an email change: a confirmation link to the new address, a link to block it to the old one. */
+    protected sendEmailChangeVerification(user: User, newEmail: string): Promise<void>;
+    /** Multi-factor authentication settings: each provider's status and actions (set up, turn off…). */
+    protected multiFactorAuthenticationSection(panel: Panel, user: User): SchemaComponent;
     save(): Promise<void>;
 }
 /** Tenant registration page: the subclass provides its label and form (`formSchema`). */
@@ -843,14 +1069,42 @@ export declare abstract class EditTenantProfile extends Page {
 }
 export declare class Login extends SimplePage {
     static callable: string[];
+    /** Signed token naming the user undertaking the multi-factor challenge: set by the server only. */
+    static locked: string[];
     data: Record<string, unknown>;
+    userUndertakingMultiFactorAuthentication: string | null;
+    /** User of the pending challenge, resolved from the token on each request. */
+    protected _multiFactorUser: User | null;
+    protected _multiFactorProviders: MultiFactorAuthenticationProvider[];
     mount(): void;
+    boot(): Promise<void>;
+    protected readMultiFactorToken(): Record<string, unknown> | null;
+    /** Whether the multi-factor challenge is shown. */
+    isUndertakingMultiFactorAuthentication(): boolean;
     getTitle(): string;
     getHeading(): string;
     getSubheading(): string | null;
+    getSchema(name: string): Schema;
     formSchema(schema: Schema): Schema;
+    /** Challenge fields of the user's enabled providers (with a picker when there are several). */
+    multiFactorChallengeFormSchema(schema: Schema): Schema;
     contentSchema(schema: Schema): Schema;
+    /** Starts a challenge for this user if one of their providers is set up; returns whether it did. */
+    protected startMultiFactorChallenge(user: User): Promise<boolean>;
     authenticate(): Promise<void>;
+    /** The user picked another provider in the challenge: run its `beforeChallenge` (an email code is sent). */
+    updatedData(value: unknown, key: string | null): Promise<void>;
+    protected cancelMultiFactorChallenge(): void;
+}
+/** Shown after sign-in when the panel requires multi-factor authentication and the user has not set any provider up. */
+export declare class SetUpRequiredMultiFactorAuthentication extends SimplePage {
+    static callable: string[];
+    boot(): Promise<void>;
+    mount(): Promise<void>;
+    getTitle(): string;
+    getHeading(): string;
+    getSubheading(): string | null;
+    contentSchema(schema: Schema): Schema;
 }
 /** Whether the host component's user has this ability on the component's resource (or relation manager). Use it in your actions' `authorize()`. */
 export declare const can: (livewire: unknown, ability: string, record?: unknown) => Promise<boolean> | boolean;
@@ -864,6 +1118,12 @@ export declare abstract class Resource {
     static navigationGroup: string | null;
     static navigationSort: number;
     static navigationBadge: string | number | null;
+    /** Menu label; defaults to the plural model label in title case. */
+    static navigationLabel: string | null;
+    /** Label of another menu item of the group, below which the resource is shown. */
+    static navigationParentItem: string | null;
+    /** Cluster of the resource: its pages are served under the cluster's URL, and its list is in the cluster's sub-navigation. */
+    static cluster: typeof Cluster | null;
     static adapter: DataAdapter;
     /** In a multi-tenant panel, whether records belong to each tenant (`true` by default). */
     static isScopedToTenant: boolean;
@@ -889,8 +1149,9 @@ export declare abstract class Resource {
     static widgets: (typeof Widget)[];
     /** Widgets shown above the table on the list page. */
     static headerWidgets: (typeof Widget)[];
-    /** Relation managers shown below the edit form. */
-    static relations: any[];
+    /** Relation managers shown below the edit form (and the view page), or groups of them (`RelationGroup`). */
+    static relations: (typeof RelationManager | RelationGroup)[];
+    static getRelations(): (typeof RelationManager | RelationGroup)[];
     /** Tabs of the list page. */
     static tabs(): Record<string, Tab>;
     /** Simple resource: a single page, with create and edit in modals. */
@@ -899,7 +1160,7 @@ export declare abstract class Resource {
     static getTitleCasePluralModelLabel(): string;
     static getUrl(page?: string, record?: string | number): string;
     /** Related records pages: `{ comments: ManagePostComments }` is served at `<slug>/{record}/comments`. */
-    static relatedPages: Record<string, typeof ManageRelatedRecords>;
+    static relatedPages: Record<string, typeof ManageRelatedRecords | typeof EditRecord | typeof ViewRecord>;
     /** Pages listed in a record's sub-navigation, in order: `['view', 'edit', 'comments']`. Empty: no sub-navigation. */
     static recordSubNavigation: string[];
     /** Record sub-navigation: one tab per declared page, the current page's tab active. */
@@ -929,6 +1190,11 @@ export declare abstract class Resource {
     static getGlobalSearchResultTitle(record: any): string;
     /** Details shown under the title: `{ Author: 'Jane' }`. Empty values are skipped. */
     static getGlobalSearchResultDetails(_record: any): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /**
+     * Buttons under a result: links (`Action.make('edit').url(…)`) or Livewire events (`.dispatch('quickView', [id])`).
+     * They are not mounted: an action needing a modal belongs on the record's pages.
+     */
+    static getGlobalSearchResultActions(_record: any): Action[] | Promise<Action[]>;
     /** URL of a result: the view page, otherwise the edit page; for a simple resource, the list with the action open. `null` if the user has no access. */
     static getGlobalSearchResultUrl(record: any, user: User | null): Promise<string | null>;
     static getGlobalSearchResults(search: string, user: User | null): Promise<GlobalSearchResult[]>;
@@ -940,13 +1206,29 @@ export declare abstract class Resource {
     static getPages(): Record<string, typeof Page>;
     private static buildPages;
 }
-/** Sub-navigation tab of a page. */
+/** Sub-navigation tab of a page; items with a `group` are gathered under its label. */
 export type SubNavigationItem = {
     label: string;
     icon: string | null;
     url: string;
     active: boolean;
+    group?: string | null;
+    badge?: string | number | null;
+    badgeColor?: string;
+};
+/** A sidebar item, as rendered. */
+export type NavigationItemView = {
+    label: string;
+    url: string;
+    icon: string | null;
+    isActive: boolean;
+    badge: string | number | null;
+    badgeColorClasses: string[];
+    childItems: NavigationItemView[];
+    activeChildItems: boolean;
 };
+/** The cluster a page belongs to: its own, or its resource's. */
+export declare const clusterOf: (page: unknown) => typeof Cluster | null;
 type ColumnSpan = number | 'full' | Record<string, number | 'full'>;
 /** Widget: a component displayed in a page's widget grid. */
 export declare abstract class Widget extends Component {
@@ -1303,6 +1585,27 @@ export declare class EmbeddedTable extends SchemaComponent {
     static make(): EmbeddedTable;
     toHtml(): Promise<string>;
 }
+/**
+ * Several relation managers under one tab of a record page: `RelationGroup.make('Contacts', [PhonesManager, EmailsManager])`.
+ * The managers are shown one below the other.
+ */
+export declare class RelationGroup {
+    private _label;
+    private _managers;
+    private _icon;
+    private _badge;
+    private _badgeColor;
+    constructor(label: string, managers: (typeof RelationManager)[]);
+    static make(label: string, managers: (typeof RelationManager)[]): RelationGroup;
+    icon(name: string | null): this;
+    badge(badge: string | number | null | (() => string | number | null | Promise<string | number | null>)): this;
+    badgeColor(color: string): this;
+    getLabel(): string;
+    getIcon(): string | null;
+    getManagers(): (typeof RelationManager)[];
+    getBadge(): Promise<string | number | null>;
+    getBadgeColor(): string;
+}
 /** List page tab: restricts the table query and can show a badge. */
 export declare class Tab {
     private _label;
@@ -1335,6 +1638,8 @@ export declare class Tab {
 export declare class ListRecords extends Page implements TableHost {
     static callable: string[];
     static resource: typeof Resource;
+    /** In a cluster, the list page shows the cluster's sub-navigation. */
+    getSubNavigation(): SubNavigationItem[] | Promise<SubNavigationItem[]>;
     tableSearch: string;
     tableSort: string | null;
     tableColumnSearches: Record<string, string>;
@@ -1459,6 +1764,19 @@ export declare class RelationManager extends ListRecords {
     static table(table: Table): Table;
     static form(schema: Schema): Schema;
     static getTitle(): string;
+    /** Icon of the manager's tab. */
+    static icon: string | null;
+    static getIcon(): string | null;
+    /** Badge of the manager's tab (a count of related records…), and its color. */
+    static badge: string | number | null;
+    static badgeColor: string;
+    static getBadge(_ownerRecord: any, _pageClass: typeof Page): string | number | null | Promise<string | number | null>;
+    static getBadgeColor(): string;
+    /**
+     * Whether the manager is shown for this record and page (all by default). Hide it here rather than by denying `viewAny`,
+     * which would forbid the whole page.
+     */
+    static canViewForRecord(_ownerRecord: any, _pageClass: typeof Page): boolean | Promise<boolean>;
     /** Owner record key: set on mount by the page, never writable from the browser. */
     ownerRecord: string;
     static locked: string[];
@@ -1466,8 +1784,16 @@ export declare class RelationManager extends ListRecords {
     /** What ListRecords expects from a resource, provided here by the relation manager. */
     get resource(): any;
     getTable(): Table;
-    /** Attaches an existing record to the owner. */
-    static attach(_ownerKey: string, _recordKey: string): Promise<void>;
+    /** Attaches an existing record to the owner; `pivot` holds the values of the `pivotForm()` fields. */
+    static attach(_ownerKey: string, _recordKey: string, _pivot?: Record<string, unknown>): Promise<void>;
+    /**
+     * Fields stored on the pivot table (a role, a quantity…): added to the attach modal and to the edit form of a row.
+     * Their values go to `attach()` and `updatePivot()`, never to the related record. List the pivot columns in the
+     * relation's query (`adapterFor()`) so that the table and the edit form can read them.
+     */
+    static pivotForm(_schema: Schema): SchemaComponent[];
+    /** Saves the pivot fields of an attached record (edit form of a row). */
+    static updatePivot(_ownerKey: string, _recordKey: string, _pivot: Record<string, unknown>): Promise<void>;
     /** Detaches records from the owner without deleting them. */
     static detach(_ownerKey: string, _recordKeys: string[]): Promise<void>;
     /** Attachable records matching the search: [key, label]. */
@@ -1537,6 +1863,20 @@ declare abstract class ResourceFormPage extends Page {
     updatedData(_value: unknown, key: string | null): Promise<void>;
     static resource: typeof Resource;
     data: Record<string, unknown>;
+    /** Hash of the form data as last saved: the browser compares it with the current data (unsaved changes alert). */
+    savedDataHash: string;
+    static locked: string[];
+    /** `true` / `false` overrides the panel's `databaseTransactions()` for this page. */
+    static hasDatabaseTransactions: boolean | null;
+    /** `true` / `false` overrides the panel's `unsavedChangesAlerts()` for this page. */
+    static hasUnsavedDataChangesAlert: boolean | null;
+    protected hasDatabaseTransactions(): boolean;
+    protected hasUnsavedDataChangesAlert(): boolean;
+    /** Runs `fn` in a database transaction of the resource's adapter, when the page uses them. */
+    protected wrapInDatabaseTransaction<T>(fn: () => Promise<T>): Promise<T>;
+    /** Remembers the form data as saved: leaving the page with other data asks for confirmation. */
+    protected rememberData(): void;
+    render(): Promise<string>;
     get resource(): typeof Resource;
     getDataAdapter(): DataAdapter;
     getRecordKey(): string | null;
@@ -1663,6 +2003,7 @@ export declare class DissociateBulkAction {
     static make(): Action;
 }
 /** Restores a soft-deleted record. Only visible when the record is deleted. */
+/** Restores a soft-deleted record: the page's record, or a table row. Only visible when the record is deleted. */
 export declare class RestoreAction {
     static make(): Action;
 }
@@ -1697,7 +2038,19 @@ export declare class EditRecord extends ResourceFormPage {
      */
     previousUrl: string;
     protected getCancelUrl(): string;
+    /** Relation managers of this page: the resource's by default (`static relationManagers` on the page replaces them). */
+    getRelationManagers(): (typeof RelationManager | RelationGroup)[];
+    /** `true`: the form becomes the first tab, next to the relation managers. */
+    hasCombinedRelationManagerTabsWithContent(): boolean;
+    getContentTabLabel(): string;
+    getContentTabIcon(): string | null;
+    protected withRelationManagers(content: Schema): Schema;
     contentSchema(schema: Schema): Schema;
+    /**
+     * Saves the fields of one component of the form (a section with its own "Save" action), after validating them only:
+     * `livewire.saveFormComponentOnly('contact')` (the component's `key()`, or the component).
+     */
+    saveFormComponentOnly(component: SchemaComponent | string, notificationTitle?: string | null): Promise<void>;
     static locked: string[];
     _record: any;
     mount(params: Record<string, unknown>): Promise<void>;
@@ -1752,6 +2105,13 @@ export declare class ViewRecord extends Page {
     getActionMountContext(): Record<string, unknown>;
     protected getActionRecord(): unknown;
     infolistSchema(schema: Schema): Schema;
+    /** Relation managers of this page: the resource's by default (`static relationManagers` on the page replaces them). */
+    getRelationManagers(): (typeof RelationManager | RelationGroup)[];
+    /** `true`: the infolist becomes the first tab, next to the relation managers. */
+    hasCombinedRelationManagerTabsWithContent(): boolean;
+    getContentTabLabel(): string;
+    getContentTabIcon(): string | null;
+    protected withRelationManagers(content: Schema): Schema;
     contentSchema(schema: Schema): Schema;
     /** Defaults to a link to the edit page. */
     getHeaderActions(): Action[];
@@ -1764,6 +2124,17 @@ export declare class ViewRecord extends Page {
     getSubNavigation(): SubNavigationItem[];
     getPageClasses(): string[];
 }
+/** Tenant menu: current tenant, other tenants, registration, profile. */
+/** Options of an error page: a description replacing the status's own, and the error (its stack is shown in development). */
+export type ErrorPageOptions = {
+    description?: string;
+    error?: unknown;
+};
+/**
+ * Answers with the panel's error page for a status (404, 403, 500…): the cable car in trouble, in the request's theme.
+ * Requests that do not accept HTML get plain text. Use it in your own middleware, a maintenance mode answering 503 for example.
+ */
+export declare function renderErrorPage(panel: Panel, req: Request, res: Response, status: number, options?: ErrorPageOptions): void;
 /** Sidebar: logo, tenant menu, search, navigation and, without a topbar, the bell and user menu. */
 export declare class Sidebar extends Component {
     static callable: string[];
@@ -1799,3 +2170,5 @@ export declare const discoverWidgets: (directory: string | URL) => Promise<(type
 /** Panels default-exported (`export default Panel.make()…`) by a folder's modules. */
 export declare function discoverPanels(directory: string | URL): Promise<Panel[]>;
 export declare function panelRouter(panel: Panel, runtime: WireRuntime): Router;
+/** The panel's 404 page for URLs nothing else answered: mount it after your routes, for a panel served at the root. */
+export declare function panelNotFound(panel: Panel): (req: Request, res: Response) => void;