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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NavetteJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @navette-js/schemas
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Layout components and schemas for Navette, the Node.js port of Filament.
+
+Part of [Navette](https://github.com/NavetteJS/navette), a Node.js port of [Filament](https://filamentphp.com). Install the whole framework with `npm install @navette-js/panels`.
+
+**Beta:** the API may still change between beta releases.
+
+License: MIT. Third-party notices: see `THIRD-PARTY-NOTICES.md` where present.

package/lib/index.d.ts

@@ -0,0 +1,519 @@
+import { HtmlString, type ColorManager, type Lazy } from '@navette-js/support';
+/** Ce qu'un schéma attend du composant à état qui l'héberge. */
+export interface SchemaHost {
+    readonly id: string;
+    _errors: Record<string, string[]>;
+    getSchema(name: string): Schema | Promise<Schema>;
+}
+export type ComponentContext = {
+    livewire: SchemaHost;
+    component: Component;
+    operation: string | null;
+    record: unknown;
+    get: (path: string) => unknown;
+    state: unknown;
+};
+type SpanValue = number | string | ((ctx: ComponentContext) => number | string | Promise<number | string>);
+type ColumnSpan = Record<string, SpanValue> | number | string;
+export declare abstract class Component {
+    private _grow;
+    /** Dans un Flex : `false` pour garder la largeur naturelle au lieu d'occuper la place disponible. */
+    grow(condition?: boolean): this;
+    canGrow(): boolean;
+    /** Réglage par défaut de toutes les instances créées ensuite par `make()` : `TextInput.configureUsing((input) => input.maxLength(255))`. */
+    static configureUsing<T>(this: abstract new (...args: any[]) => T, configure: (instance: T) => void): void;
+    protected _name: string | null;
+    protected _keyName: string | null;
+    protected _hidden: Lazy<boolean, ComponentContext>;
+    protected _visible: Lazy<boolean, ComponentContext>;
+    protected _columnSpan: ColumnSpan;
+    protected _extraAttributes: Record<string, string>;
+    protected _columnStart: number | null;
+    container: Schema;
+    hidden(condition?: Lazy<boolean, ComponentContext>): this;
+    visible(condition?: Lazy<boolean, ComponentContext>): this;
+    key(key: string | null): this;
+    /** Masqué pour une opération donnée (`'create'`, `'edit'`…). */
+    hiddenOn(operations: string | string[]): this;
+    /** Visible seulement pour une opération donnée. */
+    visibleOn(operations: string | string[]): this;
+    /** Comme Filament : un nombre vaut pour le point de rupture `lg` ; un objet remplace entièrement la valeur par défaut. Les valeurs peuvent être des closures. */
+    columnSpan(span: ColumnSpan): this;
+    /** Colonne de départ dans la grille, à partir du point de rupture `lg` (comme Filament). */
+    columnStart(start: number | null): this;
+    extraAttributes(attributes: Record<string, string>): this;
+    get livewire(): SchemaHost;
+    isLiberatedFromContainerGrid(): boolean;
+    /** Méthodes que le JavaScript du composant peut appeler côté serveur (annoncées au navigateur). */
+    getExposedMethods(): string[];
+    /** Faux pour une méthode exposée après laquelle le composant hôte doit être redessiné (étape suivante d'un assistant : erreurs de validation). */
+    isRenderlessMethod(_method: string): boolean;
+    hasStatePath(): boolean;
+    /** Clé absolue du composant : `<clé du schéma>.<clé ou nom>`, ou null. */
+    getKey(): string | null;
+    getLivewireKey(): string | null;
+    getStatePath(): string;
+    getAlpineScopeConfiguration(): Record<string, unknown>;
+    context(): ComponentContext;
+    isVisible(): Promise<boolean>;
+    /** HTML propre au composant (sans son enveloppe de grille). */
+    abstract toHtml(): Promise<string>;
+    /** Port de Component::toSchemaHtml : enveloppe de colonne de grille, rendue même si le composant est masqué. */
+    toSchemaHtml(isVisible: boolean): Promise<string>;
+}
+export declare class Schema {
+    livewire: SchemaHost;
+    private _key;
+    private _components;
+    private _statePath;
+    private _columns;
+    private _root;
+    private _inline;
+    private _operation;
+    private _record;
+    private _extraClass;
+    private _partial;
+    private _dense;
+    constructor(livewire: SchemaHost);
+    static make(livewire: SchemaHost): Schema;
+    key(key: string): this;
+    components(components: Component[]): this;
+    schema(components: Component[]): this;
+    statePath(path: string | null): this;
+    columns(columns: Record<string, number> | number | null): this;
+    root(isRoot?: boolean): this;
+    inline(isInline?: boolean): this;
+    operation(operation: string | null): this;
+    record(record: unknown): this;
+    /** Classe placée avant celles de la grille (ex. `fi-section-content`). */
+    extraClass(name: string | null): this;
+    /** Espacement resserré entre composants (`fi-sc-dense`). */
+    dense(condition?: boolean): this;
+    /** Schéma rendu partiellement : sa racine porte `wire:partial="schema.<clé>"`. */
+    partiallyRendered(condition?: boolean): this;
+    private _partialName;
+    /** Nom du fragment `wire:partial` de la racine, quand il ne suit pas la clé du schéma (formulaire de filtres : `table-filters-form`). */
+    partialName(name: string | null): this;
+    private _gap;
+    /** `false` : composants accolés, sans espacement (`fi-sc-has-gap` absent), comme dans un FusedGroup. */
+    gap(condition?: boolean): this;
+    private _fieldWrapperView;
+    /**
+     * Enveloppe des champs de ce schéma : `'filament-forms::plain-field-wrapper'` ne garde qu'un libellé réservé aux lecteurs d'écran
+     * (champs d'un FusedGroup). `null` : l'enveloppe habituelle.
+     */
+    fieldWrapperView(view: string | null): this;
+    getFieldWrapperView(): string | null;
+    getKey(): string;
+    getStatePath(): string;
+    getComponents(): Component[];
+    getOperation(): string | null;
+    getRecord(): unknown;
+    isInline(): boolean;
+    isRoot(): boolean;
+    /** Tous les champs à état, en profondeur. */
+    getFlatComponents(): Component[];
+    /** Les mêmes, sans les composants masqués ni leur descendance : un champ placé dans une section masquée n'est ni validé ni enregistré, comme dans Filament. */
+    getVisibleFlatComponents(): Promise<Component[]>;
+    /** Port de Schema::renderEmbeddedHtml. */
+    toHtml(): Promise<string>;
+}
+/** Schéma enfant d'un composant de mise en page : partage la clé et le chemin d'état du parent, sans être racine. */
+export declare function childSchema(parent: Component, components: Component[]): Schema;
+/** Groupe à état : ses enfants vivent sous `<chemin du conteneur>.<nom>` (utilisé par les formulaires de filtres). */
+export declare class StatefulGroup extends Component {
+    private children;
+    constructor(name: string, children: Component[]);
+    static make(name: string, children: Component[]): StatefulGroup;
+    hasStatePath(): boolean;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** Regroupe des composants dans une grille, sans habillage (port de Group). */
+export declare class Group extends Component {
+    protected children: Component[];
+    protected _columns: Record<string, number> | number | null;
+    constructor(children?: Component[]);
+    static make(children?: Component[]): Group;
+    schema(components: Component[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** Grille de colonnes (port de Grid) : deux colonnes par défaut à partir de `lg`. */
+export declare class Grid extends Group {
+    constructor(columns?: Record<string, number> | number);
+    static make(columns?: Record<string, number> | number | Component[]): Grid;
+}
+/**
+ * Composants côte à côte à partir d'un point de rupture (port de Flex) : chacun occupe la place disponible,
+ * sauf ceux marqués `grow(false)`, qui gardent leur largeur naturelle.
+ */
+export declare class Flex extends Component {
+    private children;
+    private _from;
+    constructor(children?: Component[]);
+    static make(children?: Component[]): Flex;
+    schema(components: Component[]): this;
+    from(breakpoint: 'sm' | 'md' | 'lg' | 'xl' | '2xl'): this;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+export declare const slug: (text: string) => string;
+/** Section : carte regroupant des composants, avec un en-tête facultatif (titre, actions). Sans repli ni icône pour l'instant. */
+export declare class Section extends Component {
+    private children;
+    private _columns;
+    private _heading;
+    private _afterHeader;
+    constructor(heading?: string | null);
+    static make(heading?: string | null): Section;
+    schema(components: Component[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    private _collapsible;
+    private _collapsed;
+    /** Section repliable par son en-tête ; `collapsed()` la replie d'emblée. */
+    collapsible(condition?: boolean): this;
+    collapsed(condition?: boolean): this;
+    /** Actions affichées à droite du titre. */
+    afterHeader(actions: Renderable[]): this;
+    /** Actions que la section expose au montage. */
+    getActions(): Renderable[];
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/**
+ * Balisage libre dans un schéma. Le contenu est inséré TEL QUEL : n'y placez jamais une valeur venue d'un utilisateur ou de la base
+ * sans l'échapper avec `e()` de `@navette-js/support`.
+ */
+export declare class Html extends Component {
+    private content;
+    constructor(content: string | ((ctx: ComponentContext) => string | Promise<string>));
+    static make(content: string | ((ctx: ComponentContext) => string | Promise<string>)): Html;
+    toHtml(): Promise<string>;
+}
+/** Un onglet d'un composant Tabs : un titre, une icône facultative et son propre schéma (port de Tabs\Tab). */
+export declare class Tab extends Component {
+    private children;
+    private _columns;
+    private _icon;
+    private label;
+    constructor(label: string);
+    static make(label: string): Tab;
+    schema(components: Component[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    icon(name: string | null): this;
+    getLabel(): string;
+    getIcon(): string | null;
+    /** Clé de l'onglet côté navigateur (sans le préfixe du schéma). */
+    /** Clé de l'onglet dans son groupe : `::data::` suit le chemin d'état du schéma, absent d'un infolist (comme dans Filament). */
+    getTabKey(): string;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** Onglets de mise en page : tous les panneaux sont rendus, le navigateur n'affiche que l'onglet actif (port de Tabs). */
+export declare class Tabs extends Component {
+    private tabs;
+    private label;
+    constructor(label: string);
+    static make(label: string): Tabs;
+    schema(tabs: Tab[]): this;
+    getExposedMethods(): string[];
+    getLazyLoadedTabBadges(): Record<string, unknown>;
+    getDeferredTabBadges(): Record<string, unknown>;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** Point d'injection d'un render hook, avec les portées du composant hôte. Libéré de la grille du conteneur. */
+export declare class RenderHook extends Component {
+    private hook;
+    constructor(hook: string);
+    static make(hook: string): RenderHook;
+    isLiberatedFromContainerGrid(): boolean;
+    toHtml(): Promise<string>;
+}
+/** Intègre un autre schéma du composant hôte (`form`, `infolist`…) comme schéma racine. */
+export declare class EmbeddedSchema extends Component {
+    private schemaName;
+    constructor(name: string);
+    static make(name: string): EmbeddedSchema;
+    toHtml(): Promise<string>;
+}
+/** Balise <form> : contenu, pied (actions), soumission vers une méthode du composant hôte. */
+export declare class Form extends Component {
+    private children;
+    private _footer;
+    private _id;
+    private _submit;
+    constructor(children: Component[]);
+    static make(children?: Component[]): Form;
+    id(id: string): this;
+    livewireSubmitHandler(method: string): this;
+    footer(components: Component[]): this;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** Élément rendu dans un conteneur d'actions : en pratique une Action (paquet actions). */
+export interface Renderable {
+    isVisible(ctx: ComponentContext): Promise<boolean>;
+    toHtml(ctx: ComponentContext): Promise<string>;
+}
+/** Rangée d'actions d'un schéma. */
+export declare class Actions extends Component {
+    private actions;
+    private _fullWidth;
+    private _alignment;
+    constructor(actions: Renderable[]);
+    static make(actions: Renderable[]): Actions;
+    fullWidth(condition?: boolean): this;
+    alignment(alignment: string | null): this;
+    toHtml(): Promise<string>;
+}
+/** Gestionnaire de couleurs utilisé hors d'un panel ; dans un panel, celui du panel de l'hôte a la priorité. */
+export declare const useColorManager: (manager: ColorManager) => void;
+/** Élément d'une rangée en ligne : un composant de schéma ou une action. */
+export type InlineItem = Component | Renderable;
+/**
+ * Rangée « en ligne » (port d'un schéma enfant `inline()` de Filament : pied, contrôles, après le libellé) où composants et actions se mêlent.
+ * Les actions sont montées avec `schemaComponent: mountKey` (par défaut le schéma racine, qui les retrouve par `getActions()` du composant parent).
+ * `actionView` : `'button'` (bouton plein), `'link'` (lien, ou bouton-icône pour une action `iconButton()`), `'auto'` (bouton-icône si `iconButton()`, bouton sinon).
+ * `scope` remplace des clés de la configuration Alpine des composants (`path`, `containerPath`).
+ */
+export declare function renderInlineItems(parent: Component, items: InlineItem[], options?: {
+    alignment?: string | null;
+    scope?: Record<string, unknown>;
+    mountKey?: string | null;
+    actionView?: 'button' | 'link' | 'auto';
+}): Promise<string>;
+/**
+ * Cadre titré regroupant des champs (port de Fieldset) : une légende et une grille de deux colonnes par défaut.
+ * Avec `statePath()`, les champs vivent sous ce chemin et le fieldset reçoit une clé (et un `id`).
+ */
+export declare class Fieldset extends Component {
+    private children;
+    private _columns;
+    private _label;
+    private _hiddenLabel;
+    private _contained;
+    private _markedAsRequired;
+    constructor(label?: Lazy<string | null, ComponentContext>);
+    static make(label?: Lazy<string | null, ComponentContext>): Fieldset;
+    schema(components: Component[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    label(label: Lazy<string | null, ComponentContext>): this;
+    /** Légende gardée pour les lecteurs d'écran seulement. */
+    hiddenLabel(condition?: boolean): this;
+    /** `false` : sans bordure ni marge intérieure. */
+    contained(condition?: boolean): this;
+    /** Astérisque après la légende (le fieldset lui-même n'est jamais validé). */
+    markAsRequired(condition?: boolean): this;
+    /** Chemin d'état des champs, relatif au conteneur (port de `statePath()`). */
+    statePath(path: string | null): this;
+    hasStatePath(): boolean;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/**
+ * Texte dans un schéma (port de Text) : simple `<span>`, ou pastille avec `badge()`. Le contenu est échappé ;
+ * une `HtmlString` (de `@navette-js/support`) est insérée telle quelle, à ne construire qu'avec des valeurs échappées.
+ */
+export declare class Text extends Component {
+    private _content;
+    private _badge;
+    private _color;
+    private _size;
+    private _weight;
+    private _fontFamily;
+    private _icon;
+    private _iconPosition;
+    private _iconSize;
+    private _tooltip;
+    private _copyable;
+    private _copyableState;
+    private _copyMessage;
+    private _copyMessageDuration;
+    constructor(content: Lazy<string | HtmlString | null, ComponentContext>);
+    static make(content: Lazy<string | HtmlString | null, ComponentContext>): Text;
+    content(content: Lazy<string | HtmlString | null, ComponentContext>): this;
+    /** Affiché en pastille. */
+    badge(condition?: Lazy<boolean, ComponentContext>): this;
+    /** Couleur (`gray` par défaut ; `primary`, `danger`…). */
+    color(color: Lazy<string | null, ComponentContext>): this;
+    /** Taille du texte (`xs`, `sm`, `md`, `lg`) ou de la pastille. */
+    size(size: string | null): this;
+    /** Graisse (`bold`, `semibold`, `medium`…). */
+    weight(weight: string | null): this;
+    /** Famille de police (`sans`, `serif`, `mono`). */
+    fontFamily(family: string | null): this;
+    /** Icône d'une pastille. */
+    icon(name: string | null): this;
+    iconPosition(position: 'before' | 'after'): this;
+    iconSize(size: string | null): this;
+    tooltip(text: Lazy<string | null, ComponentContext>): this;
+    /** Un clic copie le texte (ou `copyableState()`) dans le presse-papiers. */
+    copyable(condition?: Lazy<boolean, ComponentContext>): this;
+    copyableState(state: Lazy<string | null, ComponentContext>): this;
+    copyMessage(message: string | null): this;
+    copyMessageDuration(milliseconds: number): this;
+    getContent(): Promise<string | HtmlString | null>;
+    toHtml(): Promise<string>;
+}
+/** Icône Heroicons dans un schéma (port de Icon) : décorative, sauf si une infobulle ou un `aria-label` (attributs supplémentaires) la décrit. */
+export declare class Icon extends Component {
+    private _icon;
+    private _color;
+    private _size;
+    private _tooltip;
+    constructor(name: Lazy<string | null, ComponentContext>);
+    static make(name: Lazy<string | null, ComponentContext>): Icon;
+    icon(name: Lazy<string | null, ComponentContext>): this;
+    /** Couleur (`primary` par défaut). */
+    color(color: Lazy<string | null, ComponentContext>): this;
+    /** Taille (`xs` … `2xl`) ; `base` revient à la taille par défaut. */
+    size(size: string | null): this;
+    tooltip(text: Lazy<string | null, ComponentContext>): this;
+    toHtml(): Promise<string>;
+}
+/** Image dans un schéma (port de Image). Seules une adresse du site (`/…`) ou une adresse http(s) sont affichées. */
+export declare class Image extends Component {
+    private _url;
+    private _alt;
+    private _height;
+    private _width;
+    private _alignment;
+    private _tooltip;
+    constructor(url: Lazy<string, ComponentContext>, alt: Lazy<string, ComponentContext>);
+    static make(url: Lazy<string, ComponentContext>, alt: Lazy<string, ComponentContext>): Image;
+    url(url: Lazy<string, ComponentContext>): this;
+    alt(alt: Lazy<string, ComponentContext>): this;
+    private static dimension;
+    /** Hauteur (`8rem` par défaut) ; un nombre est en pixels. */
+    imageHeight(height: number | string | null): this;
+    imageWidth(width: number | string | null): this;
+    imageSize(size: number | string): this;
+    /** Alignement (`start`, `center`, `end`). */
+    alignment(alignment: string | null): this;
+    alignStart(): this;
+    alignCenter(): this;
+    alignEnd(): this;
+    tooltip(text: Lazy<string | null, ComponentContext>): this;
+    toHtml(): Promise<string>;
+}
+/** Liste à puces (port de UnorderedList) : chaque élément est un composant ; une chaîne devient un `Text`. Deux colonnes à partir de `sm`. */
+export declare class UnorderedList extends Component {
+    private children;
+    private _columns;
+    private _size;
+    constructor(items?: (Component | string | HtmlString)[]);
+    static make(items?: (Component | string | HtmlString)[]): UnorderedList;
+    private static normalize;
+    schema(items: (Component | string | HtmlString)[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    /** Taille du texte (`xs`, `sm`, `md`, `lg`). */
+    size(size: string | null): this;
+    getChildSchemas(): Schema[];
+    toHtml(): Promise<string>;
+}
+/** État vide (port de EmptyState) : icône, titre, description et un pied (actions, composants). */
+export declare class EmptyState extends Component {
+    private _heading;
+    private _description;
+    private _icon;
+    private _iconColor;
+    private _iconSize;
+    private _compact;
+    private _contained;
+    private _headingTag;
+    private _footer;
+    constructor(heading: Lazy<string, ComponentContext>);
+    static make(heading: Lazy<string, ComponentContext>): EmptyState;
+    heading(heading: Lazy<string, ComponentContext>): this;
+    description(description: Lazy<string | null, ComponentContext>): this;
+    icon(name: string | null): this;
+    /** Couleur de l'icône (`primary` par défaut). */
+    iconColor(color: string | null): this;
+    iconSize(size: string | null): this;
+    /** Version resserrée. */
+    compact(condition?: boolean): this;
+    /** `false` : sans carte autour. */
+    contained(condition?: boolean): this;
+    /** Balise du titre (`h2` par défaut). */
+    headingTag(tag: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'): this;
+    /** Pied : actions et composants, en ligne. */
+    footer(items: InlineItem[]): this;
+    /** Actions du pied, montées sur le schéma racine. */
+    getActions(): Renderable[];
+    toHtml(): Promise<string>;
+}
+/**
+ * Encadré d'information (port de Callout) : statut (`info()`, `success()`, `warning()`, `danger()`) qui fixe couleur et icône,
+ * titre, description, actions de pied (en liens) et actions de contrôle (à droite).
+ */
+export declare class Callout extends Component {
+    private _heading;
+    private _description;
+    private _status;
+    private _color;
+    private _hasColor;
+    private _icon;
+    private _iconColor;
+    private _iconSize;
+    private _footerActions;
+    private _footerActionsAlignment;
+    private _footer;
+    private _controlActions;
+    constructor(heading?: Lazy<string | null, ComponentContext>);
+    static make(heading?: Lazy<string | null, ComponentContext>): Callout;
+    heading(heading: Lazy<string | null, ComponentContext>): this;
+    description(description: Lazy<string | null, ComponentContext>): this;
+    /** Statut : couleur, icône et préfixe lu par les lecteurs d'écran (« Note: »…). */
+    status(status: string | null): this;
+    danger(): this;
+    info(): this;
+    success(): this;
+    warning(): this;
+    /** Couleur du fond ; `null` retire celle du statut (l'icône la garde). */
+    color(color: string | null): this;
+    icon(name: string | null): this;
+    iconColor(color: string | null): this;
+    /** Taille de l'icône (`lg` par défaut). */
+    iconSize(size: string | null): this;
+    /** Actions du pied, rendues en liens (port de `actions()` / `footerActions()`). */
+    actions(actions: Renderable[]): this;
+    footerActions(actions: Renderable[]): this;
+    /** Alignement des actions du pied (`start`, `center`, `end`, `between`). */
+    footerActionsAlignment(alignment: string): this;
+    /** Pied libre (composants et actions), à la place des actions de pied. */
+    footer(items: InlineItem[] | null): this;
+    /** Actions à droite de l'encadré (fermeture…), en petite taille. */
+    controlActions(actions: Renderable[]): this;
+    getColor(): string | null;
+    getIcon(): string | null;
+    /** Actions de l'encadré, montées sur le schéma racine. */
+    getActions(): Renderable[];
+    toHtml(): Promise<string>;
+}
+/**
+ * Champs accolés sous un seul libellé (port de FusedGroup) : chaque champ n'a plus qu'un libellé pour lecteurs d'écran,
+ * et la première erreur de validation des champs s'affiche sous le groupe.
+ */
+export declare class FusedGroup extends Component {
+    private children;
+    private _columns;
+    private _label;
+    private _hiddenLabel;
+    private _markedAsRequired;
+    constructor(children?: Component[]);
+    static make(children?: Component[]): FusedGroup;
+    schema(components: Component[]): this;
+    columns(columns: Record<string, number> | number | null): this;
+    label(label: Lazy<string | null, ComponentContext>): this;
+    hiddenLabel(condition?: boolean): this;
+    /** Astérisque après le libellé (la validation reste celle de chaque champ). */
+    markAsRequired(condition?: boolean): this;
+    getChildSchemas(): Schema[];
+    /** Première erreur des champs du groupe (y compris d'un élément d'un champ à valeurs multiples). */
+    private firstError;
+    toHtml(): Promise<string>;
+}
+export {};