@navette-js/tables 1.0.0-beta.1 → 1.0.0-beta.2

package/lib/index.d.ts

@@ -1,7 +1,7 @@
 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`. */
+/** Render hook slots of a table. */
 export declare const TablesRenderHook: {
     readonly CONTENT_AFTER: "tables::content.after";
     readonly CONTENT_BEFORE: "tables::content.before";
@@ -23,18 +23,18 @@ export declare const TablesRenderHook: {
     readonly TOOLBAR_START: "tables::toolbar.start";
     readonly FILTER_INDICATORS: "tables::filter.indicators";
     readonly HEADER_CELL: "tables::header.cell";
-    /** Anciens noms, conservés par Filament. */
+    /** Legacy aliases of the column manager trigger slots. */
     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. */
+/** Methods and properties that trigger the table's loading state (`wire:target`). */
 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). */
+/** Base class of table columns. */
 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))`. */
+    /** Default setup for every instance created afterwards by `make()`, e.g. `TextColumn.configureUsing((column) => column.sortable())`. */
     static configureUsing<T>(this: abstract new (...args: any[]) => T, configure: (instance: T) => void): void;
     readonly name: string;
     protected _label: string | null;
@@ -48,30 +48,30 @@ export declare abstract class Column<R = any> {
     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). */
+    /** Label of the column group this column belongs to (set by 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. */
+    /** `column`: column (or query alias) to sort by when it differs from the name, e.g. for a relationship. */
     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). */
+    /** `inverted`: the sort column runs opposite to the displayed value (e.g. an age sorted by birth date). */
     isSortInverted(): boolean;
-    /** Lien posé sur la cellule ; il prend le pas sur l'action de ligne. */
+    /** Link on the cell; takes precedence over the row action. */
     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. */
+    /** `isGlobal: false` excludes the column from the global search; `isIndividual` adds a search field for this column. */
     getSearchColumn(): string;
     searchable(options?: boolean | {
         isIndividual?: boolean;
         isGlobal?: boolean;
         column?: string;
     }): this;
-    /** Colonne que l'utilisateur peut masquer depuis le gestionnaire de colonnes. */
+    /** Lets the user hide the column from the column manager. */
     toggleable(condition?: boolean, options?: {
         isToggledHiddenByDefault?: boolean;
     }): this;
@@ -87,10 +87,10 @@ export declare abstract class Column<R = any> {
     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). */
+    /** Suffix of the `fi-ta-header-cell-…` / `fi-ta-cell-…` classes: underscores become dashes, dots are kept. */
     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. */
+    /** True for editable cells: they are not wrapped in a link or button to the record. */
     isClickDisabled(): boolean;
     abstract toHtml(record: R, recordKey?: string | number): Promise<string>;
 }
@@ -109,41 +109,41 @@ export declare class TextColumn<R = any> extends Column<R> {
     private _limit;
     private _tooltip;
     static make<R = any>(name: string): TextColumn<R>;
-    /** Affiche la valeur dans une pastille. */
+    /** Displays the value in a badge. */
     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). */
+    /** Text displayed instead of the raw value (e.g. an enum label). */
     formatStateUsing(formatter: (ctx: {
         state: unknown;
         record: R;
     }) => string): this;
-    /** Date courte, comme `->date()` de Filament (« Nov 9, 2026 »). */
+    /** Short date, e.g. "Nov 9, 2026". */
     date(condition?: boolean): this;
     private _dateTime;
-    /** Date et heure, « M j, Y H:i:s » (format par défaut de Filament). */
+    /** Date and time, e.g. "Nov 9, 2026 14:30:00". */
     dateTime(condition?: boolean): this;
-    /** Nombre formaté avec séparateurs de milliers (`->numeric()`). */
+    /** Number formatted with thousands separators. */
     private _decimals;
-    /** `numeric(1)` : nombre de décimales fixe. */
+    /** `numeric(1)`: fixed number of decimals. */
     numeric(condition?: boolean | number): this;
-    /** Ligne de totaux sous la table. */
+    /** Summary row below the 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). */
+    /** Truncates the displayed text to `length` characters, followed by "...". */
     limit(length: number | null): this;
-    /** Infobulle au survol du texte ; `null` pour ne pas en afficher. */
+    /** Tooltip on hover; `null` for none. */
     tooltip(tooltip: ((record: R) => string | null) | string | null): this;
     copyable(condition?: boolean): this;
-    /** Montant formaté dans la devise donnée (`money('usd')`). */
+    /** Amount formatted in the given currency, e.g. `money('usd')`. */
     money(currency?: string | ((record: R) => string)): this;
-    /** Texte affiché quand la valeur est vide. */
+    /** Text displayed when the value is empty. */
     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. */
+    /** Cell content: a short markup for plain text, a full markup as soon as an option (badge, icon, color…) is set. */
     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. */
+/** Values a summarizer works from: aggregates over the query (all records) or over the displayed page. */
 export type SummaryValues = {
     count: number;
     sum: Record<string, number>;
@@ -156,7 +156,7 @@ export type SummaryItem = {
     label: string | null;
     value: string;
 };
-/** Résumé d'une colonne sous la table (port de Summarizers\Summarizer) : somme, moyenne, nombre ou étendue. */
+/** Column summary below the table: sum, average, count or range. */
 export declare abstract class Summarizer {
     abstract readonly kind: 'sum' | 'avg' | 'count' | 'range';
     protected _label: string | null;
@@ -167,37 +167,37 @@ export declare abstract class Summarizer {
     format(value: number): string;
     abstract summarize(column: string, values: SummaryValues): SummaryItem | null;
 }
-/** Total d'une colonne (port du summarizer Sum). */
+/** Column total. */
 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). */
+/** Column 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). */
+/** Record 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). */
+/** Smallest and largest value of a column. */
 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. */
+    /** Dates: day only when the bounds fall on different days, day and time otherwise; a single value when both are equal. */
     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. */
+/** Row grouping: rows are sorted by the column and each group gets a header row. */
 export declare class Group<R = any> {
     private id;
     private _label;
@@ -210,17 +210,17 @@ export declare class Group<R = any> {
     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). */
+    /** Query column holding the group value, when it differs from the id (relationship). */
     column(column: string | null): this;
-    /** Titre du groupe tiré de l'enregistrement (libellé d'une énumération, par exemple). */
+    /** Group title computed from the record (e.g. an enum label). */
     getTitleUsing(resolver: ((record: R) => string | null) | null): this;
     getDescriptionUsing(resolver: ((record: R) => string | null) | null): this;
-    /** Noms de Filament (`getTitleFromRecordUsing`, `getDescriptionFromRecordUsing`). */
+    /** Aliases using the `get…FromRecordUsing` naming. */
     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. */
+    /** Groups collapse when their header is clicked. */
     collapsible(condition?: boolean): this;
-    /** La colonne est une date : les lignes d'un même jour forment un groupe. */
+    /** The column is a date: rows from the same day form one group. */
     date(condition?: boolean): this;
     titlePrefixedWithLabel(condition?: boolean): this;
     getId(): string;
@@ -229,43 +229,43 @@ export declare class Group<R = any> {
     isCollapsible(): boolean;
     isDate(): boolean;
     isTitlePrefixedWithLabel(): boolean;
-    /** Valeur du groupe pour un enregistrement, en texte ; `null` quand elle est vide. */
+    /** Group value of a record, as text; `null` when empty. */
     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. */
+    /** Restricts a query to the records of the group with the given key. */
     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 ».
+ * Column layout: as soon as a table has one, records are rendered as cards (`fi-ta-content`) instead of table rows,
+ * and sorting goes through a "Sort by" select.
  */
 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. */
+    /** Leaf columns, in order: the ones the table sorts, searches and toggles. */
     getColumns(): Column<R>[];
     abstract getClasses(): string[];
 }
-/** Colonnes côte à côte, à partir d'un point de rupture (port de Layout\Split). */
+/** Columns side by side, from a given breakpoint. */
 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). */
+/** Columns stacked vertically. */
 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). */
+    /** Gap between columns: 1 (small), 2 (medium) or 3 (large). */
     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). */
+/** Column group: a shared label above the column headers. */
 export declare class ColumnGroup<R = any> {
     private label;
     private _columns;
@@ -274,31 +274,31 @@ export declare class ColumnGroup<R = any> {
     columns(columns: Column<R>[]): this;
     getColumns(): Column<R>[];
 }
-/** Pastille de couleur (port de ColorColumn). */
+/** Color swatch column. */
 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. */
+/** Image column: the state is the image URL. Only local or http(s) URLs are rendered. */
 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). */
+    /** CSS height of the image (`2.5rem` by default). */
     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). */
+/** Icon depending on the value; `boolean()` shows a green check or a red cross. */
 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é). */
+/** Application-defined validation rule of an editable column: synchronous check and message (`:attribute` already replaced). */
 export type ColumnValidationRule = {
     name: string;
     passes: (value: unknown) => boolean;
@@ -309,10 +309,10 @@ type StateHook<R> = (ctx: {
     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.
+ * Base class of in-cell editable columns. The browser calls `updateTableColumnState(column, key, value)` on the host component:
+ * the column must be declared, visible and enabled for this record, and the value must pass the rules; only then do
+ * `beforeStateUpdated`, the write and `afterStateUpdated` run. The write does not check model permissions: use `disabled()`
+ * to restrict editing.
  */
 export declare abstract class EditableColumn<R = any> extends Column<R> {
     protected _disabled: ((record: R) => boolean | Promise<boolean>) | boolean;
@@ -325,50 +325,49 @@ export declare abstract class EditableColumn<R = any> extends Column<R> {
     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. */
+    /** An editable cell is neither a link nor a button to the record. */
     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 applied to the received value: strings (`required`, `max:255`, `in:a,b`…) or `{ name, passes, message }` objects. */
     rules(rules: (string | ColumnValidationRule)[]): this;
     getRules(): (string | ColumnValidationRule)[];
-    /** Équivalent de l'ajout de `required` aux règles. */
+    /** Same as adding `required` to the rules. */
     required(condition?: boolean): this;
     isRequired(): boolean;
-    /** Nom de la colonne dans les messages (par défaut, le libellé avec une minuscule initiale). */
+    /** Column name used in messages (defaults to the label with a lowercase first letter). */
     validationAttribute(label: string | null): this;
-    /** Messages remplaçant ceux de Laravel, par nom de règle : `{ max: 'Trop long.' }`. */
+    /** Custom messages by rule name, e.g. `{ max: 'Too 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. */
+    /** Rules specific to the column type (e.g. select options). */
     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) ».
+     * Error message, or `null` if the value is valid. An empty value is only checked by `required`, and several errors
+     * produce the first message followed by "(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. */
+    /** Custom write, replacing the update of the record's column. Its return value is sent back to the browser. */
     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 on the control, shown while no error is displayed. */
     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). */
+    /** Value written from a validated value: blank values become `null`. */
     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()`.
+     * Saves an already validated value. Only the column's declared name is written: a relationship column (`author.name`)
+     * can only be edited with `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. */
+    /** `x-tooltip` expression of editable controls: the column tooltip, replaced by the validation error when there is one. */
     protected tooltipExpression(record: R): string;
-    /** Ouverture commune des cellules modifiables : composant Alpine chargé à la demande, état serveur et clé de l'enregistrement. */
+    /** Shared opening markup of editable cells: lazily loaded Alpine component, server state and record key. */
     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.
+ * In-cell editable select (native select only). The received value must be one of the declared options.
  */
 export declare class SelectColumn<R = any> extends EditableColumn<R> {
     private _options;
@@ -380,7 +379,7 @@ export declare class SelectColumn<R = any> extends EditableColumn<R> {
     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). */
+/** In-cell editable toggle. The received value must be a boolean (`boolean` rule by default). */
 export declare class ToggleColumn<R = any> extends EditableColumn<R> {
     private _onColor;
     private _offColor;
@@ -388,23 +387,23 @@ export declare class ToggleColumn<R = any> extends EditableColumn<R> {
     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`). */
+    /** Toggle color when on (`primary` by default) and off (`gray`). */
     onColor(color: string | null): this;
     offColor(color: string | null): this;
-    /** Icônes affichées dans le bouton de l'interrupteur. */
+    /** Icons shown inside the toggle's thumb. */
     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). */
+/** In-cell editable checkbox. The received value must be a boolean (`boolean` rule by default). */
 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. */
+/** In-cell editable text input. Only a string or a number is accepted from the browser. */
 export declare class TextInputColumn<R = any> extends EditableColumn<R> {
     private _type;
     private _mask;
@@ -420,9 +419,9 @@ export declare class TextInputColumn<R = any> extends EditableColumn<R> {
     private _prefixInline;
     private _suffixInline;
     static make<R = any>(name: string): TextInputColumn<R>;
-    /** Type HTML du champ (`text` par défaut ; `number`, `email`, `color`…). */
+    /** HTML input type (`text` by default; `number`, `email`, `color`…). */
     type(type: string | null): this;
-    /** Masque de saisie Alpine (`x-mask`) ; le champ devient alors un champ texte. */
+    /** Alpine input mask (`x-mask`); the input then becomes a text input. */
     mask(mask: string | null): this;
     inputMode(mode: string | null): this;
     step(step: number | string | null): this;
@@ -439,8 +438,8 @@ export declare class TextInputColumn<R = any> extends EditableColumn<R> {
     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()`).
+ * Custom-rendered column: `view()` takes a function returning the cell HTML, or the name of an EJS view rendered with
+ * `{ state, record, column }`. This HTML is the application's own: data inside it must be escaped there (`e()`).
  */
 export declare class ViewColumn<R = any> extends Column<R> {
     private _view;
@@ -453,59 +452,59 @@ export declare class ViewColumn<R = any> extends Column<R> {
     }) => string | Promise<string>) | string, data?: Record<string, unknown>): this;
     toHtml(record: R): Promise<string>;
 }
-/** @deprecated Port de BadgeColumn : utiliser `TextColumn.make(nom).badge()`. */
+/** @deprecated Use `TextColumn.make(name).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()`. */
+/** @deprecated Use `IconColumn.make(name).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.
+ * Writes an editable cell value received from the browser. Everything is checked again: the column must be declared, editable
+ * and visible, the record within the adapter's scope and not disabled for this column, `authorize` (the host's edit permission)
+ * must accept it, and the value must pass the column's rules.
  */
 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. */
+/** Filter state: the values of its form. */
 export type FilterState = Record<string, unknown>;
-/** Pastille « filtre actif » : son libellé, et le champ du filtre que son retrait efface. */
+/** Active filter indicator: its label, and the filter field cleared when it is removed. */
 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. */
+/** Filters layout: toolbar dropdown (default), or collapsible panel above the content. */
 export type FiltersLayout = 'dropdown' | 'above-content-collapsible';
 export interface TableFilter {
     readonly name: string;
     getLabel(): string;
-    /** État initial (formulaire vide). */
+    /** Initial state (empty form). */
     getDefaultState(): FilterState;
-    /** Options du champ `value` : [valeur, libellé], et libellé de l'option vide. */
+    /** Options of the `value` field as [value, label] pairs, and the empty option's label. */
     getFormDefinition(): {
         placeholder: string;
         options: [string, string][];
     };
     isActive(state: FilterState): boolean;
-    /** Applique le filtre à la requête de liste. Ne lit que des valeurs connues. */
+    /** Applies the filter to the list query. Only reads known values. */
     apply(query: Omit<ListQuery, 'page' | 'perPage'>, state: FilterState): void;
-    /** Composants de formulaire du filtre, à la place du sélecteur décrit par `getFormDefinition()`. */
+    /** Form components of the filter, replacing the select described by `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. */
+    /** Applied state derived from the form state (received from the browser): keeps only what the filter knows. */
     sanitizeState?(state: unknown): FilterState;
     getIndicators?(state: FilterState): FilterIndicator[];
-    /** Options du sélecteur chargées à la demande (relation), à la place de celles de `getFormDefinition()`. */
+    /** Select options loaded on demand (relationship), replacing those of `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). */
+    /** Data loaded from the database before indicators are computed (e.g. related record labels). */
     loadIndicatorData?(state: FilterState, host: TableHost): Promise<void>;
 }
-/** Filtre « corbeille » des modèles à suppression douce (port de TrashedFilter). */
+/** "Trashed" filter for soft-deletable models. */
 export declare class TrashedFilter implements TableFilter {
     readonly name = "trashed";
     static make(): TrashedFilter;
@@ -518,7 +517,7 @@ export declare class TrashedFilter implements TableFilter {
     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). */
+/** Filters on a column value picked from a list (single select). */
 export declare class SelectFilter implements TableFilter {
     readonly name: string;
     private _label;
@@ -527,9 +526,9 @@ export declare class SelectFilter implements TableFilter {
     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). */
+    /** Filtered column when it differs from the filter name (e.g. a relationship's foreign key). */
     column(column: string): this;
-    /** Options fixes, ou fonction asynchrone (enregistrements d'une relation). */
+    /** Fixed options, or an async function (e.g. records of a relationship). */
     options(options: [string, string][] | Record<string, string> | (() => Promise<[string, string][]>)): this;
     getLabel(): string;
     getDefaultState(): FilterState;
@@ -538,12 +537,12 @@ export declare class SelectFilter implements TableFilter {
         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. */
+    /** Options are evaluated on every render, so the select gets a key derived from them (forces a re-render when they change). */
     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). */
+/** Three-state filter on a boolean column: all, yes, no. */
 export declare class TernaryFilter implements TableFilter {
     readonly name: string;
     private _label;
@@ -559,7 +558,7 @@ export declare class TernaryFilter implements TableFilter {
     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. */
+/** Custom form filter (`schema()`): the query and indicators are written by the application. */
 export declare class Filter implements TableFilter {
     readonly name: string;
     private _label;
@@ -569,11 +568,11 @@ export declare class Filter implements TableFilter {
     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. */
+    /** Filter fields; their names are the only state keys accepted from the browser. */
     schema(components: unknown[]): this;
-    /** Condition posée sur la requête à partir de l'état nettoyé du formulaire. */
+    /** Query condition built from the sanitized form state. */
     query(modifier: (query: any, data: FilterState) => void): this;
-    /** Pastilles des valeurs appliquées : `{ champ: libellé }` ; retirer une pastille efface son champ. */
+    /** Indicators of applied values as `{ field: label }`; removing one clears its field. */
     indicateUsing(resolver: (data: FilterState) => Record<string, string>): this;
     private fields;
     getLabel(): string;
@@ -621,55 +620,55 @@ export declare class Table<R = any> {
     private _groupingDirectionSettingHidden;
     private _groupingSettingsInDropdownOnDesktop;
     private _collapsedGroupsByDefault;
-    /** Regroupements proposés dans la barre d'outils (un identifiant de colonne vaut `Group.make(identifiant)`). */
+    /** Groupings offered in the toolbar (a column id is shorthand for `Group.make(id)`). */
     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.
+     * Default grouping. If it is one of `groups()`, it is only preselected when the table opens (`initializeTableGrouping`)
+     * and the user can remove it; otherwise it always applies, without a selector.
      */
     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()`). */
+    /** Shows only group headers and summaries, without rows or pagination. */
     groupsOnly(condition?: boolean): this;
     isGroupsOnly(): boolean;
-    /** Masque le sélecteur de regroupement de la barre d'outils. */
+    /** Hides the toolbar grouping selector. */
     groupingSettingsHidden(condition?: boolean): this;
     areGroupingSettingsHidden(): boolean;
-    /** Masque le choix du sens (croissant / décroissant) du regroupement. */
+    /** Hides the grouping direction (ascending / descending) choice. */
     groupingDirectionSettingHidden(condition?: boolean): this;
     isGroupingDirectionSettingHidden(): boolean;
-    /** Sur grand écran aussi, le sélecteur de regroupement est dans un menu déroulant. */
+    /** Puts the grouping selector in a dropdown on desktop too. */
     groupingSettingsInDropdownOnDesktop(condition?: boolean): this;
-    /** @deprecated Ancien nom de `groupingSettingsInDropdownOnDesktop()`. */
+    /** @deprecated Use `groupingSettingsInDropdownOnDesktop()`. */
     groupsInDropdownOnDesktop(condition?: boolean): this;
     areGroupingSettingsInDropdownOnDesktop(): boolean;
-    /** Les groupes repliables s'affichent repliés. */
+    /** Collapsible groups start collapsed. */
     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. */
+    /** Column layout, or `null` for a regular table. */
     getColumnsLayout(): (Column<R> | ColumnLayout<R>)[] | null;
-    /** Action montée au clic sur une ligne (ex. `'edit'`), à la place d'une URL. */
+    /** Action mounted when a row is clicked (e.g. `'edit'`), instead of a URL. */
     recordAction(name: string | null): this;
     getRecordAction(): string | null;
-    /** Titre affiché dans l'en-tête de la table. */
+    /** Heading shown in the table header. */
     heading(heading: string | null): this;
     getHeading(): string | null;
-    /** Actions affichées dans l'en-tête de la table. */
+    /** Actions shown in the table header. */
     headerActions(actions: any[]): this;
     getHeaderActions(): any[];
-    /** Actions groupées (menu « Bulk actions ») ; sans appel, l'hôte fournit ses actions par défaut. */
+    /** Bulk actions ("Bulk actions" menu); if never called, the host provides its default ones. */
     groupedBulkActions(actions: any[]): this;
     getBulkActions(): any[] | null;
-    /** Actions de ligne : des `Action` ou un `ActionGroup` (menu déroulant). */
+    /** Row actions: `Action`s or an `ActionGroup` (dropdown). */
     recordActions(actions: any[]): this;
     getRecordActions(): any[];
-    /** Classes CSS ajoutées à la ligne selon l'enregistrement. */
+    /** CSS classes added to a row depending on its record. */
     recordClasses(resolver: (record: R) => string | null): this;
     getRecordClasses(record: R): string | null;
     filters(filters: TableFilter[], options?: {
@@ -677,21 +676,21 @@ export declare class Table<R = any> {
     }): 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). */
+    /** No-op kept for API compatibility: filters always wait for the "Apply" button. */
     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()`). */
+    /** Lets users reorder rows by hand; `column` stores the position. */
     reorderable(column: string | null): this;
     getReorderColumn(): string | null;
     paginationPageOptions(options: number[]): this;
     private _defaultPageOption;
-    /** Nombre de lignes par page à l'ouverture (port de `defaultPaginationPageOption()`). */
+    /** Rows per page when the table opens. */
     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`). */
+    /** `'simple'`: previous / next buttons only, without page numbers or total. */
     paginationMode(mode: 'default' | 'simple'): this;
     getPaginationMode(): 'default' | 'simple';
     stackedOnMobile(condition?: boolean): this;
@@ -708,11 +707,11 @@ export declare class Table<R = any> {
     isStackedOnMobile(): boolean;
     getPluralModelLabel(): string;
     hasToggleableColumns(): boolean;
-    /** État par défaut du gestionnaire de colonnes (port de getDefaultTableColumnState). */
+    /** Default column manager state. */
     getDefaultColumnState(): ColumnState[];
     getDefaultFilterState(): Record<string, FilterState>;
 }
-/** État de table porté par le composant hôte (équivalent du trait InteractsWithTable). */
+/** Table state held by the host component. */
 export interface TableHost {
     readonly id: string;
     tableSearch: string;
@@ -722,37 +721,39 @@ export interface TableHost {
     paginators: Record<string, number>;
     tableFilters?: Record<string, FilterState>;
     tableColumns?: ColumnState[];
-    /** Regroupement courant : `identifiant` ou `identifiant:direction`. */
+    /** Current grouping: `id` or `id:direction`. */
     tableGrouping?: string | null;
-    /** Mode « tri manuel » : toutes les lignes, dans l'ordre de la colonne de rang, avec des poignées. */
+    /** Reordering mode: all rows, in position order, with drag handles. */
     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 ». */
+/** Visible columns: those left checked in the column manager. Browser state can only hide columns declared 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. */
+/** Sanitizes column state from the browser: only `isToggled` of toggleable columns is kept. */
 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. */
+/**
+ * List query (search, column searches, filters, sort) for the host's state, without pagination.
+ * Only what the table declares is accepted, whatever state the browser sends.
+ */
 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. */
+/** Current grouping: only a group declared by the table is accepted, whatever state the browser sends. */
 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. */
+/** When the table opens (host mount): preselects the default grouping when the user can change it. */
 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). */
+/** Indicators of the applied filters (only filters that declare some have them). */
 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é. */
+/** Cycles a column's sort: none → asc → desc → none. */
 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. */
+/** Loads the page of records matching the host's state. */
 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. */
+/** Pagination elements: the first and last pages and a window around the current page, with `...` gaps. */
 export declare function paginationElements(current: number, last: number, onEachSide?: number): (number | '...')[];
 export declare const useColorManager: (manager: ColorManager) => void;
 export type RenderTableOptions<R> = {
@@ -767,20 +768,20 @@ export type RenderTableOptions<R> = {
         icon: string;
         key: string;
     }[]>;
-    /** `false` : le tri manuel n'est pas proposé (utilisateur non autorisé). */
+    /** `false`: reordering is not offered (user not authorized). */
     canReorder?: boolean;
-    /** HTML placé dans `.fi-ta`, après le conteneur de la table (modales des actions). */
+    /** HTML placed in `.fi-ta`, after the table container (action modals). */
     after?: string;
-    /** HTML déjà rendu des actions d'en-tête de la table. */
+    /** Already rendered HTML of the table header actions. */
     headerActions?: string[];
-    /** HTML déjà rendu des actions de ligne (ActionGroup…), à la place des liens de `rowActions`. */
+    /** Already rendered HTML of the row actions (ActionGroup…), replacing the `rowActions` links. */
     rowActionsHtml?: (record: R) => Promise<string>;
     bulkActions?: string[];
-    /** HTML du formulaire des filtres (schéma `tableFiltersForm`), s'il y a des filtres. */
+    /** HTML of the filters form (`tableFiltersForm` schema), if there are filters. */
     filtersForm?: string | null;
 };
-/** Nombre maximal de lignes affichées (et réordonnées) en mode tri manuel. */
+/** Maximum number of rows shown (and reorderable) in reordering mode. */
 export declare const REORDER_LIMIT = 1000;
-/** Plafond d'enregistrements lus pour une table `groupsOnly` (non paginée, comme dans Filament). */
+/** Maximum records read for a `groupsOnly` table (which is not paginated). */
 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>;