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

package/lib/index.d.ts

@@ -1,10 +1,21 @@
+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, 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';
 import { type DatabaseNotificationStore, type GlobalSearchCategory, type GlobalSearchResult } from './topbar.ts';
@@ -71,6 +82,29 @@ export interface AuthProvider {
     markEmailAsVerified?(user: User): MaybePromise<void>;
     /** A value that changes with the stored password, so a used reset link becomes invalid. */
     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
@@ -90,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;
@@ -97,7 +140,8 @@ export type PanelContext = {
     panel: Panel;
     user: User | null;
     mailbox: string;
-    tenant?: unknown;
+    tenant?: unknown; /** Signed in through the shared session, but not allowed into this panel. */
+    denied?: boolean;
 };
 /**
  * Predefined panel theme: a set of colors (palettes or plain colors), optionally a font and some CSS.
@@ -114,6 +158,19 @@ export type Theme = {
     /** CSS added to the page for this theme (written by the panel developer, inserted as-is). */
     css?: string;
 };
+/** Navigation group: label, icon (then its items have none, as in Filament) and whether it can be collapsed. */
+export declare class NavigationGroup {
+    private _label;
+    private _icon;
+    private _collapsible;
+    constructor(label: string);
+    static make(label: string): NavigationGroup;
+    icon(name: string | null): this;
+    collapsible(condition?: boolean): this;
+    getLabel(): string;
+    getIcon(): string | null;
+    isCollapsible(): boolean;
+}
 export declare class NavigationItem {
     label: string;
     _url: string;
@@ -123,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;
@@ -149,10 +212,24 @@ export declare class Panel {
     private _login;
     private _auth;
     private _key;
+    private _sessionStore;
+    /** Where per-browser data is kept (persisted table filters, search and sort): in memory by default. */
+    sessionStore(store: SessionStore): this;
+    getSessionStore(): SessionStore;
+    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;
     private _resources;
     private _navigationItems;
     private _navigationGroups;
+    private _navigationGroupOptions;
     private _maxContentWidth;
     readonly colors: ColorManager;
     static make(): Panel;
@@ -191,12 +268,44 @@ export declare class Panel {
     login(page?: typeof Login): this;
     auth(provider: AuthProvider): this;
     key(key: string): this;
+    private _authGuard;
+    private _canAccess;
+    /**
+     * Session shared with the other panels that use the same guard (`'web'` by default): signing into one signs into all of
+     * them, and `canAccess()` decides who may enter each one. `null` gives this panel a session of its own.
+     * Panels sharing a guard must use the same key and the same auth provider.
+     */
+    authGuard(guard: string | null): this;
+    getAuthGuard(): string | null;
+    /** Who may use this panel, e.g. `panel.canAccess((user) => user.role === 'admin')`. Checked on every request and at login. */
+    canAccess(rule: ((user: User, panel: Panel) => MaybePromise<boolean>) | null): this;
+    /** True if this user may use this panel: the panel's rule and the provider's `canAccessPanel()`, when set, must both allow it. */
+    userCanAccess(user: User): Promise<boolean>;
+    /** Name of the session cookie: per guard (shared), or per panel. */
+    getSessionCookieName(): string;
     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. */
-    navigationGroups(groups: string[]): this;
+    /** Order of the navigation groups: labels, or `NavigationGroup.make('Shop').icon('o-shopping-cart').collapsible(false)`. */
+    private _darkMode;
+    private _darkModeForced;
+    private _defaultThemeMode;
+    /** `false`: light mode only (no switcher); `darkMode(true, true)`: dark mode only. */
+    darkMode(condition?: boolean, isForced?: boolean): this;
+    /** Mode used until the user picks one in the switcher: `'system'` (default), `'light'` or `'dark'`. */
+    defaultThemeMode(mode: 'light' | 'dark' | 'system'): this;
+    hasDarkMode(): boolean;
+    hasDarkModeForced(): boolean;
+    getDefaultThemeMode(): 'light' | 'dark' | 'system';
+    navigationGroups(groups: (string | NavigationGroup)[]): this;
     private _plugins;
     /** Applies a plugin: an object that configures the panel (resources, pages, render hooks, themes…). */
     plugin(plugin: Plugin): this;
@@ -212,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;
@@ -320,10 +436,68 @@ 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>;
     getAuthKey(): string;
+    private _authSlugs;
+    private authSlug;
+    /** URL segment of the login page (`login` by default). */
+    loginRouteSlug(slug: string): this;
+    /** URL segment of the registration page (`register` by default). */
+    registrationRouteSlug(slug: string): this;
+    /** URL segments of the password reset pages: `<prefix>/<request>` and `<prefix>/<reset>` (`password-reset/request` and `password-reset/reset` by default). */
+    passwordResetRoutePrefix(prefix: string): this;
+    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>;
     getRegistrationUrl(): string;
     getRequestPasswordResetUrl(): string;
     getResetPasswordUrl(user: User, fingerprint: string): string;
@@ -335,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>;
@@ -363,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. */
@@ -395,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. */
@@ -408,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;
@@ -527,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 {
@@ -540,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. */
@@ -556,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';
@@ -577,49 +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>;
-    }[];
-    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`.
      */
-    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`.
@@ -632,6 +938,7 @@ export declare class Dashboard extends Page {
     /** Filters form state. Stays `null` while the page has no filters. */
     filters: Record<string, unknown> | null;
     /** Dashboard widgets. Defaults to the panel's (`panel.widgets([...])`). */
+    /** The panel's widgets, ordered by their `sort` (stable). */
     getWidgets(): (typeof Widget)[];
     /** Grid columns: a number (at the `lg` breakpoint), or one number per breakpoint. */
     getColumns(): number | Record<string, number>;
@@ -641,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;
@@ -725,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`). */
@@ -763,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;
@@ -784,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;
@@ -809,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. */
@@ -819,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. */
@@ -837,6 +1178,10 @@ export declare abstract class Resource {
     /** Columns searched by global search; defaults to the title attribute. Empty array: the resource is not searchable. */
     static globallySearchableAttributes: string[] | null;
     static getGloballySearchableAttributes(): string[];
+    /** `false`: the resource is left out of global search. */
+    static isGloballySearchable: boolean;
+    /** `false`: the search term is matched as a whole instead of word by word. */
+    static shouldSplitGlobalSearchTerms: boolean;
     static canGloballySearch(): boolean;
     /** Position of this resource's group in the results; without one, after the others in registration order. */
     static globalSearchSort: number | null;
@@ -845,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[]>;
@@ -856,26 +1206,44 @@ 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;
 };
-type ColumnSpan = number | 'full';
+/** 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 {
     static componentName: string;
-    /** Width in the widget grid: a number of columns, or `'full'`. */
+    /** Width in the widget grid: a number of columns or `'full'` (from `lg`), or a span per breakpoint (`{ md: 2, xl: 3 }`). */
     static columnSpan: ColumnSpan;
+    /** Position on the dashboard (lower first); widgets without a sort keep their order, after the sorted ones. */
+    static sort: number | null;
     /** Loaded when it becomes visible. */
     static isLazy: boolean;
     get panel(): Panel;
     /** Restricts the widget to some users: returning `false` removes it from the page and refuses to load it. */
     static canView(_user: User): boolean | Promise<boolean>;
     boot(): Promise<void>;
-    /** Grid column classes and style, at the `lg` breakpoint. */
+    /** Grid column classes and style: at the `lg` breakpoint, or per breakpoint. */
     protected gridColumn(): {
         classes: string[];
         style: string;
@@ -1086,6 +1454,10 @@ export declare abstract class StatsOverviewWidget extends Widget {
     /** Polling interval, or `null` to disable polling. */
     static pollingInterval: string | null;
     abstract getStats(): Stat[] | Promise<Stat[]>;
+    /** Heading shown above the stats. */
+    protected getHeading(): string | null;
+    /** Description under the heading. */
+    protected getDescription(): string | null;
     /** Row columns: three, or four when the number of stats fits better. */
     protected getColumns(count: number): number;
     render(): Promise<string>;
@@ -1102,6 +1474,10 @@ export type ChartData = {
  * has changed (checksum).
  */
 export declare abstract class ChartWidget extends Widget {
+    /** Empty state shown when `getData()` returns nothing. */
+    protected getEmptyStateHeading(): string;
+    protected getEmptyStateDescription(): string | null;
+    protected getEmptyStateIcon(): string | null;
     static callable: string[];
     static locked: string[];
     /** Polling interval, or `null` to disable polling. */
@@ -1209,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;
@@ -1222,6 +1619,13 @@ export declare class Tab {
     badge(resolver: () => number | string | null | Promise<number | string | null>): this;
     badgeColor(color: string): this;
     query(modifier: (query: any) => void): this;
+    private _icon;
+    private _iconPosition;
+    /** Icon of the tab, before its label (or after, with `iconPosition('after')`). */
+    icon(name: string | null): this;
+    iconPosition(position: 'before' | 'after'): this;
+    getIcon(): string | null;
+    getIconPosition(): 'before' | 'after';
     getLabel(key: string): string;
     hasBadge(): boolean;
     getBadge(): Promise<number | string | null>;
@@ -1234,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>;
@@ -1253,16 +1659,29 @@ export declare class ListRecords extends Page implements TableHost {
     toggleTableReordering(): Promise<void>;
     /** Saves the new order: only keys belonging to the table are kept, each gets its position. */
     reorderTable(order: unknown, _draggedRecordKey?: unknown): Promise<void>;
+    /** Key of this table's persisted state: per page class (and resource or relationship). */
+    protected tableSessionKey(part: string): string;
+    /** Session of the persisted table state: the browser (its CSRF token) and the signed-in user. */
+    private tableSession;
+    dehydrate(): Promise<void>;
+    /** Restores the persisted table state; every value is sanitized like browser input. */
+    private restoreTableSession;
     mount(_params?: Record<string, unknown>): Promise<void>;
     /** Filters form: one group per filter, bound to `tableDeferredFilters.<filter>`. */
     tableFiltersFormSchema(schema: Schema): Schema;
+    /** Applied state of every declared filter, sanitized from the given (browser) state. */
+    protected sanitizeTableFilters(source: Record<string, unknown> | undefined): Record<string, FilterState>;
+    /** Live filters (`deferFilters(false)`): a changed field applies at once. */
+    updatedTableFilters(value: unknown, key: string | null): Promise<void>;
     applyTableFilters(): void;
     /** Removes an active filter indicator: the field is cleared from both the applied state and the form. */
-    removeTableFilter(filterName: unknown, field?: unknown): void;
+    removeTableFilter(filterName: unknown, field?: unknown): Promise<void>;
     /** Live field in the filters form (e.g. a rule's operator changed): runs its `afterStateUpdated`. */
     updatedTableDeferredFilters(_value: unknown, key: string | null): Promise<void>;
+    private runFilterFieldHook;
     resetTableFiltersForm(): void;
-    removeTableFilters(): void;
+    /** "Remove all": resets every removable filter (to its empty state, not its default), the search and the column searches. */
+    removeTableFilters(): Promise<void>;
     applyTableColumnManager(state?: unknown, _wasReordered?: unknown): void;
     resetTableColumnManager(): void;
     activeTab: string | null;
@@ -1292,10 +1711,23 @@ export declare class ListRecords extends Page implements TableHost {
     updateTableColumnState(columnName: unknown, recordKey: unknown, input: unknown): Promise<unknown>;
     /** Selected keys: the sent list, or, in "select all" mode, every record of the current query except deselected ones. */
     getSelectedRecordKeys(): Promise<string[]>;
+    /**
+     * Runs `process` for each selected record, loaded in chunks of `chunkSelectedRecords()`. Records failing the action's
+     * `authorizeIndividualRecords()` are skipped; `process` reports a failure by returning `false` or throwing. Then sends the
+     * action's success notification, or its failure notification with the number of records skipped and failed.
+     */
+    processSelectedRecords(action: Action, process: (record: any) => unknown | Promise<unknown>): Promise<{
+        total: number;
+        success: number;
+        unauthorized: number;
+        failed: number;
+    }>;
     deselectAllTableRecords(): void;
     getTable(): Table;
     renderTable(): Promise<string>;
+    protected renderTableEmptyStateActions(ctx: any): Promise<string[]>;
     /** Table header actions (none on a list page: they go in the page header). */
+    protected renderTableToolbarActions(ctx: any): Promise<string[]>;
     protected renderTableHeaderActions(ctx: any): Promise<string[]>;
     sortTable(column?: string | null, direction?: string | null): void;
     gotoPage(page: number, _pageName?: string): void;
@@ -1332,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[];
@@ -1339,14 +1784,30 @@ 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]. */
     static searchAttachable(_ownerKey: string, _search: string): Promise<[string, string][]>;
     /** Label of an attachable record, or `null` if it is not attachable (also used as validation). */
     static attachableLabel(_ownerKey: string, _recordKey: string): Promise<string | null>;
+    /** Sets the owner of an existing record (its foreign key). */
+    static associate(_ownerKey: string, _recordKey: string): Promise<void>;
+    /** Clears the owner of records (their foreign key), without deleting them. */
+    static dissociate(_ownerKey: string, _recordKeys: string[]): Promise<void>;
+    /** Associable records matching the search: [key, label]. */
+    static searchAssociable(_ownerKey: string, _search: string): Promise<[string, string][]>;
+    /** Label of an associable record, or `null` if it is not associable (also used as validation). */
+    static associableLabel(_ownerKey: string, _recordKey: string): Promise<string | null>;
     getHeaderActions(): Action[];
     placeholder(): string;
     /** A relation manager has its own render hook locations, not the list page's. */
@@ -1402,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;
@@ -1425,13 +1900,21 @@ declare abstract class ResourceFormPage extends Page {
     /** Where "Cancel" goes when the browser has no history: the list page, unless the page decides otherwise. */
     protected getCancelUrl(): string;
     protected cancelAction(): Action;
+    /** Before the form is filled (with defaults, or with the record on the edit page). */
+    protected beforeFill(): void | Promise<void>;
+    /** After the form is filled. */
+    protected afterFill(): void | Promise<void>;
+    /** Before the form is validated, when it is submitted. */
+    protected beforeValidate(): void | Promise<void>;
+    /** After the form is validated successfully, before the data is transformed and saved. */
+    protected afterValidate(): void | Promise<void>;
     /** Validates the form; on error, sets the errors on the component and notifies the browser. */
     protected validateForm(): Promise<boolean>;
 }
 /** Record creation page. */
 export declare class CreateRecord extends ResourceFormPage {
     static callable: string[];
-    mount(): void;
+    mount(): Promise<void>;
     getOperation(): 'create';
     getSubmitMethod(): string;
     getTitle(): string;
@@ -1461,9 +1944,21 @@ export declare class DeleteAction {
     /** On an edit page, deletes the page's record and returns to the list. On a table row, deletes the row. */
     static make(): Action;
 }
-/** Replicate action: an `Action` with a list of attributes not to copy. */
+/** Replicate action: an `Action` with a list of attributes not to copy, and hooks around the saving of the copy. */
 export type ReplicateActionInstance = Action & {
     excludeAttributes(attributes: string[]): ReplicateActionInstance;
+    /** Runs before the copy is saved, with its attributes (`replica`, changeable) and the modal form's data. */
+    beforeReplicaSaved(callback: (ctx: {
+        replica: Record<string, unknown>;
+        data: Record<string, unknown>;
+        record: unknown;
+    }) => unknown): ReplicateActionInstance;
+    /** Runs after the copy is saved, with the saved record. */
+    afterReplicaSaved(callback: (ctx: {
+        replica: unknown;
+        data: Record<string, unknown>;
+        record: unknown;
+    }) => unknown): ReplicateActionInstance;
 };
 /** Duplicates a table row: the copy takes the record's attributes, except its key, timestamps and excluded ones. */
 export declare class ReplicateAction {
@@ -1495,7 +1990,20 @@ export declare class DetachAction {
 export declare class DetachBulkAction {
     static make(): Action;
 }
+/** Gives an existing record to the owner of a one-to-many relation manager (its foreign key). */
+export declare class AssociateAction {
+    static make(): Action;
+}
+/** Removes a row from the owner (clears its foreign key) without deleting it. */
+export declare class DissociateAction {
+    static make(): Action;
+}
+/** Dissociates the selected rows. */
+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;
 }
@@ -1503,10 +2011,21 @@ export declare class RestoreAction {
 export declare class ForceDeleteAction {
     static make(): Action;
 }
-/** Deletes the records selected in a table. */
+/**
+ * Deletes the records selected in a table. Without `authorizeIndividualRecords()`, the selection is deleted in one query;
+ * with it, record by record, and the notification reports the records that could not be deleted.
+ */
 export declare class DeleteBulkAction {
     static make(): Action;
 }
+/** Restores the soft-deleted records selected in a table, each one checked with the `restore` ability. */
+export declare class RestoreBulkAction {
+    static make(): Action;
+}
+/** Permanently deletes the soft-deleted records selected in a table, each one checked with the `forceDelete` ability. */
+export declare class ForceDeleteBulkAction {
+    static make(): Action;
+}
 /** Record edit page. */
 export declare class EditRecord extends ResourceFormPage {
     static callable: string[];
@@ -1519,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>;
@@ -1574,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[];
@@ -1586,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[];
@@ -1620,5 +2169,6 @@ export declare const discoverPages: (directory: string | URL) => Promise<(typeof
 export declare const discoverWidgets: (directory: string | URL) => Promise<(typeof Widget)[]>;
 /** Panels default-exported (`export default Panel.make()…`) by a folder's modules. */
 export declare function discoverPanels(directory: string | URL): Promise<Panel[]>;
-/** Express router for a panel: assets, runtime endpoint, authentication, tenants, protected pages. */
 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;