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

package/lib/index.d.ts

@@ -0,0 +1,1619 @@
+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";
+/** Utilisateur connecté. Votre fournisseur d'authentification peut y ajouter ce qu'il veut (rôle, équipe…) : les politiques le reçoivent tel quel. */
+export type User = {
+    id: string | number;
+    name: string;
+    email: string;
+    [key: string]: unknown;
+};
+/**
+ * Politique d'une resource : une fonction par capacité, nommée comme dans Laravel
+ * (`viewAny`, `create`, `update`, `delete`, `deleteAny`, `restore`, `forceDelete`, `reorder`, ou vos propres noms).
+ * Capacité absente : autorisée.
+ */
+export type Policy<R = any> = Partial<Record<string, (user: User, record: R | null) => boolean | Promise<boolean>>>;
+/** Plugin : un paquet de configuration réutilisable. `register` reçoit le panel en cours de construction ; `boot` est appelé au montage du routeur. */
+export type Plugin = {
+    id: string;
+    register(panel: Panel): void;
+    boot?(panel: Panel): void;
+};
+/** Question posée au crochet d'autorisation du panel. `resource`, `page` ou `widget` dit sur quoi elle porte. */
+export type AuthorizationCheck = {
+    user: User;
+    ability: string;
+    resource: unknown | null;
+    record: unknown | null;
+    page: typeof Page | null;
+    widget: typeof Widget | null;
+};
+/** Rend `true` ou `false` pour décider, `undefined` pour laisser la politique de la resource (ou `canAccess` / `canView`) répondre. */
+export type Authorizer = (check: AuthorizationCheck) => boolean | undefined | Promise<boolean | undefined>;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Fournisseur d'utilisateurs. `attempt` et `find` suffisent pour la connexion ; les méthodes facultatives activent
+ * l'inscription (`create`, `findByEmail`), la réinitialisation du mot de passe (`findByEmail`, `update`, `getPasswordFingerprint`),
+ * la vérification de l'adresse (`hasVerifiedEmail`, `markEmailAsVerified`) et la page de profil (`update`).
+ * `knexAuthProvider(knex)` les fournit toutes pour une table `users` au format de Laravel.
+ */
+export interface AuthProvider {
+    attempt(email: string, password: string): MaybePromise<User | null>;
+    find(id: string | number): MaybePromise<User | null>;
+    findByEmail?(email: string): MaybePromise<User | null>;
+    /** Crée l'utilisateur ; le mot de passe est reçu en clair, à hacher par le fournisseur. */
+    create?(data: {
+        name: string;
+        email: string;
+        password: string;
+    }): MaybePromise<User>;
+    /** Met à jour nom, adresse ou mot de passe (en clair, à hacher). Changer d'adresse doit annuler sa vérification. */
+    update?(user: User, data: {
+        name?: string;
+        email?: string;
+        password?: string;
+    }): MaybePromise<User>;
+    hasVerifiedEmail?(user: User): MaybePromise<boolean>;
+    markEmailAsVerified?(user: User): MaybePromise<void>;
+    /** Valeur qui change avec le mot de passe enregistré : un lien de réinitialisation déjà servi devient invalide. */
+    getPasswordFingerprint?(user: User): MaybePromise<string>;
+}
+/**
+ * Locataires d'un panel (équipes, organisations…) : port de `->tenant(Team::class)`. Chaque page du panel vit alors
+ * sous `/<panel>/<clé du locataire>/…`, et seul un membre du locataire peut l'ouvrir.
+ */
+export interface TenantProvider<T = any> {
+    /** Locataires dont l'utilisateur est membre. */
+    getTenants(user: User): MaybePromise<T[]>;
+    /** Locataire d'après sa clé dans l'adresse (venue du navigateur : à valider). */
+    find(key: string): MaybePromise<T | null>;
+    canAccess(user: User, tenant: T): MaybePromise<boolean>;
+    getKey(tenant: T): string;
+    getName(tenant: T): string;
+    /** Texte au-dessus du nom dans le menu (« Current team »), ou `null`. */
+    getCurrentTenantLabel?(tenant: T): string | null;
+    getAvatarUrl?(tenant: T): string | null;
+    /** Création (page d'inscription d'un locataire) : l'utilisateur en devient membre. */
+    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;
+};
+/**
+ * Thème prédéfini d'un panel : un jeu de couleurs (palettes ou simples couleurs), éventuellement une police et du CSS.
+ * Quand un panel en déclare plusieurs, l'utilisateur choisit le sien dans son menu ; le choix est gardé dans un cookie.
+ */
+export type Theme = {
+    id: string;
+    label: string;
+    colors?: Record<string, Palette | string>;
+    font?: {
+        family: string;
+        url?: string;
+    };
+    /** CSS ajouté à la page pour ce thème (écrit par le développeur du panel, inséré tel quel). */
+    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;
+    /** Par défaut un élément est actif sur son URL exacte, comme une page Filament (les resources fourniront leur propre règle). */
+    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;
+    /** Icône d'onglet du navigateur. */
+    favicon(url: string | null): this;
+    getFavicon(): string | null;
+    /**
+     * Feuille de thème compilée par l'application (Tailwind) : elle remplace la feuille par défaut de Filament.
+     * Équivalent de `->viteTheme()` : le thème importe `@navette-js/panels/theme.css` et déclare ses propres sources.
+     */
+    theme(url: string | null): this;
+    getTheme(): string | null;
+    /**
+     * Mouvement et indicateurs de chargement propres à Navette (ressorts, pastille d'activité, roue des zones différées).
+     * C'est un écart assumé avec Filament : `motion(false)` rend l'interface d'origine, sans rien d'ajouté.
+     */
+    motion(enabled?: boolean): this;
+    hasMotion(): boolean;
+    /** Thèmes proposés à l'utilisateur ; le premier est le thème par défaut. */
+    themes(themes: Theme[]): this;
+    getThemes(): Theme[];
+    /** Thème de la requête : celui du cookie s'il est déclaré, sinon le premier. Null si le panel n'a pas de thèmes. */
+    resolveTheme(req: Request): Theme | null;
+    rememberTheme(res: Response, theme: Theme): void;
+    /** Exécute un rendu avec les couleurs du thème de la requête. */
+    withTheme<T>(req: Request, fn: () => T): T;
+    setColors(colors: Record<string, Palette | string>): this;
+    /** Police du panel. Sans URL : fournisseur Bunny Fonts, comme `->font('Albert Sans')` dans Filament. */
+    font(family: string, url?: string): this;
+    login(page?: typeof Login): this;
+    auth(provider: AuthProvider): this;
+    key(key: string): this;
+    pages(pages: (typeof Page)[]): this;
+    /** Enregistre des resources : leurs pages et leur élément de navigation. */
+    resources(resources: (typeof Resource)[]): this;
+    navigationItems(items: NavigationItem[]): this;
+    /** Ordre des groupes de navigation. */
+    navigationGroups(groups: string[]): this;
+    private _plugins;
+    /** Applique un plugin : un objet qui configure le panel (resources, pages, render hooks, thèmes…). */
+    plugin(plugin: Plugin): this;
+    plugins(plugins: Plugin[]): this;
+    getPlugins(): Plugin[];
+    private _renderHooks;
+    /**
+     * Insère du HTML à un emplacement nommé de l'interface de ce panel (noms : `PanelsRenderHook`, `TablesRenderHook`, `ActionsRenderHook`, `WidgetsRenderHook`).
+     * `scopes` limite le hook à certaines pages ou resources (leur classe). Le HTML rendu est inséré tel quel : échappez toute donnée avec `e()`.
+     */
+    renderHook(name: string, render: RenderHookCallback, scopes?: unknown | unknown[] | null): this;
+    getRenderHooks(): RenderHookRegistry;
+    private _authorizer;
+    /** Branche votre propre système de permissions : consulté avant toute politique, pour chaque capacité, page et widget. */
+    authorizeUsing(authorizer: Authorizer | null): this;
+    /** Décision d'autorisation : le crochet du panel d'abord, puis la règle fournie ; sans utilisateur, toujours non. */
+    authorize(user: User | null, ability: string, subject?: {
+        resource?: unknown;
+        record?: unknown;
+        page?: typeof Page;
+        widget?: typeof Widget;
+        rule?: (() => boolean | Promise<boolean>) | null;
+    }): Promise<boolean>;
+    /** Une page est-elle accessible à cet utilisateur ? Liste : `viewAny` ; création : `create` ; édition : vérifiée sur l'enregistrement ; page libre : `canAccess`. */
+    canAccessPage(PageClass: typeof Page, user: User | null): Promise<boolean>;
+    private _widgets;
+    /** Widgets du panel (tableau de bord, pages libres) : enregistrés comme composants, à afficher par `getHeaderWidgets()` d'une page. */
+    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` retire le champ de recherche globale. Il n'apparaît de toute façon que si une resource est cherchable. */
+    globalSearch(condition?: boolean): this;
+    /** Raccourcis qui placent le curseur dans le champ : `['command+k', 'ctrl+k']`. */
+    globalSearchKeyBindings(keyBindings: string[]): this;
+    getGlobalSearchKeyBindings(): string[];
+    /** Délai entre la frappe et la recherche (`500ms` par défaut). */
+    globalSearchDebounce(debounce: string): this;
+    getGlobalSearchDebounce(): string;
+    globalSearchFieldSuffix(suffix: string | null): this;
+    /** Affiche le premier raccourci dans le champ, écrit selon la plateforme du navigateur (comme Filament : « META+K » hors Mac pour `command+k`). */
+    globalSearchFieldKeyBindingSuffix(): this;
+    getGlobalSearchFieldSuffix(userAgent?: string): string | null;
+    hasGlobalSearch(): boolean;
+    /** Résultats par resource, dans l'ordre d'enregistrement ; seules les resources que l'utilisateur peut lister sont interrogées. */
+    getGlobalSearchResults(search: string, user: User | null): Promise<GlobalSearchCategory[]>;
+    private _databaseNotifications;
+    private _databaseNotificationsPolling;
+    /** Active la cloche des notifications enregistrées en base, lues et écrites par ce stockage (`knexNotificationStore(knex)`). */
+    databaseNotifications(store: DatabaseNotificationStore | null): this;
+    getDatabaseNotifications(): DatabaseNotificationStore | null;
+    /** Intervalle de rafraîchissement (`30s` par défaut) ; `null` pour ne pas interroger le serveur. */
+    databaseNotificationsPolling(interval: string | null): this;
+    getDatabaseNotificationsPollingInterval(): string | null;
+    private _topbar;
+    private _topNavigation;
+    private _navigation;
+    private _sidebarCollapsibleOnDesktop;
+    private _sidebarFullyCollapsibleOnDesktop;
+    private _positions;
+    /** Barre du haut (présente par défaut, comme dans Filament) : `topbar(false)` met logo, recherche, cloche et menu dans la sidebar. */
+    topbar(condition?: boolean): this;
+    hasTopbar(): boolean;
+    /** Navigation dans la barre du haut (menus déroulants par groupe) au lieu de la sidebar. */
+    topNavigation(condition?: boolean): this;
+    hasTopNavigation(): boolean;
+    /** `navigation(false)` retire toute navigation (ni sidebar ni menus). */
+    navigation(condition?: boolean): this;
+    hasNavigation(): boolean;
+    /** Sidebar repliable sur grand écran en une colonne d'icônes. */
+    sidebarCollapsibleOnDesktop(condition?: boolean): this;
+    isSidebarCollapsibleOnDesktop(): boolean;
+    /** Sidebar entièrement masquable sur grand écran. */
+    sidebarFullyCollapsibleOnDesktop(condition?: boolean): this;
+    isSidebarFullyCollapsibleOnDesktop(): boolean;
+    /** Emplacement du menu utilisateur ; par défaut, la barre du haut si elle existe. */
+    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;
+    /** Éléments ajoutés au menu utilisateur (actions à adresse ou à modale). `sort()` négatif : au-dessus du choix du thème. Clés `profile` et `logout` : remplacent ceux par défaut. */
+    userMenuItems(items: Record<string, Action> | Action[]): this;
+    getUserMenuItems(): Record<string, Action>;
+    private _registration;
+    private _passwordReset;
+    private _emailVerification;
+    private _profile;
+    private _mailer;
+    /** Page d'inscription (`/register`). Le fournisseur d'utilisateurs doit savoir créer (`create`) et chercher par adresse (`findByEmail`). */
+    registration(page?: typeof Register | null): this;
+    hasRegistration(): boolean;
+    getRegistrationPage(): typeof Register | null;
+    /** Mot de passe oublié : demande (`/password-reset/request`) et réinitialisation par un lien signé envoyé par e-mail. */
+    passwordReset(request?: typeof RequestPasswordReset, reset?: typeof ResetPassword): this;
+    hasPasswordReset(): boolean;
+    getPasswordResetPages(): {
+        request: typeof RequestPasswordReset;
+        reset: typeof ResetPassword;
+    };
+    /** Vérification de l'adresse e-mail : un lien signé est envoyé à l'inscription ; tant qu'il n'est pas suivi, seule l'invitation à vérifier est accessible (`isRequired`). */
+    emailVerification(prompt?: typeof EmailVerificationPrompt, isRequired?: boolean): this;
+    hasEmailVerification(): boolean;
+    isEmailVerificationRequired(): boolean;
+    getEmailVerificationPrompt(): typeof EmailVerificationPrompt | null;
+    /** Page de profil (`/profile`) : nom, adresse, mot de passe. `isSimple` : mise en page simple (par défaut) ou complète. */
+    profile(page?: typeof EditProfile, isSimple?: boolean): this;
+    hasProfile(): boolean;
+    getProfile(): {
+        page: typeof EditProfile;
+        isSimple: boolean;
+    };
+    /** Envoi des e-mails (réinitialisation, vérification). Par défaut : écrits dans la console. */
+    mailer(mailer: Mailer): this;
+    sendMail(message: MailMessage): Promise<void>;
+    getAuthKey(): string;
+    getRegistrationUrl(): string;
+    getRequestPasswordResetUrl(): string;
+    getResetPasswordUrl(user: User, fingerprint: string): string;
+    /** Charge d'un jeton de réinitialisation valide pour ce panel, sinon `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;
+    /** L'utilisateur doit-il encore vérifier son adresse avant d'utiliser le panel ? */
+    mustVerifyEmail(user: User | null): Promise<boolean>;
+    private _tenant;
+    private _tenantOwnershipColumn;
+    private _tenantRegistration;
+    private _tenantProfile;
+    private _tenantMenu;
+    private _tenantMenuItems;
+    private _tenantScope;
+    /**
+     * Rend le panel multi-locataire. `ownershipColumn` : colonne qui rattache un enregistrement à son locataire (`team_id`) ;
+     * les resources du panel ne lisent et n'écrivent alors que les enregistrements du locataire courant (voir `Resource.isScopedToTenant`).
+     */
+    tenant(provider: TenantProvider | null, options?: {
+        ownershipColumn?: string;
+    }): this;
+    hasTenancy(): boolean;
+    getTenantProvider(): TenantProvider;
+    getTenantOwnershipColumn(): string | null;
+    /** Page de création d'un locataire (`/new`). */
+    tenantRegistration(page: typeof RegisterTenant | null): this;
+    getTenantRegistrationPage(): typeof RegisterTenant | null;
+    /** Page de profil du locataire (`/<locataire>/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>;
+    /** Exécute `fn` pour un locataire : les adresses produites (`getUrl`) et les requêtes des resources lui sont rattachées. */
+    withTenant<T>(tenant: unknown, fn: () => T): T;
+    /** Locataire de la requête en cours (équivalent de `Filament::getTenant()`), ou `null`. */
+    getTenant<T = any>(): T | null;
+    getTenantUrlKey(tenant: unknown): string;
+    private _subNavigationPosition;
+    /** Position par défaut de la sous-navigation des pages (`start`, comme Filament). */
+    subNavigationPosition(position: 'start' | 'end' | 'top'): this;
+    getSubNavigationPosition(): 'start' | 'end' | 'top';
+    private _appUrl;
+    /** Adresse publique de l'application (`https://exemple.fr`), utilisée dans les liens envoyés par e-mail. Sans elle, l'origine de la requête est reprise : à éviter en production (en-tête `Host` falsifiable). */
+    appUrl(url: string | null): this;
+    getAppUrl(): string | null;
+    getMaxContentWidth(): string;
+    /** Adresse dans le panel ; dans un panel à locataires, préfixée par le locataire courant (ou celui donné). */
+    getUrl(sub?: string, tenant?: unknown): string;
+    /** Adresse hors locataire (connexion, inscription, profil, création d'un locataire). */
+    getBaseUrl(sub?: string): string;
+    getLoginUrl(): string;
+    getLogoutUrl(): string;
+    /** Préfixe de l'endpoint Livewire de ce panel (`/livewire`, ou `/<chemin>/livewire`) : chaque panel a le sien. */
+    getLivewirePrefix(): string;
+    assetUrl(file: string): string;
+    getBrand(): Record<string, unknown>;
+    getFont(): typeof this._font;
+    /** Avatar par défaut : port de UiAvatarsProvider (service externe ui-avatars.com, initiales du nom). */
+    getUserAvatarUrl(user: User): string;
+    /** Avatar d'un locataire : celui de son fournisseur (`getAvatarUrl`), sinon ses initiales. */
+    getTenantAvatarUrl(tenant: unknown): string;
+    private _spa;
+    /** Navigation sans rechargement (`wire:navigate`) entre les pages du panel, comme `->spa()`. */
+    spa(condition?: boolean): this;
+    hasSpaMode(): boolean;
+    getAvatarUrlFor(name: string): string;
+    /** Groupes de navigation : pages enregistrées + éléments libres, triés, groupés dans l'ordre déclaré. */
+    /** Compteurs de navigation calculés (équivalent de getNavigationBadge()) : adresse de la page → valeur. */
+    resolveNavigationBadges(): Promise<Map<string, string | number | null>>;
+    /** Adresses des pages du menu que cet utilisateur ne peut pas ouvrir. */
+    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>;
+}
+/**
+ * Emplacements de render hook d'un panel — mêmes noms que `Filament\View\PanelsRenderHook`.
+ * Ceux d'une brique pas encore portée (barre du haut, recherche globale, menu de locataire, sous-navigation, inscription,
+ * réinitialisation du mot de passe, enregistrements liés) sont déclarés mais ne sont rendus nulle part pour l'instant : voir `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";
+    /** Le nom contient « module-menu » dans Filament : conservé tel quel. */
+    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";
+};
+/** Emplacements de render hook des widgets — mêmes noms que `Filament\Widgets\View\WidgetsRenderHook`. Rendus par `TableWidget`. */
+export declare const WidgetsRenderHook: {
+    readonly TABLE_WIDGET_END: "widgets::table-widget.end";
+    readonly TABLE_WIDGET_START: "widgets::table-widget.start";
+};
+/**
+ * Emplacements déclarés mais rendus nulle part pour l'instant, avec la brique qui leur manque.
+ * Les quatre « tabs » ne sont rendus par aucune vue de Filament 5.11.2 non plus.
+ */
+export declare const UNPLACED_RENDER_HOOKS: Record<string, string>;
+/** Base commune : composant à état hébergeant des schémas (`<nom>Schema(schema)`). */
+declare abstract class BasePage extends Component implements SchemaHost {
+    get panel(): Panel;
+    getSchema(name: string): Schema;
+    contentSchema(schema: Schema): Schema;
+    /** Portées des render hooks de cette page : sa classe (et sa resource pour une page de resource), comme `getRenderHookScopes()` dans Filament. */
+    getRenderHookScopes(): unknown[];
+}
+/** Page d'un panel, dans la mise en page complète (sidebar, en-tête). */
+export declare class Page extends BasePage {
+    /** Méthodes que le navigateur peut appeler. Une sous-classe ajoute les siennes : `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;
+    /** Page réservée à certains utilisateurs : rendre `false` la retire du menu et la refuse (403). */
+    static canAccess(_user: User): boolean | Promise<boolean>;
+    static getTitle(): string;
+    static getNavigationLabel(): string;
+    /** Chaque requête, y compris les mises à jour envoyées par le navigateur, exige un utilisateur authentifié : un snapshot conservé après déconnexion ne suffit pas. */
+    boot(): Promise<void>;
+    protected isAccessAuthorized(ctx: PanelContext): boolean | Promise<boolean>;
+    getTitle(): string;
+    getHeading(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getHeaderActions(): Action[];
+    getPageClasses(): string[];
+    /** Sous-navigation de la page : vide par défaut. */
+    getSubNavigation(): SubNavigationItem[] | Promise<SubNavigationItem[]>;
+    /** Position de la sous-navigation : `start` (colonne avant le contenu), `end` (après) ou `top` (onglets). Par défaut : celle de la resource, sinon du panel. */
+    static subNavigationPosition: 'start' | 'end' | 'top' | null;
+    getSubNavigationPosition(): 'start' | 'end' | 'top';
+    /** Widgets affichés sous le contenu de la page (port de getFooterWidgets). */
+    getFooterWidgets(): (typeof Widget)[];
+    getFooterWidgetsColumns(): number | Record<string, number>;
+    /** Port de filament-widgets::components.widgets, dans le schéma `footerWidgets` de la page. */
+    protected renderFooterWidgets(): Promise<string>;
+    /** Widgets affichés au-dessus du contenu de la page, et données passées à chacun (propriétés du widget). */
+    getHeaderWidgets(): (typeof Widget)[];
+    getHeaderWidgetsColumns(): number;
+    getWidgetData(): Record<string, unknown>;
+    /** Port de filament-widgets::components.widgets, dans le schéma `headerWidgets` de la page. */
+    protected renderHeaderWidgets(): Promise<string>;
+    /** Widgets que l'utilisateur courant a le droit de voir (port de filterVisibleWidgets). */
+    protected filterVisibleWidgets(candidates: (typeof Widget)[]): Promise<(typeof Widget)[]>;
+    /** Grille de widgets d'un schéma (port de Grid + getWidgetsSchemaComponents) : chaque widget est un composant enfant, « lazy » par défaut. */
+    protected renderWidgetsGrid(widgets: (typeof Widget)[], columns: number | Record<string, number>, schemaKey: string): Promise<string>;
+    /** Contenu de la page : par défaut son schéma `content`. */
+    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;
+    /** Enregistrement visé par une action montée dans un contexte donné (ligne de table…). */
+    protected resolveActionRecord(_context: Record<string, unknown>): Promise<unknown>;
+    /** Actions pouvant être montées dans un contexte donné (en-tête de page par défaut). */
+    protected getMountableActions(context: Record<string, unknown>): Action[] | Promise<Action[]>;
+    /**
+     * Actions portées par un composant de schéma (Repeater : ajouter, supprimer, déplacer ; Section : actions d'en-tête).
+     * La clé vient du navigateur : elle doit désigner un composant réel du schéma, ou le schéma lui-même.
+     */
+    protected getSchemaComponentActions(key: string): Promise<Action[]>;
+    /** Contexte retenu pour une action montée : celui du serveur, jamais celui du navigateur tel quel. */
+    protected resolveMountContext(clientContext: unknown): Record<string, unknown>;
+    private findMountableAction;
+    private actionContext;
+    /** Schéma du formulaire d'une action montée : clé `mountedActionSchema<n>`, état sous `mountedActions.<n>.data` (comme Filament). */
+    getMountedActionSchema(index: number): Promise<Schema | null>;
+    private renderActionModal;
+    /** Annule un rendu partiel de modale préparé par un champ réactif, quand la même requête exécute ensuite une action. */
+    private cancelModalPartialRender;
+    /** Champ réactif du formulaire d'une action montée : exécute `afterStateUpdated`, puis ne renvoie que la modale concernée (comme Filament). */
+    updatedMountedActions(_value: unknown, key: string | null): Promise<void>;
+    /** Appel, depuis le JavaScript d'un champ, d'une méthode que ce champ expose (ex. recherche d'un Select). Sans rendu. */
+    callSchemaComponentMethod(componentKey: unknown, method: unknown, args?: unknown): Promise<unknown>;
+    /** Une action masquée ne peut être ni montée ni exécutée, même par un appel forgé depuis le navigateur. */
+    private assertActionVisible;
+    private syncActionModals;
+    /** Faux pour un composant à table : ses modales sont rendues dans la table (comme Filament). */
+    protected rendersActionModalsInPage(): boolean;
+    renderActionModals(): Promise<string>;
+    /** Monte une action : sans modale elle s'exécute tout de suite ; avec modale, seul le fragment des modales est renvoyé. */
+    mountAction(name: unknown, args?: unknown, _context?: unknown): Promise<void>;
+    unmountAction(_shouldCancelParentActions?: unknown): void;
+    callMountedAction(_args?: unknown): Promise<void>;
+    render(): Promise<string>;
+}
+/**
+ * Tableau de bord (port de Filament\Pages\Dashboard) : une grille de widgets, précédée d'un formulaire de filtres
+ * quand la page définit `filtersFormSchema(schema)` (port de HasFiltersForm). Les filtres sont passés aux widgets sous `pageFilters`.
+ */
+export declare class Dashboard extends Page {
+    static slug: string;
+    static title: string;
+    static navigationIcon: string;
+    static navigationSort: number;
+    /** État du formulaire de filtres. Reste `null` tant que la page n'a pas de filtres. */
+    filters: Record<string, unknown> | null;
+    /** Widgets du tableau de bord. Par défaut : ceux du panel (`panel.widgets([...])`). */
+    getWidgets(): (typeof Widget)[];
+    /** Colonnes de la grille : un nombre (au point de rupture `lg`), ou un nombre par point de rupture. */
+    getColumns(): number | Record<string, number>;
+    hasFiltersForm(): boolean;
+    getSchema(name: string): Schema;
+    mount(): void;
+    getWidgetData(): Record<string, unknown>;
+    protected renderContent(): Promise<string>;
+}
+/** Limiteur de tentatives en mémoire : `max` essais par fenêtre, par clé. Suffisant pour une instance ; à remplacer par un magasin partagé si le panel tourne sur plusieurs. */
+export declare class Throttle {
+    private hits;
+    private max;
+    private windowMs;
+    constructor(max?: number, windowMs?: number);
+    /** Enregistre un essai ; rend 0 s'il est permis, sinon le nombre de secondes à attendre. */
+    hit(key: string, now?: number): number;
+    clear(key: string): void;
+}
+/** Page à mise en page « simple » (connexion, inscription…). */
+export declare abstract class SimplePage extends BasePage {
+    abstract getTitle(): string;
+    getHeading(): string | null;
+    /** Sous-titre, en HTML de confiance (composé par la page, données échappées). */
+    getSubheading(): string | null;
+    hasLogo(): boolean;
+    render(): Promise<string>;
+}
+/** Inscription (port de Filament\Auth\Pages\Register) : nom, adresse, mot de passe confirmé ; l'utilisateur est connecté, puis invité à vérifier son adresse si le panel l'exige. */
+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;
+    /** Données validées, juste avant la création (ajouter une valeur, normaliser l'adresse…). */
+    protected mutateFormDataBeforeRegister(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Création de l'utilisateur : par défaut `create()` du fournisseur d'utilisateurs. */
+    protected handleRegistration(data: Record<string, unknown>): Promise<User> | User;
+    register(): Promise<void>;
+}
+/** Demande de réinitialisation du mot de passe (port de RequestPasswordReset) : un lien signé, valable 60 minutes, part par e-mail. */
+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>;
+}
+/** Nouveau mot de passe, depuis le lien reçu par e-mail (port de ResetPassword). Le lien ne sert qu'une fois : il meurt avec l'ancien mot de passe. */
+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;
+    /** Comme Filament : le formulaire n'a pas de chemin d'état, ses champs sont des propriétés de la page. */
+    getSchema(name: string): Schema;
+    getTitle(): string;
+    getHeading(): string;
+    formSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    resetPassword(): Promise<void>;
+}
+/** Invitation à vérifier son adresse (port de EmailVerificationPrompt), avec le lien « Resend it. ». */
+export declare class EmailVerificationPrompt extends SimplePage {
+    static callable: string[];
+    mount(): Promise<void>;
+    getTitle(): string;
+    getHeading(): string;
+    contentSchema(schema: Schema): Schema;
+    /** Seule action de la page : renvoyer l'e-mail (deux fois par minute au plus). */
+    mountAction(name: unknown): Promise<void>;
+}
+/** Profil de l'utilisateur (port de EditProfile) : nom, adresse, nouveau mot de passe ; le mot de passe actuel est exigé pour changer l'adresse ou le mot de passe. */
+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>;
+}
+/** Création d'un locataire (port de RegisterTenant) : la sous-classe donne son libellé et son formulaire (`formSchema`). */
+export declare abstract class RegisterTenant extends SimplePage {
+    static callable: string[];
+    static slug: string;
+    data: Record<string, unknown>;
+    static getLabel(): string;
+    /** Le panel accepte-t-il la création ? Par défaut : si le fournisseur de locataires sait créer. */
+    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>;
+}
+/** Profil du locataire courant (port de EditTenantProfile), dans la mise en page complète. */
+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>;
+}
+/** L'utilisateur du composant hôte a-t-il cette capacité sur la resource (ou le relation manager) du composant ? À utiliser dans `authorize()` de vos actions. */
+export declare const can: (livewire: unknown, ability: string, record?: unknown) => Promise<boolean> | boolean;
+/** Resource : un modèle, ses pages, sa table et sa navigation (port partiel de Filament\Resources\Resource). */
+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;
+    /** Dans un panel à locataires : les enregistrements sont-ils propres à chaque locataire ? (vrai par défaut, comme Filament) */
+    static isScopedToTenant: boolean;
+    /** Colonne du locataire pour cette resource (par défaut celle du panel : `panel.tenant(provider, { ownershipColumn })`). */
+    static tenantOwnershipColumn: string | null;
+    /**
+     * Pages de la resource, à remplacer par vos sous-classes pour en changer le comportement :
+     * `static pages = { index: MyList, create: MyCreate, edit: MyEdit }`.
+     */
+    static pages: {
+        index?: typeof ListRecords;
+        create?: typeof CreateRecord;
+        edit?: typeof EditRecord;
+        view?: typeof ViewRecord;
+    };
+    /** Page de consultation (`ViewRecord`) : vrai pour l'ajouter aux pages de la resource ; la ligne d'une table y mène alors, comme dans Filament. */
+    static hasViewPage: boolean;
+    /** Qui peut faire quoi sur cette resource. Sans politique, tout utilisateur connecté peut tout. */
+    static policy: Policy | null;
+    /** L'utilisateur a-t-il cette capacité (sur cet enregistrement, s'il y en a un) ? */
+    static can(ability: string, user: User | null, record?: unknown): Promise<boolean>;
+    /** Widgets de la resource (équivalent de getWidgets()) : enregistrés comme composants. */
+    static widgets: (typeof Widget)[];
+    /** Widgets affichés au-dessus de la table de la page de liste (équivalent de ListRecords::getHeaderWidgets()). */
+    static headerWidgets: (typeof Widget)[];
+    /** Relation managers affichés sous le formulaire d'édition (équivalent de getRelations()). */
+    static relations: any[];
+    /** Onglets de la page de liste (équivalent de ListRecords::getTabs()). */
+    static tabs(): Record<string, Tab>;
+    /** Resource « simple » (équivalent de ManageRecords) : une seule page, création et édition en modales. */
+    static isSimple: boolean;
+    static getPluralModelLabel(): string;
+    static getTitleCasePluralModelLabel(): string;
+    static getUrl(page?: string, record?: string | number): string;
+    /** Pages d'enregistrements liés (port de ManageRelatedRecords) : `{ comments: ManagePostComments }` répond sous `<slug>/{record}/comments`. */
+    static relatedPages: Record<string, typeof ManageRelatedRecords>;
+    /** Pages proposées dans la sous-navigation d'un enregistrement, dans l'ordre : `['view', 'edit', 'comments']`. Vide : pas de sous-navigation. */
+    static recordSubNavigation: string[];
+    /** Port de getRecordSubNavigation() + generateNavigationItems() : un onglet par page déclarée, celui de la page courante actif. */
+    static getRecordSubNavigation(page: {
+        getRecordKey(): string | null;
+        constructor: Function;
+    }): SubNavigationItem[];
+    private static _registered;
+    /** Classe de page réellement enregistrée pour un nom (les pages sont générées une seule fois par resource). */
+    static getRegisteredPage(name: string): typeof Page | undefined;
+    static table(table: Table): Table;
+    static form(schema: Schema): Schema;
+    /** Schéma de la page de consultation (équivalent de `infolist()`). */
+    static infolist(schema: Schema): Schema;
+    /** Colonnes interrogées par la recherche globale ; par défaut, l'attribut de titre. Tableau vide : resource non cherchable. */
+    static globallySearchableAttributes: string[] | null;
+    static getGloballySearchableAttributes(): string[];
+    static canGloballySearch(): boolean;
+    /** Rang du groupe de cette resource dans les résultats (`$globalSearchSort`) ; sans rang : après les autres, dans l'ordre d'enregistrement. */
+    static globalSearchSort: number | null;
+    /** Nombre de résultats rendus par resource (50, comme Filament). */
+    static globalSearchResultsLimit: number;
+    static getGlobalSearchResultTitle(record: any): string;
+    /** Précisions affichées sous le titre : `{ Author: 'Jane' }`. Les valeurs vides sont écartées. */
+    static getGlobalSearchResultDetails(_record: any): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Adresse d'un résultat : page « View », sinon édition ; pour une resource simple, la liste avec l'action ouverte. Nul si l'utilisateur n'a aucun accès. */
+    static getGlobalSearchResultUrl(record: any, user: User | null): Promise<string | null>;
+    static getGlobalSearchResults(search: string, user: User | null): Promise<GlobalSearchResult[]>;
+    /** Attribut affiché comme titre d'un enregistrement (`$recordTitleAttribute`). */
+    static recordTitleAttribute: string | null;
+    /** Sans attribut de titre : le libellé du modèle, en capitales initiales (« Leave Request »), comme Filament. */
+    static getRecordTitle(record: any): string;
+    /** Pages de la resource, générées : liste, création, édition. */
+    static getPages(): Record<string, typeof Page>;
+    private static buildPages;
+}
+/** Onglet de sous-navigation d'une page. */
+export type SubNavigationItem = {
+    label: string;
+    icon: string | null;
+    url: string;
+    active: boolean;
+};
+type ColumnSpan = number | 'full';
+/** Widget : composant affiché dans une grille de page (port de Filament\Widgets\Widget). */
+export declare abstract class Widget extends Component {
+    static componentName: string;
+    /** Largeur dans la grille de widgets : un nombre de colonnes, ou `'full'`. */
+    static columnSpan: ColumnSpan;
+    /** Chargé quand il devient visible (comme `$isLazy`). */
+    static isLazy: boolean;
+    get panel(): Panel;
+    /** Widget réservé à certains utilisateurs : rendre `false` le retire de la page et refuse son chargement. */
+    static canView(_user: User): boolean | Promise<boolean>;
+    boot(): Promise<void>;
+    /** Classes et style de colonne de grille, au point de rupture `lg` comme Filament. */
+    protected gridColumn(): {
+        classes: string[];
+        style: string;
+    };
+    placeholder(): string;
+    /** Enveloppe commune (port de filament-widgets::components.widget). */
+    protected wrap(content: string, classes?: string[]): string;
+}
+/**
+ * Calendrier (propre à Navette) : vues mois, semaine et liste, navigation rendue par le serveur, sans bibliothèque JavaScript.
+ *
+ * Le minimum : étendre la classe et rendre les événements de la période affichée.
+ *
+ *     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' }]; }
+ *     }
+ *
+ * Tout le reste se redéfinit méthode par méthode : vues proposées, premier jour de la semaine, langue, libellés, nombre
+ * d'événements par case, réaction au clic sur un jour (`onDateClick`) ou sur un événement (`onEventClick`), rendu d'un
+ * événement (`renderEvent`), pied de case (`renderDayFooter`), boutons de la barre d'outils (`renderToolbarEnd`), et
+ * l'apparence par les variables CSS de `.nv-cal` (`getExtraClasses`, `getStyle`).
+ */
+export declare abstract class CalendarWidget extends Widget {
+    static columnSpan: ColumnSpan;
+    /** Titre affiché avant la période (« Leave — November 2026 »). */
+    static heading: string | null;
+    static callable: string[];
+    /** La vue et la date ne changent que par les méthodes ci-dessous, qui les valident. */
+    static locked: string[];
+    view: CalendarView;
+    /** Date d'ancrage (`YYYY-MM-DD`) : le mois ou la semaine affichés la contiennent. Vide : aujourd'hui. */
+    date: string;
+    /** Événements dont une partie tombe entre `start` et `end` (inclus, `YYYY-MM-DD`). Appelée à chaque rendu : filtrez en base. */
+    abstract getEvents(range: {
+        start: string;
+        end: string;
+        view: CalendarView;
+    }): CalendarEvent[] | Promise<CalendarEvent[]>;
+    /** Vues proposées, la première étant celle d'arrivée. Une seule vue : le sélecteur disparaît. */
+    getViews(): CalendarView[];
+    /** 0 = dimanche, 1 = lundi… */
+    getFirstDayOfWeek(): number;
+    /** Langue des noms de mois et de jours (`Intl`). */
+    getLocale(): string;
+    getLabels(): CalendarLabels;
+    /** En vue mois, au-delà de ce nombre, la case affiche « +N more » (qui ouvre la liste sur ce jour). */
+    getMaxEventsPerDay(): number;
+    getHeading(): string | null;
+    /** Date du jour, `YYYY-MM-DD` (UTC par défaut ; à redéfinir pour un autre fuseau). */
+    getToday(): string;
+    /** Clic sur un numéro de jour. Redéfinir cette méthode rend les jours cliquables : ouvrir une page (`this.redirect`), notifier, changer de vue… */
+    onDateClick(_date: string): void | Promise<void>;
+    /** Clic sur un événement sans adresse. L'événement est relu côté serveur : `event.extra` est disponible. */
+    onEventClick(_event: CalendarEvent): void | Promise<void>;
+    /** HTML d'un événement (déjà échappé), ou `null` pour le rendu par défaut (`renderCalendarEvent`). */
+    renderEvent(_event: CalendarEvent, _context: {
+        day: string;
+        view: CalendarView;
+    }): string | null;
+    /** HTML ajouté au bas de chaque case (déjà échappé). */
+    renderDayFooter(_day: string, _events: CalendarEvent[]): string;
+    /** HTML placé à droite de la barre d'outils (déjà échappé) : un lien « New », un filtre… */
+    renderToolbarEnd(): string;
+    /** Classes ajoutées au calendrier, pour y accrocher vos styles ou redéfinir ses variables CSS. */
+    getExtraClasses(): string[];
+    /** Variables CSS posées sur le calendrier : `{ '--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 » : la liste, ancrée sur ce jour (ou la semaine si la liste n'est pas proposée). */
+    showDay(date: unknown): void;
+    private datesClickable;
+    private eventsClickable;
+    selectDate(date: unknown): Promise<void>;
+    /** L'identifiant vient du navigateur : l'événement est recherché parmi ceux de la période affichée, jamais cru sur parole. */
+    selectEvent(id: unknown): Promise<void>;
+    render(): Promise<string>;
+}
+/**
+ * Page calendrier (propre à Navette) : le même calendrier que `CalendarWidget`, sur une page entière, avec les actions de
+ * Filament — donc des modales, des formulaires, des confirmations, des panneaux latéraux.
+ *
+ *     class Planning extends CalendarPage {
+ *         static slug = 'planning';
+ *         async getEvents({ start, end }) { return db('shifts').where('day', '>=', start).where('day', '<=', end)… }
+ *         // Clic sur un jour : une modale avec un formulaire, prérempli avec la 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(); });
+ *         }
+ *         // Clic sur un événement : une autre action ; l'événement est relu côté serveur.
+ *         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); });
+ *         }
+ *     }
+ *
+ * Trois façons de réagir à un clic, au choix : une **adresse** sur l'événement (`url` : page dédiée), une **action** (modale),
+ * ou du **code libre** en redéfinissant `onDateClick()` / `onEventClick()` (rediriger, notifier, écrire en base, monter l'action
+ * de son choix avec `this.mountAction(nom, arguments)`). `getHeaderActions()` ajoute des boutons en tête de page, et
+ * `getCalendarActions()` déclare d'autres actions montables depuis votre propre rendu (`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 ouverte au clic sur un jour ; elle reçoit `arguments.date`. Nul : les jours ne sont pas cliquables (sauf `onDateClick` redéfini). */
+    dateAction(): Action | null;
+    /** Action ouverte au clic sur un événement sans adresse ; elle reçoit `arguments.event` (identifiant, à relire avec `findEvent`). */
+    eventAction(): Action | null;
+    /** Autres actions montables depuis votre propre HTML : `wire:click="mountAction('nom', { … })"`. */
+    getCalendarActions(): Action[];
+    /** Par défaut : ouvre `dateAction()`. À redéfinir pour faire autre chose (rediriger vers une page de création, par exemple). */
+    onDateClick(date: string): Promise<void>;
+    /** Par défaut : ouvre `eventAction()`. L'événement a été retrouvé côté serveur avant l'appel. */
+    onEventClick(event: CalendarEvent): Promise<void>;
+    /** Date d'un clic, relue dans les arguments d'une action : ils viennent du navigateur, seule une vraie date est rendue. */
+    static dateOf(args: Record<string, unknown> | null | undefined): string | null;
+    /** Événement de la période affichée portant cet identifiant, ou nul : ne jamais agir sur un identifiant reçu sans passer par ici. */
+    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>;
+}
+/** Compte de l'utilisateur connecté : avatar, nom, déconnexion (port de Filament\Widgets\AccountWidget). */
+export declare class AccountWidget extends Widget {
+    static isLazy: boolean;
+    render(): string;
+}
+/** Version de Navette et liens utiles (pendant de Filament\Widgets\FilamentInfoWidget, dont il reprend le balisage et les classes). */
+export declare class NavetteInfoWidget extends Widget {
+    static isLazy: boolean;
+    static homeUrl: string;
+    static documentationUrl: string;
+    static githubUrl: string;
+    static version: string;
+    render(): string;
+}
+/** Une statistique d'un StatsOverviewWidget (port de Stat). */
+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;
+    /** Couleur de la description et de la courbe. */
+    color(color: string | null): this;
+    icon(name: string | null): this;
+    /** Courbe de tendance : une liste de valeurs, ou des valeurs par libellé. */
+    chart(values: Record<string, number> | number[] | null): this;
+    url(url: string | null): this;
+    hasChart(): boolean;
+    toHtml(panel: Panel, key: string): string;
+}
+/** Rangée de statistiques (port de StatsOverviewWidget). */
+export declare abstract class StatsOverviewWidget extends Widget {
+    static columnSpan: ColumnSpan;
+    /** Intervalle de rafraîchissement (`'5s'` dans Filament par défaut), ou null pour ne pas rafraîchir. */
+    static pollingInterval: string | null;
+    abstract getStats(): Stat[] | Promise<Stat[]>;
+    /** Colonnes de la rangée : comme Filament, trois, ou quatre quand le nombre de statistiques s'y prête. */
+    protected getColumns(count: number): number;
+    render(): Promise<string>;
+}
+/** Données d'un graphique, au format de Chart.js : `{ datasets: [{ label, data, … }], labels: [...] }`. */
+export type ChartData = {
+    datasets?: Record<string, unknown>[];
+    labels?: unknown[];
+    [key: string]: unknown;
+};
+/**
+ * Graphique Chart.js (port de Filament\Widgets\ChartWidget). Une sous-classe donne `getType()` (`'line'`, `'bar'`, `'pie'`,
+ * `'doughnut'`, `'radar'`, `'polarArea'`, `'scatter'`, `'bubble'`) et `getData()`. Le rendu est fait dans le navigateur par le
+ * composant `chart.js` de Filament ; le serveur n'envoie de nouvelles données que si elles ont changé (somme de contrôle).
+ */
+export declare abstract class ChartWidget extends Widget {
+    static callable: string[];
+    static locked: string[];
+    /** Intervalle de rafraîchissement (`'5s'` par défaut dans Filament), ou null pour ne pas rafraîchir. */
+    static pollingInterval: string | null;
+    static heading: string | null;
+    static description: string | null;
+    /** Couleur des séries qui n'en précisent pas. */
+    static color: string;
+    /** Hauteur maximale du graphique (`'300px'`). */
+    static maxHeight: string | null;
+    static isCollapsible: boolean;
+    dataChecksum: string | null;
+    /** Filtre choisi, parmi `getFilters()`. */
+    filter: string | null;
+    private _cachedData;
+    abstract getType(): string;
+    getData(): ChartData | Promise<ChartData>;
+    /** Options de Chart.js. */
+    getOptions(): Record<string, unknown> | null;
+    /** Filtres proposés dans l'en-tête : valeur vers libellé. */
+    getFilters(): Record<string, string> | null;
+    getHeading(): string | null;
+    getDescription(): string | null;
+    getColor(): string;
+    getMaxHeight(): string | null;
+    /** Texte lu par les lecteurs d'écran à la place du graphique. */
+    getChartAssistiveContent(): string | null;
+    protected getCachedData(): Promise<ChartData>;
+    protected generateDataChecksum(): Promise<string>;
+    mount(): Promise<void>;
+    /** Appelé par le rafraîchissement périodique et avant chaque rendu : n'émet les données que si elles ont changé. */
+    updateChartData(): Promise<void>;
+    render(): Promise<string>;
+}
+/**
+ * Table dans un widget (port de Filament\Widgets\TableWidget) : recherche, tri, pagination simple (précédent / suivant).
+ * Une sous-classe donne `table(table)` et `getDataAdapterForTable()`. Pas d'actions ni de filtres pour l'instant.
+ */
+export declare abstract class TableWidget extends Widget implements TableHost {
+    static columnSpan: ColumnSpan;
+    static callable: string[];
+    /** Titre de la table ; par défaut tiré du nom de la classe (`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>;
+}
+/** Widgets qui reçoivent les filtres du tableau de bord (port de InteractsWithPageFilters) : `static reactive = PAGE_FILTERS` et une propriété `pageFilters`. */
+export declare const PAGE_FILTERS: string[];
+/**
+ * Widget de statistiques lié à la table d'une page de liste (port de InteractsWithPageTable) : il reçoit l'état de la table
+ * (recherche, filtres, onglet…) et peut agréger exactement les enregistrements qu'elle affiche.
+ */
+export declare abstract class PageTableStatsWidget extends StatsOverviewWidget {
+    /** Page de liste dont la table est observée (équivalent de getTablePage()). */
+    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;
+    /** Agrégats sur la requête courante de la table. L'état reçu passe par la même validation que sur la page. */
+    protected aggregatePageTable(columns?: {
+        sum?: string[];
+        avg?: string[];
+    }, modify?: ((query: any) => void) | null): Promise<{
+        count: number;
+        sum: Record<string, number>;
+        avg: Record<string, number>;
+    }>;
+    /** Tendance mensuelle sur la requête courante de la table (voir `ObjectionAdapter.trendPerMonth`). */
+    protected trendPageTable(options: {
+        start: Date;
+        end: Date;
+        dateColumn?: string;
+        average?: string;
+        modify?: (query: any) => void;
+    }): Promise<number[]>;
+}
+/** Composant de schéma qui intègre la table du composant hôte (port de EmbeddedTable). */
+export declare class EmbeddedTable extends SchemaComponent {
+    static make(): EmbeddedTable;
+    toHtml(): Promise<string>;
+}
+/** Onglet d'une page de liste : restreint la requête de la table et peut afficher un compteur (port de Tab). */
+export declare class Tab {
+    private _label;
+    private _badge;
+    private _badgeColor;
+    private _hasBadgeColor;
+    private _query;
+    constructor(label?: string | null);
+    static make(label?: string | null): Tab;
+    /** Compteur, calculé après l'affichage de la page (comme `lazyLoadedBadge()`). */
+    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;
+    /** Faux tant que `badgeColor()` n'a pas été appelé : un badge chargé après coup ne reçoit alors aucune classe de couleur, comme dans Filament. */
+    hasBadgeColor(): boolean;
+    getQuery(): ((query: any) => void) | null;
+}
+/** Page de liste d'une resource : état de table et méthodes appelées par le navigateur (port de ListRecords + InteractsWithTable). */
+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;
+    /** Regroupement courant de la table (`identifiant:direction`), choisi dans la barre d'outils. */
+    tableGrouping: string | null;
+    updatedTableGrouping(): void;
+    /** Entre dans le mode « tri manuel » ou en sort (port de toggleTableReordering). */
+    toggleTableReordering(): Promise<void>;
+    /** Enregistre le nouvel ordre : seules les clés de la table sont retenues, chacune reçoit son rang (port de reorderTable). */
+    reorderTable(order: unknown, _draggedRecordKey?: unknown): Promise<void>;
+    mount(_params?: Record<string, unknown>): Promise<void>;
+    /** Formulaire des filtres : un groupe par filtre, lié à `tableDeferredFilters.<filtre>`. */
+    tableFiltersFormSchema(schema: Schema): Schema;
+    applyTableFilters(): void;
+    /** Retrait d'un indicateur de filtre actif : le champ visé est effacé de l'état appliqué et du formulaire. */
+    removeTableFilter(filterName: unknown, field?: unknown): void;
+    /** Champ réactif du formulaire des filtres (changement d'opérateur d'une règle) : exécute son `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>;
+    /** Onglet actif, ramené à une clé déclarée (une valeur inconnue envoyée par le navigateur vaut l'onglet par défaut). */
+    getActiveTabKey(): string;
+    updatedActiveTab(): void;
+    modifyTableQuery(query: {
+        modifiers?: ((q: any) => void)[];
+    }): void;
+    get resource(): typeof Resource;
+    getHeaderWidgets(): (typeof Widget)[];
+    /** Port de ExposesTableToWidgets : l'état de la table est passé aux widgets, qui peuvent refaire la même requête. */
+    getWidgetData(): Record<string, unknown>;
+    protected rendersActionModalsInPage(): boolean;
+    getBulkActions(): Action[];
+    /** Actions de ligne déclarées par la table, groupes dépliés. */
+    getRecordActions(): Action[];
+    protected getMountableActions(context: Record<string, unknown>): Action[] | Promise<Action[]>;
+    /** Seules les formes de contexte connues sont retenues ; la clé d'enregistrement est revérifiée en base au montage. */
+    protected resolveMountContext(clientContext: unknown): Record<string, unknown>;
+    protected resolveActionRecord(context: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Écriture d'une cellule modifiable (port de `updateTableColumnState`). Tout vient du navigateur : la colonne doit exister, être
+     * modifiable et visible, l'enregistrement être dans la portée de la table et modifiable par l'utilisateur, la valeur être valide.
+     */
+    updateTableColumnState(columnName: unknown, recordKey: unknown, input: unknown): Promise<unknown>;
+    /** Clés sélectionnées : la liste envoyée, ou — en mode « tout sélectionner » — tous les enregistrements de la requête courante sauf ceux désélectionnés. */
+    getSelectedRecordKeys(): Promise<string[]>;
+    deselectAllTableRecords(): void;
+    getTable(): Table;
+    renderTable(): Promise<string>;
+    /** Actions affichées dans l'en-tête de la table (aucune pour une page de liste : elles sont dans l'en-tête de page). */
+    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 des enregistrements liés à un autre (port de RelationManager) : composant enfant de la page d'édition, chargé quand il devient visible.
+ * Les sous-classes déclarent `relationship`, `adapterFor()`, `table()` et `form()`.
+ */
+export declare class RelationManager extends ListRecords {
+    static relationship: string;
+    static modelLabel: string;
+    static pluralModelLabel: string | null;
+    static recordTitleAttribute: string | null;
+    /** Adaptateur limité aux enregistrements liés au propriétaire donné. */
+    static adapterFor(_ownerKey: string): DataAdapter;
+    /** Politique des enregistrements liés (mêmes capacités que celle d'une resource). */
+    static policy: Policy | null;
+    protected isAccessAuthorized(ctx: PanelContext): Promise<boolean>;
+    static table(table: Table): Table;
+    static form(schema: Schema): Schema;
+    static getTitle(): string;
+    /** Clé de l'enregistrement propriétaire : fixée au montage par la page, jamais modifiable depuis le navigateur. */
+    ownerRecord: string;
+    static locked: string[];
+    _facade: any;
+    /** Ce que ListRecords attend d'une resource, fourni ici par le relation manager. */
+    get resource(): any;
+    getTable(): Table;
+    /** Rattache un enregistrement existant au propriétaire. */
+    static attach(_ownerKey: string, _recordKey: string): Promise<void>;
+    /** Détache des enregistrements du propriétaire, sans les supprimer. */
+    static detach(_ownerKey: string, _recordKeys: string[]): Promise<void>;
+    /** Enregistrements rattachables correspondant à la recherche : [clé, libellé]. */
+    static searchAttachable(_ownerKey: string, _search: string): Promise<[string, string][]>;
+    /** Libellé d'un enregistrement rattachable, ou null s'il ne l'est pas (sert aussi de validation). */
+    static attachableLabel(_ownerKey: string, _recordKey: string): Promise<string | null>;
+    getHeaderActions(): Action[];
+    placeholder(): string;
+    /** Comme Filament : un relation manager a ses propres emplacements, pas ceux de la page de liste. */
+    contentSchema(schema: Schema): Schema;
+    render(): Promise<string>;
+}
+/**
+ * Page des enregistrements liés à un enregistrement (port de ManageRelatedRecords) : une table, avec création, consultation et
+ * édition en modales. Déclarée par `static relatedPages` de la resource propriétaire, elle répond sous `<slug>/{record}/<nom>`.
+ */
+export declare class ManageRelatedRecords extends ListRecords {
+    /** Resource propriétaire : fixée à l'enregistrement de la page. */
+    static parentResource: typeof Resource;
+    static relationship: string;
+    static modelLabel: string;
+    static pluralModelLabel: string | null;
+    static recordTitleAttribute: string | null;
+    static policy: Policy | null;
+    /** Adaptateur limité aux enregistrements liés au propriétaire donné. */
+    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;
+    /** Clé de l'enregistrement propriétaire : tirée de l'adresse au montage, jamais modifiable depuis le navigateur. */
+    recordKey: string;
+    static locked: string[];
+    _owner: any;
+    _facade: any;
+    private get related();
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** Le propriétaire est relu et son accès vérifié à chaque requête. */
+    hydrate(): Promise<void>;
+    getRecordKey(): string | null;
+    /** Ce que ListRecords attend d'une resource, fourni ici par la page. */
+    get resource(): any;
+    getTable(): Table;
+    getHeaderActions(): Action[];
+    /** Comme Filament : le contenu de la page est un groupe (onglets éventuels, puis la table). */
+    contentSchema(schema: Schema): Schema;
+    getTitle(): string;
+    getSubNavigation(): SubNavigationItem[];
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getPageClasses(): string[];
+}
+/** Base des pages à formulaire d'une resource. */
+declare abstract class ResourceFormPage extends Page {
+    /** Champ réactif du formulaire (`live()` + `afterStateUpdated()`) : `set(nom, valeur)` écrit à côté du champ modifié. */
+    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;
+    /** Deux colonnes par défaut à partir de `lg`, comme `defaultForm()` de Filament ; la resource peut en décider autrement. */
+    formSchema(schema: Schema): Schema;
+    /**
+     * Étapes d'un assistant (équivalent du trait HasWizard de Filament) : dès que la méthode en retourne, la page présente son formulaire
+     * étape par étape, avec « Back » / « Next » et le bouton d'enregistrement sur la dernière étape.
+     */
+    protected getSteps(): Step[] | null;
+    /** Vrai : les étapes sont accessibles dans n'importe quel ordre, sans validation au passage. */
+    protected hasSkippableSteps(): boolean;
+    /** Étape affichée à l'ouverture (à partir de 1). */
+    protected getStartStep(): number;
+    protected getWizardComponent(steps: Step[]): Wizard;
+    contentSchema(schema: Schema): Schema;
+    /** Destination de « Cancel » quand le navigateur n'a pas d'historique : la liste, sauf si la page en décide autrement. */
+    protected getCancelUrl(): string;
+    protected cancelAction(): Action;
+    /** Valide le formulaire ; en cas d'erreur, les pose sur le composant et prévient le navigateur. */
+    protected validateForm(): Promise<boolean>;
+}
+/** Page de création d'un enregistrement (port de CreateRecord). */
+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[];
+    /** Transforme les données validées avant la création (ajouter l'auteur, calculer un champ…). */
+    protected mutateFormDataBeforeCreate(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Juste avant la création ; lever une erreur l'annule. */
+    protected beforeCreate(_data: Record<string, unknown>): void | Promise<void>;
+    /** La création elle-même : par défaut, l'adaptateur de la resource. */
+    protected handleRecordCreation(data: Record<string, unknown>): Promise<any>;
+    /** Après la création (journal, envoi d'un message…). */
+    protected afterCreate(_record: any): void | Promise<void>;
+    /** Où aller ensuite : par défaut, la page d'édition du nouvel enregistrement. */
+    protected getRedirectUrl(record: any): string;
+    /** Titre de la notification de succès ; `null` pour ne rien afficher. */
+    protected getCreatedNotificationTitle(): string | null;
+    create(another?: boolean): Promise<void>;
+    createAnother(): Promise<void>;
+}
+/** Action de suppression d'un enregistrement, avec confirmation (port de Filament\Actions\DeleteAction dans une page de resource). */
+export declare class DeleteAction {
+    /** Sur une page d'édition : supprime l'enregistrement de la page puis revient à la liste. Sur une ligne de table : supprime la ligne. */
+    static make(): Action;
+}
+/** Action de duplication : comme `Action`, avec la liste des attributs à ne pas recopier. */
+export type ReplicateActionInstance = Action & {
+    excludeAttributes(attributes: string[]): ReplicateActionInstance;
+};
+/** Duplication d'une ligne de table (port de ReplicateAction) : la copie reprend les attributs de l'enregistrement, sauf sa clé, ses dates et ceux exclus. */
+export declare class ReplicateAction {
+    static make(): ReplicateActionInstance;
+}
+/** Création en modale avec le formulaire de la resource (port de CreateAction). */
+export declare class CreateAction {
+    /** Sans argument, la resource (ou le relation manager) est celle du composant hôte. */
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Édition en modale d'une ligne de table, avec le formulaire de la resource (port de EditAction). */
+export declare class EditAction {
+    /** Sans argument, la resource (ou le relation manager) est celle du composant hôte. */
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Lien vers la page de consultation de l'enregistrement (port de ViewAction, quand la resource a une page « View »). */
+export declare class ViewAction {
+    static make(resource?: typeof Resource | null): Action;
+}
+/** Rattache un enregistrement existant au propriétaire d'un relation manager (port de AttachAction). */
+export declare class AttachAction {
+    static make(): Action;
+}
+/** Détache une ligne du propriétaire sans la supprimer (port de DetachAction). */
+export declare class DetachAction {
+    static make(): Action;
+}
+/** Détache les lignes sélectionnées (port de DetachBulkAction). */
+export declare class DetachBulkAction {
+    static make(): Action;
+}
+/** Restauration d'un enregistrement supprimé (port de RestoreAction). Visible seulement s'il est supprimé. */
+export declare class RestoreAction {
+    static make(): Action;
+}
+/** Suppression définitive d'un enregistrement supprimé (port de ForceDeleteAction). Visible seulement s'il est supprimé. */
+export declare class ForceDeleteAction {
+    static make(): Action;
+}
+/** Suppression groupée des enregistrements sélectionnés dans une table (port de DeleteBulkAction). */
+export declare class DeleteBulkAction {
+    static make(): Action;
+}
+/** Page d'édition d'un enregistrement (port de EditRecord). */
+export declare class EditRecord extends ResourceFormPage {
+    static callable: string[];
+    recordKey: string;
+    /** Onglet de relation manager actif (indice dans `Resource.relations`). */
+    activeRelationManager: string;
+    /**
+     * Page précédente (équivalent de `url()->previous()`), retenue au premier affichage. Elle vient de l'en-tête Referer :
+     * seule une adresse de ce même site est acceptée, et elle n'est plus modifiable ensuite.
+     */
+    previousUrl: string;
+    protected getCancelUrl(): string;
+    contentSchema(schema: Schema): Schema;
+    static locked: string[];
+    _record: any;
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** L'enregistrement est relu à chaque requête, comme dans Filament (pas de liaison de route). */
+    hydrate(): Promise<void>;
+    protected getRecord(): unknown;
+    getRecordKey(): string | null;
+    getActionMountContext(): Record<string, unknown>;
+    protected getActionRecord(): unknown;
+    /** Comme une page générée par Filament : suppression, plus restauration et suppression définitive si le modèle a la suppression douce. */
+    getHeaderActions(): Action[];
+    getOperation(): 'edit';
+    getSubmitMethod(): string;
+    getTitle(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getSubNavigation(): SubNavigationItem[];
+    getPageClasses(): string[];
+    getFormActions(): Action[];
+    /** Transforme les valeurs de l'enregistrement avant de remplir le formulaire. */
+    protected mutateFormDataBeforeFill(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Transforme les données validées avant l'enregistrement. */
+    protected mutateFormDataBeforeSave(data: Record<string, unknown>): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /** Juste avant l'enregistrement ; lever une erreur l'annule. */
+    protected beforeSave(_data: Record<string, unknown>): void | Promise<void>;
+    /** L'enregistrement lui-même : par défaut, l'adaptateur de la resource. */
+    protected handleRecordUpdate(record: any, data: Record<string, unknown>): Promise<any>;
+    /** Après l'enregistrement. */
+    protected afterSave(_record: any): void | Promise<void>;
+    /** Adresse où aller après l'enregistrement ; `null` (défaut) : rester sur la page. */
+    protected getRedirectUrl(_record: any): string | null;
+    /** Titre de la notification de succès ; `null` pour ne rien afficher. */
+    protected getSavedNotificationTitle(): string | null;
+    save(): Promise<void>;
+}
+/** Page de consultation d'un enregistrement (port de ViewRecord) : le schéma `infolist()` de la resource, en lecture seule. */
+export declare class ViewRecord extends Page {
+    static resource: typeof Resource;
+    static locked: string[];
+    recordKey: string;
+    /** Onglet de relation manager actif (indice dans `Resource.relations`). */
+    activeRelationManager: string;
+    _record: any;
+    get resource(): typeof Resource;
+    getDataAdapter(): DataAdapter;
+    mount(params: Record<string, unknown>): Promise<void>;
+    /** L'enregistrement est relu à chaque requête, comme sur la page d'édition. */
+    hydrate(): Promise<void>;
+    getRecordKey(): string | null;
+    getActionMountContext(): Record<string, unknown>;
+    protected getActionRecord(): unknown;
+    infolistSchema(schema: Schema): Schema;
+    contentSchema(schema: Schema): Schema;
+    /** Par défaut : le lien vers la page d'édition (EditAction d'une page « View »). */
+    getHeaderActions(): Action[];
+    protected editAction(): Action;
+    getTitle(): string;
+    getBreadcrumbs(): {
+        label: string;
+        url: string | null;
+    }[];
+    getSubNavigation(): SubNavigationItem[];
+    getPageClasses(): string[];
+}
+/** Sidebar : logo, menu du locataire, recherche, navigation, et — sans barre du haut — cloche et menu utilisateur. */
+export declare class Sidebar extends Component {
+    static callable: string[];
+    currentPath: string;
+    static locked: string[];
+    mount(params: Record<string, unknown>): void;
+    /** Un élément de resource reste actif sur ses pages de création et d'édition. */
+    render(): Promise<string>;
+    /** Choix d'un thème par l'utilisateur : seul un thème déclaré par le panel est accepté ; la page est rechargée pour l'appliquer. */
+    setTheme(id: unknown): void;
+}
+/** Barre du haut (port de Filament\Livewire\Topbar) : logo, navigation éventuelle, recherche, cloche, menu utilisateur. */
+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;
+}
+/** Menu utilisateur des pages simples d'un utilisateur connecté (port de SimpleUserMenu). */
+export declare class SimpleUserMenu extends Component {
+    static callable: string[];
+    render(): Promise<string>;
+    setTheme(id: unknown): void;
+}
+/** Routeur Express d'un panel : assets, endpoint du runtime, authentification, locataires, pages protégées. */
+export declare function panelRouter(panel: Panel, runtime: WireRuntime): Router;