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

package/lib/index.d.ts

@@ -29,11 +29,11 @@ export declare abstract class Field extends Component {
     disabled(condition?: Lazy<boolean, ComponentContext>): this;
     autofocus(condition?: boolean): this;
     default(value: unknown): this;
-    /** Texte d'aide affiché sous le champ. */
+    /** Helper text shown under the field. */
     helperText(text: string | null): this;
-    /** Identifiant du texte d'aide, à lier au contrôle par `aria-describedby`. */
+    /** Helper text id, linked to the control through `aria-describedby`. */
     protected getHelperTextId(): string | null;
-    /** Libellé réservé aux lecteurs d'écran. */
+    /** Keeps the label for screen readers only. */
     hiddenLabel(condition?: boolean): this;
     protected _hint: Lazy<string | HtmlString | null, ComponentContext>;
     protected _hintColor: Lazy<string | null, ComponentContext>;
@@ -41,38 +41,38 @@ export declare abstract class Field extends Component {
     protected _hintIconTooltip: Lazy<string | null, ComponentContext>;
     protected _hintActions: Action[];
     /**
-     * Indication affichée à droite du libellé (un composant `Text`). Le texte est échappé ; une `HtmlString` de `@navette-js/support`
-     * (`raw('<a href="…">…</a>')`) est insérée telle quelle : n'y placez que des valeurs échappées avec `e()`.
+     * Hint shown to the right of the label (a `Text` component). The text is escaped; an `HtmlString` from `@navette-js/support`
+     * (`raw('<a href="…">…</a>')`) is inserted as is, so only put values escaped with `e()` in it.
      */
     hint(hint: Lazy<string | HtmlString | null, ComponentContext>): this;
-    /** Couleur de l'indication et de son icône (`gray` pour le texte, `primary` pour l'icône par défaut). */
+    /** Color of the hint and its icon (by default `gray` for the text, `primary` for the icon). */
     hintColor(color: Lazy<string | null, ComponentContext>): this;
-    /** Icône d'indication, avec une infobulle facultative (qui sert aussi de nom accessible). */
+    /** Hint icon, with an optional tooltip (also used as its accessible name). */
     hintIcon(name: Lazy<string | null, ComponentContext>, tooltip?: Lazy<string | null, ComponentContext>): this;
     hintIconTooltip(tooltip: Lazy<string | null, ComponentContext>): this;
-    /** Action affichée après l'indication (en lien, petite taille), montée sur le champ. */
+    /** Action shown after the hint (small link), mounted on the field. */
     hintAction(action: Action): this;
     hintActions(actions: Action[]): this;
     getHintActions(): Action[];
-    /** Actions que le champ expose au montage (`schemaComponent` = clé du champ) : ici, ses actions d'indication. */
+    /** Actions the field exposes for mounting (`schemaComponent` = field key): its hint actions. */
     getActions(): Action[];
-    /** Rangée « après le libellé » : indication, icône d'indication et actions d'indication. */
+    /** Row after the label: hint, hint icon and hint actions. */
     protected renderAfterLabel(): Promise<string>;
-    /** Exécuté côté serveur quand l'état du champ change (champ `live()`). `set(nom, valeur)` modifie un autre champ du même formulaire. */
+    /** Runs on the server when the field state changes (`live()` field). `set(name, value)` changes another field of the same form. */
     afterStateUpdated(callback: (ctx: ComponentContext & {
         set: (name: string, value: unknown) => void;
     }) => unknown): this;
     hasAfterStateUpdated(): boolean;
     callAfterStateUpdated(set: (name: string, value: unknown) => void): Promise<void>;
-    /** Force l'inclusion du champ dans les données envoyées, même désactivé (`->disabled()->dehydrated()`). */
+    /** Forces the field into the submitted data, even when disabled (`.disabled().dehydrated()`). */
     dehydrated(condition?: boolean): this;
-    /** Par défaut, un champ désactivé n'est ni validé ni enregistré. */
+    /** By default, a disabled field is neither validated nor saved. */
     isDehydrated(): Promise<boolean>;
     getDefaultState(): unknown;
-    /** Mise en forme de la valeur d'un enregistrement quand elle entre dans le formulaire (hydratation). */
+    /** Shapes a record value as it enters the form (hydration). */
     hydrateState(value: unknown): unknown;
     rule(rule: Rule): this;
-    /** Règle `unique` : la valeur ne doit pas exister dans la colonne du même nom ; `ignoreRecord` exclut l'enregistrement en cours d'édition. */
+    /** `unique` rule: the value must not exist in the column of the same name; `ignoreRecord` excludes the record being edited. */
     unique(options?: {
         ignoreRecord?: boolean;
         column?: string;
@@ -82,13 +82,12 @@ export declare abstract class Field extends Component {
     isDisabled(): Promise<boolean>;
     getErrors(): string[];
     hasError(): boolean;
-    /** Règles de validation : `required` d'abord, puis celles du champ. Les messages sont ceux de Laravel (en). */
+    /** Validation rules: `required` first, then the field's own. */
     getValidationRules(): Promise<Rule[]>;
     validate(): Promise<string[]>;
-    /** Port de Field::wrapEmbeddedHtml (enveloppe par défaut). */
-    /** Valeur écrite dans les données à enregistrer (les champs composés n'y laissent qu'une ossature, remplie par leurs enfants). */
+    /** Value written to the data to save (composite fields only leave a skeleton, filled by their children). */
     dehydrateState(state: unknown): unknown;
-    /** Dernière mise en forme de la valeur enregistrée, une fois les champs enfants dé-hydratés (liste d'éléments d'un Builder). */
+    /** Final shaping of the saved value, once child fields are dehydrated (e.g. a Builder's item list). */
     finalizeDehydratedState(state: unknown): unknown;
     protected wrap(html: string, options?: {
         labelPrefix?: string;
@@ -112,66 +111,65 @@ export declare class TextInput extends Field {
     private _prefix;
     private _live;
     static make(name: string): TextInput;
-    /** Nombre décimal : `type="number"`, `step="any"`. */
+    /** Decimal number: `type="number"`, `step="any"`. */
     numeric(): this;
-    /** Nombre entier : `type="number"`, `step="1"`. */
+    /** Integer: `type="number"`, `step="1"`. */
     integer(): this;
     private _step;
-    /** Pas de saisie d'un champ numérique (`step`), à la place de celui déduit de `numeric()` ou `integer()`. */
+    /** Input `step` of a numeric field, overriding the one implied by `numeric()` or `integer()`. */
     step(step: number | 'any' | null): this;
     minValue(value: number): this;
     maxValue(value: number): this;
-    /** Libellé affiché avant la zone de saisie (ex. `$`). */
+    /** Label shown before the input (e.g. `$`). */
     prefix(label: string | null): this;
     private _suffix;
-    /** Libellé affiché après la saisie (« hours », « kg »…). */
+    /** Label shown after the input ("hours", "kg"…). */
     suffix(label: string | null): this;
-    /** L'état est envoyé au serveur à chaque frappe, ou à la perte de focus avec `onBlur`. */
+    /** Sends the state to the server on every keystroke, or on blur with `onBlur`. */
     live(options?: {
         onBlur?: boolean;
     }): this;
     type(type: string): this;
     password(condition?: boolean): this;
     revealable(condition?: boolean): this;
-    /** `true` → "on", `false` → "off", chaîne → telle quelle (comme CanBeAutocompleted). */
+    /** `true` → "on", `false` → "off", a string as is. */
     autocomplete(value?: string | boolean): this;
     placeholder(text: string | null): this;
-    /** Adresse web : champ de type `url`, valeur http(s) valide exigée. */
     private _mask;
-    /** Masque de saisie Alpine (`(999) 999-9999`) : guide la frappe dans le navigateur, sans valeur de validation. */
+    /** Alpine input mask (`(999) 999-9999`): guides typing in the browser, with no validation value. */
     mask(pattern: string | null): this;
-    /** Numéro de téléphone : chiffres, espaces et ponctuation usuelle. */
+    /** Phone number: digits, spaces and common punctuation. */
     tel(): this;
+    /** Web address: `url` input type, a valid http(s) value is required. */
     url(): this;
     maxLength(length: number): this;
     minLength(length: number): this;
-    /** Port de TextInput::toEmbeddedHtml (sans affixes libres, masque ni datalist pour l'instant). */
     toHtml(): Promise<string>;
 }
-/** Sélecteur de date natif (`<input type="date">`). Le sélecteur JavaScript de Filament n'est pas encore porté. */
+/** Native date picker (`<input type="date">`). */
 export declare class DatePicker extends Field {
     private _maxDate;
     private _minDate;
     private _live;
     static make(name: string): DatePicker;
     private _datePlaceholder;
-    /** Texte indicatif (les navigateurs ne l'affichent pas sur un champ `date` natif ; l'attribut est posé comme dans Filament). */
+    /** Placeholder attribute (browsers do not display it on a native `date` input). */
     placeholder(text: string | null): this;
-    /** Envoie l'état au serveur dès qu'il change (`wire:model.live`). */
+    /** Sends the state to the server as soon as it changes (`wire:model.live`). */
     live(condition?: boolean): this;
-    /** Comme Filament : l'état d'un DatePicker est une date `AAAA-MM-JJ`, quelle que soit la précision stockée. */
+    /** The state is a `YYYY-MM-DD` date, whatever the stored precision. */
     hydrateState(value: unknown): unknown;
     private static resolve;
     private bound;
-    /** Date la plus tardive acceptée : `'today'`, une date `AAAA-MM-JJ`, ou une fonction du contexte (`({ get }) => get('endDate') || 'today'`). */
+    /** Latest accepted date: `'today'`, a `YYYY-MM-DD` date, or a context function (`({ get }) => get('endDate') || 'today'`). */
     maxDate(date: Lazy<string | null, ComponentContext>): this;
     minDate(date: Lazy<string | null, ComponentContext>): this;
     toHtml(): Promise<string>;
 }
 type Options = [string, string][] | Record<string, string>;
 /**
- * Liste déroulante. Native (`<select>`) par défaut ; `searchable()` active le sélecteur JavaScript de Filament,
- * qui interroge le serveur par les méthodes exposées (`getSearchResultsForJs`…).
+ * Dropdown. Native (`<select>`) by default; `searchable()` switches to the JavaScript select,
+ * which queries the server through the exposed methods (`getSearchResultsForJs`…).
  */
 export declare class Select extends Field {
     private _options;
@@ -187,39 +185,38 @@ export declare class Select extends Field {
     private _searchResultsUsing;
     private _optionLabelUsing;
     static make(name: string): Select;
-    /** Résultats de recherche calculés par le serveur à chaque frappe (sans liste d'options préchargée). */
+    /** Search results computed by the server on every keystroke (no preloaded option list). */
     getSearchResultsUsing(resolver: (search: string, ctx: ComponentContext) => Options | Promise<Options>): this;
-    /** Libellé d'une valeur ; sert aussi à valider qu'une valeur choisie par recherche existe bien. */
+    /** Label of a value; also used to validate that a searched value exists. */
     getOptionLabelUsing(resolver: (value: string, ctx: ComponentContext) => string | null | Promise<string | null>): this;
-    /** Options fixes, ou fonction (éventuellement asynchrone) évaluée à chaque requête. */
-    /** `dynamic: false` : options fournies par une fonction mais fixes pour la durée de la page (annoncées comme statiques au navigateur). */
     /**
-     * `dynamic: false` : options fournies par une fonction mais fixes pour la durée de la page.
-     * `searchOnServer: false` : la recherche se fait dans le navigateur, parmi les options déjà envoyées (cas d'une liste complète).
+     * Fixed options, or a (possibly async) function evaluated on every request.
+     * `dynamic: false`: options come from a function but stay fixed for the page's lifetime (announced as static to the browser).
+     * `searchOnServer: false`: search runs in the browser, among the options already sent (for a complete list).
      */
     options(options: Options | ((ctx: ComponentContext) => Options | Promise<Options>), config?: {
         dynamic?: boolean;
         searchOnServer?: boolean;
     }): this;
-    /** Option non sélectionnable selon le contexte (par exemple déjà choisie dans une autre ligne). */
+    /** Disables an option depending on the context (e.g. already picked in another row). */
     disableOptionWhen(condition: (value: string, ctx: ComponentContext) => boolean): this;
-    /** L'état est envoyé au serveur dès qu'il change. */
+    /** Sends the state to the server as soon as it changes. */
     live(condition?: boolean): this;
     placeholder(label: string | null): this;
     private _selectablePlaceholder;
-    /** `false` : le sélecteur natif n'a pas d'option vide (port de `selectablePlaceholder()`). */
+    /** `false`: the native select has no empty option. */
     selectablePlaceholder(condition?: boolean): this;
     searchable(condition?: boolean): this;
-    /** Sélection multiple : l'état est une liste de valeurs ; le sélecteur JavaScript est toujours utilisé. */
+    /** Multiple selection: the state is a list of values; always uses the JavaScript select. */
     multiple(condition?: boolean): this;
     isMultiple(): boolean;
-    /** Libellés de plusieurs valeurs d'un coup (sélection multiple avec recherche serveur) ; sert aussi à valider les valeurs. */
+    /** Labels of several values at once (multiple selection with server search); also used to validate the values. */
     getOptionLabelsUsing(resolver: (values: string[], ctx: ComponentContext) => Options | Promise<Options>): this;
     getDefaultState(): unknown;
-    /** Valeurs sélectionnées, nettoyées : des chaînes, sans doublon. */
+    /** Sanitized selected values: unique strings. */
     private selectedValues;
     private labelsOf;
-    /** Sans effet ici : les options sont toujours chargées avec le formulaire. */
+    /** No-op: options are always loaded with the form. */
     preload(): this;
     hydrateState(value: unknown): unknown;
     dehydrateState(state: unknown): unknown;
@@ -250,40 +247,40 @@ export declare class Select extends Field {
     private _editOptionModalHeading;
     private _modifyEditOptionAction;
     /**
-     * Formulaire de la modale « Create » ouverte par le bouton « + » du champ. Sa validation est faite côté serveur ;
-     * `createOptionUsing()` enregistre l'option et rend sa valeur, qui devient l'état du champ (ajoutée à la liste pour un `multiple()`).
-     * Les options doivent être fournies par une fonction (`options(() => …)`, ou une recherche serveur) pour que la nouvelle valeur y figure.
+     * Form of the "Create" modal opened by the field's "+" button, validated on the server.
+     * `createOptionUsing()` saves the option and returns its value, which becomes the field state (appended for `multiple()`).
+     * Options must come from a function (`options(() => …)`, or server search) for the new value to appear.
      */
     createOptionForm(schema: Component[] | ((schema: Schema) => Component[] | Schema) | null): this;
-    /** Enregistre l'option à partir des données validées de la modale ; rend la valeur (clé) de l'option créée. */
+    /** Saves the option from the validated modal data; returns the value (key) of the created option. */
     createOptionUsing(callback: ((data: Record<string, unknown>, ctx: ComponentContext) => string | number | null | Promise<string | number | null>) | null): this;
     createOptionModalHeading(heading: string | null): this;
-    /** Personnalise l'action de création (libellé, icône, largeur de modale…). */
+    /** Customizes the create action (label, icon, modal width…). */
     createOptionAction(modify: ((action: Action) => Action | void) | null): this;
     /**
-     * Formulaire de la modale « Edit » de l'option sélectionnée (sélection simple seulement). Le champ devient `live()` pour que le bouton
-     * apparaisse dès qu'une option est choisie. Préremplissage par `fillEditOptionActionFormUsing()`, enregistrement par `updateOptionUsing()`.
+     * Form of the "Edit" modal for the selected option (single selection only). The field becomes `live()` so the button
+     * appears as soon as an option is picked. Filled by `fillEditOptionActionFormUsing()`, saved by `updateOptionUsing()`.
      */
     editOptionForm(schema: Component[] | ((schema: Schema) => Component[] | Schema) | null): this;
     updateOptionUsing(callback: ((data: Record<string, unknown>, ctx: ComponentContext) => unknown) | null): this;
-    /** Données initiales de la modale « Edit » (le contexte donne l'état courant du champ dans `state`). */
+    /** Initial data of the "Edit" modal (the context carries the current field state in `state`). */
     fillEditOptionActionFormUsing(callback: ((ctx: ComponentContext) => Record<string, unknown> | null | Promise<Record<string, unknown> | null>) | null): this;
     editOptionModalHeading(heading: string | null): this;
     editOptionAction(modify: ((action: Action) => Action | void) | null): this;
-    /** Même formulaire pour la création et la modification. */
+    /** Same form for creating and editing. */
     manageOptionForm(schema: Component[] | ((schema: Schema) => Component[] | Schema) | null): this;
     private setState;
     private getCreateOptionAction;
     private getEditOptionAction;
-    /** Actions montées sur le champ : indication, création et modification d'option. */
+    /** Actions mounted on the field: hint, create option and edit option. */
     getActions(): Action[];
-    /** Boutons « + » et « modifier » à droite du champ (port des suffixActions de Select). */
+    /** "+" and "edit" buttons on the right of the field. */
     private suffixHtml;
     toHtml(): Promise<string>;
-    /** Port du rendu JavaScript de Select::toEmbeddedHtml (sélection simple). */
+    /** JavaScript select rendering. */
     private toJsHtml;
 }
-/** Colonne d'un Repeater en table : intitulé et largeur. */
+/** Column of a table Repeater: label and width. */
 export declare class TableColumn {
     label: string;
     private _width;
@@ -298,9 +295,9 @@ type ItemLink = {
     url: string;
 };
 /**
- * Liste d'éléments répétés, chacun avec les mêmes champs (port de Repeater, affichage en table).
- * L'état est une table `clé d'élément → champs` ; l'ordre des clés est l'ordre d'affichage.
- * Ajout, suppression et déplacement sont des actions du composant, montées avec `schemaComponent`.
+ * List of repeated items sharing the same fields, displayed as a table.
+ * The state is a map `item key → fields`; key order is display order.
+ * Add, delete and move are component actions, mounted with `schemaComponent`.
  */
 export declare class Repeater extends Field {
     private _schema;
@@ -309,26 +306,26 @@ export declare class Repeater extends Field {
     private _maxItems;
     private _itemLinks;
     static make(name: string): Repeater;
-    /** Champs d'un élément : une fonction, appelée pour chaque élément. */
+    /** Item fields: a function called for each item. */
     schema(factory: () => Field[]): this;
-    /** Affichage en table, une colonne par champ. */
+    /** Table display, one column per field. */
     table(columns: TableColumn[]): this;
     defaultItems(count: number): this;
     maxItems(count: number): this;
     private _reorderable;
-    /** Faux : les éléments gardent leur ordre (cas d'une relation sans colonne d'ordre dans Filament). */
+    /** `false`: items keep their order (e.g. a relationship without an order column). */
     reorderable(condition?: boolean): this;
-    /** Lien affiché sur chaque ligne (équivalent d'une action d'élément à URL). */
+    /** Link shown on each row (an item action pointing to a URL). */
     extraItemLink(resolver: (ctx: {
         item: Record<string, unknown>;
         key: string;
     }) => ItemLink | null): this;
-    /** Éléments bien formés : les clés viennent du navigateur, seules les clés simples sont retenues. */
+    /** Well-formed items only: keys come from the browser, so only simple keys are kept. */
     getItems(): Record<string, Record<string, unknown>>;
     private setItems;
     private itemDefaults;
     getDefaultState(): unknown;
-    /** Enregistrements d'une relation → éléments `record-<id>`, réduits aux champs déclarés. */
+    /** Relationship records → `record-<id>` items, limited to the declared fields. */
     hydrateState(value: unknown): unknown;
     dehydrateState(): unknown;
     getChildSchemas(): Schema[];
@@ -336,8 +333,7 @@ export declare class Repeater extends Field {
     getActions(): Action[];
     toHtml(): Promise<string>;
 }
-/** Zone de texte multiligne (port de Textarea, sans redimensionnement automatique). */
-/** Heure (port de TimePicker, saisie native) : l'état est `HH:MM` avec `seconds(false)`, `HH:MM:SS` sinon. */
+/** Native time input: the state is `HH:MM` with `seconds(false)`, `HH:MM:SS` otherwise. */
 export declare class TimePicker extends Field {
     private _seconds;
     static make(name: string): TimePicker;
@@ -345,7 +341,7 @@ export declare class TimePicker extends Field {
     hydrateState(value: unknown): unknown;
     toHtml(): Promise<string>;
 }
-/** Date et heure (port de DateTimePicker, saisie native `datetime-local`) : l'état enregistré est `AAAA-MM-JJ HH:MM:SS`. */
+/** Native `datetime-local` input: the saved state is `YYYY-MM-DD HH:MM:SS`. */
 export declare class DateTimePicker extends Field {
     private _seconds;
     static make(name: string): DateTimePicker;
@@ -353,7 +349,7 @@ export declare class DateTimePicker extends Field {
     dehydrateState(state: unknown): unknown;
     toHtml(): Promise<string>;
 }
-/** Choix unique en boutons radio (port de Radio). */
+/** Single choice as radio buttons. */
 export declare class Radio extends Field {
     private _options;
     private _descriptions;
@@ -361,9 +357,9 @@ export declare class Radio extends Field {
     private _live;
     static make(name: string): Radio;
     options(options: Options): this;
-    /** Texte d'aide par valeur, sous le libellé de l'option. */
+    /** Helper text per value, under the option label. */
     descriptions(descriptions: Record<string, string>): this;
-    /** Options côte à côte. */
+    /** Options side by side. */
     inline(condition?: boolean): this;
     live(condition?: boolean): this;
     getValidationRules(): Promise<Rule[]>;
@@ -377,31 +373,31 @@ export declare class Textarea extends Field {
     maxLength(length: number): this;
     toHtml(): Promise<string>;
 }
-/** Saisie d'une liste de mots-clés (port de TagsInput) : l'état est un tableau de chaînes. */
+/** Tag list input: the state is an array of strings. */
 export declare class TagsInput extends Field {
     private _placeholder;
     private _suggestions;
     private _splitKeys;
     static make(name: string): TagsInput;
     placeholder(text: string | null): this;
-    /** Valeurs proposées à la saisie. */
+    /** Values suggested while typing. */
     suggestions(suggestions: string[]): this;
-    /** Touches qui valident le mot en cours, en plus d'Entrée (`['Tab', ',']`). */
+    /** Keys that confirm the current tag, besides Enter (`['Tab', ',']`). */
     splitKeys(keys: string[]): this;
     getDefaultState(): unknown;
     hydrateState(value: unknown): unknown;
-    /** Seules des chaînes non vides sont enregistrées, quelle que soit la forme reçue du navigateur. */
+    /** Only non-empty strings are saved, whatever shape the browser sends. */
     dehydrateState(state: unknown): unknown;
     toHtml(): Promise<string>;
 }
-/** Interrupteur (port de Toggle). */
+/** On/off switch. */
 export declare class Toggle extends Field {
     static make(name: string): Toggle;
     getDefaultState(): unknown;
     hydrateState(value: unknown): unknown;
     toHtml(): Promise<string>;
 }
-/** Choix unique présenté en boutons (port de ToggleButtons, sélection simple). */
+/** Single choice shown as buttons. */
 export declare class ToggleButtons extends Field {
     private _options;
     private _inline;
@@ -410,16 +406,16 @@ export declare class ToggleButtons extends Field {
     private _icons;
     static make(name: string): ToggleButtons;
     private _live;
-    /** L'état est envoyé au serveur dès qu'il change. */
+    /** Sends the state to the server as soon as it changes. */
     live(condition?: boolean): this;
-    /** Couleur par valeur (ex. celle d'une énumération). */
+    /** Color per value (e.g. from an enum). */
     colors(colors: Record<string, string>): this;
-    /** Icône par valeur. */
+    /** Icon per value. */
     icons(icons: Record<string, string>): this;
     options(options: Options): this;
-    /** Boutons côte à côte. */
+    /** Buttons side by side. */
     inline(condition?: boolean): this;
-    /** Boutons accolés en un seul groupe. */
+    /** Buttons joined into a single group. */
     grouped(condition?: boolean): this;
     getValidationRules(): Promise<Rule[]>;
     toHtml(): Promise<string>;
@@ -428,16 +424,16 @@ type RichDocument = {
     type: 'doc';
     content?: unknown[];
 };
-/** HTML enregistré → document TipTap. L'analyse écarte ce que le schéma ne connaît pas (scripts, attributs d'événement, liens `javascript:`). */
+/** Stored HTML → TipTap document. Parsing drops anything the schema does not know (scripts, event attributes, `javascript:` links). */
 export declare function richHtmlToDocument(html: string | null | undefined): RichDocument;
 /**
- * Document TipTap → HTML à enregistrer, ou null s'il est vide ou invalide. Le document vient du navigateur :
- * il est rendu puis ré-analysé, pour que seul ce que le schéma accepte soit conservé.
+ * TipTap document → HTML to save, or null if empty or invalid. The document comes from the browser,
+ * so it is rendered then re-parsed to keep only what the schema accepts.
  */
 export declare function richDocumentToHtml(document: unknown): string | null;
 /**
- * Éditeur de texte riche (port de RichEditor) : le navigateur travaille sur un document TipTap, la base reçoit du HTML.
- * Le balisage est celui de Filament, repris de l'oracle (vue générée). Non portés : pièces jointes, blocs personnalisés, mentions.
+ * Rich text editor: the browser works on a TipTap document, the database receives HTML.
+ * Not supported yet: attachments, custom blocks, mentions.
  */
 export declare class RichEditor extends Field {
     static make(name: string): RichEditor;
@@ -451,14 +447,14 @@ export declare class RichEditor extends Field {
     getCustomBlockPreviewsForJs(): unknown[];
     getUploadedFileAttachmentTemporaryUrl(): null;
     saveUploadedFileAttachmentAndGetUrl(): null;
-    /** Action « lien » de la barre d'outils : une modale (URL, nouvel onglet), puis des commandes renvoyées à l'éditeur du navigateur. */
+    /** Toolbar "link" action: a modal (URL, new tab), then commands sent back to the browser editor. */
     getActions(): Action[];
     toHtml(): Promise<string>;
 }
-/** Sélecteur de couleur (port de ColorPicker, format hexadécimal). */
+/** Color picker (hex format). */
 export declare class ColorPicker extends Field {
     static make(name: string): ColorPicker;
-    /** Format hexadécimal (le seul pris en charge ; présent pour la compatibilité d'API). */
+    /** Hex format: the only one supported, kept for API compatibility. */
     hex(): this;
     constructor(name: string);
     toHtml(): Promise<string>;
@@ -468,22 +464,22 @@ export declare class Checkbox extends Field {
     getDefaultState(): unknown;
     toHtml(): Promise<string>;
 }
-/** Plusieurs cases à cocher pour une liste de valeurs (port de CheckboxList, sans recherche ni « tout cocher »). */
+/** Checkboxes for a list of values (no search or "select all" yet). */
 export declare class CheckboxList extends Field {
     private _options;
     private _optionColumns;
     static make(name: string): CheckboxList;
     options(options: Options): this;
-    /** Nombre de colonnes sur lesquelles les options se répartissent (à partir de `lg`). */
+    /** Number of columns the options are spread over (from `lg`). */
     columns(columns: number | null): this;
     getDefaultState(): unknown;
     hydrateState(value: unknown): unknown;
-    /** Seules les valeurs proposées sont retenues, sans doublon, dans l'ordre des options. */
+    /** Only offered values are kept, without duplicates, in option order. */
     dehydrateState(state: unknown): unknown;
     getValidationRules(): Promise<Rule[]>;
     toHtml(): Promise<string>;
 }
-/** Paires clé / valeur libres, enregistrées comme un objet (port de KeyValue). */
+/** Free-form key/value pairs, saved as an object. */
 export declare class KeyValue extends Field {
     private _keyLabel;
     private _valueLabel;
@@ -495,11 +491,11 @@ export declare class KeyValue extends Field {
     getDefaultState(): unknown;
     private static toPairs;
     hydrateState(value: unknown): unknown;
-    /** Objet plat de chaînes : clés vides, objets imbriqués et clés dangereuses sont écartés ; 200 paires au plus. */
+    /** Flat object of strings: empty keys, nested objects and dangerous keys are dropped; 200 pairs at most. */
     dehydrateState(state: unknown): unknown;
     toHtml(): Promise<string>;
 }
-/** Expression JavaScript écrite par le développeur (formateur d'infobulle d'un Slider…), insérée telle quelle : jamais de donnée utilisateur. */
+/** Developer-written JavaScript expression (e.g. a Slider tooltip formatter), inserted as is: never put user data in it. */
 export declare class RawJs {
     readonly js: string;
     constructor(js: string);
@@ -507,9 +503,9 @@ export declare class RawJs {
     toString(): string;
 }
 /**
- * Éditeur Markdown (port de MarkdownEditor, éditeur EasyMDE de Filament). L'état est le texte Markdown brut, à nettoyer avant tout
- * affichage en HTML. Non portés : pièces jointes (le bouton `attachFiles` est absent par défaut) ; en lecture seule (`disabled()`),
- * le texte est affiché échappé, sans conversion Markdown.
+ * Markdown editor (EasyMDE). The state is raw Markdown text, to sanitize before any HTML display.
+ * Attachments are not supported (no `attachFiles` button by default); when read-only (`disabled()`),
+ * the text is shown escaped, without Markdown conversion.
  */
 export declare class MarkdownEditor extends Field {
     private _toolbarButtons;
@@ -518,20 +514,20 @@ export declare class MarkdownEditor extends Field {
     private _placeholder;
     private _live;
     static make(name: string): MarkdownEditor;
-    /** Boutons de la barre d'outils, en groupes (`[['bold', 'italic'], ['undo', 'redo']]`) ou à plat. */
+    /** Toolbar buttons, grouped (`[['bold', 'italic'], ['undo', 'redo']]`) or flat. */
     toolbarButtons(buttons: (string | string[])[]): this;
-    /** Retire des boutons ; sans argument, les retire tous. */
+    /** Removes buttons; with no argument, removes them all. */
     disableToolbarButtons(names?: string[]): this;
     disableAllToolbarButtons(condition?: boolean): this;
-    /** Ajoute des boutons (dans un groupe à part). */
+    /** Adds buttons (in a separate group). */
     enableToolbarButtons(names: string[]): this;
     getToolbarButtons(): (string | string[])[];
     hasToolbarButton(name: string): boolean;
-    /** Hauteur minimale de la zone d'édition (`10rem` par défaut). */
+    /** Minimum height of the editing area (`10rem` by default). */
     minHeight(height: string | null): this;
     maxHeight(height: string | null): this;
     placeholder(text: string | null): this;
-    /** L'état est envoyé au serveur au fil de la frappe (`debounce` en millisecondes), ou à la perte de focus avec `onBlur`. */
+    /** Sends the state to the server while typing (`debounce` in milliseconds), or on blur with `onBlur`. */
     live(options?: {
         onBlur?: boolean;
         debounce?: number | null;
@@ -545,18 +541,18 @@ export declare class MarkdownEditor extends Field {
     saveUploadedFileAttachmentAndGetUrl(): null;
     toHtml(): Promise<string>;
 }
-/** Éditeur de code (port de CodeEditor, CodeMirror de Filament) : coloration selon `language()`, retour à la ligne avec `wrap()`. */
+/** Code editor (CodeMirror): highlighting from `language()`, line wrapping with `wrap()`. */
 export declare class CodeEditor extends Field {
     private _language;
     private _canWrap;
     private _live;
     static make(name: string): CodeEditor;
-    /** Langage : `cpp`, `css`, `go`, `html`, `java`, `javascript`, `json`, `markdown`, `php`, `python`, `sql`, `xml`, `yaml`. */
+    /** Language: `cpp`, `css`, `go`, `html`, `java`, `javascript`, `json`, `markdown`, `php`, `python`, `sql`, `xml`, `yaml`. */
     language(language: string | null): this;
     getLanguage(): string | null;
     /**
-     * Retour à la ligne des lignes longues (port de `wrap()`). Appelée avec du HTML, c'est l'enveloppe de champ héritée,
-     * que le rendu du composant utilise.
+     * Wraps long lines. Called with an HTML string, it is the inherited field wrapper,
+     * which the component's rendering uses.
      */
     wrap(condition?: any, options?: any): any;
     canWrap(): boolean;
@@ -569,8 +565,8 @@ export declare class CodeEditor extends Field {
     toHtml(): Promise<string>;
 }
 /**
- * Curseur (port de Slider, noUiSlider de Filament) : une valeur, ou plusieurs poignées quand l'état est une liste (`default([20, 70])`).
- * Obligatoire par défaut, comme dans Filament ; les bornes, le pas et le type numérique sont vérifiés côté serveur.
+ * Slider (noUiSlider): one value, or several handles when the state is a list (`default([20, 70])`).
+ * Required by default; bounds, step and numeric type are checked on the server.
  */
 export declare class Slider extends Field {
     private _minValue;
@@ -598,35 +594,35 @@ export declare class Slider extends Field {
     range(minValue: number, maxValue: number): this;
     minValue(value: number): this;
     maxValue(value: number): this;
-    /** Pas entre deux valeurs ; `1` impose un entier, sinon la valeur doit être un multiple du pas. */
+    /** Step between values; `1` requires an integer, otherwise the value must be a multiple of the step. */
     step(step: number | null): this;
-    /** Écart minimal / maximal entre deux poignées. */
+    /** Minimum / maximum gap between two handles. */
     minDifference(difference: number | null): this;
     maxDifference(difference: number | null): this;
-    /** Marge interdite aux extrémités : un nombre, ou `[début, fin]`. */
+    /** Forbidden margin at the ends: a number, or `[start, end]`. */
     rangePadding(padding: number | [number, number] | null): this;
-    /** Segments colorés de la piste, un booléen par segment (`[true, false]` par défaut). */
+    /** Colored track segments, one boolean per segment (`[true, false]` by default). */
     fillTrack(fill?: boolean[] | null): this;
     vertical(condition?: boolean): this;
-    /** De droite à gauche (de haut en bas pour un curseur vertical, ce qui est le réglage par défaut en vertical). */
+    /** Right to left (top to bottom for a vertical slider, the default when vertical). */
     rtl(condition?: boolean | null): this;
-    /** Comportement de la poignée (`tap`, `drag`, `fixed`, `snap`, `unconstrained`…) ; `null` : aucun. */
+    /** Handle behavior (`tap`, `drag`, `fixed`, `snap`, `unconstrained`…); `null`: none. */
     behavior(behavior?: string | string[] | null): this;
-    /** Infobulles sur les poignées : booléen, un booléen par poignée, ou `RawJs` qui formate `$value`. */
+    /** Handle tooltips: a boolean, one boolean per handle, or a `RawJs` formatting `$value`. */
     tooltips(tooltips?: boolean | RawJs | (boolean | RawJs)[]): this;
-    /** Graduations : `range` (par défaut), `steps`, `positions`, `count`, `values`. */
+    /** Pips: `range` (default), `steps`, `positions`, `count`, `values`. */
     pips(mode?: string | null, density?: number | null): this;
     pipsMode(mode: string | null): this;
     pipsDensity(density: number | null): this;
-    /** Formatage des graduations (`RawJs` qui reçoit `$value`). */
+    /** Pip formatter (a `RawJs` receiving `$value`). */
     pipsFormatter(formatter: RawJs | null): this;
     pipsValues(values: number | number[] | null): this;
     steppedPips(condition?: boolean): this;
-    /** Filtre des graduations (`RawJs` qui reçoit `$value`). */
+    /** Pip filter (a `RawJs` receiving `$value`). */
     pipsFilter(filter: RawJs | null): this;
-    /** Échelle non linéaire (`{ '10%': 500, '50%': 4000 }`). */
+    /** Non-linear scale (`{ '10%': 500, '50%': 4000 }`). */
     nonLinearPoints(points: Record<string, number | number[]> | null): this;
-    /** Nombre de décimales de la valeur enregistrée. */
+    /** Decimal places of the saved value. */
     decimalPlaces(places: number | null): this;
     live(options?: {
         onBlur?: boolean;
@@ -640,35 +636,34 @@ export declare class Slider extends Field {
     hydrateState(value: unknown): unknown;
     dehydrateState(state: unknown): unknown;
     getValidationRules(): Promise<Rule[]>;
-    /** Port de convertRawJsExpressionsToFormatterObjects : un `RawJs` devient `{ to: ($value) => … }`. */
+    /** A `RawJs` becomes a `{ to: ($value) => … }` formatter object. */
     private static formatters;
     toHtml(): Promise<string>;
 }
-/** Champ caché (port de Hidden) : un `<input type="hidden">` lié à l'état, sans libellé ni place dans la grille. */
+/** Hidden field: an `<input type="hidden">` bound to the state, with no label or grid slot. */
 export declare class Hidden extends Field {
     constructor(name: string);
     static make(name: string): Hidden;
     toHtml(): Promise<string>;
 }
-/** Code à usage unique (port de OneTimeCodeInput) : une case par chiffre ; l'état est la chaîne de chiffres, de longueur `length()` exactement. */
+/** One-time code: one box per digit; the state is a digit string of exactly `length()` characters. */
 export declare class OneTimeCodeInput extends Field {
     private _length;
     private _submitOnCompletion;
     private _readOnly;
     constructor(name: string);
     static make(name: string): OneTimeCodeInput;
-    /** Nombre de chiffres (6 par défaut). */
+    /** Number of digits (6 by default). */
     length(length: number): this;
     getLength(): number;
-    /** Soumet le formulaire dès que le dernier chiffre est saisi. */
+    /** Submits the form as soon as the last digit is typed. */
     submitOnCompletion(condition?: boolean): this;
     readOnly(condition?: boolean): this;
     hydrateState(value: unknown): unknown;
     toHtml(): Promise<string>;
 }
 /**
- * Texte en lecture seule dans un formulaire (port de Placeholder, déprécié dans Filament au profit de TextEntry avec `state()`).
- * Rien n'est enregistré. Une `HtmlString` est insérée telle quelle.
+ * Read-only text in a form. Nothing is saved. An `HtmlString` is inserted as is.
  */
 export declare class Placeholder extends Component {
     private _label;
@@ -682,20 +677,20 @@ export declare class Placeholder extends Component {
     content(content: Lazy<string | number | HtmlString | null, ComponentContext>): this;
     toHtml(): Promise<string>;
 }
-/** Remplit l'état par défaut de tous les champs d'un schéma (équivalent de `$this->form->fill()`). */
+/** Fills the default state of every field in a schema. */
 export declare function fillSchema(schema: Schema, target: Record<string, unknown>): void;
-/** Remplit l'état du formulaire à partir d'un enregistrement, champ par champ (équivalent de `$this->form->fill($record->attributesToArray())`). */
+/** Fills the form state from a record, field by field. */
 export declare function fillSchemaFromRecord(schema: Schema, target: Record<string, unknown>, record: Record<string, unknown>): void;
-/** Valide tous les champs visibles d'un schéma ; retourne les erreurs par chemin d'état. */
+/** Validates every visible field of a schema; returns errors by state path. */
 export declare function validateSchema(schema: Schema): Promise<Record<string, string[]>>;
-/** État à enregistrer : seulement les champs déclarés, visibles et « déshydratés » ; une chaîne vide vaut `null` (comme Laravel). */
+/** State to save: only declared, visible, dehydrated fields; an empty string becomes `null`. */
 export declare function getSchemaState(schema: Schema): Promise<Record<string, unknown>>;
 type StepHook = (ctx: ComponentContext) => void | Promise<void>;
-/** Lancée depuis `beforeValidation` / `afterValidation` d'une étape pour rester sur l'étape courante (équivalent de l'exception `Halt` de Filament). */
+/** Throw from a step's `beforeValidation` / `afterValidation` to stay on the current step. */
 export declare class Halt extends Error {
     constructor();
 }
-/** Une étape d'un assistant : un titre, une description et une icône facultatives, son propre schéma (port de Wizard\Step). */
+/** A wizard step: a label, an optional description and icon, and its own schema. */
 export declare class Step extends Component {
     private children;
     private _columns;
@@ -712,9 +707,9 @@ export declare class Step extends Component {
     description(description: string | null): this;
     icon(name: string | null): this;
     completedIcon(name: string | null): this;
-    /** Avant la validation de l'étape, au clic sur « Next » ; lever `Halt` pour rester sur l'étape. */
+    /** Runs before the step is validated, on "Next"; throw `Halt` to stay on the step. */
     beforeValidation(callback: StepHook | null): this;
-    /** Après une validation réussie, avant de passer à l'étape suivante ; lever `Halt` pour rester sur l'étape. */
+    /** Runs after a successful validation, before moving to the next step; throw `Halt` to stay on the step. */
     afterValidation(callback: StepHook | null): this;
     getLabel(): string;
     getDescription(): string | null;
@@ -724,12 +719,12 @@ export declare class Step extends Component {
     callAfterValidation(): Promise<void>;
     getChildSchemas(): Schema[];
     toHtml(): Promise<string>;
-    /** Panneau de l'étape : un `<form>` quand l'assistant sait quoi soumettre (Entrée passe à l'étape suivante, ou enregistre à la dernière). */
+    /** Step panel: a `<form>` when the wizard has a submit handler (Enter goes to the next step, or saves on the last one). */
     toStepHtml(submitHandler: string | null, hasHeader: boolean): Promise<string>;
 }
 /**
- * Assistant par étapes (port de Wizard) : toutes les étapes sont rendues, le navigateur n'affiche que l'étape courante.
- * « Next » valide l'étape courante côté serveur avant d'avancer, sauf si l'assistant est `skippable()`.
+ * Multi-step wizard: every step is rendered, the browser only shows the current one.
+ * "Next" validates the current step on the server before moving on, unless the wizard is `skippable()`.
  */
 export declare class Wizard extends Component {
     private steps;
@@ -748,36 +743,36 @@ export declare class Wizard extends Component {
     static make(steps?: Step[]): Wizard;
     schema(steps: Step[]): this;
     label(label: string | null): this;
-    /** Étapes accessibles dans n'importe quel ordre, sans validation au passage. */
+    /** Steps can be visited in any order, without validation. */
     skippable(condition?: boolean): this;
-    /** Étape affichée à l'ouverture (à partir de 1). */
+    /** Step shown on open (1-based). */
     startOnStep(step: number): this;
-    /** Faux : sans carte autour de l'assistant (c'est le cas sur une page de resource). */
+    /** `false`: no card around the wizard (as on a resource page). */
     contained(condition?: boolean): this;
     hiddenHeader(condition?: boolean): this;
-    /** Action affichée à la place de « Back » sur la première étape. */
+    /** Action shown instead of "Back" on the first step. */
     cancelAction(action: Action | null): this;
-    /** Action affichée à la place de « Next » sur la dernière étape. */
+    /** Action shown instead of "Next" on the last step. */
     submitAction(action: Action | null): this;
-    /** Expression Alpine exécutée quand la dernière étape est soumise au clavier (ex. `$wire.create()`). */
+    /** Alpine expression run when the last step is submitted from the keyboard (e.g. `$wire.create()`). */
     alpineSubmitHandler(handler: string | null): this;
-    /** Garde l'étape courante dans l'adresse (`?step=…`). */
+    /** Keeps the current step in the URL (`?step=…`). */
     persistStepInQueryString(key?: string | null): this;
     nextAction(modify: ((action: Action) => Action | void) | null): this;
     previousAction(modify: ((action: Action) => Action | void) | null): this;
     getKey(): string;
     getExposedMethods(): string[];
-    /** « Next » redessine le composant : les erreurs de validation de l'étape doivent apparaître. */
+    /** "Next" re-renders the component so the step's validation errors show up. */
     isRenderlessMethod(): boolean;
     getChildSchemas(): Schema[];
     private getSteps;
-    /** Appelée par le navigateur au clic sur « Next » : valide l'étape courante, puis annonce l'étape suivante. */
+    /** Called by the browser on "Next": validates the current step, then announces the next one. */
     nextStep(currentStepIndex?: unknown, currentStepKey?: unknown): Promise<void>;
-    /** Le retour en arrière se fait dans le navigateur ; la méthode existe pour le contrat de Filament. */
+    /** Going back happens in the browser; this exposed method is a no-op the front end still calls. */
     previousStep(): void;
     toHtml(): Promise<string>;
 }
-/** Fichier temporaire reçu par le runtime (voir @navette-js/wire). */
+/** Temporary file received by the runtime (see @navette-js/wire). */
 export type TemporaryUpload = {
     id: string;
     path: string;
@@ -792,19 +787,19 @@ export type UploadedFileInfo = {
     type: string;
     url: string;
 };
-/** Élément de l'état enregistré quand le champ ne stocke pas lui-même (`storeFiles(false)`) : fichier déjà enregistré, ou fichier temporaire à traiter. */
+/** Saved state item when the field does not store files itself (`storeFiles(false)`): an already saved file, or a temporary file to process. */
 export type FileUploadEntry = {
     key: string;
 } | {
     file: TemporaryUpload;
 };
-/** Où vont les fichiers une fois le formulaire enregistré. */
+/** Where files go once the form is saved. */
 export interface FileStorage {
-    /** Enregistre un fichier temporaire et rend sa clé (chemin relatif). */
+    /** Stores a temporary file and returns its key (relative path). */
     store(file: TemporaryUpload, directory: string | null): Promise<string>;
     info(key: string): Promise<UploadedFileInfo | null>;
 }
-/** Stockage sur le disque local, servi sous une adresse publique. Le nom du fichier est aléatoire, son extension vient du type détecté. */
+/** Local disk storage, served under a public URL. File names are random; the extension comes from the detected type. */
 export declare class LocalFileStorage implements FileStorage {
     private root;
     private baseUrl;
@@ -814,12 +809,12 @@ export declare class LocalFileStorage implements FileStorage {
     info(key: string): Promise<UploadedFileInfo | null>;
 }
 /**
- * Téléversement de fichiers (port de FileUpload, rendu FilePond de Filament).
- * État : `{ <clé de fichier>: <clé enregistrée> | 'livewire-file:<id temporaire>' }`. Une clé enregistrée n'est acceptée du navigateur
- * que si elle figure déjà dans l'enregistrement en cours d'édition : on ne peut pas s'attribuer le fichier d'un autre.
+ * File upload (FilePond).
+ * State: `{ <file key>: <stored key> | 'livewire-file:<temporary id>' }`. A stored key from the browser is only accepted
+ * if the record being edited already has it, so nobody can claim someone else's file.
  */
 export declare class FileUpload extends Field {
-    /** Stockage par défaut de l'application. */
+    /** Application-wide default storage. */
     static storage: FileStorage | null;
     private _multiple;
     private _maxFiles;
@@ -833,38 +828,38 @@ export declare class FileUpload extends Field {
     static make(name: string): FileUpload;
     multiple(condition?: boolean): this;
     maxFiles(count: number | null): this;
-    /** Taille maximale d'un fichier, en kilo-octets. */
+    /** Maximum file size, in kilobytes. */
     maxSize(kilobytes: number | null): this;
     reorderable(condition?: boolean): this;
-    /** Types MIME acceptés (`image/jpeg`, `image/*`…), vérifiés sur le contenu du fichier reçu. */
+    /** Accepted MIME types (`image/jpeg`, `image/*`…), checked against the received file's content. */
     acceptedFileTypes(types: string[] | null): this;
     image(): this;
     directory(directory: string | null): this;
     storage(storage: FileStorage): this;
-    /** `false` : le champ n'enregistre rien lui-même ; les données reçoivent des `FileUploadEntry`, à traiter par l'adaptateur (médias). */
+    /** `false`: the field stores nothing itself; the data receives `FileUploadEntry` items for the adapter to process (media). */
     storeFiles(condition?: boolean): this;
-    /** Informations d'un fichier déjà enregistré (nom, taille, type, adresse), quand elles ne viennent pas du stockage. */
+    /** Info about an already saved file (name, size, type, URL), when it does not come from the storage. */
     getUploadedFileUsing(resolver: (key: string, ctx: ComponentContext) => UploadedFileInfo | null | Promise<UploadedFileInfo | null>): this;
     getDefaultState(): unknown;
     hydrateState(value: unknown): unknown;
     private get uploads();
     private getStorage;
-    /** Entrées de l'état, nettoyées : clé de fichier sûre, valeur chaîne. */
+    /** Sanitized state entries: safe file key, string value. */
     private entries;
-    /** Clés enregistrées que l'enregistrement en cours possède déjà : les seules qu'on accepte de relire depuis le navigateur. */
+    /** Stored keys the current record already owns: the only ones accepted back from the browser. */
     private originalKeys;
     private isTemporary;
     getExposedMethods(): string[];
     getUploadedFiles(): Promise<Record<string, UploadedFileInfo | null>>;
     private writeState;
-    /** Retire un fichier du champ. Le fichier enregistré n'est supprimé qu'à l'enregistrement du formulaire, par l'application. */
+    /** Removes a file from the field. A stored file is only deleted by the application when the form is saved. */
     removeUploadedFile(fileKey: unknown): void;
     deleteUploadedFile(fileKey: unknown): void;
     reorderUploadedFiles(fileKeys: unknown): void;
     getValidationRules(): Promise<Rule[]>;
-    /** La validation porte sur l'état entier, même vide (un champ obligatoire sans fichier doit échouer). */
+    /** Validates the whole state, even when empty (a required field without files must fail). */
     validate(): Promise<string[]>;
-    /** À l'enregistrement : les fichiers temporaires sont stockés, les clés existantes non reconnues sont écartées. */
+    /** On save: temporary files are stored, unrecognized existing keys are dropped. */
     dehydrateState(): Promise<unknown>;
     toHtml(): Promise<string>;
 }