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

package/lib/index.d.ts

@@ -0,0 +1,871 @@
+import { HtmlString, type ColorManager, type Lazy } from '@navette-js/support';
+import { Component, Schema, type ComponentContext } from '@navette-js/schemas';
+import { Action } from '@navette-js/actions';
+export declare const useColorManager: (manager: ColorManager) => void;
+type Rule = {
+    name: string;
+    passes: (value: unknown, ctx: ComponentContext) => boolean | Promise<boolean>;
+    message: (attribute: string) => string;
+};
+export declare abstract class Field extends Component {
+    protected _label: Lazy<string | null, ComponentContext>;
+    protected _required: Lazy<boolean, ComponentContext>;
+    protected _disabled: Lazy<boolean, ComponentContext>;
+    protected _autofocus: boolean;
+    protected _default: unknown;
+    protected _rules: Rule[];
+    protected _afterStateUpdated: ((ctx: ComponentContext & {
+        set: (name: string, value: unknown) => void;
+    }) => unknown) | null;
+    protected _dehydrated: boolean | null;
+    protected _hiddenLabel: boolean;
+    protected _helperText: string | null;
+    constructor(name: string);
+    hasStatePath(): boolean;
+    getName(): string;
+    getId(): string;
+    label(label: Lazy<string | null, ComponentContext>): this;
+    required(condition?: Lazy<boolean, ComponentContext>): this;
+    disabled(condition?: Lazy<boolean, ComponentContext>): this;
+    autofocus(condition?: boolean): this;
+    default(value: unknown): this;
+    /** Texte d'aide affiché sous le champ. */
+    helperText(text: string | null): this;
+    /** Identifiant du texte d'aide, à lier au contrôle par `aria-describedby`. */
+    protected getHelperTextId(): string | null;
+    /** Libellé réservé aux lecteurs d'écran. */
+    hiddenLabel(condition?: boolean): this;
+    protected _hint: Lazy<string | HtmlString | null, ComponentContext>;
+    protected _hintColor: Lazy<string | null, ComponentContext>;
+    protected _hintIcon: Lazy<string | null, ComponentContext>;
+    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(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). */
+    hintColor(color: Lazy<string | null, ComponentContext>): this;
+    /** Icône d'indication, avec une infobulle facultative (qui sert aussi de nom accessible). */
+    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. */
+    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. */
+    getActions(): Action[];
+    /** Rangée « après le libellé » : indication, icône d'indication et actions d'indication. */
+    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. */
+    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()`). */
+    dehydrated(condition?: boolean): this;
+    /** Par défaut, un champ désactivé n'est ni validé ni enregistré. */
+    isDehydrated(): Promise<boolean>;
+    getDefaultState(): unknown;
+    /** Mise en forme de la valeur d'un enregistrement quand elle entre dans le formulaire (hydratation). */
+    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(options?: {
+        ignoreRecord?: boolean;
+        column?: string;
+    }): this;
+    getLabel(): Promise<string>;
+    isRequired(): Promise<boolean>;
+    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). */
+    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). */
+    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). */
+    finalizeDehydratedState(state: unknown): unknown;
+    protected wrap(html: string, options?: {
+        labelPrefix?: string;
+        wrapperClass?: string;
+        after?: string;
+        labelAsDiv?: boolean;
+        focusable?: boolean;
+    }): Promise<string>;
+}
+export declare class TextInput extends Field {
+    private _type;
+    private _isPassword;
+    private _isRevealable;
+    private _autocomplete;
+    private _maxLength;
+    private _minLength;
+    private _placeholder;
+    private _numeric;
+    private _minValue;
+    private _maxValue;
+    private _prefix;
+    private _live;
+    static make(name: string): TextInput;
+    /** Nombre décimal : `type="number"`, `step="any"`. */
+    numeric(): this;
+    /** Nombre entier : `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()`. */
+    step(step: number | 'any' | null): this;
+    minValue(value: number): this;
+    maxValue(value: number): this;
+    /** Libellé affiché avant la zone de saisie (ex. `$`). */
+    prefix(label: string | null): this;
+    private _suffix;
+    /** Libellé affiché après la saisie (« hours », « kg »…). */
+    suffix(label: string | null): this;
+    /** L'état est envoyé au serveur à chaque frappe, ou à la perte de focus avec `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). */
+    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. */
+    mask(pattern: string | null): this;
+    /** Numéro de téléphone : chiffres, espaces et ponctuation usuelle. */
+    tel(): this;
+    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é. */
+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(text: string | null): this;
+    /** Envoie l'état au serveur dès qu'il change (`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. */
+    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'`). */
+    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`…).
+ */
+export declare class Select extends Field {
+    private _options;
+    private _placeholder;
+    private _searchable;
+    private _dynamic;
+    private _searchOnServer;
+    private _live;
+    private _hasNoInitialOptions;
+    private _multiple;
+    private _optionLabelsUsing;
+    private _disableOptionWhen;
+    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). */
+    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. */
+    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).
+     */
+    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). */
+    disableOptionWhen(condition: (value: string, ctx: ComponentContext) => boolean): this;
+    /** L'état est envoyé au serveur dès qu'il change. */
+    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()`). */
+    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(condition?: boolean): this;
+    isMultiple(): boolean;
+    /** Libellés de plusieurs valeurs d'un coup (sélection multiple avec recherche serveur) ; sert aussi à valider les valeurs. */
+    getOptionLabelsUsing(resolver: (values: string[], ctx: ComponentContext) => Options | Promise<Options>): this;
+    getDefaultState(): unknown;
+    /** Valeurs sélectionnées, nettoyées : des chaînes, sans doublon. */
+    private selectedValues;
+    private labelsOf;
+    /** Sans effet ici : les options sont toujours chargées avec le formulaire. */
+    preload(): this;
+    hydrateState(value: unknown): unknown;
+    dehydrateState(state: unknown): unknown;
+    resolveOptions(): Promise<[string, string][]>;
+    getValidationRules(): Promise<Rule[]>;
+    getExposedMethods(): string[];
+    private static forJs;
+    getOptionsForJs(): Promise<{
+        label: string;
+        value: string;
+        isDisabled: boolean;
+    }[]>;
+    private withDisabled;
+    getSearchResultsForJs(search?: unknown): Promise<{
+        label: string;
+        value: string;
+        isDisabled: boolean;
+    }[]>;
+    getOptionLabel(): Promise<string | null>;
+    getOptionLabelsForJs(): Promise<unknown[]>;
+    private _createOptionForm;
+    private _createOptionUsing;
+    private _createOptionModalHeading;
+    private _modifyCreateOptionAction;
+    private _editOptionForm;
+    private _updateOptionUsing;
+    private _fillEditOptionForm;
+    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.
+     */
+    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. */
+    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…). */
+    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()`.
+     */
+    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`). */
+    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. */
+    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. */
+    getActions(): Action[];
+    /** Boutons « + » et « modifier » à droite du champ (port des suffixActions de Select). */
+    private suffixHtml;
+    toHtml(): Promise<string>;
+    /** Port du rendu JavaScript de Select::toEmbeddedHtml (sélection simple). */
+    private toJsHtml;
+}
+/** Colonne d'un Repeater en table : intitulé et largeur. */
+export declare class TableColumn {
+    label: string;
+    private _width;
+    constructor(label: string);
+    static make(label: string): TableColumn;
+    width(width: number | string): this;
+    getWidth(): string | null;
+}
+type ItemLink = {
+    label: string;
+    icon: string;
+    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`.
+ */
+export declare class Repeater extends Field {
+    private _schema;
+    private _columns;
+    private _defaultItems;
+    private _maxItems;
+    private _itemLinks;
+    static make(name: string): Repeater;
+    /** Champs d'un élément : une fonction, appelée pour chaque élément. */
+    schema(factory: () => Field[]): this;
+    /** Affichage en table, une colonne par champ. */
+    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). */
+    reorderable(condition?: boolean): this;
+    /** Lien affiché sur chaque ligne (équivalent d'une action d'élément à 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. */
+    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. */
+    hydrateState(value: unknown): unknown;
+    dehydrateState(): unknown;
+    getChildSchemas(): Schema[];
+    getValidationRules(): Promise<Rule[]>;
+    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. */
+export declare class TimePicker extends Field {
+    private _seconds;
+    static make(name: string): TimePicker;
+    seconds(condition?: boolean): this;
+    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`. */
+export declare class DateTimePicker extends Field {
+    private _seconds;
+    static make(name: string): DateTimePicker;
+    seconds(condition?: boolean): this;
+    dehydrateState(state: unknown): unknown;
+    toHtml(): Promise<string>;
+}
+/** Choix unique en boutons radio (port de Radio). */
+export declare class Radio extends Field {
+    private _options;
+    private _descriptions;
+    private _inline;
+    private _live;
+    static make(name: string): Radio;
+    options(options: Options): this;
+    /** Texte d'aide par valeur, sous le libellé de l'option. */
+    descriptions(descriptions: Record<string, string>): this;
+    /** Options côte à côte. */
+    inline(condition?: boolean): this;
+    live(condition?: boolean): this;
+    getValidationRules(): Promise<Rule[]>;
+    toHtml(): Promise<string>;
+}
+export declare class Textarea extends Field {
+    private _rows;
+    private _maxLength;
+    static make(name: string): Textarea;
+    rows(rows: number): this;
+    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. */
+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. */
+    suggestions(suggestions: string[]): this;
+    /** Touches qui valident le mot en cours, en plus d'Entrée (`['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. */
+    dehydrateState(state: unknown): unknown;
+    toHtml(): Promise<string>;
+}
+/** Interrupteur (port de Toggle). */
+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). */
+export declare class ToggleButtons extends Field {
+    private _options;
+    private _inline;
+    private _grouped;
+    private _colors;
+    private _icons;
+    static make(name: string): ToggleButtons;
+    private _live;
+    /** L'état est envoyé au serveur dès qu'il change. */
+    live(condition?: boolean): this;
+    /** Couleur par valeur (ex. celle d'une énumération). */
+    colors(colors: Record<string, string>): this;
+    /** Icône par valeur. */
+    icons(icons: Record<string, string>): this;
+    options(options: Options): this;
+    /** Boutons côte à côte. */
+    inline(condition?: boolean): this;
+    /** Boutons accolés en un seul groupe. */
+    grouped(condition?: boolean): this;
+    getValidationRules(): Promise<Rule[]>;
+    toHtml(): Promise<string>;
+}
+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:`). */
+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é.
+ */
+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.
+ */
+export declare class RichEditor extends Field {
+    static make(name: string): RichEditor;
+    hydrateState(value: unknown): unknown;
+    getDefaultState(): unknown;
+    dehydrateState(state: unknown): unknown;
+    getValidationRules(): Promise<Rule[]>;
+    getExposedMethods(): string[];
+    getMentionSearchResultsForJs(): unknown[];
+    getMentionLabelsForJs(): unknown[];
+    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. */
+    getActions(): Action[];
+    toHtml(): Promise<string>;
+}
+/** Sélecteur de couleur (port de ColorPicker, format hexadécimal). */
+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(): this;
+    constructor(name: string);
+    toHtml(): Promise<string>;
+}
+export declare class Checkbox extends Field {
+    static make(name: string): Checkbox;
+    getDefaultState(): unknown;
+    toHtml(): Promise<string>;
+}
+/** Plusieurs cases à cocher pour une liste de valeurs (port de CheckboxList, sans recherche ni « tout cocher »). */
+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`). */
+    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. */
+    dehydrateState(state: unknown): unknown;
+    getValidationRules(): Promise<Rule[]>;
+    toHtml(): Promise<string>;
+}
+/** Paires clé / valeur libres, enregistrées comme un objet (port de KeyValue). */
+export declare class KeyValue extends Field {
+    private _keyLabel;
+    private _valueLabel;
+    private _reorderable;
+    static make(name: string): KeyValue;
+    keyLabel(label: string): this;
+    valueLabel(label: string): this;
+    reorderable(condition?: boolean): this;
+    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. */
+    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. */
+export declare class RawJs {
+    readonly js: string;
+    constructor(js: string);
+    static make(js: string): 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.
+ */
+export declare class MarkdownEditor extends Field {
+    private _toolbarButtons;
+    private _minHeight;
+    private _maxHeight;
+    private _placeholder;
+    private _live;
+    static make(name: string): MarkdownEditor;
+    /** Boutons de la barre d'outils, en groupes (`[['bold', 'italic'], ['undo', 'redo']]`) ou à plat. */
+    toolbarButtons(buttons: (string | string[])[]): this;
+    /** Retire des boutons ; sans argument, les retire tous. */
+    disableToolbarButtons(names?: string[]): this;
+    disableAllToolbarButtons(condition?: boolean): this;
+    /** Ajoute des boutons (dans un groupe à part). */
+    enableToolbarButtons(names: string[]): this;
+    getToolbarButtons(): (string | string[])[];
+    hasToolbarButton(name: string): boolean;
+    /** Hauteur minimale de la zone d'édition (`10rem` par défaut). */
+    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`. */
+    live(options?: {
+        onBlur?: boolean;
+        debounce?: number | null;
+    }): this;
+    maxLength(length: number): this;
+    minLength(length: number): this;
+    hydrateState(value: unknown): unknown;
+    getValidationRules(): Promise<Rule[]>;
+    getExposedMethods(): string[];
+    getUploadedFileAttachmentTemporaryUrl(): null;
+    saveUploadedFileAttachmentAndGetUrl(): null;
+    toHtml(): Promise<string>;
+}
+/** Éditeur de code (port de CodeEditor, CodeMirror de Filament) : coloration selon `language()`, retour à la ligne avec `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(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.
+     */
+    wrap(condition?: any, options?: any): any;
+    canWrap(): boolean;
+    live(options?: {
+        onBlur?: boolean;
+        debounce?: number | null;
+    }): this;
+    hydrateState(value: unknown): unknown;
+    getValidationRules(): Promise<Rule[]>;
+    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.
+ */
+export declare class Slider extends Field {
+    private _minValue;
+    private _maxValue;
+    private _step;
+    private _minDifference;
+    private _maxDifference;
+    private _rangePadding;
+    private _fillTrack;
+    private _vertical;
+    private _rtl;
+    private _behavior;
+    private _tooltips;
+    private _pipsMode;
+    private _pipsDensity;
+    private _pipsFormatter;
+    private _pipsValues;
+    private _steppedPips;
+    private _pipsFilter;
+    private _nonLinearPoints;
+    private _decimalPlaces;
+    private _live;
+    constructor(name: string);
+    static make(name: string): Slider;
+    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(step: number | null): this;
+    /** Écart minimal / maximal entre deux poignées. */
+    minDifference(difference: number | null): this;
+    maxDifference(difference: number | null): this;
+    /** Marge interdite aux extrémités : un nombre, ou `[début, fin]`. */
+    rangePadding(padding: number | [number, number] | null): this;
+    /** Segments colorés de la piste, un booléen par segment (`[true, false]` par défaut). */
+    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). */
+    rtl(condition?: boolean | null): this;
+    /** Comportement de la poignée (`tap`, `drag`, `fixed`, `snap`, `unconstrained`…) ; `null` : aucun. */
+    behavior(behavior?: string | string[] | null): this;
+    /** Infobulles sur les poignées : booléen, un booléen par poignée, ou `RawJs` qui formate `$value`. */
+    tooltips(tooltips?: boolean | RawJs | (boolean | RawJs)[]): this;
+    /** Graduations : `range` (par défaut), `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`). */
+    pipsFormatter(formatter: RawJs | null): this;
+    pipsValues(values: number | number[] | null): this;
+    steppedPips(condition?: boolean): this;
+    /** Filtre des graduations (`RawJs` qui reçoit `$value`). */
+    pipsFilter(filter: RawJs | null): this;
+    /** Échelle non linéaire (`{ '10%': 500, '50%': 4000 }`). */
+    nonLinearPoints(points: Record<string, number | number[]> | null): this;
+    /** Nombre de décimales de la valeur enregistrée. */
+    decimalPlaces(places: number | null): this;
+    live(options?: {
+        onBlur?: boolean;
+        debounce?: number | null;
+    }): this;
+    getMinValueWithPadding(): number;
+    getMaxValueWithPadding(): number;
+    isMultiple(): boolean;
+    getDefaultState(): unknown;
+    private cast;
+    hydrateState(value: unknown): unknown;
+    dehydrateState(state: unknown): unknown;
+    getValidationRules(): Promise<Rule[]>;
+    /** Port de convertRawJsExpressionsToFormatterObjects : un `RawJs` devient `{ to: ($value) => … }`. */
+    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. */
+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. */
+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). */
+    length(length: number): this;
+    getLength(): number;
+    /** Soumet le formulaire dès que le dernier chiffre est saisi. */
+    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.
+ */
+export declare class Placeholder extends Component {
+    private _label;
+    private _content;
+    private _hiddenLabel;
+    constructor(name: string);
+    static make(name: string): Placeholder;
+    hasStatePath(): boolean;
+    label(label: Lazy<string | null, ComponentContext>): this;
+    hiddenLabel(condition?: boolean): this;
+    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()`). */
+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())`). */
+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. */
+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). */
+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). */
+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). */
+export declare class Step extends Component {
+    private children;
+    private _columns;
+    private label;
+    private _description;
+    private _icon;
+    private _completedIcon;
+    private _beforeValidation;
+    private _afterValidation;
+    constructor(label: string);
+    static make(label: string): Step;
+    schema(components: Component[]): this;
+    columns(columns?: Record<string, number> | number | null): this;
+    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. */
+    beforeValidation(callback: StepHook | null): this;
+    /** Après une validation réussie, avant de passer à l'étape suivante ; lever `Halt` pour rester sur l'étape. */
+    afterValidation(callback: StepHook | null): this;
+    getLabel(): string;
+    getDescription(): string | null;
+    getIcon(): string | null;
+    getCompletedIcon(): string | null;
+    callBeforeValidation(): Promise<void>;
+    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). */
+    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()`.
+ */
+export declare class Wizard extends Component {
+    private steps;
+    private _label;
+    private _skippable;
+    private _startStep;
+    private _contained;
+    private _headerHidden;
+    private _cancelAction;
+    private _submitAction;
+    private _alpineSubmitHandler;
+    private _stepQueryStringKey;
+    private _modifyNext;
+    private _modifyPrevious;
+    constructor(steps?: Step[]);
+    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. */
+    skippable(condition?: boolean): this;
+    /** Étape affichée à l'ouverture (à partir de 1). */
+    startOnStep(step: number): this;
+    /** Faux : sans carte autour de l'assistant (c'est le cas sur une page de resource). */
+    contained(condition?: boolean): this;
+    hiddenHeader(condition?: boolean): this;
+    /** Action affichée à la place de « Back » sur la première étape. */
+    cancelAction(action: Action | null): this;
+    /** Action affichée à la place de « Next » sur la dernière étape. */
+    submitAction(action: Action | null): this;
+    /** Expression Alpine exécutée quand la dernière étape est soumise au clavier (ex. `$wire.create()`). */
+    alpineSubmitHandler(handler: string | null): this;
+    /** Garde l'étape courante dans l'adresse (`?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. */
+    isRenderlessMethod(): boolean;
+    getChildSchemas(): Schema[];
+    private getSteps;
+    /** Appelée par le navigateur au clic sur « Next » : valide l'étape courante, puis annonce l'étape suivante. */
+    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. */
+    previousStep(): void;
+    toHtml(): Promise<string>;
+}
+/** Fichier temporaire reçu par le runtime (voir @navette-js/wire). */
+export type TemporaryUpload = {
+    id: string;
+    path: string;
+    name: string;
+    type: string;
+    size: number;
+    extension: string;
+};
+export type UploadedFileInfo = {
+    name: string;
+    size: number;
+    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. */
+export type FileUploadEntry = {
+    key: string;
+} | {
+    file: TemporaryUpload;
+};
+/** Où vont les fichiers une fois le formulaire enregistré. */
+export interface FileStorage {
+    /** Enregistre un fichier temporaire et rend sa clé (chemin relatif). */
+    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é. */
+export declare class LocalFileStorage implements FileStorage {
+    private root;
+    private baseUrl;
+    constructor(root: string, baseUrl: string);
+    private resolve;
+    store(file: TemporaryUpload, directory: string | null): Promise<string>;
+    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.
+ */
+export declare class FileUpload extends Field {
+    /** Stockage par défaut de l'application. */
+    static storage: FileStorage | null;
+    private _multiple;
+    private _maxFiles;
+    private _maxSize;
+    private _reorderable;
+    private _acceptedFileTypes;
+    private _directory;
+    private _storeFiles;
+    private _storage;
+    private _getUploadedFileUsing;
+    static make(name: string): FileUpload;
+    multiple(condition?: boolean): this;
+    maxFiles(count: number | null): this;
+    /** Taille maximale d'un fichier, en kilo-octets. */
+    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. */
+    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). */
+    storeFiles(condition?: boolean): this;
+    /** Informations d'un fichier déjà enregistré (nom, taille, type, adresse), quand elles ne viennent pas du stockage. */
+    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. */
+    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. */
+    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. */
+    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). */
+    validate(): Promise<string[]>;
+    /** À l'enregistrement : les fichiers temporaires sont stockés, les clés existantes non reconnues sont écartées. */
+    dehydrateState(): Promise<unknown>;
+    toHtml(): Promise<string>;
+}
+export {};