@esfaenza/flow-builder 20.3.2 → 20.3.4

package/index.d.ts

@@ -13,8 +13,13 @@ import { EFMarkerType, EFConnectableSide } from '@foblex/flow';
  *  - gli enum sono stringhe, ma i tipi sono aperti (`| string`) perche' gli elenchi
  *    autoritativi arrivano da `GET /flows/dictionaries` e possono crescere (§13.11).
  */
-/** §4.2 — i sette tipi del sistema. Aperto: il dizionario `dataTypes` e' autoritativo. */
-type FlowDataType = 'String' | 'Integer' | 'Number' | 'Date' | 'Boolean' | 'Enum' | 'Object' | string;
+/**
+ * §4.2 — gli otto tipi del sistema. Aperto: il dizionario `dataTypes` e' autoritativo.
+ *
+ * `Structure` non e' un doppione di `Object` (§4.7): di un `Object` non record il flow non sa
+ * nulla oltre a trasportarlo, di una `Structure` legge e scrive i **membri**.
+ */
+type FlowDataType = 'String' | 'Integer' | 'Number' | 'Date' | 'Boolean' | 'Enum' | 'Object' | 'Structure' | string;
 type FlowProcessType = 'Screen' | 'AutoLaunched' | 'Evaluation' | 'Orchestration' | string;
 type FlowVersionStatus = 'Draft' | 'InvalidDraft' | 'UnderReview' | 'Active' | 'Obsolete' | string;
 type FlowTriggerType = 'None' | 'RecordBeforeSave' | 'RecordAfterSave' | 'RecordBeforeDelete' | 'Scheduled' | 'Event' | string;
@@ -28,6 +33,9 @@ type FlowTransactionModel = 'Automatic' | 'CurrentTransaction' | 'NewTransaction
  * §4.2 — un riferimento **oppure** un valore letterale.
  * Va valorizzato **uno e un solo** campo; `formulaExpression` e' l'unica eccezione
  * (espressione + tipo atteso). Piu' campi insieme = `VALUE_AMBIGUOUS`.
+ *
+ * Non esiste un `structureValue` e non ci sara' (§4.7): un'istanza di classe nasce dal runtime
+ * e nel metadata si cita solo per riferimento, come un record.
  */
 interface FlowValue {
     elementReference?: string;
@@ -98,7 +106,11 @@ interface FlowVariable {
     name?: string;
     description?: string;
     dataType?: FlowDataType;
-    /** Obbligatorio per `Object` ed `Enum`: nome dell'entita' o del tipo di enum. */
+    /**
+     * Obbligatorio per `Object`, `Enum` e `Structure`: nome dell'entita', del tipo di enum o
+     * della classe. Su una `Structure` la sua assenza e' un **errore** (`OBJECT_TYPE_MISSING`),
+     * non un avviso: senza il nome della classe il runtime non ha nulla da istanziare (§4.7).
+     */
     objectType?: string;
     isCollection?: boolean;
     isInput?: boolean;
@@ -348,6 +360,10 @@ interface FlowCustomError extends FlowNodeBase {
 /** §5.12 */
 interface FlowTransformValueAction {
     transformType?: FlowTransformType;
+    /**
+     * Il campo di destinazione, oppure — se il target e' una `Structure` — il nome del
+     * **membro** della classe (§5.12, §4.7).
+     */
     outputFieldApiName?: string;
     value?: FlowValue;
     inputParameters?: FlowInputParameter[];
@@ -539,10 +555,19 @@ interface FlowDictionaryEntry {
 }
 interface FlowDataTypeEntry extends FlowDictionaryEntry {
     value: FlowDataType;
-    /** `Object` ed `Enum` richiedono `objectType` (§4.6). */
+    /**
+     * `Object`, `Enum` e `Structure` richiedono `objectType` (§4.6). Su una `Structure` la sua
+     * assenza e' un errore e non un avviso: vedi {@link isStructure} e §4.7.
+     */
     requiresObjectType?: boolean;
     /** `scale` si applica solo ai numerici (§4.6). */
     supportsScale?: boolean;
+    /**
+     * §4.7 — il tipo e' un'istanza di classe: `objectType` porta il nome della classe, i valori
+     * proponibili arrivano da `listStructures()` e i suoi **membri** da
+     * `describeStructure()`. Non ha una forma letterale con cui esprimersi.
+     */
+    isStructure?: boolean;
 }
 /** §3.2 — la voce che descrive un tipo di elemento. */
 interface FlowElementTypeEntry extends FlowDictionaryEntry {
@@ -658,20 +683,69 @@ interface FlowFieldDescription {
     label?: string | null;
     dataType?: FlowDataType;
     objectType?: string | null;
+    /**
+     * `false` → non si puo' filtrare su questo campo. Non e' un dettaglio: la chiave di
+     * un'entita' con chiave composta puo' essere **non filtrabile** (porta la forma canonica
+     * della chiave), e il filtro «per identificativo» va scritto una colonna alla volta (§5.7).
+     */
     isFilterable?: boolean;
     isSortable?: boolean;
+    /** Aggiornabile da un Update: altrimenti `FIELD_NOT_UPDATEABLE` (§5.7). */
     isUpdateable?: boolean;
+    /**
+     * Valorizzabile da un Create: altrimenti `FIELD_NOT_CREATEABLE` (§5.7). **Non** e' lo stesso
+     * insieme di `isUpdateable` — la colonna di una chiave naturale la scrive chi crea il record
+     * e non si cambia dopo, un identificativo generato dal database e' l'opposto.
+     */
+    isCreateable?: boolean;
     isRequired?: boolean;
     /** `true` → i valori ammessi si chiedono a `.../fields/{field}/values`. */
     hasClosedValueSet?: boolean;
 }
-/** `any` | `filterable` | `sortable` | `updateable` (§6.4). */
-type FlowFieldUsage = 'any' | 'filterable' | 'sortable' | 'updateable';
+/** `any` | `filterable` | `sortable` | `updateable` | `createable` (§6.4). */
+type FlowFieldUsage = 'any' | 'filterable' | 'sortable' | 'updateable' | 'createable';
 interface FlowFieldValue {
     value: string;
     label?: string | null;
 }
-/** Voce di catalogo per action, script, form, eventi, tipi di enum. */
+/**
+ * §4.7 — un membro di una classe utilizzabile come `Structure`.
+ *
+ * È l'analogo di {@link FlowFieldDescription} per le classi, e la colonna che conta e'
+ * `isWritable`: un membro calcolato (una property senza setter) si legge in una condizione ma
+ * assegnarlo e' `TARGET_NOT_WRITABLE`. Nei campi che chiedono una **destinazione** si propongono
+ * quindi solo i membri scrivibili.
+ */
+interface FlowStructureMember {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+    dataType?: FlowDataType;
+    isCollection?: boolean;
+    /** Per un membro `Object`, `Enum` o `Structure`: l'entita', l'enum o la classe annidata. */
+    objectType?: string | null;
+    isWritable?: boolean;
+}
+/**
+ * §4.7.1 — la risposta di `GET /catalog/structures/{className}/members`: **non** un array di
+ * membri, ma la descrizione della classe con l'array sotto `members`.
+ *
+ * L'involucro porta la `label` della classe, che l'array nudo perderebbe e che serve
+ * all'intestazione dell'elenco dei membri; `className` e' ridondante rispetto al path e rende la
+ * risposta autoconsistente se finisce in cache. `members` e' **piatto e non ricorsivo**: un membro
+ * di tipo `Structure` porta la classe annidata in `objectType` e i suoi membri sono una seconda
+ * chiamata, altrimenti una classe che si referenzia renderebbe la risposta infinita.
+ */
+interface FlowStructureDescription {
+    className?: string;
+    label?: string | null;
+    /**
+     * Vuoto significa **membri non dichiarati**, non "classe inesistente": quella e' un 404, e le
+     * due cose portano a comportamenti opposti (digitare a mano contro segnalare la classe).
+     */
+    members?: FlowStructureMember[];
+}
+/** Voce di catalogo per action, script, form, eventi, tipi di enum, classi. */
 interface FlowCatalogEntry {
     name: string;
     label?: string | null;
@@ -852,10 +926,35 @@ type FlowInterviewStatus = 'Completed' | 'WaitingForScreen' | 'Paused' | 'Suspen
 /** I criteri dello Start non erano soddisfatti: non e' un errore (§6.5). */
  | 'NotStarted' | string;
 type FlowScreenNavigation = 'Next' | 'Previous' | 'Pause' | 'Finish' | string;
-/** Il tipo dichiarato **vince** in lettura: distingue `Integer` da `Number` (§6.5). */
+/** §6.5 — un record dentro un valore tipizzato: forma propria, non `value`. */
+interface FlowRecordValue {
+    objectType?: string;
+    id?: string | null;
+    fields?: Record<string, unknown>;
+}
+/**
+ * §4.7, §6.5 — un'istanza di classe: `className` piu' i **membri**, ognuno a sua volta un
+ * valore tipizzato. È la stessa forma in lettura e in scrittura: passando un'istanza come input
+ * si scrive `className` e i soli membri che si vogliono valorizzare.
+ */
+interface FlowStructureInstance {
+    className?: string;
+    members?: Record<string, FlowTypedValue>;
+}
+/**
+ * Il tipo dichiarato **vince** in lettura: distingue `Integer` da `Number` (§6.5).
+ *
+ * Due tipi hanno una forma propria invece di `value`: un record (`record`) e un'istanza di
+ * classe (`instance`). Chi legge guarda `type` e poi il campo giusto — un `Structure` con
+ * `value` valorizzato non esiste.
+ */
 interface FlowTypedValue {
     type?: FlowDataType;
     value?: unknown;
+    /** Con `type: 'Object'` su un record (§6.5). */
+    record?: FlowRecordValue;
+    /** Con `type: 'Structure'` (§4.7). */
+    instance?: FlowStructureInstance;
 }
 interface FlowPendingScreen {
     elementName?: string;
@@ -975,7 +1074,15 @@ type FlowErrorCategory =
 /** Qualcun altro ha salvato: proponi ricarica (§9). */
  | 'VersionConflict'
 /** Funzione non configurata su questo ambiente: disabilita il comando. */
- | 'MissingService' | 'InvalidToken' | 'InterviewNotFound'
+ | 'MissingService'
+/**
+ * §4.7.1 — classe non registrata (o `IStructureMgr` assente sull'host): il 404 dei membri di
+ * una classe. **Non e' una lista vuota**: quella dice "membri non dichiarati" e lascia
+ * digitare il nome, questa dice "classe sconosciuta" e va segnalata sulla risorsa
+ * (`STRUCTURE_TYPE_UNKNOWN`). Categoria propria perche' altrimenti un 404 ricadrebbe su
+ * `FlowNotFound`, che qui vorrebbe dire una cosa diversa e falsa.
+ */
+ | 'StructureNotFound' | 'InvalidToken' | 'InterviewNotFound'
 /** Fallback per un errore di trasporto non categorizzato. */
  | 'Unknown' | string;
 /** L'errore che ogni primitiva puo' rifiutare (§6, §10). */
@@ -1121,6 +1228,38 @@ declare abstract class FlowBuilderApi {
     abstract listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     /** `GET /catalog/enum-types` — per `objectType` delle risorse `Enum`. */
     abstract listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    /**
+     * `GET /catalog/structures` — le classi utilizzabili come `objectType` di una risorsa
+     * `Structure` (§4.7). È un **elenco di classi** nella forma di ogni altro catalogo: i membri
+     * non ci sono, si chiedono con {@link describeStructure} (§4.7.1).
+     *
+     * Opzionale di proposito: un ambiente che non la espone non deve rompersi. L'effetto e' che le
+     * classi non sono verificabili — elenco vuoto significa "non lo so", non "nessuna" — e il nome
+     * si scrive a mano, esattamente come per un catalogo non popolato (§7).
+     */
+    listStructures(): Promise<FlowCatalogEntry[]>;
+    /**
+     * `GET /catalog/structures/{className}/members` — la **descrizione** di una classe: l'analogo di
+     * `listFields` per le `Structure` (§4.7). Si chiama `describeStructure` e non
+     * `listStructureMembers` perche' la risposta non e' un elenco: e' un oggetto con `className`,
+     * `label` e l'array sotto `members` (§4.7.1, `IStructureMgr.DescribeStructure`).
+     *
+     * `members` e' **piatto**: nessuna paginazione e **nessun membro annidato** — un membro di tipo
+     * `Structure` porta la classe in `objectType` e i suoi membri si chiedono con una seconda
+     * chiamata. La risposta e' non ricorsiva di proposito: una classe che si referenzia sarebbe
+     * infinita.
+     *
+     * `isWritable` e' la colonna che decide: nei campi che chiedono una **destinazione** si
+     * propongono solo i membri scrivibili, perche' un membro calcolato si legge ma assegnarlo e'
+     * `TARGET_NOT_WRITABLE`.
+     *
+     * **Tre esiti, non due** (§4.7.1): `members` popolato e' un elenco **autorevole** (fuori
+     * elenco = `STRUCTURE_MEMBER_UNKNOWN`); `members` **vuoto** dice "membri non dichiarati" e il
+     * nome del membro va lasciato digitare; un rifiuto `StructureNotFound` dice "classe non
+     * registrata", ed e' la classe che va segnalata, non il membro. Chi implementa l'interfaccia
+     * non deve appiattire il rifiuto in una descrizione vuota: sono cose diverse.
+     */
+    describeStructure(className: string): Promise<FlowStructureDescription>;
     /** `GET /catalog/events` — per gli eventi di un Wait. */
     abstract listEvents(): Promise<FlowCatalogEntry[]>;
     /**
@@ -1217,6 +1356,18 @@ declare class HttpFlowBuilderApi extends FlowBuilderApi {
     listForms(): Promise<FlowCatalogEntry[]>;
     listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    /** §4.7.1 — solo l'elenco delle classi: i membri **non** ci sono, si chiedono a parte. */
+    listStructures(): Promise<FlowCatalogEntry[]>;
+    /**
+     * §4.7.1 — la descrizione della classe: `className`, `label` e i membri sotto `members`. Non e'
+     * un array nudo, e leggerlo come tale darebbe zero membri senza un errore.
+     *
+     * Il 404 non e' `members: []`, e qui e' l'unico posto che lo sappia: senza questa traduzione
+     * ricadrebbe su `FlowNotFound` («il flow non esiste piu’»), che sarebbe falso e indistinguibile
+     * da "membri non dichiarati". Diventa `StructureNotFound`, e chi chiama decide: classe
+     * sconosciuta = segnalare, lista vuota = lasciar digitare.
+     */
+    describeStructure(className: string): Promise<FlowStructureDescription>;
     listEvents(): Promise<FlowCatalogEntry[]>;
     listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
     startInterview(request: FlowStartInterviewRequest): Promise<FlowInterviewResult>;
@@ -1294,10 +1445,45 @@ declare const TYPES_WITH_AUTOMATIC_OUTPUT: ReadonlySet<string>;
  */
 declare const FLOW_ELEMENT_ICONS: Record<string, string>;
 /**
- * Il glifo del tipo. Per un tipo che il dizionario del backend aggiunge e questa mappa non
- * conosce, l'iniziale dell'etichetta e' un segnaposto migliore di un simbolo generico.
+ * Il glifo delle varianti (§5.5): due voci di palette dello stesso tipo con lo stesso simbolo
+ * si distinguerebbero solo dall'etichetta, e sulla palette il simbolo e' la prima cosa che si
+ * guarda. La chiave e' `tipo:variante`.
+ */
+declare const FLOW_ELEMENT_VARIANT_ICONS: Record<string, string>;
+/**
+ * Il glifo del tipo, o della sua variante quando c'e'. Per un tipo che il dizionario del
+ * backend aggiunge e questa mappa non conosce, l'iniziale dell'etichetta e' un segnaposto
+ * migliore di un simbolo generico.
+ */
+declare function elementIcon(type: string, label?: string, variant?: string): string;
+
+/**
+ * I tipi che sulla palette valgono per **piu' di una voce** — FRONTEND.md §5.5.
+ *
+ * Il Collection Processor e' un solo tipo di node con un discriminatore
+ * (`collectionProcessorType`: `Sort` o `Filter`), e i campi rilevanti cambiano con esso: un
+ * `Sort` vuole `sortOptions`, un `Filter` vuole condizioni. Sono due gesti diversi, e una
+ * voce sola («ordina o filtra») costringe a scegliere dopo, dentro il form.
+ *
+ * Qui sta **solo** la mappa tipo → campo del discriminatore: i valori ammessi restano nel
+ * dizionario del backend (`collectionProcessorTypes`), come per ogni altro enum (§6.4). Senza
+ * quel dizionario il tipo torna a essere una voce sola, che e' il comportamento giusto quando
+ * non si sa quali varianti esistano.
+ *
+ * Se un tipo nuovo arrivasse con lo stesso schema — un node con un discriminatore che ne
+ * cambia i campi — si aggiunge una riga qui e la palette si divide da se'.
+ */
+/** Tipo di elemento → campo del node che porta la variante. */
+declare const FLOW_ELEMENT_VARIANT_FIELDS: Record<string, string>;
+/** Il campo del discriminatore, se il tipo ne ha uno. */
+declare function variantFieldOf(type: string): string | undefined;
+/** La variante di un node già scritto, letta dal suo discriminatore. */
+declare function variantOf(type: string, node: Record<string, unknown>): string | undefined;
+/**
+ * I campi da scrivere su un node appena creato dalla variante scelta. Vuoto per i tipi senza
+ * varianti: chi crea l'elemento non deve sapere quali sono.
  */
-declare function elementIcon(type: string, label?: string): string;
+declare function variantPresetOf(type: string, variant: string | undefined): Record<string, unknown>;
 
 /**
  * Nomi — FRONTEND.md §3.3, §13.5.
@@ -1634,6 +1820,15 @@ declare class FlowDictionaryStore {
     /** Le categorie della palette, nell'ordine di prima apparizione nel dizionario. */
     readonly paletteCategories: _angular_core.Signal<string[]>;
     elementType(value: string): FlowElementTypeEntry | undefined;
+    /**
+     * Le varianti di un tipo, cioe' i valori del suo discriminatore (§5.5). L'unico oggi e' il
+     * Collection Processor. Elenco vuoto = tipo senza varianti, **oppure** dizionario non
+     * disponibile: in entrambi i casi la palette mostra una voce sola, che e' l'unica cosa
+     * onesta da fare quando non si sa quali varianti esistano.
+     */
+    variantsOf(type: string): FlowDictionaryEntry[];
+    /** L'etichetta di una variante, con fallback sul valore grezzo. */
+    variantLabelOf(type: string, variant: string | undefined): string;
     /** La collection in cui scrivere un node: `metadataProperty`, con fallback locale (§3.2). */
     collectionOf(type: string): FlowNodeCollection | undefined;
     /** Etichetta di un tipo, con fallback: un tipo sconosciuto mostra il proprio `value`. */
@@ -1673,13 +1868,48 @@ declare class FlowDictionaryStore {
     /** `stepInteractive` e `stepApproval` vogliono gli assegnatari (§5.13). */
     stageStepRequiresAssignees(actionType: string | undefined | null): boolean;
     dataType(value: string | undefined | null): FlowDataTypeEntry | undefined;
-    /** §4.6 — `Object` ed `Enum` richiedono `objectType`. */
+    /** §4.6, §4.7 — `Object`, `Enum` e `Structure` richiedono `objectType`. */
     requiresObjectType(dataType: string | undefined | null): boolean;
+    /**
+     * §4.7 — il tipo e' un'istanza di classe. Il flag arriva dal dizionario (`isStructure`); il
+     * fallback sul nome serve solo se il backend non lo dichiara.
+     */
+    isStructure(dataType: string | undefined | null): boolean;
+    /**
+     * §4.7 — su una `Structure` un `objectType` mancante **blocca l'attivazione**: e' un errore
+     * (`OBJECT_TYPE_MISSING`), non un avviso, perche' il runtime non ha nulla da istanziare. La
+     * differenza serve all'interfaccia, che deve mostrare i due casi con colori diversi.
+     */
+    objectTypeIsError(dataType: string | undefined | null): boolean;
     /** §4.6 — `scale` si applica solo ai numerici. */
     supportsScale(dataType: string | undefined | null): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowDictionaryStore, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDictionaryStore>;
 }
+/**
+ * §4.7.1 — la descrizione di una classe come la vede la UI: i membri, la `label` della classe che
+ * arriva dall'involucro della risposta, e l'**esito**, che ha **tre** casi da non confondere:
+ *
+ *  - `declared`: elenco **autorevole**. Si propongono solo questi, e un membro fuori elenco e'
+ *    `STRUCTURE_MEMBER_UNKNOWN`.
+ *  - `undeclared`: la classe e' valida ma `members` e' vuoto — i membri non sono dichiarati (un
+ *    host con `IStructureMgr` a registro esplicito). Tendina vuota, nome del membro
+ *    **digitabile**, e nessuna accusa: non si sa, non e' "sbagliato".
+ *  - `unknown-class`: 404, la classe non e' registrata. Non si propone e non si digita niente di
+ *    utile: e' la **classe** a essere segnalata (`STRUCTURE_TYPE_UNKNOWN`), una volta sulla
+ *    risorsa e non a ogni riferimento.
+ *  - `unknown-catalog`: la primitiva non c'e' o la richiesta e' fallita. Come `undeclared` per
+ *    la UI, ma per un motivo diverso, e non dice nulla sulla classe.
+ *
+ * Trattare il 404 come "nessun membro" farebbe digitare membri che il runtime rifiutera';
+ * trattare `members: []` come un 404 renderebbe inutilizzabile una classe perfettamente valida.
+ */
+interface FlowStructureDescribed {
+    status: 'declared' | 'undeclared' | 'unknown-class' | 'unknown-catalog';
+    members: FlowStructureMember[];
+    /** La `label` della classe, quando la descrizione l'ha portata: `null` = ricadi sul nome. */
+    label?: string | null;
+}
 declare class FlowCatalogStore {
     private readonly api;
     private readonly objectsCache;
@@ -1687,6 +1917,7 @@ declare class FlowCatalogStore {
     private readonly fieldValuesCache;
     private readonly entriesCache;
     private readonly parametersCache;
+    private readonly membersCache;
     /**
      * Una lista vuota significa "non lo so", non "nessuno": con il catalogo non popolato la
      * validazione salta i controlli invece di produrre falsi allarmi (§7). L'editor fa lo
@@ -1706,6 +1937,22 @@ declare class FlowCatalogStore {
     listForms(): Promise<FlowCatalogEntry[]>;
     listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    /**
+     * §4.7 — le classi utilizzabili come `objectType` di una `Structure`. La primitiva e'
+     * opzionale: se l'ambiente non la espone, l'errore non si memoizza e l'elenco resta vuoto —
+     * che significa "non lo so", e il nome della classe si scrive a mano.
+     */
+    listStructures(): Promise<FlowCatalogEntry[]>;
+    /**
+     * §4.7.1 — la descrizione di una classe, **con l'esito**: sono tre e non due, e appiattirli in
+     * una lista vuota perde l'informazione che serve alla UI. Vedi {@link FlowStructureDescribed}.
+     */
+    describeStructure(className: string): Promise<FlowStructureDescribed>;
+    /**
+     * §4.7 — i soli membri, per chi non deve distinguere gli esiti. Chi mostra un avviso o accusa
+     * un membro usa {@link describeStructure}: qui una lista vuota e' ambigua per costruzione.
+     */
+    listStructureMembers(className: string): Promise<FlowStructureMember[]>;
     listEvents(): Promise<FlowCatalogEntry[]>;
     /** Da chiamare se lo schema cambia sotto i piedi (raro, ma il comando esiste). */
     clear(): void;
@@ -2018,6 +2265,8 @@ declare class FlowCanvasComponent {
     /** Rilascio di un elemento dalla palette: tipo + punto nel sistema del canvas. */
     readonly elementDropped: _angular_core.OutputEmitterRef<{
         type: FlowElementType;
+        /** La variante scelta sulla palette, dove il tipo ne ha (§5.5). */
+        variant?: string;
         x: number;
         y: number;
     }>;
@@ -2068,7 +2317,11 @@ declare class FlowCanvasComponent {
     onDeleteSelected(event: {
         nodeIds: string[];
     }): void;
-    /** Rilascio di un elemento trascinato dalla palette. */
+    /**
+     * Rilascio di un elemento trascinato dalla palette. Il dato e' `{type, variant}`, ma si
+     * accetta ancora la stringa nuda: un ospite che monta il canvas con una palette propria
+     * potrebbe passare il solo tipo.
+     */
     onCreateNode(event: {
         data: unknown;
         externalItemRect: {
@@ -2094,9 +2347,27 @@ declare class FlowCanvasComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
 }
 
+/** Il gesto scelto sulla palette: un tipo e, dove esiste, la sua variante (§5.5). */
+interface FlowPalettePick {
+    type: FlowElementType;
+    variant?: string;
+}
+/**
+ * Una voce della palette. Non coincide con una voce del dizionario: un tipo con varianti ne
+ * produce una per variante, perche' «ordina» e «filtra» sono due gesti diversi anche se il
+ * modello li scrive nello stesso node.
+ */
+interface PaletteItem {
+    /** Chiave stabile della voce: serve al `track` e all'id del trascinamento. */
+    key: string;
+    entry: FlowElementTypeEntry;
+    variant?: string;
+    label: string;
+    data: FlowPalettePick;
+}
 interface PaletteGroup {
     category: string;
-    entries: FlowElementTypeEntry[];
+    items: PaletteItem[];
 }
 declare class ElementPaletteComponent {
     private readonly dictionaries;
@@ -2106,23 +2377,29 @@ declare class ElementPaletteComponent {
      * prima che l'utente lo scopra dal pannello dei problemi.
      */
     readonly processType: _angular_core.InputSignal<string | undefined>;
-    readonly elementPicked: _angular_core.OutputEmitterRef<string>;
+    readonly elementPicked: _angular_core.OutputEmitterRef<FlowPalettePick>;
     private readonly filter;
+    /** Le voci, con i tipi a varianti già divisi: e' l'elenco che l'utente vede. */
+    private readonly items;
     readonly groups: _angular_core.Signal<PaletteGroup[]>;
     readonly isEmpty: _angular_core.Signal<boolean>;
     onFilter(value: string): void;
-    pick(entry: FlowElementTypeEntry): void;
+    pick(item: PaletteItem): void;
     /** Uno screen in un flow che non mostra nulla: si segnala, non si nasconde (§3.1). */
-    isIncompatible(entry: FlowElementTypeEntry): boolean;
-    incompatibleHint(entry: FlowElementTypeEntry): string | null;
+    isIncompatible(item: PaletteItem): boolean;
+    /**
+     * Il testo del tooltip. Su una voce che nasce da una variante ci va anche il nome del tipo:
+     * e' l'unico posto in cui si vede che «ordina» e «filtra» sono lo stesso elemento.
+     */
+    hintOf(item: PaletteItem): string;
     /** Lo stesso glifo che l'elemento avra' sul canvas, così il trascinamento e' prevedibile. */
-    iconOf(entry: FlowElementTypeEntry): string;
+    iconOf(item: PaletteItem): string;
     /**
      * L'etichetta del ramo di fault, presa dalla mappa delle uscite invece di scrivere «ramo di
      * errore» per tutti: su uno stage di orchestrazione quel ramo **non** e' un guasto, e' lo step
      * rifiutato (§5.13). Un tipo nuovo eredita l'etichetta giusta senza toccare la palette.
      */
-    faultLabel(entry: FlowElementTypeEntry): string | null;
+    faultLabel(item: PaletteItem): string | null;
     categoryClass(category: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementPaletteComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementPaletteComponent, "fb-element-palette", never, { "processType": { "alias": "processType"; "required": false; "isSignal": true; }; }, { "elementPicked": "elementPicked"; }, never, never, true, never>;
@@ -2132,6 +2409,7 @@ declare class ReferencePickerComponent {
     private readonly api;
     private readonly store;
     private readonly dictionaries;
+    private readonly catalog;
     readonly value: _angular_core.InputSignal<string | undefined>;
     readonly label: _angular_core.InputSignal<string>;
     readonly placeholder: _angular_core.InputSignal<string>;
@@ -2157,6 +2435,14 @@ declare class ReferencePickerComponent {
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     readonly query: _angular_core.WritableSignal<string>;
     constructor();
+    /**
+     * §4.7 — la risorsa `Structure` da cui il valore corrente sta navigando, se c'e'. È quella
+     * che rende i membri proponibili: senza classe non c'e' catalogo da interrogare.
+     */
+    readonly structureRoot: _angular_core.Signal<FlowReference | undefined>;
+    private readonly members;
+    /** I membri come riferimenti navigati: `Richiesta.Ragione`, col tipo del membro. */
+    private readonly memberReferences;
     readonly options: _angular_core.Signal<FlowReference[]>;
     /** Le opzioni raggruppate per `kind`, così gli output automatici si distinguono. */
     readonly groups: _angular_core.Signal<{
@@ -2172,12 +2458,19 @@ declare class ReferencePickerComponent {
      *    output automatico navigato): la validazione non verifica i percorsi con il punto,
      *    quindi si accetta senza segnalare;
      *  - `host`: scope del sistema ospite che **non dichiara percorsi**: non verificabile (§4.1);
+     *  - `member`: membro di una classe, esistente: qui il percorso **e'** verificato (§4.7);
+     *  - `memberUnknown`: la radice e' una `Structure` ma il membro non c'e': e'
+     *    `STRUCTURE_MEMBER_UNKNOWN`, e a differenza di un campo di record si sa per certo;
+     *  - `memberNotWritable`: il membro esiste, e' calcolato, e questo campo vuole una
+     *    destinazione: `TARGET_NOT_WRITABLE`;
      *  - `unknown`: nessuna corrispondenza: si avvisa, senza bloccare. Ci finisce anche il
      *    percorso inesistente di uno scope che i percorsi li dichiara, perche' lì il backend
      *    risponderebbe `GLOBAL_UNKNOWN`.
      */
-    readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "unknown">;
+    readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "member" | "memberUnknown" | "memberNotWritable" | "unknown">;
     readonly hint: _angular_core.Signal<string | null>;
+    /** I due stati che sono errori e non avvisi: il colore deve dirlo. */
+    readonly isHintError: _angular_core.Signal<boolean>;
     readonly errorMessage: _angular_core.Signal<string | null>;
     open(): void;
     close(): void;
@@ -2255,7 +2548,7 @@ declare class FieldPickerComponent {
     readonly isRelationPath: _angular_core.Signal<boolean>;
     readonly isUnknown: _angular_core.Signal<boolean>;
     /** L'avviso dipende dall'uso: un campo puo' esistere e non essere filtrabile. */
-    readonly unknownMessage: _angular_core.Signal<"Questo campo non e’ fra quelli filtrabili dell’oggetto." | "Questo campo non e’ fra quelli su cui si puo’ ordinare." | "Questo campo non e’ fra quelli aggiornabili dell’oggetto." | "Questo campo non e’ fra quelli dell’oggetto.">;
+    readonly unknownMessage: _angular_core.Signal<"Questo campo non e’ fra quelli filtrabili dell’oggetto." | "Questo campo non e’ fra quelli su cui si puo’ ordinare." | "Questo campo non e’ fra quelli aggiornabili dell’oggetto." | "Questo campo non e’ fra quelli valorizzabili alla creazione." | "Questo campo non e’ fra quelli dell’oggetto.">;
     readonly describeValue: _angular_core.Signal<string | null>;
     readonly loadErrored: _angular_core.Signal<boolean>;
     open(): void;
@@ -2282,6 +2575,12 @@ declare class NamePickerComponent {
     readonly disabled: _angular_core.InputSignal<boolean>;
     /** Il testo dell'avviso sul nome fuori elenco: dipende da cosa si sta scegliendo. */
     readonly unknownMessage: _angular_core.InputSignal<string>;
+    /**
+     * La gravita' dell'avviso. Non e' cosmetica: un'action o un form che non esistono sono
+     * **errori** che bloccano l'attivazione (`ACTION_UNKNOWN`, `FORM_UNKNOWN`), mentre un flow
+     * senza versione attiva e' un avviso. Mostrarli con lo stesso colore direbbe il falso.
+     */
+    readonly unknownSeverity: _angular_core.InputSignal<"error" | "warn">;
     /** Cosa dire quando l'elenco e' vuoto: e' il caso "non lo so", non un errore. */
     readonly emptyMessage: _angular_core.InputSignal<string>;
     /** Testo monospazio: i nomi tecnici si leggono meglio, ed e' come li mostra il resto del form. */
@@ -2303,7 +2602,86 @@ declare class NamePickerComponent {
     clear(): void;
     describe(option: NamePickerOption): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NamePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NamePickerComponent, "fb-name-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "unknownMessage": { "alias": "unknownMessage"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "isMono": { "alias": "isMono"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NamePickerComponent, "fb-name-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "unknownMessage": { "alias": "unknownMessage"; "required": false; "isSignal": true; }; "unknownSeverity": { "alias": "unknownSeverity"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "isMono": { "alias": "isMono"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class StructurePickerComponent {
+    private readonly catalog;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
+    private readonly structures;
+    constructor();
+    readonly options: _angular_core.Signal<NamePickerOption[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StructurePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StructurePickerComponent, "fb-structure-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/** `any` per un membro da leggere, `writable` per una destinazione. */
+type StructureMemberUsage = 'any' | 'writable';
+declare class StructureMemberPickerComponent {
+    private readonly catalog;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** La classe di cui elencare i membri: senza classe non c'e' catalogo. */
+    readonly className: _angular_core.InputSignal<string | undefined>;
+    readonly usage: _angular_core.InputSignal<StructureMemberUsage>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
+    /**
+     * §4.7.1 — non basta l'elenco: serve l'**esito**. Elenco vuoto perche' i membri non sono
+     * dichiarati (si digita a mano) e classe non registrata (non c'e' niente da digitare) hanno
+     * la stessa lista e messaggi opposti.
+     */
+    private readonly result;
+    private readonly members;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /** Il testo digitato mentre il pannello e' aperto: filtra l'elenco. */
+    private readonly query;
+    constructor();
+    readonly text: _angular_core.Signal<string>;
+    /** Con `usage="writable"` i membri di sola lettura non si propongono affatto. */
+    readonly available: _angular_core.Signal<FlowStructureMember[]>;
+    readonly options: _angular_core.Signal<FlowStructureMember[]>;
+    /**
+     * Come chiamare la classe: la `label` la porta l'involucro della descrizione, ed e' il motivo
+     * per cui l'involucro esiste (§4.7.1). Assente, si mostra il nome della classe.
+     */
+    readonly classLabel: _angular_core.Signal<string>;
+    /** Elenco autorevole: solo qui un membro fuori elenco e' un errore (§4.7.1). */
+    readonly hasCatalog: _angular_core.Signal<boolean>;
+    /** 404: la classe non e' registrata. Il nome del membro non c'e' modo di indovinarlo. */
+    readonly isClassUnknown: _angular_core.Signal<boolean>;
+    /** Classe valida, membri non dichiarati: si digita, e non si segnala niente. */
+    readonly isUndeclared: _angular_core.Signal<boolean>;
+    /** Il primo segmento: e' l'unico che si puo' verificare (§4.7). */
+    private readonly firstSegment;
+    /** `true` se il valore naviga dentro un membro: oltre il primo segmento non si verifica. */
+    readonly isNestedPath: _angular_core.Signal<boolean>;
+    private readonly declared;
+    readonly isUnknown: _angular_core.Signal<boolean>;
+    /** Il messaggio elenca i disponibili: dire solo "non esiste" non aiuta a correggere. */
+    readonly unknownMessage: _angular_core.Signal<string>;
+    /**
+     * Un membro che esiste ma non e' scrivibile, scelto dove serve una destinazione: capita su un
+     * documento scritto altrove, e va detto qui invece di lasciarlo scoprire dall'attivazione.
+     */
+    readonly isNotWritable: _angular_core.Signal<boolean>;
+    readonly describeValue: _angular_core.Signal<string | null>;
+    /** Catalogo assente per un motivo che non riguarda la classe: "non lo so". */
+    readonly loadErrored: _angular_core.Signal<boolean>;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    onInput(text: string): void;
+    choose(member: FlowStructureMember): void;
+    clear(): void;
+    describe(member: FlowStructureMember): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StructureMemberPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StructureMemberPickerComponent, "fb-structure-member-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "usage": { "alias": "usage"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 /** Le modalita' offerte: una per campo del modello. */
@@ -2329,13 +2707,19 @@ declare class ValueEditorComponent {
      */
     readonly filledFieldCount: _angular_core.Signal<number>;
     readonly isAmbiguous: _angular_core.Signal<boolean>;
-    /** Il campo del valore che corrisponde al `dataType` (§4.2, tabella dei sette tipi). */
+    /**
+     * Il campo del valore che corrisponde al `dataType` (§4.2, tabella degli otto tipi). `Object` e
+     * `Structure` non ci sono: si passano per riferimento, e {@link literalAllowed} li esclude.
+     */
     readonly literalField: _angular_core.Signal<keyof FlowValue>;
     /**
      * `Object` non ha un campo letterale: un record si passa per riferimento (§4.2).
-     * Lo stesso vale per una collection.
+     * Lo stesso vale per una collection e per una `Structure`, che non ha un `structureValue` e
+     * non lo avra': un'istanza nasce dal runtime e nel metadata si cita per riferimento (§4.7).
      */
     readonly literalAllowed: _angular_core.Signal<boolean>;
+    /** §4.7 — la destinazione e' un'istanza di classe: si passa per riferimento e basta. */
+    readonly isStructureTarget: _angular_core.Signal<boolean>;
     readonly literalInputType: _angular_core.Signal<string>;
     readonly literalText: _angular_core.Signal<string>;
     readonly booleanValue: _angular_core.Signal<boolean>;
@@ -2407,7 +2791,7 @@ declare class ConditionEditorComponent {
      */
     hasTypeMismatch(condition: FlowCondition): boolean;
     typeMismatchMessage(condition: FlowCondition): string;
-    readonly logicMode: _angular_core.Signal<"and" | "or" | "custom" | "formula">;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
     readonly customLogic: _angular_core.Signal<string>;
     /** Feedback immediato sull'espressione: la verita' resta della validazione backend. */
     readonly customLogicError: _angular_core.Signal<string | null>;
@@ -2475,13 +2859,21 @@ declare class RecordFilterEditorComponent {
      * (§5.7, §13.10).
      */
     readonly emptyWarning: _angular_core.InputSignal<string | null>;
-    readonly emptyWarningSeverity: _angular_core.InputSignal<"warn" | "error">;
+    readonly emptyWarningSeverity: _angular_core.InputSignal<"error" | "warn">;
     readonly changed: _angular_core.OutputEmitterRef<(holder: FilterHolder) => void>;
     private readonly fields;
+    /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.7). */
+    private readonly allFields;
     readonly filters: _angular_core.Signal<FlowRecordFilter[]>;
     readonly operators: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
     constructor();
-    readonly logicMode: _angular_core.Signal<"and" | "or" | "custom" | "formula">;
+    /**
+     * §5.7 — l'identificativo esiste ma **non e' filtrabile**: e' il caso di una chiave composta,
+     * dove `Id` porta la forma canonica della chiave e le colonne filtrabili sono altre. Dirlo
+     * evita la ricerca di un campo che nell'elenco non c'e' e non ci sara'.
+     */
+    readonly identifierNotFilterable: _angular_core.Signal<boolean>;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
     readonly customLogic: _angular_core.Signal<string>;
     readonly showEmptyWarning: _angular_core.Signal<boolean>;
     addFilter(): void;
@@ -2525,11 +2917,18 @@ declare class ParameterEditorComponent {
     readonly hasCatalog: _angular_core.Signal<boolean>;
     readonly inputCatalog: _angular_core.Signal<FlowCatalogParameter[]>;
     readonly outputCatalog: _angular_core.Signal<FlowCatalogParameter[]>;
+    /**
+     * I candidati come li vuole il picker. Il tipo e l'obbligatorieta' finiscono nella
+     * descrizione: nel `<select>` erano un asterisco muto, che non diceva quale valore ci sta.
+     */
+    readonly inputOptions: _angular_core.Signal<NamePickerOption[]>;
+    readonly outputOptions: _angular_core.Signal<NamePickerOption[]>;
     /** Parametri obbligatori dichiarati dal catalogo e non ancora presenti. */
     readonly missingRequired: _angular_core.Signal<FlowCatalogParameter[]>;
-    /** Parametri presenti che il catalogo non conosce: sarebbero `PARAMETER_UNKNOWN`. */
-    unknownInput(parameter: FlowInputParameter): boolean;
-    unknownOutput(parameter: FlowOutputParameter): boolean;
+    /**
+     * Il parametro fuori catalogo (`PARAMETER_UNKNOWN`) lo segnala il picker, che ha in mano sia
+     * l'elenco sia il valore. Qui resta la descrizione, che serve all'editor di valore.
+     */
     describe(name: string | undefined): FlowCatalogParameter | undefined;
     addInput(name?: string): void;
     addOutput(name?: string): void;
@@ -2550,6 +2949,8 @@ declare class FieldAssignmentEditorComponent {
     private readonly catalog;
     readonly holder: _angular_core.InputSignal<FieldAssignmentHolder>;
     readonly object: _angular_core.InputSignal<string | undefined>;
+    /** `createable` su un Create, `updateable` su un Update: lo decide il chiamante (§5.7). */
+    readonly usage: _angular_core.InputSignal<FlowFieldUsage>;
     readonly title: _angular_core.InputSignal<string>;
     readonly disabledReason: _angular_core.InputSignal<string | null>;
     readonly changed: _angular_core.OutputEmitterRef<(holder: FieldAssignmentHolder) => void>;
@@ -2569,7 +2970,7 @@ declare class FieldAssignmentEditorComponent {
      */
     describe(name: string | undefined): FlowFieldDescription | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldAssignmentEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldAssignmentEditorComponent, "fb-field-assignment-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "object": { "alias": "object"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabledReason": { "alias": "disabledReason"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldAssignmentEditorComponent, "fb-field-assignment-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "object": { "alias": "object"; "required": false; "isSignal": true; }; "usage": { "alias": "usage"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabledReason": { "alias": "disabledReason"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
 }
 
 declare class ConnectorEditorComponent {
@@ -2882,6 +3283,16 @@ declare class ResourcePanelComponent {
     requiresObjectType(reference: FlowResourceRef): boolean;
     supportsScale(reference: FlowResourceRef): boolean;
     isEnum(reference: FlowResourceRef): boolean;
+    /** §4.7 — un'istanza di classe: `objectType` e' il nome della classe, non di un'entita'. */
+    isStructure(reference: FlowResourceRef): boolean;
+    /**
+     * §4.7 — una `Structure` non ha una forma letterale: nasce dal runtime come istanza vuota e i
+     * membri si assegnano uno alla volta. Mostrare un campo «valore iniziale» prometterebbe una
+     * cosa che il modello non sa esprimere.
+     */
+    supportsInitialValue(reference: FlowResourceRef): boolean;
+    /** Su una `Structure` l'`objectType` mancante e' un errore, non un avviso (§4.7). */
+    missingObjectType(reference: FlowResourceRef): boolean;
     /** Una costante che referenzia una risorsa e' `CONSTANT_REFERENCES_RESOURCE`. */
     constantReferencesResource(reference: FlowResourceRef): boolean;
     /** `stageOrder` duplicati: quale stage sia il corrente all'avvio diventa arbitrario. */
@@ -2950,6 +3361,9 @@ declare class DebugPanelComponent {
     private readonly api;
     private readonly store;
     private readonly session;
+    private readonly dictionaries;
+    private readonly catalog;
+    constructor();
     readonly closed: _angular_core.OutputEmitterRef<void>;
     /** Chiede all'host di evidenziare l'elemento corrente dell'esecuzione. */
     readonly elementFocused: _angular_core.OutputEmitterRef<string>;
@@ -2963,6 +3377,14 @@ declare class DebugPanelComponent {
     readonly screenOutputs: _angular_core.WritableSignal<Record<string, string>>;
     /** Le variabili `isInput` del flow: il contratto verso chi lo invoca (§4.6). */
     readonly inputVariables: _angular_core.Signal<FlowVariable[]>;
+    /**
+     * §4.7 — i membri delle classi delle variabili `Structure` di input, per classe. Un'istanza si
+     * compila un membro alla volta: non c'e' un letterale con cui scriverla in un campo solo.
+     */
+    private readonly membersByClass;
+    /** I membri **scrivibili** di una classe: gli altri li calcola il backend. */
+    membersOf(className: string | undefined): FlowStructureMember[];
+    isStructureVariable(variable: FlowVariable): boolean;
     readonly canRun: _angular_core.Signal<boolean>;
     readonly status: _angular_core.Signal<string | null>;
     readonly pendingScreen: _angular_core.Signal<_esfaenza_flow_builder.FlowPendingScreen | null>;
@@ -2994,10 +3416,17 @@ declare class DebugPanelComponent {
     }[]>;
     /** I nomi degli output dichiarati dallo screen, per generare i campi da compilare. */
     readonly screenOutputNames: _angular_core.Signal<string[]>;
+    /**
+     * §6.5 — il tipo dichiarato vince, e due tipi hanno una forma propria invece di `value`: un
+     * record e un'istanza di classe. Cercare `value` su un `Structure` mostrerebbe «—» pur avendo
+     * i dati sotto gli occhi (§4.7).
+     */
     private static render;
     setDebugEnabled(value: boolean): void;
     setInputValue(name: string, value: string): void;
     setScreenOutput(name: string, value: string): void;
+    /** Converte un valore del form nel tipo dichiarato: il tipo vince, anche in scrittura (§6.5). */
+    private static coerce;
     /** Converte i valori del form nel tipo dichiarato dalla variabile. */
     private coerceInputs;
     start(): Promise<void>;
@@ -3128,11 +3557,12 @@ declare class FlowBuilderComponent {
     /** Rilascio dalla palette: il punto di rilascio diventa `locationX`/`locationY` (§11). */
     onElementDropped(event: {
         type: FlowElementType;
+        variant?: string;
         x: number;
         y: number;
     }): void;
     /** Click sulla palette: l'elemento si posiziona in una zona libera. */
-    onElementPicked(type: FlowElementType): void;
+    onElementPicked(pick: FlowPalettePick): void;
     private createElement;
     onRemoveNode(name: string): void;
     onDuplicateNode(name: string): void;
@@ -3176,5 +3606,5 @@ declare class SelectValueDirective implements AfterViewChecked {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectValueDirective, "select[fbValue]", never, { "fbValue": { "alias": "fbValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_RESOURCE_COLLECTIONS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, elementIcon, emptyFlowDefinition, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, moveCondition, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, referenceRoot, remapConditionLogic, removeCondition, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName };
-export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormula, FlowGlobalVariableEntry, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOrchestratedStage, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowReference, FlowReferenceKind, FlowReferenceQuery, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenNavigation, FlowScreenResponseRequest, FlowScriptPluginCall, FlowSortOption, FlowSortOrder, FlowStage, FlowStageStep, FlowStageStepActionType, FlowStageStepAssignee, FlowStageStepConditionActionType, FlowStageStepRequest, FlowStageStepState, FlowStageStepStatus, FlowStageStepTypeEntry, FlowStart, FlowStartInterviewRequest, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, NamePickerOption, ParameterHolder, ValueMode };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_ICONS, FLOW_ELEMENT_VARIANT_FIELDS, FLOW_ELEMENT_VARIANT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_RESOURCE_COLLECTIONS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, StructureMemberPickerComponent, StructurePickerComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, elementIcon, emptyFlowDefinition, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, moveCondition, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, referenceRoot, remapConditionLogic, removeCondition, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, variantFieldOf, variantOf, variantPresetOf };
+export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormula, FlowGlobalVariableEntry, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOrchestratedStage, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPalettePick, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowReference, FlowReferenceKind, FlowReferenceQuery, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenNavigation, FlowScreenResponseRequest, FlowScriptPluginCall, FlowSortOption, FlowSortOrder, FlowStage, FlowStageStep, FlowStageStepActionType, FlowStageStepAssignee, FlowStageStepConditionActionType, FlowStageStepRequest, FlowStageStepState, FlowStageStepStatus, FlowStageStepTypeEntry, FlowStart, FlowStartInterviewRequest, FlowStructureDescribed, FlowStructureDescription, FlowStructureInstance, FlowStructureMember, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, NamePickerOption, PaletteGroup, PaletteItem, ParameterHolder, StructureMemberUsage, ValueMode };