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

package/lib/index.d.ts

@@ -0,0 +1,786 @@
+import type { DataAdapter, ListQuery, Page as RecordPage, SortDirection } from '@navette-js/database';
+import { Attributes, type ColorManager } from '@navette-js/support';
+export * from './query-builder.ts';
+/** Emplacements de render hook d'une table — mêmes noms que `Filament\Tables\View\TablesRenderHook`. */
+export declare const TablesRenderHook: {
+    readonly CONTENT_AFTER: "tables::content.after";
+    readonly CONTENT_BEFORE: "tables::content.before";
+    readonly SELECTION_INDICATOR_ACTIONS_AFTER: "tables::selection.indicator.actions.after";
+    readonly SELECTION_INDICATOR_ACTIONS_BEFORE: "tables::selection.indicator.actions.before";
+    readonly HEADER_AFTER: "tables::header.after";
+    readonly HEADER_BEFORE: "tables::header.before";
+    readonly TOOLBAR_AFTER: "tables::toolbar.after";
+    readonly TOOLBAR_BEFORE: "tables::toolbar.before";
+    readonly TOOLBAR_COLUMN_MANAGER_TRIGGER_AFTER: "tables::toolbar.toggle-column-trigger.after";
+    readonly TOOLBAR_COLUMN_MANAGER_TRIGGER_BEFORE: "tables::toolbar.toggle-column-trigger.before";
+    readonly TOOLBAR_END: "tables::toolbar.end";
+    readonly TOOLBAR_GROUPING_SELECTOR_AFTER: "tables::toolbar.grouping-selector.after";
+    readonly TOOLBAR_GROUPING_SELECTOR_BEFORE: "tables::toolbar.grouping-selector.before";
+    readonly TOOLBAR_REORDER_TRIGGER_AFTER: "tables::toolbar.reorder-trigger.after";
+    readonly TOOLBAR_REORDER_TRIGGER_BEFORE: "tables::toolbar.reorder-trigger.before";
+    readonly TOOLBAR_SEARCH_AFTER: "tables::toolbar.search.after";
+    readonly TOOLBAR_SEARCH_BEFORE: "tables::toolbar.search.before";
+    readonly TOOLBAR_START: "tables::toolbar.start";
+    readonly FILTER_INDICATORS: "tables::filter.indicators";
+    readonly HEADER_CELL: "tables::header.cell";
+    /** Anciens noms, conservés par Filament. */
+    readonly TOOLBAR_TOGGLE_COLUMN_TRIGGER_AFTER: "tables::toolbar.toggle-column-trigger.after";
+    readonly TOOLBAR_TOGGLE_COLUMN_TRIGGER_BEFORE: "tables::toolbar.toggle-column-trigger.before";
+};
+/** Cibles de chargement de la table (`wire:target`), dans l'ordre émis par Filament. */
+export declare const LOADING_TARGETS = "activeTab,applyTableFilters,gotoPage,nextPage,previousPage,removeTableFilter,removeTableFilters,reorderTable,resetTableColumnSearch,resetTableFiltersForm,resetTableSearch,setPage,sortTable,tableColumnSearches,tableFilters,tableGrouping,tableRecordsPerPage,tableSearch,tableSort,toggleTableReordering";
+type StateResolver<R> = (ctx: {
+    record: R;
+}) => unknown | Promise<unknown>;
+/** Base commune des colonnes (port partiel de Filament\Tables\Columns\Column). */
+export declare abstract class Column<R = any> {
+    /** Réglage par défaut de toutes les instances créées ensuite par `make()` : `TextInput.configureUsing((input) => input.maxLength(255))`. */
+    static configureUsing<T>(this: abstract new (...args: any[]) => T, configure: (instance: T) => void): void;
+    readonly name: string;
+    protected _label: string | null;
+    protected _sortable: boolean;
+    protected _searchable: boolean;
+    protected _individuallySearchable: boolean;
+    protected _toggleable: boolean;
+    protected _toggledHiddenByDefault: boolean;
+    protected _alignment: string | null;
+    protected _state: StateResolver<R> | null;
+    protected _sortColumn: string | null;
+    protected _searchColumn: string | null;
+    protected _url: ((record: R) => string | null) | null;
+    /** Libellé du groupe de colonnes auquel la colonne appartient (posé par ColumnGroup). */
+    _group: string | null;
+    constructor(name: string);
+    label(label: string): this;
+    /** `column` : colonne (ou alias de la requête) utilisée pour trier quand elle diffère du nom, par exemple pour une relation. */
+    sortable(condition?: boolean | {
+        column: string;
+        inverted?: boolean;
+    }): this;
+    getSortColumn(): string;
+    private _sortInverted;
+    /** Vrai quand la colonne de tri évolue en sens inverse de la valeur affichée (`inverted` : un âge trié par sa date). */
+    isSortInverted(): boolean;
+    /** Lien posé sur la cellule ; il prend le pas sur l'action de ligne. */
+    url(resolver: (record: R) => string | null): this;
+    getUrl(record: R): string | null;
+    /** `isGlobal: false` exclut la colonne de la recherche globale ; `isIndividual` ajoute un champ de recherche propre à la colonne. */
+    getSearchColumn(): string;
+    searchable(options?: boolean | {
+        isIndividual?: boolean;
+        isGlobal?: boolean;
+        column?: string;
+    }): this;
+    /** Colonne que l'utilisateur peut masquer depuis le gestionnaire de colonnes. */
+    toggleable(condition?: boolean, options?: {
+        isToggledHiddenByDefault?: boolean;
+    }): this;
+    alignment(alignment: 'start' | 'center' | 'end' | null): this;
+    alignEnd(): this;
+    alignLeft(): this;
+    alignCenter(): this;
+    getStateUsing(resolver: StateResolver<R>): this;
+    getLabel(): string;
+    isSortable(): boolean;
+    isGloballySearchable(): boolean;
+    isIndividuallySearchable(): boolean;
+    isToggleable(): boolean;
+    isToggledHiddenByDefault(): boolean;
+    getAlignment(): string | null;
+    /** Suffixe des classes `fi-ta-header-cell-…` / `fi-ta-cell-…` : les tirets bas deviennent des tirets, les points sont conservés (comme Filament). */
+    getCssName(): string;
+    getState(record: R): Promise<unknown>;
+    /** Vrai pour une cellule modifiable : elle n'est enveloppée ni d'un lien ni d'un bouton vers l'enregistrement. */
+    isClickDisabled(): boolean;
+    abstract toHtml(record: R, recordKey?: string | number): Promise<string>;
+}
+export declare class TextColumn<R = any> extends Column<R> {
+    private _weight;
+    private _copyable;
+    private _money;
+    private _placeholder;
+    private _badge;
+    private _color;
+    private _icon;
+    private _format;
+    private _date;
+    private _numeric;
+    private _summarizers;
+    private _limit;
+    private _tooltip;
+    static make<R = any>(name: string): TextColumn<R>;
+    /** Affiche la valeur dans une pastille. */
+    badge(condition?: boolean): this;
+    color(color: string | ((record: R) => string)): this;
+    icon(resolver: (record: R) => string | null): this;
+    /** Texte affiché à la place de la valeur brute (libellé d'une énumération, par exemple). */
+    formatStateUsing(formatter: (ctx: {
+        state: unknown;
+        record: R;
+    }) => string): this;
+    /** Date courte, comme `->date()` de Filament (« Nov 9, 2026 »). */
+    date(condition?: boolean): this;
+    private _dateTime;
+    /** Date et heure, « M j, Y H:i:s » (format par défaut de Filament). */
+    dateTime(condition?: boolean): this;
+    /** Nombre formaté avec séparateurs de milliers (`->numeric()`). */
+    private _decimals;
+    /** `numeric(1)` : nombre de décimales fixe. */
+    numeric(condition?: boolean | number): this;
+    /** Ligne de totaux sous la table. */
+    summarize(summarizer: Summarizer | Summarizer[]): this;
+    getSummarizers(): Summarizer[];
+    weight(weight: string): this;
+    /** Tronque le texte affiché à `length` caractères, suivi de « ... » (port de `limit()`, Str::limit). */
+    limit(length: number | null): this;
+    /** Infobulle au survol du texte ; `null` pour ne pas en afficher. */
+    tooltip(tooltip: ((record: R) => string | null) | string | null): this;
+    copyable(condition?: boolean): this;
+    /** Montant formaté dans la devise donnée (`money('usd')`). */
+    money(currency?: string | ((record: R) => string)): this;
+    /** Texte affiché quand la valeur est vide. */
+    placeholder(text: string | null): this;
+    /** Contenu de cellule. Filament a deux balisages : un chemin court pour le texte simple, un chemin complet dès qu'une option est posée. */
+    toHtml(record: R): Promise<string>;
+}
+/** Valeurs dont un summarizer tire son résultat : agrégats de la requête (tous les enregistrements) ou de la page affichée. */
+export type SummaryValues = {
+    count: number;
+    sum: Record<string, number>;
+    avg: Record<string, number>;
+    min: Record<string, unknown>;
+    max: Record<string, unknown>;
+};
+export type SummaryItem = {
+    type: 'text' | 'range';
+    label: string | null;
+    value: string;
+};
+/** Résumé d'une colonne sous la table (port de Summarizers\Summarizer) : somme, moyenne, nombre ou étendue. */
+export declare abstract class Summarizer {
+    abstract readonly kind: 'sum' | 'avg' | 'count' | 'range';
+    protected _label: string | null;
+    protected _money: string | null;
+    label(label: string | null): this;
+    money(currency?: string): this;
+    getLabel(): string | null;
+    format(value: number): string;
+    abstract summarize(column: string, values: SummaryValues): SummaryItem | null;
+}
+/** Total d'une colonne (port du summarizer Sum). */
+export declare class Sum extends Summarizer {
+    readonly kind = "sum";
+    static make(): Sum;
+    getLabel(): string;
+    summarize(column: string, values: SummaryValues): SummaryItem;
+}
+/** Moyenne d'une colonne (port du summarizer Average). */
+export declare class Average extends Summarizer {
+    readonly kind = "avg";
+    static make(): Average;
+    getLabel(): string;
+    summarize(column: string, values: SummaryValues): SummaryItem;
+}
+/** Nombre d'enregistrements (port du summarizer Count). */
+export declare class Count extends Summarizer {
+    readonly kind = "count";
+    static make(): Count;
+    getLabel(): string;
+    summarize(_column: string, values: SummaryValues): SummaryItem;
+}
+/** Plus petite et plus grande valeur d'une colonne (port du summarizer Range). */
+export declare class Range extends Summarizer {
+    readonly kind = "range";
+    private _minimalDateTime;
+    static make(): Range;
+    /** Dates : le jour seul quand les deux bornes diffèrent de jour, le jour et l'heure sinon ; une seule valeur si elles sont identiques. */
+    minimalDateTimeDifference(condition?: boolean): this;
+    summarize(column: string, values: SummaryValues): SummaryItem | null;
+}
+/** Regroupement des lignes d'une table (port de Grouping\Group) : les lignes sont triées par la colonne, un en-tête précède chaque groupe. */
+export declare class Group<R = any> {
+    private id;
+    private _label;
+    private _column;
+    private _title;
+    private _description;
+    private _collapsible;
+    private _date;
+    private _titlePrefixedWithLabel;
+    constructor(id: string);
+    static make<R = any>(id: string): Group<R>;
+    label(label: string | null): this;
+    /** Colonne de la requête qui porte la valeur du groupe, quand elle diffère de l'identifiant (relation). */
+    column(column: string | null): this;
+    /** Titre du groupe tiré de l'enregistrement (libellé d'une énumération, par exemple). */
+    getTitleUsing(resolver: ((record: R) => string | null) | null): this;
+    getDescriptionUsing(resolver: ((record: R) => string | null) | null): this;
+    /** Noms de Filament (`getTitleFromRecordUsing`, `getDescriptionFromRecordUsing`). */
+    getTitleFromRecordUsing(resolver: ((record: R) => string | null) | null): this;
+    getDescriptionFromRecordUsing(resolver: ((record: R) => string | null) | null): this;
+    /** Les groupes se replient d'un clic sur leur en-tête. */
+    collapsible(condition?: boolean): this;
+    /** La colonne est une date : les lignes d'un même jour forment un groupe. */
+    date(condition?: boolean): this;
+    titlePrefixedWithLabel(condition?: boolean): this;
+    getId(): string;
+    getLabel(): string;
+    getColumn(): string;
+    isCollapsible(): boolean;
+    isDate(): boolean;
+    isTitlePrefixedWithLabel(): boolean;
+    /** Valeur du groupe pour un enregistrement, en texte ; `null` quand elle est vide. */
+    getStringKey(record: R): string | null;
+    getTitle(record: R): string | null;
+    getDescription(record: R): string | null;
+    /** Restreint une requête aux enregistrements du groupe de clé donnée. */
+    scope(query: any, key: string | null): void;
+}
+/**
+ * Mise en page des colonnes (port de Tables\Columns\Layout) : dès qu'une table en contient une, ses enregistrements sont
+ * rendus en cartes (`fi-ta-content`) et non plus en lignes de tableau ; le tri passe par un sélecteur « Sort by ».
+ */
+export declare abstract class ColumnLayout<R = any> {
+    protected _children: (Column<R> | ColumnLayout<R>)[];
+    constructor(children: (Column<R> | ColumnLayout<R>)[]);
+    getChildren(): (Column<R> | ColumnLayout<R>)[];
+    /** Colonnes feuilles, dans l'ordre : ce sont elles que la table trie, cherche et masque. */
+    getColumns(): Column<R>[];
+    abstract getClasses(): string[];
+}
+/** Colonnes côte à côte, à partir d'un point de rupture (port de Layout\Split). */
+export declare class Split<R = any> extends ColumnLayout<R> {
+    private _from;
+    static make<R = any>(children: (Column<R> | ColumnLayout<R>)[]): Split<R>;
+    from(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | null): this;
+    getClasses(): string[];
+}
+/** Colonnes l'une sous l'autre (port de Layout\Stack). */
+export declare class Stack<R = any> extends ColumnLayout<R> {
+    private _space;
+    private _alignment;
+    static make<R = any>(children: (Column<R> | ColumnLayout<R>)[]): Stack<R>;
+    /** Espace entre les colonnes : 1 (petit), 2 (moyen) ou 3 (grand). */
+    space(space?: 1 | 2 | 3 | null): this;
+    alignment(alignment: 'start' | 'center' | 'end'): this;
+    getClasses(): string[];
+}
+/** Groupe de colonnes : un intitulé commun au-dessus des en-têtes (port de ColumnGroup). */
+export declare class ColumnGroup<R = any> {
+    private label;
+    private _columns;
+    constructor(label: string);
+    static make<R = any>(label: string): ColumnGroup<R>;
+    columns(columns: Column<R>[]): this;
+    getColumns(): Column<R>[];
+}
+/** Pastille de couleur (port de ColorColumn). */
+export declare class ColorColumn<R = any> extends Column<R> {
+    static make<R = any>(name: string): ColorColumn<R>;
+    toHtml(record: R): Promise<string>;
+}
+/** Image (port partiel de ImageColumn) : l'état est l'adresse de l'image. Seules les adresses locales ou http(s) sont rendues. */
+export declare class ImageColumn<R = any> extends Column<R> {
+    private _alt;
+    private _height;
+    private _circular;
+    static make<R = any>(name: string): ImageColumn<R>;
+    alt(resolver: (record: R) => string | null): this;
+    /** Hauteur CSS de l'image (`2.5rem` par défaut, comme Filament). */
+    imageHeight(height: string): this;
+    circular(condition?: boolean): this;
+    toHtml(record: R): Promise<string>;
+}
+/** Icône selon la valeur ; `boolean()` affiche une coche verte ou une croix rouge (port partiel de IconColumn). */
+export declare class IconColumn<R = any> extends Column<R> {
+    private _boolean;
+    static make<R = any>(name: string): IconColumn<R>;
+    boolean(condition?: boolean): this;
+    toHtml(record: R): Promise<string>;
+}
+/** Règle de validation d'une colonne modifiable écrite par l'application : test synchrone et message (`:attribute` déjà remplacé). */
+export type ColumnValidationRule = {
+    name: string;
+    passes: (value: unknown) => boolean;
+    message: (attribute: string) => string;
+};
+type StateHook<R> = (ctx: {
+    state: unknown;
+    record: R;
+}) => unknown | Promise<unknown>;
+/**
+ * Base des colonnes modifiables dans la cellule (port des traits CanBeValidated et CanUpdateState de Filament). Le navigateur appelle
+ * `updateTableColumnState(colonne, clé, valeur)` sur le composant hôte : la colonne doit être déclarée, visible et active pour cet
+ * enregistrement, la valeur passer les règles ; ensuite seulement viennent `beforeStateUpdated`, l'écriture et `afterStateUpdated`.
+ * Comme dans Filament, l'écriture ne consulte pas les droits du modèle : `disabled()` reste le moyen de restreindre la modification.
+ */
+export declare abstract class EditableColumn<R = any> extends Column<R> {
+    protected _disabled: ((record: R) => boolean | Promise<boolean>) | boolean;
+    protected _rules: (string | ColumnValidationRule)[];
+    protected _validationAttribute: string | null;
+    protected _validationMessages: Record<string, string>;
+    protected _updateStateUsing: StateHook<R> | null;
+    protected _beforeStateUpdated: StateHook<R> | null;
+    protected _afterStateUpdated: StateHook<R> | null;
+    protected _tooltip: ((record: R) => string | null) | string | null;
+    disabled(condition?: ((record: R) => boolean | Promise<boolean>) | boolean): this;
+    isDisabledFor(record: R): Promise<boolean>;
+    /** Une cellule modifiable n'est ni un lien ni un bouton vers l'enregistrement. */
+    isClickDisabled(): boolean;
+    isEditable(): boolean;
+    /** Règles appliquées à la valeur reçue : chaînes Laravel (`required`, `max:255`, `in:a,b`…) ou règles `{ name, passes, message }`. */
+    rules(rules: (string | ColumnValidationRule)[]): this;
+    getRules(): (string | ColumnValidationRule)[];
+    /** Équivalent de l'ajout de `required` aux règles. */
+    required(condition?: boolean): this;
+    isRequired(): boolean;
+    /** Nom de la colonne dans les messages (par défaut, le libellé avec une minuscule initiale). */
+    validationAttribute(label: string | null): this;
+    /** Messages remplaçant ceux de Laravel, par nom de règle : `{ max: 'Trop long.' }`. */
+    validationMessages(messages: Record<string, string>): this;
+    getValidationAttribute(): string;
+    /** Règles propres au type de colonne (options d'une liste, par exemple), vérifiées après celles de l'application. */
+    protected getImplicitRules(): ColumnValidationRule[];
+    /**
+     * Message d'erreur, ou `null` si la valeur est acceptable. Comme le validateur de Laravel : une valeur vide ne passe que `required`,
+     * et plusieurs erreurs donnent le premier message suivi de « (and N more errors) ».
+     */
+    validate(input: unknown): string | null;
+    /** Écriture personnalisée, à la place de la mise à jour de la colonne de l'enregistrement. Sa valeur de retour est renvoyée au navigateur. */
+    updateStateUsing(callback: StateHook<R> | null): this;
+    beforeStateUpdated(callback: StateHook<R> | null): this;
+    afterStateUpdated(callback: StateHook<R> | null): this;
+    /** Infobulle au survol du contrôle, tant qu'aucune erreur n'est affichée. */
+    tooltip(tooltip: ((record: R) => string | null) | string | null): this;
+    getUpdateStateMessages(): Record<'saving' | 'saved' | 'failure', string>;
+    /** Valeur écrite à partir d'une valeur validée : une valeur vide devient `null` (comme `blank()` dans Filament). */
+    castState(input: unknown): unknown;
+    /**
+     * Enregistre une valeur déjà validée (port de `updateState`). Seul le nom déclaré de la colonne est écrit : une colonne de relation
+     * (`auteur.nom`) n'est modifiable qu'avec `updateStateUsing()`.
+     */
+    updateState(record: R, input: unknown, adapter: Pick<DataAdapter<R>, 'getKey' | 'update'>): Promise<unknown>;
+    /** Expression `x-tooltip` des contrôles modifiables : l'infobulle de la colonne, remplacée par l'erreur de validation quand il y en a une. */
+    protected tooltipExpression(record: R): string;
+    /** Ouverture commune des cellules modifiables : composant Alpine chargé à la demande, état serveur et clé de l'enregistrement. */
+    protected editableAttributes(component: string, asset: string, recordKey: string | number, state: unknown): Attributes;
+    protected static readonly STATUS_HTML = "<p x-cloak x-show=\"error\" x-bind:id=\"$id('table-column-error')\" x-ref=\"error\" x-text=\"error\" class=\"fi-sr-only\"></p><p role=\"status\" aria-live=\"polite\" aria-atomic=\"true\" x-text=\"status\" class=\"fi-sr-only\"></p>";
+}
+/**
+ * Liste déroulante modifiable dans la cellule (port de SelectColumn, liste native seulement). La valeur reçue doit être l'une des
+ * options déclarées.
+ */
+export declare class SelectColumn<R = any> extends EditableColumn<R> {
+    private _options;
+    private _selectablePlaceholder;
+    static make<R = any>(name: string): SelectColumn<R>;
+    options(options: [string, string][] | Record<string, string>): this;
+    getOptions(): [string, string][];
+    selectablePlaceholder(condition?: boolean): this;
+    protected getImplicitRules(): ColumnValidationRule[];
+    toHtml(record: R, recordKey?: string | number): Promise<string>;
+}
+/** Interrupteur modifiable dans la cellule (port de ToggleColumn). La valeur reçue doit être un booléen (règle `boolean` par défaut). */
+export declare class ToggleColumn<R = any> extends EditableColumn<R> {
+    private _onColor;
+    private _offColor;
+    private _onIcon;
+    private _offIcon;
+    constructor(name: string);
+    static make<R = any>(name: string): ToggleColumn<R>;
+    /** Couleur de l'interrupteur allumé (`primary` par défaut) et éteint (`gray`). */
+    onColor(color: string | null): this;
+    offColor(color: string | null): this;
+    /** Icônes affichées dans le bouton de l'interrupteur. */
+    onIcon(icon: string | null): this;
+    offIcon(icon: string | null): this;
+    castState(input: unknown): unknown;
+    toHtml(record: R, recordKey?: string | number): Promise<string>;
+}
+/** Case à cocher modifiable dans la cellule (port de CheckboxColumn). La valeur reçue doit être un booléen (règle `boolean` par défaut). */
+export declare class CheckboxColumn<R = any> extends EditableColumn<R> {
+    constructor(name: string);
+    static make<R = any>(name: string): CheckboxColumn<R>;
+    castState(input: unknown): unknown;
+    toHtml(record: R, recordKey?: string | number): Promise<string>;
+}
+/** Champ de saisie modifiable dans la cellule (port de TextInputColumn). Seuls un texte ou un nombre sont acceptés du navigateur. */
+export declare class TextInputColumn<R = any> extends EditableColumn<R> {
+    private _type;
+    private _mask;
+    private _inputMode;
+    private _step;
+    private _placeholder;
+    private _prefix;
+    private _suffix;
+    private _prefixIcon;
+    private _suffixIcon;
+    private _prefixIconColor;
+    private _suffixIconColor;
+    private _prefixInline;
+    private _suffixInline;
+    static make<R = any>(name: string): TextInputColumn<R>;
+    /** Type HTML du champ (`text` par défaut ; `number`, `email`, `color`…). */
+    type(type: string | null): this;
+    /** Masque de saisie Alpine (`x-mask`) ; le champ devient alors un champ texte. */
+    mask(mask: string | null): this;
+    inputMode(mode: string | null): this;
+    step(step: number | string | null): this;
+    placeholder(text: string | null): this;
+    prefix(label: string | null, isInline?: boolean): this;
+    suffix(label: string | null, isInline?: boolean): this;
+    inlinePrefix(condition?: boolean): this;
+    inlineSuffix(condition?: boolean): this;
+    prefixIcon(name: string | null, isInline?: boolean): this;
+    suffixIcon(name: string | null, isInline?: boolean): this;
+    prefixIconColor(color: string | null): this;
+    suffixIconColor(color: string | null): this;
+    protected getImplicitRules(): ColumnValidationRule[];
+    toHtml(record: R, recordKey?: string | number): Promise<string>;
+}
+/**
+ * Colonne au rendu libre (port de ViewColumn) : `view()` reçoit une fonction qui renvoie le HTML de la cellule, ou le nom d'une vue EJS
+ * rendue avec `{ state, record, column }`. Ce HTML est celui de l'application : les données qu'il contient doivent y être échappées (`e()`).
+ */
+export declare class ViewColumn<R = any> extends Column<R> {
+    private _view;
+    private _viewData;
+    static make<R = any>(name: string): ViewColumn<R>;
+    view(view: ((ctx: {
+        state: unknown;
+        record: R;
+        column: ViewColumn<R>;
+    }) => string | Promise<string>) | string, data?: Record<string, unknown>): this;
+    toHtml(record: R): Promise<string>;
+}
+/** @deprecated Port de BadgeColumn : utiliser `TextColumn.make(nom).badge()`. */
+export declare class BadgeColumn<R = any> extends TextColumn<R> {
+    constructor(name: string);
+    static make<R = any>(name: string): BadgeColumn<R>;
+}
+/** @deprecated Port de BooleanColumn : utiliser `IconColumn.make(nom).boolean()`. */
+export declare class BooleanColumn<R = any> extends IconColumn<R> {
+    constructor(name: string);
+    static make<R = any>(name: string): BooleanColumn<R>;
+}
+/**
+ * Écriture d'une cellule modifiable reçue du navigateur (port de `updateTableColumnState`). Tout est revérifié : la colonne doit
+ * être déclarée, modifiable et visible, l'enregistrement dans la portée de l'adaptateur et non désactivé pour cette colonne,
+ * `authorize` (droit de modification de l'hôte) l'accepter, et la valeur passer les règles de la colonne.
+ */
+export declare function updateTableColumnState<R>(table: Table<R>, host: TableHost, adapter: DataAdapter<R>, columnName: unknown, recordKey: unknown, input: unknown, options?: {
+    authorize?: (record: R) => boolean | Promise<boolean>;
+}): Promise<unknown>;
+/** État d'un filtre : les valeurs de son formulaire. */
+export type FilterState = Record<string, unknown>;
+/** Pastille « filtre actif » : son libellé, et le champ du filtre que son retrait efface. */
+export type FilterIndicator = {
+    label: string;
+    field: string;
+};
+/** Disposition des filtres : menu déroulant de la barre d'outils (défaut), ou panneau repliable au-dessus du contenu. */
+export type FiltersLayout = 'dropdown' | 'above-content-collapsible';
+export interface TableFilter {
+    readonly name: string;
+    getLabel(): string;
+    /** État initial (formulaire vide). */
+    getDefaultState(): FilterState;
+    /** Options du champ `value` : [valeur, libellé], et libellé de l'option vide. */
+    getFormDefinition(): {
+        placeholder: string;
+        options: [string, string][];
+    };
+    isActive(state: FilterState): boolean;
+    /** Applique le filtre à la requête de liste. Ne lit que des valeurs connues. */
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    /** Composants de formulaire du filtre, à la place du sélecteur décrit par `getFormDefinition()`. */
+    getFormComponents?(): unknown[];
+    getColumnSpan?(): Record<string, number | string>;
+    /** État appliqué à partir de l'état du formulaire (reçu du navigateur) : ne garde que ce que le filtre connaît. */
+    sanitizeState?(state: unknown): FilterState;
+    getIndicators?(state: FilterState): FilterIndicator[];
+    /** Options du sélecteur chargées à la demande (relation), à la place de celles de `getFormDefinition()`. */
+    getFormOptions?(): Promise<[string, string][]>;
+    removeIndicator?(state: FilterState, field: string): FilterState;
+    /** Données lues en base avant le calcul des indicateurs (libellés d'enregistrements liés, par exemple). */
+    loadIndicatorData?(state: FilterState, host: TableHost): Promise<void>;
+}
+/** Filtre « corbeille » des modèles à suppression douce (port de TrashedFilter). */
+export declare class TrashedFilter implements TableFilter {
+    readonly name = "trashed";
+    static make(): TrashedFilter;
+    getLabel(): string;
+    getDefaultState(): FilterState;
+    getFormDefinition(): {
+        placeholder: string;
+        options: [string, string][];
+    };
+    isActive(state: FilterState): boolean;
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+}
+/** Filtre par valeur d'une colonne, choisie dans une liste (port de SelectFilter, sélection simple). */
+export declare class SelectFilter implements TableFilter {
+    readonly name: string;
+    private _label;
+    private _column;
+    private _options;
+    constructor(name: string);
+    static make(name: string): SelectFilter;
+    label(label: string): this;
+    /** Colonne filtrée quand elle diffère du nom du filtre (clé étrangère d'une relation, par exemple). */
+    column(column: string): this;
+    /** Options fixes, ou fonction asynchrone (enregistrements d'une relation). */
+    options(options: [string, string][] | Record<string, string> | (() => Promise<[string, string][]>)): this;
+    getLabel(): string;
+    getDefaultState(): FilterState;
+    getFormDefinition(): {
+        placeholder: string;
+        options: [string, string][];
+    };
+    getFormOptions(): Promise<[string, string][]>;
+    /** Comme Filament : les options d'un SelectFilter sont évaluées à chaque rendu, le sélecteur porte donc une clé dérivée d'elles. */
+    readonly hasDynamicOptions = true;
+    isActive(state: FilterState): boolean;
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+}
+/** Filtre à trois états sur une colonne booléenne : tous, oui, non (port de TernaryFilter). */
+export declare class TernaryFilter implements TableFilter {
+    readonly name: string;
+    private _label;
+    constructor(name: string);
+    static make(name: string): TernaryFilter;
+    label(label: string): this;
+    getLabel(): string;
+    getDefaultState(): FilterState;
+    getFormDefinition(): {
+        placeholder: string;
+        options: [string, string][];
+    };
+    isActive(state: FilterState): boolean;
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+}
+/** Filtre à formulaire libre (port de Filter avec `schema()`) : la requête et les indicateurs sont écrits par l'application. */
+export declare class Filter implements TableFilter {
+    readonly name: string;
+    private _label;
+    private _components;
+    private _query;
+    private _indicate;
+    constructor(name: string);
+    static make(name: string): Filter;
+    label(label: string): this;
+    /** Champs du filtre ; leurs noms sont les seules clés d'état acceptées du navigateur. */
+    schema(components: unknown[]): this;
+    /** Condition posée sur la requête à partir de l'état nettoyé du formulaire. */
+    query(modifier: (query: any, data: FilterState) => void): this;
+    /** Pastilles des valeurs appliquées : `{ champ: libellé }` ; retirer une pastille efface son champ. */
+    indicateUsing(resolver: (data: FilterState) => Record<string, string>): this;
+    private fields;
+    getLabel(): string;
+    getDefaultState(): FilterState;
+    getFormDefinition(): {
+        placeholder: string;
+        options: [string, string][];
+    };
+    getFormComponents(): unknown[];
+    sanitizeState(state: unknown): FilterState;
+    isActive(state: FilterState): boolean;
+    apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
+    getIndicators(state: FilterState): FilterIndicator[];
+    removeIndicator(state: FilterState, field: string): FilterState;
+}
+export type ColumnState = {
+    type: 'column';
+    name: string;
+    label: string;
+    isHidden: boolean;
+    isToggled: boolean;
+    isToggleable: boolean;
+    isToggledHiddenByDefault: boolean | null;
+};
+export declare class Table<R = any> {
+    private _columns;
+    private _recordAction;
+    private _recordActions;
+    private _heading;
+    private _headerActions;
+    private _bulkActions;
+    private _recordClasses;
+    private _filters;
+    private _filtersLayout;
+    private _defaultSort;
+    private _recordUrl;
+    private _pageOptions;
+    private _stackedOnMobile;
+    private _label;
+    private _groups;
+    private _defaultGroup;
+    private _defaultGroupDirection;
+    private _groupsOnly;
+    private _groupingSettingsHidden;
+    private _groupingDirectionSettingHidden;
+    private _groupingSettingsInDropdownOnDesktop;
+    private _collapsedGroupsByDefault;
+    /** Regroupements proposés dans la barre d'outils (un identifiant de colonne vaut `Group.make(identifiant)`). */
+    groups(groups: (Group<R> | string)[]): this;
+    getGroups(): Group<R>[];
+    getGroup(id: string | null | undefined): Group<R> | null;
+    /**
+     * Regroupement par défaut (port de `defaultGroup()`). S'il fait partie de `groups()`, il est seulement présélectionné à l'ouverture
+     * (`initializeTableGrouping`) et l'utilisateur peut le retirer ; sinon il s'applique toujours, sans sélecteur.
+     */
+    defaultGroup(group: Group<R> | string | null, direction?: SortDirection): this;
+    getDefaultGroup(): Group<R> | null;
+    getDefaultGroupDirection(): SortDirection;
+    isDefaultGroupSelectable(): boolean;
+    /** Seuls les en-têtes et résumés des groupes sont affichés, sans les lignes ni la pagination (port de `groupsOnly()`). */
+    groupsOnly(condition?: boolean): this;
+    isGroupsOnly(): boolean;
+    /** Masque le sélecteur de regroupement de la barre d'outils. */
+    groupingSettingsHidden(condition?: boolean): this;
+    areGroupingSettingsHidden(): boolean;
+    /** Masque le choix du sens (croissant / décroissant) du regroupement. */
+    groupingDirectionSettingHidden(condition?: boolean): this;
+    isGroupingDirectionSettingHidden(): boolean;
+    /** Sur grand écran aussi, le sélecteur de regroupement est dans un menu déroulant. */
+    groupingSettingsInDropdownOnDesktop(condition?: boolean): this;
+    /** @deprecated Ancien nom de `groupingSettingsInDropdownOnDesktop()`. */
+    groupsInDropdownOnDesktop(condition?: boolean): this;
+    areGroupingSettingsInDropdownOnDesktop(): boolean;
+    /** Les groupes repliables s'affichent repliés. */
+    collapsedGroupsByDefault(condition?: boolean): this;
+    areGroupsCollapsedByDefault(): boolean;
+    private _columnsLayout;
+    columns(columns: (Column<R> | ColumnGroup<R> | ColumnLayout<R>)[]): this;
+    /** Mise en page des colonnes, ou `null` pour un tableau classique. */
+    getColumnsLayout(): (Column<R> | ColumnLayout<R>)[] | null;
+    /** Action montée au clic sur une ligne (ex. `'edit'`), à la place d'une URL. */
+    recordAction(name: string | null): this;
+    getRecordAction(): string | null;
+    /** Titre affiché dans l'en-tête de la table. */
+    heading(heading: string | null): this;
+    getHeading(): string | null;
+    /** Actions affichées dans l'en-tête de la table. */
+    headerActions(actions: any[]): this;
+    getHeaderActions(): any[];
+    /** Actions groupées (menu « Bulk actions ») ; sans appel, l'hôte fournit ses actions par défaut. */
+    groupedBulkActions(actions: any[]): this;
+    getBulkActions(): any[] | null;
+    /** Actions de ligne : des `Action` ou un `ActionGroup` (menu déroulant). */
+    recordActions(actions: any[]): this;
+    getRecordActions(): any[];
+    /** Classes CSS ajoutées à la ligne selon l'enregistrement. */
+    recordClasses(resolver: (record: R) => string | null): this;
+    getRecordClasses(record: R): string | null;
+    filters(filters: TableFilter[], options?: {
+        layout?: FiltersLayout;
+    }): this;
+    filtersLayout(layout: FiltersLayout): this;
+    getFiltersLayout(): FiltersLayout;
+    /** Les filtres ne s'appliquent qu'au bouton « Apply » : c'est déjà le comportement de toutes les tables (méthode gardée pour la compatibilité d'API). */
+    deferFilters(): this;
+    defaultSort(column: string, direction?: SortDirection): this;
+    recordUrl(resolver: (record: R) => string | null): this;
+    private _reorderColumn;
+    /** Lignes réordonnables à la main ; `column` reçoit le rang (port de `reorderable()`). */
+    reorderable(column: string | null): this;
+    getReorderColumn(): string | null;
+    paginationPageOptions(options: number[]): this;
+    private _defaultPageOption;
+    /** Nombre de lignes par page à l'ouverture (port de `defaultPaginationPageOption()`). */
+    defaultPaginationPageOption(option: number | null): this;
+    getDefaultPageOption(): number;
+    private _paginationMode;
+    /** `'simple'` : boutons précédent / suivant seulement, sans numéros de page ni total (port de `PaginationMode::Simple`). */
+    paginationMode(mode: 'default' | 'simple'): this;
+    getPaginationMode(): 'default' | 'simple';
+    stackedOnMobile(condition?: boolean): this;
+    pluralModelLabel(label: string): this;
+    getColumns(): Column<R>[];
+    getColumn(name: string): Column<R> | undefined;
+    getFilters(): TableFilter[];
+    getDefaultSort(): {
+        column: string;
+        direction: SortDirection;
+    } | null;
+    getRecordUrl(record: R): string | null;
+    getPageOptions(): number[];
+    isStackedOnMobile(): boolean;
+    getPluralModelLabel(): string;
+    hasToggleableColumns(): boolean;
+    /** État par défaut du gestionnaire de colonnes (port de getDefaultTableColumnState). */
+    getDefaultColumnState(): ColumnState[];
+    getDefaultFilterState(): Record<string, FilterState>;
+}
+/** État de table porté par le composant hôte (équivalent du trait InteractsWithTable). */
+export interface TableHost {
+    readonly id: string;
+    tableSearch: string;
+    tableSort: string | null;
+    tableColumnSearches: Record<string, string>;
+    tableRecordsPerPage: number;
+    paginators: Record<string, number>;
+    tableFilters?: Record<string, FilterState>;
+    tableColumns?: ColumnState[];
+    /** Regroupement courant : `identifiant` ou `identifiant:direction`. */
+    tableGrouping?: string | null;
+    /** Mode « tri manuel » : toutes les lignes, dans l'ordre de la colonne de rang, avec des poignées. */
+    isTableReordering?: boolean;
+}
+/** Colonnes affichées : celles que l'état du gestionnaire laisse cochées. L'état du navigateur ne peut masquer qu'une colonne déclarée « toggleable ». */
+export declare function getVisibleColumns<R>(table: Table<R>, host: TableHost): Column<R>[];
+/** Nettoie un état de colonnes reçu du navigateur : seul `isToggled` des colonnes « toggleable » est repris. */
+export declare function sanitizeColumnState<R>(table: Table<R>, state: unknown): ColumnState[];
+/** Requête de liste (recherche, recherches par colonne, filtres, tri) correspondant à l'état de l'hôte, sans pagination.
+ *  Seul ce que la table déclare est accepté, quel que soit l'état envoyé par le navigateur. */
+export declare function getTableQuery<R>(table: Table<R>, host: TableHost): Omit<ListQuery, 'page' | 'perPage'>;
+/** Regroupement courant : seul un groupe déclaré par la table est accepté, quel que soit l'état envoyé par le navigateur. */
+export declare function getTableGrouping<R>(table: Table<R>, host: TableHost): {
+    group: Group<R>;
+    direction: SortDirection;
+} | null;
+/** À l'ouverture de la table (montage de l'hôte) : présélectionne le regroupement par défaut quand l'utilisateur peut le changer. */
+export declare function initializeTableGrouping<R>(table: Table<R>, host: TableHost): void;
+export declare function countActiveFilters<R>(table: Table<R>, host: TableHost): number;
+/** Indicateurs des filtres appliqués (seuls les filtres qui en déclarent en ont). */
+export declare function getFilterIndicators<R>(table: Table<R>, host: TableHost): {
+    filter: string;
+    field: string;
+    label: string;
+}[];
+/** Port de sortTable() : non trié → asc → desc → non trié. */
+export declare function sortTable(host: TableHost, column?: string | null, direction?: string | null): void;
+/** Charge la page d'enregistrements correspondant à l'état de l'hôte. */
+export declare function getTableRecords<R>(table: Table<R>, host: TableHost, adapter: DataAdapter<R>): Promise<RecordPage<R>>;
+/** Éléments de pagination : port de UrlWindow de Laravel avec onEachSide(0), comme Filament. */
+export declare function paginationElements(current: number, last: number, onEachSide?: number): (number | '...')[];
+export declare const useColorManager: (manager: ColorManager) => void;
+export type RenderTableOptions<R> = {
+    rowActions?: (record: R) => {
+        label: string;
+        url: string;
+        icon: string;
+        key: string;
+    }[] | Promise<{
+        label: string;
+        url: string;
+        icon: string;
+        key: string;
+    }[]>;
+    /** `false` : le tri manuel n'est pas proposé (utilisateur non autorisé). */
+    canReorder?: boolean;
+    /** HTML placé dans `.fi-ta`, après le conteneur de la table (modales des actions). */
+    after?: string;
+    /** HTML déjà rendu des actions d'en-tête de la table. */
+    headerActions?: string[];
+    /** HTML déjà rendu des actions de ligne (ActionGroup…), à la place des liens de `rowActions`. */
+    rowActionsHtml?: (record: R) => Promise<string>;
+    bulkActions?: string[];
+    /** HTML du formulaire des filtres (schéma `tableFiltersForm`), s'il y a des filtres. */
+    filtersForm?: string | null;
+};
+/** Nombre maximal de lignes affichées (et réordonnées) en mode tri manuel. */
+export declare const REORDER_LIMIT = 1000;
+/** Plafond d'enregistrements lus pour une table `groupsOnly` (non paginée, comme dans Filament). */
+export declare const GROUPS_ONLY_LIMIT = 1000;
+export declare function renderTable<R>(table: Table<R>, host: TableHost, adapter: DataAdapter<R>, options?: RenderTableOptions<R>): Promise<string>;