@navette-js/panels 0.0.0-stage → 1.0.0-beta.2

package/lib/index.d.ts

@@ -0,0 +1,1624 @@
+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';
+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 { 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';
+export { DatabaseNotifications, GlobalSearch, knexNotificationStore, timeAgo, type DatabaseNotificationAction, type DatabaseNotificationRecord, type DatabaseNotificationStore, type GlobalSearchCategory, type GlobalSearchResult } from './topbar.ts';
+import { ColorManager, RenderHookRegistry, type Palette, type RenderHookCallback } from '@navette-js/support';
+import type { DataAdapter } from '@navette-js/database';
+import { Table, type ColumnState, type FilterState, type TableHost } from '@navette-js/tables';
+import { Component, type WireRuntime } from '@navette-js/wire';
+export declare const ASSET_VERSION = "5.11.2.0";
+/** The signed-in user. Your auth provider may add any field (role, team…): policies receive it as-is. */
+export type User = {
+    id: string | number;
+    name: string;
+    email: string;
+    [key: string]: unknown;
+};
+/**
+ * Resource policy: one function per ability
+ * (`viewAny`, `create`, `update`, `delete`, `deleteAny`, `restore`, `forceDelete`, `reorder`, or your own names).
+ * A missing ability is allowed.
+ */
+export type Policy<R = any> = Partial<Record<string, (user: User, record: R | null) => boolean | Promise<boolean>>>;
+/** A reusable bundle of configuration. `register` receives the panel being built; `boot` is called when the router is mounted. */
+export type Plugin = {
+    id: string;
+    register(panel: Panel): void;
+    boot?(panel: Panel): void;
+};
+/** Question asked to the panel's authorization hook. `resource`, `page` or `widget` tells what it is about. */
+export type AuthorizationCheck = {
+    user: User;
+    ability: string;
+    resource: unknown | null;
+    record: unknown | null;
+    page: typeof Page | null;
+    widget: typeof Widget | null;
+};
+/** Return `true` or `false` to decide, or `undefined` to let the resource policy (or `canAccess` / `canView`) answer. */
+export type Authorizer = (check: AuthorizationCheck) => boolean | undefined | Promise<boolean | undefined>;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * User provider. `attempt` and `find` are enough for login; the optional methods enable
+ * registration (`create`, `findByEmail`), password reset (`findByEmail`, `update`, `getPasswordFingerprint`),
+ * email verification (`hasVerifiedEmail`, `markEmailAsVerified`) and the profile page (`update`).
+ * `knexAuthProvider(knex)` implements all of them for a `users` table.
+ */
+export interface AuthProvider {
+    attempt(email: string, password: string): MaybePromise<User | null>;
+    find(id: string | number): MaybePromise<User | null>;
+    findByEmail?(email: string): MaybePromise<User | null>;
+    /** Creates the user. The password is plain text; the provider must hash it. */
+    create?(data: {
+        name: string;
+        email: string;
+        password: string;
+    }): MaybePromise<User>;
+    /** Updates name, email or password (plain text, to hash). Changing the email must reset its verification. */
+    update?(user: User, data: {
+        name?: string;
+        email?: string;
+        password?: string;
+    }): MaybePromise<User>;
+    hasVerifiedEmail?(user: User): MaybePromise<boolean>;
+    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>;
+}
+/**
+ * Panel tenants (teams, organizations…). Every panel page then lives under
+ * `/<panel>/<tenant key>/…`, and only a member of the tenant can open it.
+ */
+export interface TenantProvider<T = any> {
+    /** Tenants the user is a member of. */
+    getTenants(user: User): MaybePromise<T[]>;
+    /** Tenant from its URL key (comes from the browser: validate it). */
+    find(key: string): MaybePromise<T | null>;
+    canAccess(user: User, tenant: T): MaybePromise<boolean>;
+    getKey(tenant: T): string;
+    getName(tenant: T): string;
+    /** Text above the tenant name in the menu ("Current team"), or `null`. */
+    getCurrentTenantLabel?(tenant: T): string | null;
+    getAvatarUrl?(tenant: T): string | null;
+    /** 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>;
+}
+export type PanelContext = {
+    req: Request;
+    res: Response;
+    panel: Panel;
+    user: User | null;
+    mailbox: string;
+    tenant?: unknown;
+};
+/**
+ * Predefined panel theme: a set of colors (palettes or plain colors), optionally a font and some CSS.
+ * When a panel declares several, users pick theirs from the user menu; the choice is kept in a cookie.
+ */
+export type Theme = {
+    id: string;
+    label: string;
+    colors?: Record<string, Palette | string>;
+    font?: {
+        family: string;
+        url?: string;
+    };
+    /** CSS added to the page for this theme (written by the panel developer, inserted as-is). */
+    css?: string;
+};
+export declare class NavigationItem {
+    label: string;
+    _url: string;
+    _icon: string | null;
+    _group: string | null;
+    _sort: number;
+    _isActive: ((path: string) => boolean) | null;
+    _badge: string | number | null;
+    _badgeColor: string;
+    constructor(label: string);
+    static make(label: string): NavigationItem;
+    url(url: string): this;
+    icon(icon: string | null): this;
+    group(group: string | null): this;
+    sort(sort: number): this;
+    badge(badge: string | number | null, color?: string): this;
+    /** By default an item is active on its exact URL; this overrides the rule. */
+    isActiveWhen(fn: (path: string) => boolean): this;
+    isActive(path: string): boolean;
+}
+export declare class Panel {
+    private _id;
+    private _path;
+    private _brandName;
+    private _brandLogo;
+    private _darkModeBrandLogo;
+    private _brandLogoHeight;
+    private _favicon;
+    private _theme;
+    private _motion;
+    private _themes;
+    private _font;
+    private _login;
+    private _auth;
+    private _key;
+    private _pages;
+    private _resources;
+    private _navigationItems;
+    private _navigationGroups;
+    private _maxContentWidth;
+    readonly colors: ColorManager;
+    static make(): Panel;
+    id(id: string): this;
+    path(path: string): this;
+    brandName(name: string): this;
+    brandLogo(url: string): this;
+    darkModeBrandLogo(url: string): this;
+    brandLogoHeight(height: string): this;
+    /** Browser tab icon. */
+    favicon(url: string | null): this;
+    getFavicon(): string | null;
+    /**
+     * Theme stylesheet compiled by the application (Tailwind); it replaces the default stylesheet.
+     * The theme imports `@navette-js/panels/theme.css` and declares its own sources.
+     */
+    theme(url: string | null): this;
+    getTheme(): string | null;
+    /**
+     * Navette's motion and loading indicators (springs, activity dot, spinner for deferred areas).
+     * `motion(false)` renders the plain interface without them.
+     */
+    motion(enabled?: boolean): this;
+    hasMotion(): boolean;
+    /** Themes offered to the user; the first one is the default. */
+    themes(themes: Theme[]): this;
+    getThemes(): Theme[];
+    /** Theme for the request: the cookie's theme if declared, otherwise the first one. `null` if the panel has no themes. */
+    resolveTheme(req: Request): Theme | null;
+    rememberTheme(res: Response, theme: Theme): void;
+    /** Runs a render with the colors of the request's theme. */
+    withTheme<T>(req: Request, fn: () => T): T;
+    setColors(colors: Record<string, Palette | string>): this;
+    /** Panel font. Without a URL, it is loaded from Bunny Fonts. */
+    font(family: string, url?: string): this;
+    login(page?: typeof Login): this;
+    auth(provider: AuthProvider): this;
+    key(key: string): this;
+    pages(pages: (typeof Page)[]): this;
+    /** Registers resources: their pages and navigation items. */
+    resources(resources: (typeof Resource)[]): this;
+    navigationItems(items: NavigationItem[]): this;
+    /** Order of navigation groups. */
+    navigationGroups(groups: string[]): this;
+    private _plugins;
+    /** Applies a plugin: an object that configures the panel (resources, pages, render hooks, themes…). */
+    plugin(plugin: Plugin): this;
+    plugins(plugins: Plugin[]): this;
+    getPlugins(): Plugin[];
+    private _renderHooks;
+    /**
+     * Inserts HTML at a named location of this panel's UI (names: `PanelsRenderHook`, `TablesRenderHook`, `ActionsRenderHook`, `WidgetsRenderHook`).
+     * `scopes` limits the hook to some pages or resources (their class). The HTML is inserted as-is: escape any data with `e()`.
+     */
+    renderHook(name: string, render: RenderHookCallback, scopes?: unknown | unknown[] | null): this;
+    getRenderHooks(): RenderHookRegistry;
+    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. */
+    authorize(user: User | null, ability: string, subject?: {
+        resource?: unknown;
+        record?: unknown;
+        page?: typeof Page;
+        widget?: typeof Widget;
+        rule?: (() => boolean | Promise<boolean>) | null;
+    }): Promise<boolean>;
+    /** Whether the user can open a page. List: `viewAny`; create: `create`; edit: checked against the record; custom page: `canAccess`. */
+    canAccessPage(PageClass: typeof Page, user: User | null): Promise<boolean>;
+    private _widgets;
+    /** Panel widgets (dashboard, custom pages): registered as components, displayed through a page's `getHeaderWidgets()`. */
+    widgets(widgets: (typeof Widget)[]): this;
+    getWidgets(): (typeof Widget)[];
+    maxContentWidth(width: string): this;
+    getId(): string;
+    getBrandName(): string;
+    getAuth(): AuthProvider;
+    getLoginPage(): typeof Login | null;
+    getPages(): (typeof Page)[];
+    getResources(): (typeof Resource)[];
+    private _globalSearch;
+    private _globalSearchKeyBindings;
+    private _globalSearchDebounce;
+    private _globalSearchSuffix;
+    /** `false` removes the global search field. It only appears when at least one resource is searchable. */
+    globalSearch(condition?: boolean): this;
+    /** Keyboard shortcuts that focus the field: `['command+k', 'ctrl+k']`. */
+    globalSearchKeyBindings(keyBindings: string[]): this;
+    getGlobalSearchKeyBindings(): string[];
+    /** Delay between typing and searching (`500ms` by default). */
+    globalSearchDebounce(debounce: string): this;
+    getGlobalSearchDebounce(): string;
+    globalSearchFieldSuffix(suffix: string | null): this;
+    /** Shows the first shortcut in the field, written for the browser's platform (`command+k` shows as "META+K" outside macOS). */
+    globalSearchFieldKeyBindingSuffix(): this;
+    getGlobalSearchFieldSuffix(userAgent?: string): string | null;
+    hasGlobalSearch(): boolean;
+    /** Results per resource, in registration order. Only resources the user can list are queried. */
+    getGlobalSearchResults(search: string, user: User | null): Promise<GlobalSearchCategory[]>;
+    private _databaseNotifications;
+    private _databaseNotificationsPolling;
+    /** Enables the database notifications bell, read from and written to this store (`knexNotificationStore(knex)`). */
+    databaseNotifications(store: DatabaseNotificationStore | null): this;
+    getDatabaseNotifications(): DatabaseNotificationStore | null;
+    /** Polling interval (`30s` by default); `null` disables polling. */
+    databaseNotificationsPolling(interval: string | null): this;
+    getDatabaseNotificationsPollingInterval(): string | null;
+    private _topbar;
+    private _topNavigation;
+    private _navigation;
+    private _sidebarCollapsibleOnDesktop;
+    private _sidebarFullyCollapsibleOnDesktop;
+    private _positions;
+    /** Topbar, shown by default. `topbar(false)` moves the logo, search, bell and user menu into the sidebar. */
+    topbar(condition?: boolean): this;
+    hasTopbar(): boolean;
+    /** Navigation in the topbar (one dropdown per group) instead of the sidebar. */
+    topNavigation(condition?: boolean): this;
+    hasTopNavigation(): boolean;
+    /** `navigation(false)` removes all navigation (no sidebar, no menus). */
+    navigation(condition?: boolean): this;
+    hasNavigation(): boolean;
+    /** On desktop, the sidebar can collapse to a column of icons. */
+    sidebarCollapsibleOnDesktop(condition?: boolean): this;
+    isSidebarCollapsibleOnDesktop(): boolean;
+    /** On desktop, the sidebar can be fully hidden. */
+    sidebarFullyCollapsibleOnDesktop(condition?: boolean): this;
+    isSidebarFullyCollapsibleOnDesktop(): boolean;
+    /** Where the user menu goes; defaults to the topbar when there is one. */
+    userMenuPosition(position: 'topbar' | 'sidebar' | null): this;
+    getUserMenuPosition(): 'topbar' | 'sidebar';
+    globalSearchPosition(position: 'topbar' | 'sidebar' | null): this;
+    getGlobalSearchPosition(): 'topbar' | 'sidebar';
+    databaseNotificationsPosition(position: 'topbar' | 'sidebar' | null): this;
+    getDatabaseNotificationsPosition(): 'topbar' | 'sidebar';
+    private _userMenuItems;
+    /** Items added to the user menu (URL or modal actions). A negative `sort()` places them above the theme switcher. Keys `profile` and `logout` replace the defaults. */
+    userMenuItems(items: Record<string, Action> | Action[]): this;
+    getUserMenuItems(): Record<string, Action>;
+    private _registration;
+    private _passwordReset;
+    private _emailVerification;
+    private _profile;
+    private _mailer;
+    /** Registration page (`/register`). The auth provider must implement `create` and `findByEmail`. */
+    registration(page?: typeof Register | null): this;
+    hasRegistration(): boolean;
+    getRegistrationPage(): typeof Register | null;
+    /** Password reset: request page (`/password-reset/request`), then reset through a signed link sent by email. */
+    passwordReset(request?: typeof RequestPasswordReset, reset?: typeof ResetPassword): this;
+    hasPasswordReset(): boolean;
+    getPasswordResetPages(): {
+        request: typeof RequestPasswordReset;
+        reset: typeof ResetPassword;
+    };
+    /** Email verification: a signed link is sent on registration. Until it is followed, only the verification prompt is accessible (`isRequired`). */
+    emailVerification(prompt?: typeof EmailVerificationPrompt, isRequired?: boolean): this;
+    hasEmailVerification(): boolean;
+    isEmailVerificationRequired(): boolean;
+    getEmailVerificationPrompt(): typeof EmailVerificationPrompt | null;
+    /** Profile page (`/profile`): name, email, password. `isSimple`: simple layout (default) or full panel layout. */
+    profile(page?: typeof EditProfile, isSimple?: boolean): this;
+    hasProfile(): boolean;
+    getProfile(): {
+        page: typeof EditProfile;
+        isSimple: boolean;
+    };
+    /** Mailer for password reset and verification emails. Defaults to the console. */
+    mailer(mailer: Mailer): this;
+    sendMail(message: MailMessage): Promise<void>;
+    getAuthKey(): string;
+    getRegistrationUrl(): string;
+    getRequestPasswordResetUrl(): string;
+    getResetPasswordUrl(user: User, fingerprint: string): string;
+    /** Payload of a password reset token valid for this panel, otherwise `null`. */
+    readResetPasswordToken(token: unknown): {
+        uid: string | number;
+        fp: string;
+    } | null;
+    getVerifyEmailUrl(user: User): string;
+    checkVerifyEmailUrl(id: string, hash: string, expires: unknown, signature: unknown): boolean;
+    getEmailVerificationPromptUrl(): string;
+    getProfileUrl(): string | null;
+    /** Whether the user must still verify their email before using the panel. */
+    mustVerifyEmail(user: User | null): Promise<boolean>;
+    private _tenant;
+    private _tenantOwnershipColumn;
+    private _tenantRegistration;
+    private _tenantProfile;
+    private _tenantMenu;
+    private _tenantMenuItems;
+    private _tenantScope;
+    /**
+     * Makes the panel multi-tenant. `ownershipColumn` is the column linking a record to its tenant (`team_id`);
+     * the panel's resources then only read and write the current tenant's records (see `Resource.isScopedToTenant`).
+     */
+    tenant(provider: TenantProvider | null, options?: {
+        ownershipColumn?: string;
+    }): this;
+    hasTenancy(): boolean;
+    getTenantProvider(): TenantProvider;
+    getTenantOwnershipColumn(): string | null;
+    /** Tenant registration page (`/new`). */
+    tenantRegistration(page: typeof RegisterTenant | null): this;
+    getTenantRegistrationPage(): typeof RegisterTenant | null;
+    /** Tenant profile page (`/<tenant>/profile`). */
+    tenantProfile(page: typeof EditTenantProfile | null): this;
+    getTenantProfilePage(): typeof EditTenantProfile | null;
+    tenantMenu(condition?: boolean): this;
+    hasTenantMenu(): boolean;
+    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. */
+    withTenant<T>(tenant: unknown, fn: () => T): T;
+    /** Tenant of the current request, or `null`. */
+    getTenant<T = any>(): T | null;
+    getTenantUrlKey(tenant: unknown): string;
+    private _subNavigationPosition;
+    /** Default position of page sub-navigation (`start`). */
+    subNavigationPosition(position: 'start' | 'end' | 'top'): this;
+    getSubNavigationPosition(): 'start' | 'end' | 'top';
+    private _appUrl;
+    /** Public URL of the application (`https://example.com`), used in emailed links. Without it the request origin is used, which should be avoided in production (the `Host` header can be forged). */
+    appUrl(url: string | null): this;
+    getAppUrl(): string | null;
+    getMaxContentWidth(): string;
+    /** URL inside the panel; in a multi-tenant panel, prefixed with the current (or given) tenant. */
+    getUrl(sub?: string, tenant?: unknown): string;
+    /** URL outside any tenant (login, registration, profile, tenant registration). */
+    getBaseUrl(sub?: string): string;
+    getLoginUrl(): string;
+    getLogoutUrl(): string;
+    /** Prefix of this panel's Livewire endpoint (`/livewire` or `/<path>/livewire`): each panel has its own. */
+    getLivewirePrefix(): string;
+    assetUrl(file: string): string;
+    getBrand(): Record<string, unknown>;
+    getFont(): typeof this._font;
+    /** Default avatar: the name's initials from the external ui-avatars.com service. */
+    getUserAvatarUrl(user: User): string;
+    /** 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;
+    hasSpaMode(): boolean;
+    getAvatarUrlFor(name: string): string;
+    /** Navigation groups: registered pages plus custom items, sorted, grouped in the declared order. */
+    /** Computed navigation badges: page URL → value. */
+    resolveNavigationBadges(): Promise<Map<string, string | number | null>>;
+    /** URLs of menu pages this user cannot open. */
+    resolveInaccessiblePages(user: User | null): Promise<Set<string>>;
+    getNavigation(path: string, badges?: Map<string, string | number | null>, hidden?: Set<string>): {
+        label: string | null;
+        itemsId: string;
+        isActive: boolean;
+        items: {
+            label: string;
+            url: string;
+            icon: string | null;
+            isActive: boolean;
+            badge: string | number | null;
+            badgeColorClasses: string[];
+        }[];
+    }[];
+    private sign;
+    logIn(res: Response, user: User, remember: boolean): void;
+    logOut(res: Response): void;
+    user(req: Request): Promise<User | null>;
+}
+/**
+ * Render hook locations of a panel. A few are declared but not rendered anywhere yet: see `UNPLACED_RENDER_HOOKS`.
+ */
+export declare const PanelsRenderHook: {
+    readonly AUTH_LOGIN_FORM_AFTER: "panels::auth.login.form.after";
+    readonly AUTH_LOGIN_FORM_BEFORE: "panels::auth.login.form.before";
+    readonly AUTH_PASSWORD_RESET_REQUEST_FORM_AFTER: "panels::auth.password-reset.request.form.after";
+    readonly AUTH_PASSWORD_RESET_REQUEST_FORM_BEFORE: "panels::auth.password-reset.request.form.before";
+    readonly AUTH_PASSWORD_RESET_RESET_FORM_AFTER: "panels::auth.password-reset.reset.form.after";
+    readonly AUTH_PASSWORD_RESET_RESET_FORM_BEFORE: "panels::auth.password-reset.reset.form.before";
+    readonly AUTH_REGISTER_FORM_AFTER: "panels::auth.register.form.after";
+    readonly AUTH_REGISTER_FORM_BEFORE: "panels::auth.register.form.before";
+    readonly BODY_END: "panels::body.end";
+    readonly BODY_START: "panels::body.start";
+    readonly CONTENT_AFTER: "panels::content.after";
+    readonly CONTENT_BEFORE: "panels::content.before";
+    readonly CONTENT_END: "panels::content.end";
+    readonly CONTENT_START: "panels::content.start";
+    readonly FOOTER: "panels::footer";
+    readonly GLOBAL_SEARCH_AFTER: "panels::global-search.after";
+    readonly GLOBAL_SEARCH_BEFORE: "panels::global-search.before";
+    readonly GLOBAL_SEARCH_END: "panels::global-search.end";
+    readonly GLOBAL_SEARCH_START: "panels::global-search.start";
+    readonly HEAD_END: "panels::head.end";
+    readonly HEAD_START: "panels::head.start";
+    readonly LAYOUT_END: "panels::layout.end";
+    readonly LAYOUT_START: "panels::layout.start";
+    readonly PAGE_END: "panels::page.end";
+    readonly PAGE_FOOTER_WIDGETS_AFTER: "panels::page.footer-widgets.after";
+    readonly PAGE_FOOTER_WIDGETS_BEFORE: "panels::page.footer-widgets.before";
+    readonly PAGE_FOOTER_WIDGETS_END: "panels::page.footer-widgets.end";
+    readonly PAGE_FOOTER_WIDGETS_START: "panels::page.footer-widgets.start";
+    readonly PAGE_HEADER_ACTIONS_AFTER: "panels::page.header.actions.after";
+    readonly PAGE_HEADER_ACTIONS_BEFORE: "panels::page.header.actions.before";
+    readonly PAGE_HEADER_HEADING_AFTER: "panels::page.header.heading.after";
+    readonly PAGE_HEADER_HEADING_BEFORE: "panels::page.header.heading.before";
+    readonly PAGE_HEADER_WIDGETS_AFTER: "panels::page.header-widgets.after";
+    readonly PAGE_HEADER_WIDGETS_BEFORE: "panels::page.header-widgets.before";
+    readonly PAGE_HEADER_WIDGETS_END: "panels::page.header-widgets.end";
+    readonly PAGE_HEADER_WIDGETS_START: "panels::page.header-widgets.start";
+    readonly PAGE_START: "panels::page.start";
+    /** The hook name says "module-menu", not "mobile-menu": kept for compatibility. */
+    readonly PAGE_SUB_NAVIGATION_MOBILE_MENU_AFTER: "panels::page.sub-navigation.module-menu.after";
+    readonly PAGE_SUB_NAVIGATION_MOBILE_MENU_BEFORE: "panels::page.sub-navigation.module-menu.before";
+    readonly PAGE_SUB_NAVIGATION_SIDEBAR_AFTER: "panels::page.sub-navigation.sidebar.after";
+    readonly PAGE_SUB_NAVIGATION_SIDEBAR_BEFORE: "panels::page.sub-navigation.sidebar.before";
+    readonly PAGE_SUB_NAVIGATION_START_AFTER: "panels::page.sub-navigation.start.after";
+    readonly PAGE_SUB_NAVIGATION_START_BEFORE: "panels::page.sub-navigation.start.before";
+    readonly PAGE_SUB_NAVIGATION_TOP_AFTER: "panels::page.sub-navigation.top.after";
+    readonly PAGE_SUB_NAVIGATION_TOP_BEFORE: "panels::page.sub-navigation.top.before";
+    readonly PAGE_SUB_NAVIGATION_END_AFTER: "panels::page.sub-navigation.end.after";
+    readonly PAGE_SUB_NAVIGATION_END_BEFORE: "panels::page.sub-navigation.end.before";
+    readonly RESOURCE_PAGES_LIST_RECORDS_TABLE_AFTER: "panels::resource.pages.list-records.table.after";
+    readonly RESOURCE_PAGES_LIST_RECORDS_TABLE_BEFORE: "panels::resource.pages.list-records.table.before";
+    readonly RESOURCE_PAGES_LIST_RECORDS_TABS_END: "panels::resource.pages.list-records.tabs.end";
+    readonly RESOURCE_PAGES_LIST_RECORDS_TABS_START: "panels::resource.pages.list-records.tabs.start";
+    readonly RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_AFTER: "panels::resource.pages.manage-related-records.table.after";
+    readonly RESOURCE_PAGES_MANAGE_RELATED_RECORDS_TABLE_BEFORE: "panels::resource.pages.manage-related-records.table.before";
+    readonly RESOURCE_RELATION_MANAGER_AFTER: "panels::resource.relation-manager.after";
+    readonly RESOURCE_RELATION_MANAGER_BEFORE: "panels::resource.relation-manager.before";
+    readonly RESOURCE_TABS_END: "panels::resource.tabs.end";
+    readonly RESOURCE_TABS_START: "panels::resource.tabs.start";
+    readonly SCRIPTS_AFTER: "panels::scripts.after";
+    readonly SCRIPTS_BEFORE: "panels::scripts.before";
+    readonly SIDEBAR_FOOTER: "panels::sidebar.footer";
+    readonly SIDEBAR_LOGO_AFTER: "panels::sidebar.logo.after";
+    readonly SIDEBAR_LOGO_BEFORE: "panels::sidebar.logo.before";
+    readonly SIDEBAR_START: "panels::sidebar.start";
+    readonly SIDEBAR_NAV_END: "panels::sidebar.nav.end";
+    readonly SIDEBAR_NAV_START: "panels::sidebar.nav.start";
+    readonly SIMPLE_LAYOUT_END: "panels::simple-layout.end";
+    readonly SIMPLE_LAYOUT_START: "panels::simple-layout.start";
+    readonly SIMPLE_PAGE_END: "panels::simple-page.end";
+    readonly SIMPLE_PAGE_START: "panels::simple-page.start";
+    readonly STYLES_AFTER: "panels::styles.after";
+    readonly STYLES_BEFORE: "panels::styles.before";
+    readonly TENANT_MENU_AFTER: "panels::tenant-menu.after";
+    readonly TENANT_MENU_BEFORE: "panels::tenant-menu.before";
+    readonly TOPBAR_AFTER: "panels::topbar.after";
+    readonly TOPBAR_BEFORE: "panels::topbar.before";
+    readonly TOPBAR_END: "panels::topbar.end";
+    readonly TOPBAR_LOGO_AFTER: "panels::topbar.logo.after";
+    readonly TOPBAR_LOGO_BEFORE: "panels::topbar.logo.before";
+    readonly TOPBAR_START: "panels::topbar.start";
+    readonly USER_MENU_AFTER: "panels::user-menu.after";
+    readonly USER_MENU_BEFORE: "panels::user-menu.before";
+    readonly USER_MENU_PROFILE_AFTER: "panels::user-menu.profile.after";
+    readonly USER_MENU_PROFILE_BEFORE: "panels::user-menu.profile.before";
+};
+/** Widget render hook locations, rendered by `TableWidget`. */
+export declare const WidgetsRenderHook: {
+    readonly TABLE_WIDGET_END: "widgets::table-widget.end";
+    readonly TABLE_WIDGET_START: "widgets::table-widget.start";
+};
+/**
+ * Hook locations that are declared but not rendered anywhere yet, with the reason.
+ */
+export declare const UNPLACED_RENDER_HOOKS: Record<string, string>;
+/** Common base: a stateful component hosting schemas (`<name>Schema(schema)`). */
+declare abstract class BasePage extends Component implements SchemaHost {
+    get panel(): Panel;
+    getSchema(name: string): Schema;
+    contentSchema(schema: Schema): Schema;
+    /** Render hook scopes of this page: its class (and its resource, for a resource page). */
+    getRenderHookScopes(): unknown[];
+}
+/** A panel page, in the full layout (sidebar, header). */
+export declare class Page extends BasePage {
+    /** Methods the browser may call. A subclass adds its own: `static callable = ['approve']`. */
+    static callable: string[];
+    static slug: string;
+    static title: string | null;
+    static navigationLabel: string | null;
+    static navigationIcon: string | null;
+    static navigationGroup: string | null;
+    static navigationSort: number;
+    static navigationBadge: string | number | null;
+    static navigationBadgeColor: string;
+    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>;
+    static getTitle(): string;
+    static getNavigationLabel(): string;
+    /** Every request, including browser updates, requires an authenticated user: a snapshot kept after logout is not enough. */
+    boot(): Promise<void>;
+    protected isAccessAuthorized(ctx: PanelContext): boolean | Promise<boolean>;
+    getTitle(): string;
+    getHeading(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getHeaderActions(): Action[];
+    getPageClasses(): string[];
+    /** Page sub-navigation; empty by default. */
+    getSubNavigation(): SubNavigationItem[] | Promise<SubNavigationItem[]>;
+    /** 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';
+    /** Widgets shown below the page content. */
+    getFooterWidgets(): (typeof Widget)[];
+    getFooterWidgetsColumns(): number | Record<string, number>;
+    /** Footer widget grid, in the page's `footerWidgets` schema. */
+    protected renderFooterWidgets(): Promise<string>;
+    /** Widgets shown above the page content, with the data passed to each (widget properties). */
+    getHeaderWidgets(): (typeof Widget)[];
+    getHeaderWidgetsColumns(): number;
+    getWidgetData(): Record<string, unknown>;
+    /** Header widget grid, in the page's `headerWidgets` schema. */
+    protected renderHeaderWidgets(): Promise<string>;
+    /** Widgets the current user is allowed to see. */
+    protected filterVisibleWidgets(candidates: (typeof Widget)[]): Promise<(typeof Widget)[]>;
+    /** 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.
+     */
+    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>;
+    render(): Promise<string>;
+}
+/**
+ * Dashboard: a widget grid, preceded by a filters form when the page defines `filtersFormSchema(schema)`.
+ * The filters are passed to widgets as `pageFilters`.
+ */
+export declare class Dashboard extends Page {
+    static slug: string;
+    static title: string;
+    static navigationIcon: string;
+    static navigationSort: number;
+    /** 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([...])`). */
+    getWidgets(): (typeof Widget)[];
+    /** Grid columns: a number (at the `lg` breakpoint), or one number per breakpoint. */
+    getColumns(): number | Record<string, number>;
+    hasFiltersForm(): boolean;
+    getSchema(name: string): Schema;
+    mount(): void;
+    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;
+    getHeading(): string | null;
+    /** Subheading, as trusted HTML (built by the page, with data escaped). */
+    getSubheading(): string | null;
+    hasLogo(): boolean;
+    render(): Promise<string>;
+}
+/** Registration page: name, email, confirmed password. The user is logged in, then asked to verify their email if the panel requires it. */
+export declare class Register extends SimplePage {
+    static callable: string[];
+    data: Record<string, unknown>;
+    mount(): void;
+    getTitle(): string;
+    getHeading(): string;
+    getSubheading(): string | null;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    /** Validated data, just before creation (add a value, normalize the email…). */
+    protected mutateFormDataBeforeRegister(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Creates the user; defaults to the auth provider's `create()`. */
+    protected handleRegistration(data: Record<string, unknown>): Promise<User> | User;
+    register(): Promise<void>;
+}
+/** Password reset request page: a signed link, valid for 60 minutes, is sent by email. */
+export declare class RequestPasswordReset extends SimplePage {
+    static callable: string[];
+    data: Record<string, unknown>;
+    mount(): void;
+    getTitle(): string;
+    getHeading(): string;
+    getSubheading(): string | null;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    request(): Promise<void>;
+}
+/** Sets a new password from the emailed link. The link works once: it dies with the old password. */
+export declare class ResetPassword extends SimplePage {
+    static callable: string[];
+    static locked: string[];
+    email: string | null;
+    password: string;
+    passwordConfirmation: string;
+    token: string | null;
+    mount(params: Record<string, unknown>): void;
+    /** The form has no state path: its fields are page properties. */
+    getSchema(name: string): Schema;
+    getTitle(): string;
+    getHeading(): string;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    resetPassword(): Promise<void>;
+}
+/** Email verification prompt, with a "Resend it." link. */
+export declare class EmailVerificationPrompt extends SimplePage {
+    static callable: string[];
+    mount(): Promise<void>;
+    getTitle(): string;
+    getHeading(): string;
+    contentSchema(schema: Schema): Schema;
+    /** The page's only action: resend the email (at most twice per minute). */
+    mountAction(name: unknown): Promise<void>;
+}
+/** User profile page: name, email, new password. The current password is required to change the email or password. */
+export declare class EditProfile extends SimplePage {
+    static callable: string[];
+    static slug: string;
+    data: Record<string, unknown>;
+    static getLabel(): string;
+    mount(): Promise<void>;
+    boot(): Promise<void>;
+    getTitle(): string;
+    hasLogo(): boolean;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    save(): Promise<void>;
+}
+/** Tenant registration page: the subclass provides its label and form (`formSchema`). */
+export declare abstract class RegisterTenant extends SimplePage {
+    static callable: string[];
+    static slug: string;
+    data: Record<string, unknown>;
+    static getLabel(): string;
+    /** Whether tenants can be created; by default, if the tenant provider implements `create`. */
+    static canView(panel: Panel, _user: User): boolean | Promise<boolean>;
+    boot(): Promise<void>;
+    mount(): void;
+    getTitle(): string;
+    hasLogo(): boolean;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    protected mutateFormDataBeforeRegister(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    protected handleRegistration(data: Record<string, unknown>): unknown;
+    register(): Promise<void>;
+}
+/** Current tenant's profile page, in the full layout. */
+export declare abstract class EditTenantProfile extends Page {
+    static callable: string[];
+    static slug: string;
+    static shouldRegisterNavigation: boolean;
+    data: Record<string, unknown>;
+    static getLabel(): string;
+    static getTitle(): string;
+    protected isAccessAuthorized(ctx: PanelContext): boolean | Promise<boolean>;
+    mount(): void;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    save(): Promise<void>;
+}
+export declare class Login extends SimplePage {
+    static callable: string[];
+    data: Record<string, unknown>;
+    mount(): void;
+    getTitle(): string;
+    getHeading(): string;
+    getSubheading(): string | null;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    authenticate(): Promise<void>;
+}
+/** 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;
+/** Resource: a model with its pages, table and navigation. */
+export declare abstract class Resource {
+    static panel: Panel;
+    static slug: string;
+    static modelLabel: string;
+    static pluralModelLabel: string | null;
+    static navigationIcon: string | null;
+    static navigationGroup: string | null;
+    static navigationSort: number;
+    static navigationBadge: string | number | null;
+    static adapter: DataAdapter;
+    /** In a multi-tenant panel, whether records belong to each tenant (`true` by default). */
+    static isScopedToTenant: boolean;
+    /** Tenant column for this resource (defaults to the panel's: `panel.tenant(provider, { ownershipColumn })`). */
+    static tenantOwnershipColumn: string | null;
+    /**
+     * Resource pages; replace them with your subclasses to change their behavior:
+     * `static pages = { index: MyList, create: MyCreate, edit: MyEdit }`.
+     */
+    static pages: {
+        index?: typeof ListRecords;
+        create?: typeof CreateRecord;
+        edit?: typeof EditRecord;
+        view?: typeof ViewRecord;
+    };
+    /** `true` adds a view page (`ViewRecord`) to the resource; table rows then link to it. */
+    static hasViewPage: boolean;
+    /** Who can do what on this resource. Without a policy, any signed-in user can do everything. */
+    static policy: Policy | null;
+    /** Whether the user has this ability (on this record, if any). */
+    static can(ability: string, user: User | null, record?: unknown): Promise<boolean>;
+    /** Resource widgets, registered as components. */
+    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[];
+    /** Tabs of the list page. */
+    static tabs(): Record<string, Tab>;
+    /** Simple resource: a single page, with create and edit in modals. */
+    static isSimple: boolean;
+    static getPluralModelLabel(): string;
+    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>;
+    /** 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. */
+    static getRecordSubNavigation(page: {
+        getRecordKey(): string | null;
+        constructor: Function;
+    }): SubNavigationItem[];
+    private static _registered;
+    /** Page class actually registered under a name (pages are generated once per resource). */
+    static getRegisteredPage(name: string): typeof Page | undefined;
+    static table(table: Table): Table;
+    static form(schema: Schema): Schema;
+    /** Schema of the view page. */
+    static infolist(schema: Schema): Schema;
+    /** Columns searched by global search; defaults to the title attribute. Empty array: the resource is not searchable. */
+    static globallySearchableAttributes: string[] | null;
+    static getGloballySearchableAttributes(): string[];
+    static canGloballySearch(): boolean;
+    /** Position of this resource's group in the results; without one, after the others in registration order. */
+    static globalSearchSort: number | null;
+    /** Maximum results rendered per resource. */
+    static globalSearchResultsLimit: number;
+    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>>;
+    /** 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[]>;
+    /** Attribute used as a record's title. */
+    static recordTitleAttribute: string | null;
+    /** Without a title attribute: the model label in title case ("Leave Request"). */
+    static getRecordTitle(record: any): string;
+    /** Generated resource pages: list, create, edit. */
+    static getPages(): Record<string, typeof Page>;
+    private static buildPages;
+}
+/** Sub-navigation tab of a page. */
+export type SubNavigationItem = {
+    label: string;
+    icon: string | null;
+    url: string;
+    active: boolean;
+};
+type ColumnSpan = 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'`. */
+    static columnSpan: ColumnSpan;
+    /** 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. */
+    protected gridColumn(): {
+        classes: string[];
+        style: string;
+    };
+    placeholder(): string;
+    /** Common widget wrapper. */
+    protected wrap(content: string, classes?: string[]): string;
+}
+/**
+ * Calendar widget: month, week and list views, server-rendered navigation, no JavaScript library.
+ *
+ * Minimal use: extend the class and return the events of the displayed period.
+ *
+ *     class LeaveCalendar extends CalendarWidget {
+ *         static heading = 'Leave';
+ *         async getEvents({ start, end }) { return [{ id: 1, title: 'Ada — vacation', start: '2026-11-12', end: '2026-11-14', color: 'success' }]; }
+ *     }
+ *
+ * Everything else can be overridden method by method: available views, first day of the week, locale, labels, events
+ * per cell, day clicks (`onDateClick`) and event clicks (`onEventClick`), event rendering (`renderEvent`), cell footer
+ * (`renderDayFooter`), toolbar buttons (`renderToolbarEnd`), and appearance through the `.nv-cal` CSS variables
+ * (`getExtraClasses`, `getStyle`).
+ */
+export declare abstract class CalendarWidget extends Widget {
+    static columnSpan: ColumnSpan;
+    /** Heading shown before the period ("Leave — November 2026"). */
+    static heading: string | null;
+    static callable: string[];
+    /** View and date only change through the methods below, which validate them. */
+    static locked: string[];
+    view: CalendarView;
+    /** Anchor date (`YYYY-MM-DD`): the displayed month or week contains it. Empty: today. */
+    date: string;
+    /** Events overlapping `start`–`end` (inclusive, `YYYY-MM-DD`). Called on every render: filter in the database. */
+    abstract getEvents(range: {
+        start: string;
+        end: string;
+        view: CalendarView;
+    }): CalendarEvent[] | Promise<CalendarEvent[]>;
+    /** Available views; the first is the initial one. With a single view, the switcher is hidden. */
+    getViews(): CalendarView[];
+    /** 0 = Sunday, 1 = Monday… */
+    getFirstDayOfWeek(): number;
+    /** Locale for month and day names (`Intl`). */
+    getLocale(): string;
+    getLabels(): CalendarLabels;
+    /** In month view, beyond this number the cell shows "+N more" (which opens the list on that day). */
+    getMaxEventsPerDay(): number;
+    getHeading(): string | null;
+    /** Today's date, `YYYY-MM-DD` (UTC by default; override for another time zone). */
+    getToday(): string;
+    /** Click on a day number. Overriding this makes days clickable: open a page (`this.redirect`), notify, switch view… */
+    onDateClick(_date: string): void | Promise<void>;
+    /** Click on an event without a URL. The event is reloaded server-side, so `event.extra` is available. */
+    onEventClick(_event: CalendarEvent): void | Promise<void>;
+    /** Already-escaped HTML for an event, or `null` for the default rendering (`renderCalendarEvent`). */
+    renderEvent(_event: CalendarEvent, _context: {
+        day: string;
+        view: CalendarView;
+    }): string | null;
+    /** Already-escaped HTML appended to the bottom of each cell. */
+    renderDayFooter(_day: string, _events: CalendarEvent[]): string;
+    /** Already-escaped HTML at the end of the toolbar: a "New" link, a filter… */
+    renderToolbarEnd(): string;
+    /** Extra classes on the calendar, to hook your styles or override its CSS variables. */
+    getExtraClasses(): string[];
+    /** CSS variables set on the calendar: `{ '--nv-cal-day-min-height': '9rem' }`. */
+    getStyle(): Record<string, string>;
+    private anchor;
+    private currentView;
+    private shift;
+    previousPeriod(): void;
+    nextPeriod(): void;
+    goToToday(): void;
+    setView(view: unknown): void;
+    /** "+N more": the list view anchored on that day (or the week view if list is not available). */
+    showDay(date: unknown): void;
+    private datesClickable;
+    private eventsClickable;
+    selectDate(date: unknown): Promise<void>;
+    /** The id comes from the browser: the event is looked up among those of the displayed period, never trusted as-is. */
+    selectEvent(id: unknown): Promise<void>;
+    render(): Promise<string>;
+}
+/**
+ * Calendar page: the same calendar as `CalendarWidget`, on a full page, with actions — so modals, forms,
+ * confirmations and slide-overs.
+ *
+ *     class Planning extends CalendarPage {
+ *         static slug = 'planning';
+ *         async getEvents({ start, end }) { return db('shifts').where('day', '>=', start).where('day', '<=', end)… }
+ *         // Day click: a modal with a form, prefilled with the date.
+ *         dateAction() {
+ *             return Action.make('createShift').modalHeading('New shift')
+ *                 .schema([Select.make('employee_id').options(…).required(), DatePicker.make('day').required()])
+ *                 .fillForm(({ arguments: args }) => ({ day: CalendarPage.dateOf(args) }))
+ *                 .action(async ({ data }) => { await db('shifts').insert(data); Notification.make().success().title('Saved').send(); });
+ *         }
+ *         // Event click: another action; the event is reloaded server-side.
+ *         eventAction() {
+ *             return Action.make('editShift').schema([…])
+ *                 .fillForm(async ({ livewire, arguments: args }) => (await livewire.findEvent(args.event))?.extra ?? {})
+ *                 .action(async ({ livewire, arguments: args, data }) => { const event = await livewire.findEvent(args.event); if (event) await db('shifts').where({ id: event.id }).update(data); });
+ *         }
+ *     }
+ *
+ * Three ways to handle a click: a **URL** on the event (`url`: dedicated page), an **action** (modal),
+ * or **custom code** by overriding `onDateClick()` / `onEventClick()` (redirect, notify, write to the database, mount any
+ * action with `this.mountAction(name, arguments)`). `getHeaderActions()` adds buttons to the page header, and
+ * `getCalendarActions()` declares other actions mountable from your own rendering (`renderEvent`, `renderToolbarEnd`).
+ */
+export declare abstract class CalendarPage extends Page {
+    static callable: string[];
+    static locked: string[];
+    view: CalendarView;
+    date: string;
+    abstract getEvents(range: {
+        start: string;
+        end: string;
+        view: CalendarView;
+    }): CalendarEvent[] | Promise<CalendarEvent[]>;
+    getViews(): CalendarView[];
+    getFirstDayOfWeek(): number;
+    getLocale(): string;
+    getLabels(): CalendarLabels;
+    getMaxEventsPerDay(): number;
+    getCalendarHeading(): string | null;
+    getToday(): string;
+    renderEvent(_event: CalendarEvent, _context: {
+        day: string;
+        view: CalendarView;
+    }): string | null;
+    renderDayFooter(_day: string, _events: CalendarEvent[]): string;
+    renderToolbarEnd(): string;
+    getExtraClasses(): string[];
+    getStyle(): Record<string, string>;
+    /** Action opened on day click; it receives `arguments.date`. `null`: days are not clickable (unless `onDateClick` is overridden). */
+    dateAction(): Action | null;
+    /** Action opened on click on an event without a URL; it receives `arguments.event` (an id, to resolve with `findEvent`). */
+    eventAction(): Action | null;
+    /** Other actions mountable from your own HTML: `wire:click="mountAction('name', { … })"`. */
+    getCalendarActions(): Action[];
+    /** Opens `dateAction()` by default. Override to do something else (e.g. redirect to a create page). */
+    onDateClick(date: string): Promise<void>;
+    /** Opens `eventAction()` by default. The event has been resolved server-side before the call. */
+    onEventClick(event: CalendarEvent): Promise<void>;
+    /** Clicked date, read from an action's arguments. They come from the browser: only a valid date is returned. */
+    static dateOf(args: Record<string, unknown> | null | undefined): string | null;
+    /** Event of the displayed period with this id, or `null`. Never act on a received id without going through this. */
+    findEvent(id: unknown): Promise<CalendarEvent | null>;
+    protected getMountableActions(context: Record<string, unknown>): Promise<Action[]>;
+    private firstDay;
+    private anchor;
+    private currentView;
+    private shift;
+    previousPeriod(): void;
+    nextPeriod(): void;
+    goToToday(): void;
+    setView(view: unknown): void;
+    showDay(date: unknown): void;
+    private datesClickable;
+    private eventsClickable;
+    selectDate(date: unknown): Promise<void>;
+    selectEvent(id: unknown): Promise<void>;
+    protected renderContent(): Promise<string>;
+}
+/** Signed-in user's account: avatar, name, logout. */
+export declare class AccountWidget extends Widget {
+    static isLazy: boolean;
+    render(): string;
+}
+/** Navette version and useful links. */
+export declare class NavetteInfoWidget extends Widget {
+    static isLazy: boolean;
+    static homeUrl: string;
+    static documentationUrl: string;
+    static githubUrl: string;
+    static version: string;
+    render(): string;
+}
+/** One stat of a StatsOverviewWidget. */
+export declare class Stat {
+    private _description;
+    private _descriptionIcon;
+    private _descriptionIconPosition;
+    private _color;
+    private _icon;
+    private _chart;
+    private _url;
+    private label;
+    private value;
+    constructor(label: string, value: string | number | null);
+    static make(label: string, value: string | number | null): Stat;
+    description(text: string | null): this;
+    descriptionIcon(name: string | null, position?: 'before' | 'after'): this;
+    /** Color of the description and chart. */
+    color(color: string | null): this;
+    icon(name: string | null): this;
+    /** Trend chart: a list of values, or values keyed by label. */
+    chart(values: Record<string, number> | number[] | null): this;
+    url(url: string | null): this;
+    hasChart(): boolean;
+    toHtml(panel: Panel, key: string): string;
+}
+/** A row of stats. */
+export declare abstract class StatsOverviewWidget extends Widget {
+    static columnSpan: ColumnSpan;
+    /** Polling interval, or `null` to disable polling. */
+    static pollingInterval: string | null;
+    abstract getStats(): Stat[] | Promise<Stat[]>;
+    /** Row columns: three, or four when the number of stats fits better. */
+    protected getColumns(count: number): number;
+    render(): Promise<string>;
+}
+/** Chart data in Chart.js format: `{ datasets: [{ label, data, … }], labels: [...] }`. */
+export type ChartData = {
+    datasets?: Record<string, unknown>[];
+    labels?: unknown[];
+    [key: string]: unknown;
+};
+/**
+ * Chart.js chart. A subclass provides `getType()` (`'line'`, `'bar'`, `'pie'`, `'doughnut'`, `'radar'`, `'polarArea'`,
+ * `'scatter'`, `'bubble'`) and `getData()`. Rendering happens in the browser; the server only sends new data when it
+ * has changed (checksum).
+ */
+export declare abstract class ChartWidget extends Widget {
+    static callable: string[];
+    static locked: string[];
+    /** Polling interval, or `null` to disable polling. */
+    static pollingInterval: string | null;
+    static heading: string | null;
+    static description: string | null;
+    /** Color of datasets that do not set one. */
+    static color: string;
+    /** Maximum chart height (`'300px'`). */
+    static maxHeight: string | null;
+    static isCollapsible: boolean;
+    dataChecksum: string | null;
+    /** Selected filter, one of `getFilters()`. */
+    filter: string | null;
+    private _cachedData;
+    abstract getType(): string;
+    getData(): ChartData | Promise<ChartData>;
+    /** Chart.js options. */
+    getOptions(): Record<string, unknown> | null;
+    /** Filters offered in the header: value → label. */
+    getFilters(): Record<string, string> | null;
+    getHeading(): string | null;
+    getDescription(): string | null;
+    getColor(): string;
+    getMaxHeight(): string | null;
+    /** Text read by screen readers instead of the chart. */
+    getChartAssistiveContent(): string | null;
+    protected getCachedData(): Promise<ChartData>;
+    protected generateDataChecksum(): Promise<string>;
+    mount(): Promise<void>;
+    /** Called by polling and before each render: only emits data when it has changed. */
+    updateChartData(): Promise<void>;
+    render(): Promise<string>;
+}
+/**
+ * Table in a widget: search, sort, simple pagination (previous / next).
+ * A subclass provides `table(table)` and `getDataAdapterForTable()`. No actions or filters yet.
+ */
+export declare abstract class TableWidget extends Widget implements TableHost {
+    static columnSpan: ColumnSpan;
+    static callable: string[];
+    /** Table heading; derived from the class name by default (`FlaggedOrders` → "Flagged Orders"). */
+    static heading: string | null;
+    tableSearch: string;
+    tableSort: string | null;
+    tableColumnSearches: Record<string, string>;
+    tableRecordsPerPage: number;
+    paginators: Record<string, number>;
+    tableColumns: ColumnState[];
+    abstract table(table: Table<any>): Table<any>;
+    abstract getDataAdapterForTable(): DataAdapter;
+    getTableHeading(): string;
+    getTable(): Table<any>;
+    mount(): void;
+    tableGrouping: string | null;
+    sortTable(column?: string | null, direction?: string | null): void;
+    gotoPage(page: number, _pageName?: string): void;
+    nextPage(_pageName?: string): void;
+    previousPage(_pageName?: string): void;
+    applyTableColumnManager(state?: unknown, _wasReordered?: unknown): void;
+    resetTableColumnManager(): void;
+    updatedTableSearch(): void;
+    updatedTableColumnSearches(): void;
+    updatedTableRecordsPerPage(): void;
+    updatedTableSort(): void;
+    render(): Promise<string>;
+}
+/** For widgets that receive the dashboard filters: `static reactive = PAGE_FILTERS` plus a `pageFilters` property. */
+export declare const PAGE_FILTERS: string[];
+/**
+ * Stats widget bound to a list page's table: it receives the table state (search, filters, tab…)
+ * and can aggregate exactly the records the table displays.
+ */
+export declare abstract class PageTableStatsWidget extends StatsOverviewWidget {
+    /** List page whose table is observed. */
+    static tablePage: () => typeof ListRecords;
+    static reactive: string[];
+    activeTab: string | null;
+    paginators: Record<string, number>;
+    tableColumnSearches: Record<string, string>;
+    tableFilters: Record<string, FilterState>;
+    tableRecordsPerPage: number;
+    tableSearch: string;
+    tableSort: string | null;
+    /** Aggregates over the table's current query. The received state goes through the same validation as on the page. */
+    protected aggregatePageTable(columns?: {
+        sum?: string[];
+        avg?: string[];
+    }, modify?: ((query: any) => void) | null): Promise<{
+        count: number;
+        sum: Record<string, number>;
+        avg: Record<string, number>;
+    }>;
+    /** Monthly trend over the table's current query (see `ObjectionAdapter.trendPerMonth`). */
+    protected trendPageTable(options: {
+        start: Date;
+        end: Date;
+        dateColumn?: string;
+        average?: string;
+        modify?: (query: any) => void;
+    }): Promise<number[]>;
+}
+/** Schema component that embeds the host component's table. */
+export declare class EmbeddedTable extends SchemaComponent {
+    static make(): EmbeddedTable;
+    toHtml(): Promise<string>;
+}
+/** List page tab: restricts the table query and can show a badge. */
+export declare class Tab {
+    private _label;
+    private _badge;
+    private _badgeColor;
+    private _hasBadgeColor;
+    private _query;
+    constructor(label?: string | null);
+    static make(label?: string | null): Tab;
+    /** Badge computed after the page is displayed. */
+    badge(resolver: () => number | string | null | Promise<number | string | null>): this;
+    badgeColor(color: string): this;
+    query(modifier: (query: any) => void): this;
+    getLabel(key: string): string;
+    hasBadge(): boolean;
+    getBadge(): Promise<number | string | null>;
+    getBadgeColor(): string;
+    /** False until `badgeColor()` is called: a lazy-loaded badge then gets no color class. */
+    hasBadgeColor(): boolean;
+    getQuery(): ((query: any) => void) | null;
+}
+/** Resource list page: table state and methods called by the browser. */
+export declare class ListRecords extends Page implements TableHost {
+    static callable: string[];
+    static resource: typeof Resource;
+    tableSearch: string;
+    tableSort: string | null;
+    tableColumnSearches: Record<string, string>;
+    tableRecordsPerPage: number;
+    paginators: Record<string, number>;
+    selectedTableRecords: string[];
+    deselectedTableRecords: string[];
+    isTrackingDeselectedTableRecords: boolean;
+    tableFilters: Record<string, FilterState>;
+    tableDeferredFilters: Record<string, FilterState>;
+    tableColumns: ColumnState[];
+    isTableReordering: boolean;
+    /** Current table grouping (`id:direction`), chosen in the toolbar. */
+    tableGrouping: string | null;
+    updatedTableGrouping(): void;
+    /** Toggles manual reordering mode. */
+    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>;
+    mount(_params?: Record<string, unknown>): Promise<void>;
+    /** Filters form: one group per filter, bound to `tableDeferredFilters.<filter>`. */
+    tableFiltersFormSchema(schema: Schema): Schema;
+    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;
+    /** Live field in the filters form (e.g. a rule's operator changed): runs its `afterStateUpdated`. */
+    updatedTableDeferredFilters(_value: unknown, key: string | null): Promise<void>;
+    resetTableFiltersForm(): void;
+    removeTableFilters(): void;
+    applyTableColumnManager(state?: unknown, _wasReordered?: unknown): void;
+    resetTableColumnManager(): void;
+    activeTab: string | null;
+    getTabs(): Record<string, Tab>;
+    /** Active tab, coerced to a declared key (an unknown value from the browser means the default tab). */
+    getActiveTabKey(): string;
+    updatedActiveTab(): void;
+    modifyTableQuery(query: {
+        modifiers?: ((q: any) => void)[];
+    }): void;
+    get resource(): typeof Resource;
+    getHeaderWidgets(): (typeof Widget)[];
+    /** The table state is passed to widgets, which can rerun the same query. */
+    getWidgetData(): Record<string, unknown>;
+    protected rendersActionModalsInPage(): boolean;
+    getBulkActions(): Action[];
+    /** Row actions declared by the table, with groups flattened. */
+    getRecordActions(): Action[];
+    protected getMountableActions(context: Record<string, unknown>): Action[] | Promise<Action[]>;
+    /** Only known context shapes are kept; the record key is checked again in the database on mount. */
+    protected resolveMountContext(clientContext: unknown): Record<string, unknown>;
+    protected resolveActionRecord(context: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Writes an editable cell. Everything comes from the browser: the column must exist and be editable and visible, the record
+     * must be in the table's scope and editable by the user, and the value must be valid.
+     */
+    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[]>;
+    deselectAllTableRecords(): void;
+    getTable(): Table;
+    renderTable(): Promise<string>;
+    /** Table header actions (none on a list page: they go in the page header). */
+    protected renderTableHeaderActions(ctx: any): Promise<string[]>;
+    sortTable(column?: string | null, direction?: string | null): void;
+    gotoPage(page: number, _pageName?: string): void;
+    nextPage(_pageName?: string): void;
+    previousPage(_pageName?: string): void;
+    updatedTableSearch(): void;
+    getDataAdapterForTable(): DataAdapter;
+    getDataAdapter(): DataAdapter;
+    updatedTableColumnSearches(): void;
+    updatedTableRecordsPerPage(): void;
+    updatedTableSort(): void;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getHeaderActions(): Action[];
+    getPageClasses(): string[];
+    contentSchema(schema: Schema): Schema;
+}
+/**
+ * Table of records related to another one: a child component of the edit page, loaded when it becomes visible.
+ * Subclasses declare `relationship`, `adapterFor()`, `table()` and `form()`.
+ */
+export declare class RelationManager extends ListRecords {
+    static relationship: string;
+    static modelLabel: string;
+    static pluralModelLabel: string | null;
+    static recordTitleAttribute: string | null;
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey: string): DataAdapter;
+    /** Policy for related records (same abilities as a resource policy). */
+    static policy: Policy | null;
+    protected isAccessAuthorized(ctx: PanelContext): Promise<boolean>;
+    static table(table: Table): Table;
+    static form(schema: Schema): Schema;
+    static getTitle(): string;
+    /** Owner record key: set on mount by the page, never writable from the browser. */
+    ownerRecord: string;
+    static locked: string[];
+    _facade: any;
+    /** 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>;
+    /** 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>;
+    getHeaderActions(): Action[];
+    placeholder(): string;
+    /** A relation manager has its own render hook locations, not the list page's. */
+    contentSchema(schema: Schema): Schema;
+    render(): Promise<string>;
+}
+/**
+ * Page listing records related to a record: a table, with create, view and edit in modals.
+ * Declared in the owner resource's `static relatedPages`, it is served at `<slug>/{record}/<name>`.
+ */
+export declare class ManageRelatedRecords extends ListRecords {
+    /** Owner resource: set when the page is registered. */
+    static parentResource: typeof Resource;
+    static relationship: string;
+    static modelLabel: string;
+    static pluralModelLabel: string | null;
+    static recordTitleAttribute: string | null;
+    static policy: Policy | null;
+    /** Data adapter limited to records related to the given owner. */
+    static adapterFor(_ownerKey: string): DataAdapter;
+    static table(table: Table): Table;
+    static form(schema: Schema): Schema;
+    static infolist(schema: Schema): Schema;
+    static getTitle(): string;
+    static getNavigationLabel(): string;
+    /** Owner record key: read from the URL on mount, never writable from the browser. */
+    recordKey: string;
+    static locked: string[];
+    _owner: any;
+    _facade: any;
+    private get related();
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** The owner is reloaded and access to it checked on every request. */
+    hydrate(): Promise<void>;
+    getRecordKey(): string | null;
+    /** What ListRecords expects from a resource, provided here by the page. */
+    get resource(): any;
+    getTable(): Table;
+    getHeaderActions(): Action[];
+    /** The page content is a group (tabs, if any, then the table). */
+    contentSchema(schema: Schema): Schema;
+    getTitle(): string;
+    getSubNavigation(): SubNavigationItem[];
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getPageClasses(): string[];
+}
+/** Base class for a resource's form pages. */
+declare abstract class ResourceFormPage extends Page {
+    /** Live form field (`live()` + `afterStateUpdated()`): `set(name, value)` writes next to the updated field. */
+    updatedData(_value: unknown, key: string | null): Promise<void>;
+    static resource: typeof Resource;
+    data: Record<string, unknown>;
+    get resource(): typeof Resource;
+    getDataAdapter(): DataAdapter;
+    getRecordKey(): string | null;
+    abstract getOperation(): 'create' | 'edit';
+    abstract getSubmitMethod(): string;
+    abstract getFormActions(): Action[];
+    protected getRecord(): unknown;
+    /** Two columns from `lg` by default; the resource may decide otherwise. */
+    formSchema(schema: Schema): Schema;
+    /**
+     * Wizard steps: as soon as this method returns some, the page shows its form step by step,
+     * with "Back" / "Next" and the submit button on the last step.
+     */
+    protected getSteps(): Step[] | null;
+    /** `true`: steps can be visited in any order, without validation along the way. */
+    protected hasSkippableSteps(): boolean;
+    /** Step shown on open (1-based). */
+    protected getStartStep(): number;
+    protected getWizardComponent(steps: Step[]): Wizard;
+    contentSchema(schema: Schema): Schema;
+    /** Where "Cancel" goes when the browser has no history: the list page, unless the page decides otherwise. */
+    protected getCancelUrl(): string;
+    protected cancelAction(): Action;
+    /** 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;
+    getOperation(): 'create';
+    getSubmitMethod(): string;
+    getTitle(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getPageClasses(): string[];
+    getFormActions(): Action[];
+    /** Transforms validated data before creation (add the author, compute a field…). */
+    protected mutateFormDataBeforeCreate(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Right before creation; throwing cancels it. */
+    protected beforeCreate(_data: Record<string, unknown>): void | Promise<void>;
+    /** The creation itself; defaults to the resource's data adapter. */
+    protected handleRecordCreation(data: Record<string, unknown>): Promise<any>;
+    /** After creation (logging, sending a message…). */
+    protected afterCreate(_record: any): void | Promise<void>;
+    /** Where to go next; defaults to the new record's edit page. */
+    protected getRedirectUrl(record: any): string;
+    /** Success notification title; `null` to show nothing. */
+    protected getCreatedNotificationTitle(): string | null;
+    create(another?: boolean): Promise<void>;
+    createAnother(): Promise<void>;
+}
+/** Delete action with confirmation. */
+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. */
+export type ReplicateActionInstance = Action & {
+    excludeAttributes(attributes: string[]): ReplicateActionInstance;
+};
+/** Duplicates a table row: the copy takes the record's attributes, except its key, timestamps and excluded ones. */
+export declare class ReplicateAction {
+    static make(): ReplicateActionInstance;
+}
+/** Create in a modal with the resource form. */
+export declare class CreateAction {
+    /** Without an argument, the resource (or relation manager) is the host component's. */
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Edit a table row in a modal, with the resource form. */
+export declare class EditAction {
+    /** Without an argument, the resource (or relation manager) is the host component's. */
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Link to the record's view page (when the resource has one). */
+export declare class ViewAction {
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Attaches an existing record to a relation manager's owner. */
+export declare class AttachAction {
+    static make(): Action;
+}
+/** Detaches a row from the owner without deleting it. */
+export declare class DetachAction {
+    static make(): Action;
+}
+/** Detaches the selected rows. */
+export declare class DetachBulkAction {
+    static make(): Action;
+}
+/** Restores a soft-deleted record. Only visible when the record is deleted. */
+export declare class RestoreAction {
+    static make(): Action;
+}
+/** Permanently deletes a soft-deleted record. Only visible when the record is deleted. */
+export declare class ForceDeleteAction {
+    static make(): Action;
+}
+/** Deletes the records selected in a table. */
+export declare class DeleteBulkAction {
+    static make(): Action;
+}
+/** Record edit page. */
+export declare class EditRecord extends ResourceFormPage {
+    static callable: string[];
+    recordKey: string;
+    /** Active relation manager tab (index in `Resource.relations`). */
+    activeRelationManager: string;
+    /**
+     * Previous page, captured on first display from the Referer header: only a same-site URL is accepted,
+     * and it cannot be changed afterwards.
+     */
+    previousUrl: string;
+    protected getCancelUrl(): string;
+    contentSchema(schema: Schema): Schema;
+    static locked: string[];
+    _record: any;
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** The record is reloaded on every request (no route model binding). */
+    hydrate(): Promise<void>;
+    protected getRecord(): unknown;
+    getRecordKey(): string | null;
+    getActionMountContext(): Record<string, unknown>;
+    protected getActionRecord(): unknown;
+    /** Delete, plus restore and force-delete when the model uses soft deletes. */
+    getHeaderActions(): Action[];
+    getOperation(): 'edit';
+    getSubmitMethod(): string;
+    getTitle(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getSubNavigation(): SubNavigationItem[];
+    getPageClasses(): string[];
+    getFormActions(): Action[];
+    /** Transforms the record's values before filling the form. */
+    protected mutateFormDataBeforeFill(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Transforms validated data before saving. */
+    protected mutateFormDataBeforeSave(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Right before saving; throwing cancels it. */
+    protected beforeSave(_data: Record<string, unknown>): void | Promise<void>;
+    /** The save itself; defaults to the resource's data adapter. */
+    protected handleRecordUpdate(record: any, data: Record<string, unknown>): Promise<any>;
+    /** After saving. */
+    protected afterSave(_record: any): void | Promise<void>;
+    /** URL to go to after saving; `null` (default) stays on the page. */
+    protected getRedirectUrl(_record: any): string | null;
+    /** Success notification title; `null` to show nothing. */
+    protected getSavedNotificationTitle(): string | null;
+    save(): Promise<void>;
+}
+/** Record view page: the resource's read-only `infolist()` schema. */
+export declare class ViewRecord extends Page {
+    static resource: typeof Resource;
+    static locked: string[];
+    recordKey: string;
+    /** Active relation manager tab (index in `Resource.relations`). */
+    activeRelationManager: string;
+    _record: any;
+    get resource(): typeof Resource;
+    getDataAdapter(): DataAdapter;
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** The record is reloaded on every request, as on the edit page. */
+    hydrate(): Promise<void>;
+    getRecordKey(): string | null;
+    getActionMountContext(): Record<string, unknown>;
+    protected getActionRecord(): unknown;
+    infolistSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    /** Defaults to a link to the edit page. */
+    getHeaderActions(): Action[];
+    protected editAction(): Action;
+    getTitle(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getSubNavigation(): SubNavigationItem[];
+    getPageClasses(): string[];
+}
+/** Sidebar: logo, tenant menu, search, navigation and, without a topbar, the bell and user menu. */
+export declare class Sidebar extends Component {
+    static callable: string[];
+    currentPath: string;
+    static locked: string[];
+    mount(params: Record<string, unknown>): void;
+    /** A resource item stays active on its create and edit pages. */
+    render(): Promise<string>;
+    /** Theme choice by the user: only a theme declared by the panel is accepted; the page reloads to apply it. */
+    setTheme(id: unknown): void;
+}
+/** Topbar: logo, optional navigation, search, bell, user menu. */
+export declare class Topbar extends Component {
+    static callable: string[];
+    currentPath: string;
+    static locked: string[];
+    mount(params: Record<string, unknown>): void;
+    render(): Promise<string>;
+    setTheme(id: unknown): void;
+}
+/** User menu on simple pages for a signed-in user. */
+export declare class SimpleUserMenu extends Component {
+    static callable: string[];
+    render(): Promise<string>;
+    setTheme(id: unknown): void;
+}
+/** Resources defined in a folder: `.resources(await discoverResources(new URL('./resources/', import.meta.url)))`. New files are picked up on the next start. */
+export declare const discoverResources: (directory: string | URL) => Promise<(typeof Resource)[]>;
+/** Custom pages (and dashboards) defined in a folder. Resource and authentication pages are excluded. */
+export declare const discoverPages: (directory: string | URL) => Promise<(typeof Page)[]>;
+/** Widgets defined in a folder. */
+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;