@esfaenza/flow-builder 20.3.3 → 20.3.5

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>;
@@ -1486,6 +1637,34 @@ declare function stageStepOutputReferenced(reference: string | undefined, steps:
  */
 declare const ORCHESTRATION_CONDITION_OUTPUT = "isOrchestrationConditionMet";
 
+/**
+ * La gravita' di un rilievo, ridotta a tre secchi — FRONTEND.md §7.
+ *
+ * Perche' esiste: `FlowIssueSeverity` e' un tipo **aperto** (`'Error' | 'Warning' | 'Info' |
+ * string`) perche' il backend puo' aggiungere livelli senza toccare il frontend (§13.11). La
+ * conseguenza e' che confrontare la stringa cosi' com'e' e' un fallimento silenzioso: un
+ * `error` minuscolo, un `WARN`, un `Log` non corrispondono a niente, e allora il filtro del
+ * pannello non seleziona nulla, il conteggio resta a zero e il node sul canvas non si colora —
+ * senza un errore da nessuna parte. Era il difetto dei filtri della §7.
+ *
+ * Da qui in avanti si confronta il **secchio**, non la stringa. I livelli che non conosciamo
+ * cadono in `Info`: sono note, non problemi, e restano visibili invece di sparire.
+ */
+/** Le tre gravita' su cui l'interfaccia decide: colore, icona, filtro, attivazione. */
+type FlowSeverityBucket = 'Error' | 'Warning' | 'Info';
+/** Un livello sconosciuto e' una nota: si mostra, non si nasconde. */
+declare function severityBucket(severity: string | null | undefined): FlowSeverityBucket;
+/** L'ordine in cui si presentano: prima cio' che blocca l'attivazione. */
+declare const SEVERITY_BUCKETS: readonly FlowSeverityBucket[];
+declare const SEVERITY_LABEL: Record<FlowSeverityBucket, string>;
+/**
+ * Caratteri Unicode, non icone: la libreria non porta asset e non dipende dal font di icone
+ * dell'applicazione ospite — la stessa scelta di `element-icons.ts`. Sono glifi che rendono
+ * bene dentro un pastiglia colorata a 14px e non hanno un fallback emoji che cambia forma da
+ * un sistema all'altro.
+ */
+declare const SEVERITY_ICON: Record<FlowSeverityBucket, string>;
+
 /** Un node come lo vede l'editor: il node piu' da dove viene. */
 interface FlowNodeRef {
     name: string;
@@ -1717,13 +1896,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;
@@ -1731,6 +1945,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
@@ -1750,6 +1965,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;
@@ -1772,7 +2003,16 @@ declare class FlowValidationStore {
     readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
     readonly errorCount: _angular_core.Signal<number>;
     readonly warningCount: _angular_core.Signal<number>;
-    readonly infoCount: _angular_core.Signal<number>;
+    /**
+     * I conteggi per gravita' **ricavati dai rilievi**, non quelli del risultato.
+     *
+     * Servono a etichettare i filtri del pannello, e un'etichetta di filtro deve contare
+     * esattamente cio' che il filtro mostrera': `errorCount` del backend e' l'unica verita' per
+     * l'attivazione (§8.3) ma non e' allineato ai secchi, quindi usarlo sul chip produrrebbe un
+     * «Errori 3» che apre una lista di due. Il livello si normalizza (`severityBucket`) perche'
+     * la stringa e' aperta.
+     */
+    readonly issueCounts: _angular_core.Signal<Record<FlowSeverityBucket, number>>;
     /**
      * `false` finche' non e' arrivata una validazione: non presentare l'assenza di rilievi
      * come garanzia di correttezza (§7, ultimo capoverso).
@@ -1786,7 +2026,7 @@ declare class FlowValidationStore {
     readonly documentIssues: _angular_core.Signal<FlowValidationIssue[]>;
     constructor();
     /** La gravita' peggiore su un elemento, per decidere il colore del node sul canvas. */
-    severityOf(elementName: string): 'Error' | 'Warning' | 'Info' | null;
+    severityOf(elementName: string): FlowSeverityBucket | null;
     /**
      * I rilievi che riguardano un campo dentro un elemento.
      * `path` e' del tipo `rules[Approvato].connector.targetReference`: il confronto e' per
@@ -2000,8 +2240,12 @@ interface FlowCanvasNode {
     showsOutletLabels: boolean;
     /** `false` → nessun percorso lo raggiunge dallo Start: va reso "scollegato" (§6.4). */
     isReachable: boolean;
-    /** La gravita' peggiore dei rilievi sull'elemento (§7). */
-    severity: FlowIssueSeverity | null;
+    /**
+     * La gravita' peggiore dei rilievi sull'elemento (§7), **normalizzata**: il template
+     * confronta `=== 'Error'`, e `FlowIssueSeverity` e' un tipo aperto in cui un `error`
+     * minuscolo non colorerebbe niente.
+     */
+    severity: FlowSeverityBucket | null;
     /** Numero di rilievi, per il badge. */
     issueCount: number;
     /** L'elemento espone il proprio risultato sotto il proprio nome (§4.5). */
@@ -2055,6 +2299,12 @@ declare class FlowCanvasComponent {
      * Assente → si usa il calcolo locale.
      */
     readonly outline: _angular_core.InputSignal<FlowOutline | null>;
+    /**
+     * Lo decide il backend, non il client (§8): su una versione non modificabile i comandi che
+     * mutano il documento non si offrono. Arriva come input invece di leggere la sessione,
+     * perche' il canvas resti montabile da solo.
+     */
+    readonly isEditable: _angular_core.InputSignal<boolean>;
     readonly selectionChange: _angular_core.OutputEmitterRef<string | null>;
     readonly nodeOpened: _angular_core.OutputEmitterRef<string>;
     readonly nodeRemoveRequested: _angular_core.OutputEmitterRef<string>;
@@ -2067,6 +2317,28 @@ declare class FlowCanvasComponent {
         x: number;
         y: number;
     }>;
+    private readonly canvas;
+    private readonly _hasMovedViewport;
+    /** L'utente ha zoomato o spostato la vista: il comando per rimetterla a posto ha senso. */
+    readonly hasMovedViewport: _angular_core.Signal<boolean>;
+    /** Il primo `fNodesRendered` inquadra, i successivi no: rifarlo combatterebbe con l'utente. */
+    private hasFramedOnce;
+    /**
+     * `fitToScreen` va chiamato **dopo** che i node sono stati renderizzati: prima, la libreria
+     * non conosce ancora le loro dimensioni e inquadra la vista sbagliata (FF1009).
+     *
+     * Con un solo node (un flow appena creato ha solo lo Start) non si inquadra niente: la
+     * vista si spalancherebbe su una card sola.
+     */
+    onNodesRendered(): void;
+    /**
+     * Qualunque zoom o panoramica accende il pulsante. `frameFlow` passa
+     * `emitCanvasChange: false`, quindi il ritorno alla vista iniziale non rientra da qui e il
+     * pulsante si spegne invece di restare acceso per sempre.
+     */
+    onCanvasChange(): void;
+    resetViewport(): void;
+    private frameFlow;
     /** Raggiungibilita': backend se c'e', locale altrimenti. */
     private readonly reachability;
     readonly nodes: _angular_core.Signal<FlowCanvasNode[]>;
@@ -2133,6 +2405,12 @@ declare class FlowCanvasComponent {
      * dell'area sottostante.
      */
     onEditClick(event: Event, name: string): void;
+    /**
+     * `stopPropagation` come per ✎: senza, il clic arriva anche al node e la selezione cambia
+     * mentre l'elemento sta sparendo. La rimozione la esegue il documento, non il canvas:
+     * `removeNode` toglie anche i connector che lo puntavano.
+     */
+    onRemoveClick(event: Event, name: string): void;
     connectorIdOf(node: FlowCanvasNode, outletKey: string): string;
     targetIdOf(node: FlowCanvasNode): string;
     isSelected(node: FlowCanvasNode): boolean;
@@ -2141,7 +2419,7 @@ declare class FlowCanvasComponent {
     /** Classe della fascia colorata, per categoria del dizionario. */
     categoryClass(node: FlowCanvasNode): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowCanvasComponent, never>;
-    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>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "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). */
@@ -2206,6 +2484,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>;
@@ -2231,6 +2510,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<{
@@ -2246,12 +2533,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;
@@ -2329,7 +2623,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;
@@ -2386,6 +2680,85 @@ declare class NamePickerComponent {
     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. */
 type ValueMode = 'reference' | 'literal' | 'formula' | 'globalConstant' | 'empty';
 declare class ValueEditorComponent {
@@ -2409,13 +2782,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>;
@@ -2558,9 +2937,17 @@ declare class RecordFilterEditorComponent {
     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();
+    /**
+     * §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>;
@@ -2637,6 +3024,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>;
@@ -2656,7 +3045,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 {
@@ -2969,6 +3358,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. */
@@ -2981,7 +3380,7 @@ declare class ResourcePanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourcePanelComponent, "fb-resource-panel", never, {}, { "closed": "closed"; }, never, never, true, never>;
 }
 
-type SeverityFilter = 'all' | 'Error' | 'Warning' | 'Info';
+type SeverityFilter = 'all' | FlowSeverityBucket;
 declare class ProblemsPanelComponent {
     private readonly validation;
     /** Chiede di selezionare l'elemento: `$start` per i rilievi sul documento. */
@@ -2991,12 +3390,25 @@ declare class ProblemsPanelComponent {
     readonly isRunning: _angular_core.Signal<boolean>;
     readonly hasResult: _angular_core.Signal<boolean>;
     readonly lastError: _angular_core.Signal<string | null>;
+    /**
+     * I conteggi dei chip vengono dai rilievi, non dal risultato: il numero sul filtro deve
+     * essere quello che il filtro apre (vedi `FlowValidationStore.issueCounts`).
+     */
+    private readonly counts;
     readonly errorCount: _angular_core.Signal<number>;
     readonly warningCount: _angular_core.Signal<number>;
     readonly infoCount: _angular_core.Signal<number>;
+    readonly totalCount: _angular_core.Signal<number>;
     readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
     readonly isClean: _angular_core.Signal<boolean>;
+    /** Ci sono rilievi, ma il filtro attivo non ne mostra nessuno: va detto, non lasciato in bianco. */
+    readonly isFilteredEmpty: _angular_core.Signal<boolean>;
+    readonly activeFilterLabel: _angular_core.Signal<string>;
+    /** Un secondo clic sul filtro attivo torna a «Tutti»: e' l'unico modo per uscirne col mouse dov'e'. */
     setFilter(filter: SeverityFilter): void;
+    bucketOf(issue: FlowValidationIssue): FlowSeverityBucket;
+    iconText(bucket: FlowSeverityBucket): string;
+    labelText(bucket: FlowSeverityBucket): string;
     focus(issue: FlowValidationIssue): void;
     close(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProblemsPanelComponent, never>;
@@ -3037,6 +3449,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>;
@@ -3050,6 +3465,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>;
@@ -3081,10 +3504,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>;
@@ -3182,6 +3612,14 @@ declare class FlowBuilderComponent {
     setInterviewLabel(value: string): void;
     setProcessType(value: string): void;
     readonly processTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    /**
+     * Il `processType` del documento non e' fra quelli del dizionario. Non e' un caso di scuola:
+     * basta che il dizionario arrivi senza `processTypes`, o che il backend salvi una scrittura
+     * diversa da quella che elenca, e la select — che non ha un'opzione corrispondente — si
+     * presenta bianca su un flow che invece ha il suo tipo. Il template aggiunge l'opzione
+     * mancante; qui si decide solo se serve.
+     */
+    readonly isProcessTypeOutOfCatalog: _angular_core.Signal<boolean>;
     /** `AutoLaunched` + screen e' un errore di validazione: si segnala subito (§13.6). */
     readonly hasScreensInAutoLaunched: _angular_core.Signal<boolean>;
     /** Un flow `Screen` senza screen e' `SCREEN_FLOW_WITHOUT_SCREENS`. */
@@ -3264,5 +3702,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_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, 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, 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, PaletteGroup, PaletteItem, 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, SEVERITY_BUCKETS, SEVERITY_ICON, SEVERITY_LABEL, 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, severityBucket, 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, FlowSeverityBucket, 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 };