@esfaenza/flow-builder 20.3.4 → 20.3.6

package/index.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, AfterViewChecked } from '@angular/core';
+import { InjectionToken, Signal, AfterViewChecked } from '@angular/core';
 import * as _esfaenza_flow_builder from '@esfaenza/flow-builder';
 import { EFMarkerType, EFConnectableSide } from '@foblex/flow';
 
@@ -1637,140 +1637,33 @@ declare function stageStepOutputReferenced(reference: string | undefined, steps:
  */
 declare const ORCHESTRATION_CONDITION_OUTPUT = "isOrchestrationConditionMet";
 
-/** Un node come lo vede l'editor: il node piu' da dove viene. */
-interface FlowNodeRef {
-    name: string;
-    type: FlowElementType;
-    collection: FlowNodeCollection;
-    index: number;
-    node: FlowAnyNode;
-}
-/** Un arco derivato dal documento, con la sua origine precisa. */
-interface FlowEdge {
-    /** Id stabile: `<sorgente>|<chiave uscita>`. */
-    id: string;
-    /** `$start` per gli archi uscenti dallo Start. */
-    from: string;
-    /** `undefined` → il connector esiste ma non ha destinazione: ramo incompleto (§6.4). */
-    to?: string;
-    outletKey: string;
-    kind: FlowConnectionKind;
-    label?: string | null;
-    isGoTo?: boolean;
-}
-/** Una risorsa come la vede l'editor. */
-interface FlowResourceRef {
-    name: string;
-    collection: FlowResourceCollection;
-    index: number;
-    resource: Record<string, unknown>;
-}
-/** Documento minimo per un flow nuovo (§11, "Creare un flow"). */
-declare function emptyFlowDefinition(fullName: string, label: string, processType: string): FlowDefinition;
-declare class FlowDocumentStore {
-    private readonly _document;
-    private readonly _isDirty;
-    private readonly _undoStack;
-    private readonly _redoStack;
-    /** Il documento in lavorazione. Sola lettura: si modifica con i metodi di questo store. */
-    readonly document: _angular_core.Signal<FlowDefinition>;
-    readonly isDirty: _angular_core.Signal<boolean>;
-    readonly canUndo: _angular_core.Signal<boolean>;
-    readonly canRedo: _angular_core.Signal<boolean>;
-    /** §3.4 — l'elemento Start: array di uno, usa sempre il primo. */
-    readonly start: _angular_core.Signal<FlowStart>;
-    /** §3.1 — tutte le collection appiattite in un'unica lista di node. */
-    readonly nodes: _angular_core.Signal<FlowNodeRef[]>;
-    readonly nodeByName: _angular_core.Signal<Map<string, FlowNodeRef>>;
-    readonly resources: _angular_core.Signal<FlowResourceRef[]>;
-    /**
-     * §3.3 — l'insieme dei nomi già usati: node, risorse **e** step di orchestrazione, un unico
-     * spazio di nomi. Il controllo di unicita' che guarda solo le variabili lascia passare una
-     * variabile omonima di un node (§13.5); quello che dimentica gli step lascia passare uno
-     * step omonimo di una variabile, che e' `NAME_DUPLICATED` allo stesso modo (§5.13).
-     */
-    readonly usedNames: _angular_core.Signal<string[]>;
-    /** Gli archi derivati dal documento, Start incluso. */
-    readonly edges: _angular_core.Signal<FlowEdge[]>;
-    /**
-     * Raggiungibilita' calcolata localmente, per un feedback immediato mentre si disegna.
-     * La fonte autoritativa resta `isReachable` di `POST /flows/outline` (§6.4): questa e'
-     * un'anticipazione, non un sostituto.
-     */
-    readonly reachableNames: _angular_core.Signal<ReadonlySet<string>>;
-    /** Carica un documento dal backend: azzera storico e flag di modifica. */
-    load(definition: FlowDefinition): void;
-    /** Dopo un salvataggio riuscito: il documento resta, la modifica non e' piu' pendente. */
-    markSaved(): void;
-    /**
-     * Applica una modifica al documento.
-     * Il mutatore riceve una **copia** e la modifica liberamente; lo store si occupa di
-     * storico e di sostituire il riferimento (nuovo oggetto → i signal derivati ricalcolano).
-     */
-    update(mutate: (draft: FlowDefinition) => void, options?: {
-        silent?: boolean;
-    }): void;
-    private pushHistory;
-    undo(): void;
-    redo(): void;
-    /** Inserisce un node nella collection indicata dal dizionario (`metadataProperty`). */
-    addNode(collection: FlowNodeCollection, node: FlowAnyNode): void;
-    /** Modifica un node per nome. Il mutatore riceve la copia di lavoro. */
-    updateNode(name: string, mutate: (node: FlowAnyNode) => void, options?: {
-        silent?: boolean;
-    }): void;
-    /** Modifica lo Start. */
-    updateStart(mutate: (start: FlowStart) => void, options?: {
-        silent?: boolean;
-    }): void;
-    /**
-     * Sposta un node sul canvas. `silent` per non riempire lo storico durante il drag:
-     * il chiamante registra un solo passo alla fine del gesto.
-     */
-    moveNode(name: string, x: number, y: number, options?: {
-        silent?: boolean;
-    }): void;
-    /**
-     * Rimuove un node **e** ogni connector che lo referenzia: un `targetReference` orfano
-     * e' `CONNECTOR_TARGET_UNKNOWN`, cioe' un errore che blocca l'attivazione (§7).
-     */
-    removeNode(name: string): void;
-    /** Azzera i connector che puntano a un node scomparso, Start compreso. */
-    private static clearReferencesTo;
-    /**
-     * Rinomina un node riscrivendo **tutti** i riferimenti che lo raggiungono.
-     * Nessuna primitiva del backend lo fa (§13.8): se l'editor offre la rinomina, la
-     * riscrittura la deve fare lui. Copre `targetReference`, i riferimenti a risorsa e i
-     * riferimenti a output automatico (`Vecchio.Campo` → `Nuovo.Campo`).
-     */
-    renameNode(oldName: string, newName: string): void;
-    /** Rinomina una risorsa, riscrivendo i riferimenti che la usano. */
-    renameResource(collection: FlowResourceCollection, index: number, newName: string): void;
-    /**
-     * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti.
-     * Cammina l'intero documento: e' l'unico modo per non dimenticare un campo, dato che
-     * i riferimenti compaiono in una ventina di posti diversi (§4).
-     */
-    private static rewriteReferences;
-    /** Duplica un node con un nome nuovo, senza copiarne le uscite. */
-    duplicateNode(name: string, newName: string, offset?: {
-        x: number;
-        y: number;
-    }): void;
-    /** Scrive la destinazione di un'uscita. `target` assente → il ramo resta incompleto. */
-    setConnector(fromName: string, outletKey: string, target: string | undefined, isGoTo?: boolean): void;
-    /** Rimuove un arco: il percorso finisce lì, che e' legittimo (§3.5). */
-    removeConnector(fromName: string, outletKey: string): void;
-    addResource(collection: FlowResourceCollection, resource: Record<string, unknown>): void;
-    updateResource(collection: FlowResourceCollection, index: number, mutate: (resource: Record<string, unknown>) => void): void;
-    removeResource(collection: FlowResourceCollection, index: number): void;
-    /** Modifica i campi del documento radice (label, description, processType, …). */
-    updateHeader(mutate: (definition: FlowDefinition) => void, options?: {
-        silent?: boolean;
-    }): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowDocumentStore, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDocumentStore>;
-}
+/**
+ * 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>;
 
 declare class FlowDictionaryStore {
     private readonly api;
@@ -1960,6 +1853,313 @@ declare class FlowCatalogStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowCatalogStore>;
 }
 
+/**
+ * Navigazione dei percorsi puntati — FRONTEND.md §4.4, §4.7, §4.7.1, §5.2, §5.7.
+ *
+ * La specifica e' cambiata su questo punto: i percorsi con il punto **si verificano**. Un percorso
+ * di relazione (`Cliente.Citta`) si naviga un segmento alla volta e l'ultimo si verifica come un
+ * campo semplice; dentro un'istanza di classe i membri annidati (`Richiesta.Cliente.Nome`) si
+ * verificano **fino in fondo**, seguendo `objectType` di classe in classe e passando ai campi
+ * dello schema quando il membro porta un record. Dove la catena si interrompe il rilievo e'
+ * l'avviso `PATH_NOT_VERIFIABLE`, che significa "non lo so" e non "sbagliato".
+ *
+ * Perche' sta qui e non in tre pickers: la catena e' la stessa per campi e membri — cambiano solo
+ * la primitiva che descrive la tappa (`listFields` contro `describeStructure`) e le parole
+ * dell'avviso. Tenerla in un posto solo e' anche il modo di non far divergere l'editor dal
+ * validatore, che naviga la stessa catena.
+ *
+ * Le due cose da non confondere:
+ *
+ *  - **`objectType` di un membro** porta il nome di una classe se il membro e' `Structure`, il nome
+ *    di un'**entita' dello schema** se il membro e' `Object` — e da lì in poi si continua con i
+ *    campi, non con i membri (§4.7.1). Un `Enum` non e' un contenitore: `objectType` lì e' un tipo
+ *    di enumerazione e il percorso finisce.
+ *  - **scrivibile** non vuol dire la stessa cosa nei due mondi: un membro porta il proprio
+ *    `isWritable`, un campo no — fuori da un Create o da un Update il contesto non c'e', quindi
+ *    basta che sia `isCreateable` **oppure** `isUpdateable`, e un campo che non e' ne' l'uno ne'
+ *    l'altro e' `TARGET_NOT_WRITABLE` in qualunque contesto (§5.7).
+ */
+
+/** Una tappa navigabile: un'entita' dello schema, oppure una classe (§4.7). */
+type PathContainerKind = 'object' | 'structure';
+interface PathContainer {
+    kind: PathContainerKind;
+    /** Nome dell'entita' o della classe. */
+    name: string;
+}
+/**
+ * Un segmento proponibile in una tappa — campo o membro ridotti al minimo comune, perche' chi
+ * naviga non deve sapere quale dei due sta guardando.
+ */
+interface PathEntry {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+    dataType?: FlowDataType;
+    objectType?: string | null;
+    isCollection?: boolean;
+    /** Scrivibile come destinazione: `isWritable` per un membro, `createable || updateable` per un campo. */
+    isWritable: boolean;
+    /** Dove il percorso continua dopo questo segmento; assente = qui finisce cio' che si sa. */
+    next?: PathContainer;
+}
+/**
+ * Esito della descrizione di una tappa. Sono quattro come per le classi (§4.7.1) e vanno tenuti
+ * distinti: solo `declared` autorizza a dire che un segmento non esiste.
+ */
+type PathLevelStatus = 'declared' | 'undeclared' | 'unknown-container' | 'unknown-catalog';
+interface PathLevel {
+    container: PathContainer;
+    status: PathLevelStatus;
+    entries: PathEntry[];
+    /** L'etichetta della tappa, quando la descrizione la porta (l'involucro della §4.7.1). */
+    label?: string | null;
+}
+/**
+ * Cio' che serve per navigare: le due primitive di catalogo. {@link FlowCatalogStore} la soddisfa
+ * per forma, e prenderla come parametro tiene questo modulo verificabile senza un'iniezione.
+ */
+interface PathCatalog {
+    listFields(object: string, usage?: FlowFieldUsage): Promise<FlowFieldDescription[]>;
+    describeStructure(className: string): Promise<FlowStructureDescribed>;
+}
+/**
+ * Perche' la navigazione si e' fermata. `unknown-segment` e' l'unico che accusa qualcuno: gli altri
+ * sono `PATH_NOT_VERIFIABLE`, cioe' "non lo so".
+ */
+type PathStopReason = 'unknown-segment'
+/** Il segmento non dichiara dove continuare: nessun `objectType`, o un tipo che non e' un contenitore. */
+ | 'no-object-type'
+/** Dentro una collection non si naviga: il percorso designa l'insieme, non un elemento. */
+ | 'collection'
+/** Tappa valida di cui campi o membri non sono dichiarati: si digita, non si accusa. */
+ | 'undeclared'
+/** Classe non registrata (404): l'errore sta sulla classe, non sul percorso. */
+ | 'unknown-container'
+/** Catalogo assente o richiesta fallita: non dice niente sulla tappa. */
+ | 'unknown-catalog';
+interface PathResolution {
+    root: PathContainer;
+    /** Il percorso come e' stato scritto, ripulito dagli spazi. */
+    path: string;
+    segments: string[];
+    /** Le tappe attraversate, nell'ordine. L'ultima e' quella dove la navigazione si e' fermata. */
+    levels: PathLevel[];
+    /** I segmenti risolti, uno per tappa attraversata. */
+    resolved: PathEntry[];
+    /**
+     *  - `empty`: non c'e' ancora un ultimo segmento da verificare (percorso vuoto, o appena aperto
+     *    con il punto): niente da segnalare, ma c'e' da proporre;
+     *  - `resolved`: ogni segmento verificato, {@link last} e' cio' che il percorso designa;
+     *  - `unknown`: un segmento non esiste nella sua tappa, che era autorevole;
+     *  - `unverifiable`: la catena si interrompe — `PATH_NOT_VERIFIABLE`.
+     */
+    status: 'empty' | 'resolved' | 'unknown' | 'unverifiable';
+    reason?: PathStopReason;
+    /** Dove si e' fermata: indice nel percorso e testo del segmento. */
+    stoppedAt?: {
+        index: number;
+        segment: string;
+    };
+    /** Il segmento finale, solo con `resolved`: e' il campo o il membro che il percorso designa. */
+    last?: PathEntry;
+    /**
+     * La tappa dell'**ultimo** segmento, quando la navigazione ci e' arrivata: e' cio' che l'editor
+     * propone, con `prefix` da premettere al nome scelto. Assente se la catena si e' interrotta
+     * prima: lì non c'e' niente da proporre.
+     */
+    tail?: {
+        level: PathLevel;
+        prefix: string;
+        segment: string;
+    };
+}
+/**
+ * Descrive una tappa. `usage` vale solo per le entita' e solo dove serve: i segmenti **intermedi**
+ * si chiedono sempre con `any`, perche' l'uso riguarda l'ultimo — un filtro su `Cliente.Citta`
+ * esige che `Citta` sia filtrabile, non che lo sia la relazione (§4.4).
+ */
+declare function loadPathLevel(catalog: PathCatalog, container: PathContainer, usage?: FlowFieldUsage): Promise<PathLevel>;
+/**
+ * Naviga `path` a partire da `root`, un segmento alla volta. Non rifiuta mai: un catalogo assente
+ * e' un esito (`unverifiable`), non un errore da gestire in ogni chiamante.
+ */
+declare function resolvePath(catalog: PathCatalog, root: PathContainer, path: string | undefined, options?: {
+    usage?: FlowFieldUsage;
+}): Promise<PathResolution>;
+/** Come chiamare una tappa in un messaggio: la classe ha una label, l'entita' il proprio nome. */
+declare function pathContainerLabel(level: PathLevel | undefined): string;
+/**
+ * Il testo dell'avviso `PATH_NOT_VERIFIABLE`, con il **motivo**: "non verificabile" senza dire
+ * perche' e' indistinguibile da un difetto dell'editor.
+ */
+declare function pathNotVerifiableMessage(resolution: PathResolution): string;
+/** I nomi proponibili nella tappa dove un segmento non e' stato trovato: il messaggio li elenca. */
+declare function pathAvailableNames(resolution: PathResolution): string[];
+/**
+ * La riga di descrizione di un segmento proponibile. `showWritability` la chiede chi sta
+ * compilando una **destinazione**: in un filtro "sola lettura" sarebbe rumore, in un campo di
+ * destinazione e' l'informazione che evita `TARGET_NOT_WRITABLE`.
+ */
+declare function describePathEntry(entry: PathEntry, options?: {
+    showWritability?: boolean;
+}): string;
+interface PathNavigationRequest {
+    /** `null` = niente da navigare: nessuna radice scelta, o radice non navigabile. */
+    root: PathContainer | null;
+    path: string | undefined;
+    /** L'uso con cui chiedere i campi dell'**ultimo** segmento (§6.4). */
+    usage?: FlowFieldUsage;
+}
+interface PathNavigation {
+    /** `null` finche' non c'e' una radice o la prima risposta non e' arrivata. */
+    resolution: Signal<PathResolution | null>;
+    isPending: Signal<boolean>;
+}
+/**
+ * La navigazione come coppia di signal, per i pickers. Da chiamare in un **contesto di
+ * iniezione** (il costruttore del componente), perche' dentro crea un `effect`.
+ *
+ * Il token di sequenza non e' cosmetico: le tappe si caricano una alla volta e una risposta
+ * superata che arriva dopo mostrerebbe l'avviso di un percorso che l'utente ha già cambiato.
+ */
+declare function navigatePath(catalog: PathCatalog, request: () => PathNavigationRequest | null): PathNavigation;
+
+/** Un node come lo vede l'editor: il node piu' da dove viene. */
+interface FlowNodeRef {
+    name: string;
+    type: FlowElementType;
+    collection: FlowNodeCollection;
+    index: number;
+    node: FlowAnyNode;
+}
+/** Un arco derivato dal documento, con la sua origine precisa. */
+interface FlowEdge {
+    /** Id stabile: `<sorgente>|<chiave uscita>`. */
+    id: string;
+    /** `$start` per gli archi uscenti dallo Start. */
+    from: string;
+    /** `undefined` → il connector esiste ma non ha destinazione: ramo incompleto (§6.4). */
+    to?: string;
+    outletKey: string;
+    kind: FlowConnectionKind;
+    label?: string | null;
+    isGoTo?: boolean;
+}
+/** Una risorsa come la vede l'editor. */
+interface FlowResourceRef {
+    name: string;
+    collection: FlowResourceCollection;
+    index: number;
+    resource: Record<string, unknown>;
+}
+/** Documento minimo per un flow nuovo (§11, "Creare un flow"). */
+declare function emptyFlowDefinition(fullName: string, label: string, processType: string): FlowDefinition;
+declare class FlowDocumentStore {
+    private readonly _document;
+    private readonly _isDirty;
+    private readonly _undoStack;
+    private readonly _redoStack;
+    /** Il documento in lavorazione. Sola lettura: si modifica con i metodi di questo store. */
+    readonly document: _angular_core.Signal<FlowDefinition>;
+    readonly isDirty: _angular_core.Signal<boolean>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /** §3.4 — l'elemento Start: array di uno, usa sempre il primo. */
+    readonly start: _angular_core.Signal<FlowStart>;
+    /** §3.1 — tutte le collection appiattite in un'unica lista di node. */
+    readonly nodes: _angular_core.Signal<FlowNodeRef[]>;
+    readonly nodeByName: _angular_core.Signal<Map<string, FlowNodeRef>>;
+    readonly resources: _angular_core.Signal<FlowResourceRef[]>;
+    /**
+     * §3.3 — l'insieme dei nomi già usati: node, risorse **e** step di orchestrazione, un unico
+     * spazio di nomi. Il controllo di unicita' che guarda solo le variabili lascia passare una
+     * variabile omonima di un node (§13.5); quello che dimentica gli step lascia passare uno
+     * step omonimo di una variabile, che e' `NAME_DUPLICATED` allo stesso modo (§5.13).
+     */
+    readonly usedNames: _angular_core.Signal<string[]>;
+    /** Gli archi derivati dal documento, Start incluso. */
+    readonly edges: _angular_core.Signal<FlowEdge[]>;
+    /**
+     * Raggiungibilita' calcolata localmente, per un feedback immediato mentre si disegna.
+     * La fonte autoritativa resta `isReachable` di `POST /flows/outline` (§6.4): questa e'
+     * un'anticipazione, non un sostituto.
+     */
+    readonly reachableNames: _angular_core.Signal<ReadonlySet<string>>;
+    /** Carica un documento dal backend: azzera storico e flag di modifica. */
+    load(definition: FlowDefinition): void;
+    /** Dopo un salvataggio riuscito: il documento resta, la modifica non e' piu' pendente. */
+    markSaved(): void;
+    /**
+     * Applica una modifica al documento.
+     * Il mutatore riceve una **copia** e la modifica liberamente; lo store si occupa di
+     * storico e di sostituire il riferimento (nuovo oggetto → i signal derivati ricalcolano).
+     */
+    update(mutate: (draft: FlowDefinition) => void, options?: {
+        silent?: boolean;
+    }): void;
+    private pushHistory;
+    undo(): void;
+    redo(): void;
+    /** Inserisce un node nella collection indicata dal dizionario (`metadataProperty`). */
+    addNode(collection: FlowNodeCollection, node: FlowAnyNode): void;
+    /** Modifica un node per nome. Il mutatore riceve la copia di lavoro. */
+    updateNode(name: string, mutate: (node: FlowAnyNode) => void, options?: {
+        silent?: boolean;
+    }): void;
+    /** Modifica lo Start. */
+    updateStart(mutate: (start: FlowStart) => void, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Sposta un node sul canvas. `silent` per non riempire lo storico durante il drag:
+     * il chiamante registra un solo passo alla fine del gesto.
+     */
+    moveNode(name: string, x: number, y: number, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Rimuove un node **e** ogni connector che lo referenzia: un `targetReference` orfano
+     * e' `CONNECTOR_TARGET_UNKNOWN`, cioe' un errore che blocca l'attivazione (§7).
+     */
+    removeNode(name: string): void;
+    /** Azzera i connector che puntano a un node scomparso, Start compreso. */
+    private static clearReferencesTo;
+    /**
+     * Rinomina un node riscrivendo **tutti** i riferimenti che lo raggiungono.
+     * Nessuna primitiva del backend lo fa (§13.8): se l'editor offre la rinomina, la
+     * riscrittura la deve fare lui. Copre `targetReference`, i riferimenti a risorsa e i
+     * riferimenti a output automatico (`Vecchio.Campo` → `Nuovo.Campo`).
+     */
+    renameNode(oldName: string, newName: string): void;
+    /** Rinomina una risorsa, riscrivendo i riferimenti che la usano. */
+    renameResource(collection: FlowResourceCollection, index: number, newName: string): void;
+    /**
+     * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti.
+     * Cammina l'intero documento: e' l'unico modo per non dimenticare un campo, dato che
+     * i riferimenti compaiono in una ventina di posti diversi (§4).
+     */
+    private static rewriteReferences;
+    /** Duplica un node con un nome nuovo, senza copiarne le uscite. */
+    duplicateNode(name: string, newName: string, offset?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Scrive la destinazione di un'uscita. `target` assente → il ramo resta incompleto. */
+    setConnector(fromName: string, outletKey: string, target: string | undefined, isGoTo?: boolean): void;
+    /** Rimuove un arco: il percorso finisce lì, che e' legittimo (§3.5). */
+    removeConnector(fromName: string, outletKey: string): void;
+    addResource(collection: FlowResourceCollection, resource: Record<string, unknown>): void;
+    updateResource(collection: FlowResourceCollection, index: number, mutate: (resource: Record<string, unknown>) => void): void;
+    removeResource(collection: FlowResourceCollection, index: number): void;
+    /** Modifica i campi del documento radice (label, description, processType, …). */
+    updateHeader(mutate: (definition: FlowDefinition) => void, options?: {
+        silent?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowDocumentStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDocumentStore>;
+}
+
 declare class FlowValidationStore {
     private readonly api;
     private readonly destroyRef;
@@ -1975,7 +2175,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).
@@ -1989,7 +2198,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
@@ -2203,8 +2412,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). */
@@ -2258,6 +2471,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>;
@@ -2270,6 +2489,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[]>;
@@ -2336,6 +2577,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;
@@ -2344,7 +2591,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). */
@@ -2436,13 +2683,26 @@ declare class ReferencePickerComponent {
     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;
+     * La risorsa da cui il valore corrente sta navigando, quando la sua forma e' **dichiarata**: una
+     * `Structure` con la classe, un record con l'entita'. È cio' che rende il percorso verificabile.
+     *
+     * Un output automatico e' escluso di proposito: la primitiva ne dichiara il tipo, ma la
+     * specifica tiene i percorsi che ne partono fuori dalla validazione (§7, ultimo capoverso), e
+     * l'editor non deve accusare cio' che il backend non verifica.
+     */
+    private readonly navigableRoot;
+    /** Il percorso dopo la radice: `Cliente.Email` di `Richiesta.Cliente.Email`. */
+    private readonly navigatedPath;
+    private readonly navigation;
+    private readonly resolution;
+    /** La tappa in cui si sta scrivendo: da qui vengono le proposte dei segmenti. */
+    private readonly tail;
+    /**
+     * I segmenti come riferimenti navigati: `Richiesta.Cliente.Email`, col tipo del segmento. Un
+     * segmento di sola lettura non si propone in un campo di destinazione, a meno che da lì il
+     * percorso continui: `Richiesta.Cliente` non si assegna, ma `Richiesta.Cliente.Email` sì (§5.7).
+     */
+    private readonly pathReferences;
     readonly options: _angular_core.Signal<FlowReference[]>;
     /** Le opzioni raggruppate per `kind`, così gli output automatici si distinguono. */
     readonly groups: _angular_core.Signal<{
@@ -2454,20 +2714,23 @@ declare class ReferencePickerComponent {
     /**
      * Stato del valore corrente rispetto all'elenco.
      *  - `known`: presente nell'elenco;
-     *  - `navigated`: la radice e' nota ma c'e' un percorso dopo il punto (campo di record,
-     *    output automatico navigato): la validazione non verifica i percorsi con il punto,
-     *    quindi si accetta senza segnalare;
+     *  - `navigated`: la radice e' nota ma la sua forma non e' dichiarata (output automatico di un
+     *    elemento): il percorso resta fuori dalla validazione, 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
+     *  - `member`: percorso dentro una forma dichiarata, verificato fino in fondo (§4.4, §4.7.1);
+     *  - `memberUnknown`: un segmento non esiste nella sua tappa: `STRUCTURE_MEMBER_UNKNOWN` su una
+     *    classe, `FIELD_UNKNOWN` su un'entita', e a differenza di prima si sa per certo;
+     *  - `memberNotWritable`: il segmento esiste, non e' scrivibile, e questo campo vuole una
      *    destinazione: `TARGET_NOT_WRITABLE`;
+     *  - `pathUnverified`: la catena si interrompe (`PATH_NOT_VERIFIABLE`): avviso, non errore;
      *  - `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" | "member" | "memberUnknown" | "memberNotWritable" | "unknown">;
+    readonly valueState: _angular_core.Signal<"empty" | "unknown" | "known" | "navigated" | "host" | "member" | "memberUnknown" | "memberNotWritable" | "pathUnverified">;
+    /** Le parole cambiano con la tappa: un campo di un'entita' non e' un membro di una classe. */
+    private readonly tailIsObject;
+    private readonly tailContainer;
     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>;
@@ -2477,7 +2740,15 @@ declare class ReferencePickerComponent {
     toggle(): void;
     onQuery(value: string): void;
     choose(reference: FlowReference): void;
-    /** Scrittura libera: indispensabile per i campi di un record e per gli scope dell'host. */
+    /**
+     * Scende di un livello dentro un percorso proponibile invece di scegliere il segmento: scrive il
+     * punto, e l'elenco diventa quello della tappa successiva. Serve perche' `Richiesta.Cliente` puo'
+     * essere il riferimento che si vuole **oppure** la tappa da cui continuare.
+     */
+    descend(reference: FlowReference): void;
+    /** `true` se da questo riferimento il percorso continua: la sua forma e' dichiarata. */
+    canDescend(reference: FlowReference): boolean;
+    /** Scrittura libera: indispensabile per gli scope dell'host e per i percorsi non enumerabili. */
     onManualInput(value: string): void;
     clear(): void;
     describe(reference: FlowReference): string;
@@ -2535,29 +2806,55 @@ declare class FieldPickerComponent {
     readonly placeholder: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
-    private readonly fields;
-    private readonly loadFailed;
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     /** Il testo digitato mentre il pannello e' aperto: filtra l'elenco. */
     private readonly query;
+    /**
+     * La navigazione del percorso corrente. Il testo digitato conta quanto il valore: mentre si
+     * scrive `Cliente.Cit` l'elenco deve già essere quello dei campi di `Cliente`.
+     */
+    private readonly navigation;
+    private readonly resolution;
     constructor();
     readonly text: _angular_core.Signal<string>;
-    readonly options: _angular_core.Signal<FlowFieldDescription[]>;
+    /** La tappa in cui si sta scrivendo: da qui vengono le proposte, non dalla radice. */
+    private readonly tail;
+    /** Cio' che si premette al nome scelto: `''` sul primo segmento, `Cliente.` sul secondo. */
+    readonly prefix: _angular_core.Signal<string>;
+    readonly options: _angular_core.Signal<PathEntry[]>;
+    /** `true` se la tappa in cui si scrive ha un elenco **autorevole** (§4.7.1). */
     readonly hasCatalog: _angular_core.Signal<boolean>;
-    /** `true` se il valore e' un percorso di relazione: non enumerabile, non verificato (§4.4). */
-    readonly isRelationPath: _angular_core.Signal<boolean>;
+    /** L'etichetta della tappa: serve nell'intestazione dell'elenco quando non e' la radice. */
+    readonly levelLabel: _angular_core.Signal<string>;
+    /** `true` se il valore e' un percorso navigato: cambia il testo dei messaggi, non la severita'. */
+    readonly isPath: _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 valorizzabili alla creazione." | "Questo campo non e’ fra quelli dell’oggetto.">;
+    /** §4.4 — la catena si e' interrotta: avviso, non errore. Il percorso puo' essere giusto. */
+    readonly isNotVerifiable: _angular_core.Signal<boolean>;
+    /**
+     * L'avviso dipende dall'uso — un campo puo' esistere e non essere filtrabile — e dalla **tappa**:
+     * su `Cliente.Citta` il campo che non esiste e' di `Cliente`, non dell'oggetto di partenza.
+     */
+    readonly unknownMessage: _angular_core.Signal<string>;
+    readonly notVerifiableMessage: _angular_core.Signal<string>;
     readonly describeValue: _angular_core.Signal<string | null>;
+    /** Catalogo non raggiungibile sulla **radice**: il campo resta scrivibile a mano, non bloccato. */
     readonly loadErrored: _angular_core.Signal<boolean>;
     open(): void;
     close(): void;
     toggle(): void;
     onInput(text: string): void;
-    choose(field: FlowFieldDescription): void;
+    choose(entry: PathEntry): void;
+    /**
+     * Scende dentro una relazione invece di scegliere il campo: il pannello resta aperto e l'elenco
+     * diventa quello dell'oggetto referenziato. È l'equivalente di scrivere il punto, e infatti
+     * scrive il punto: il valore intermedio e' quello che si vedrebbe digitando.
+     */
+    descend(entry: PathEntry): void;
+    /** `true` se da questo campo il percorso continua: e' una relazione con l'oggetto dichiarato. */
+    canDescend(entry: PathEntry): boolean;
     clear(): void;
-    describe(field: FlowFieldDescription): string;
+    describe(entry: PathEntry): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldPickerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldPickerComponent, "fb-field-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "object": { "alias": "object"; "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>;
 }
@@ -2631,55 +2928,76 @@ declare class StructureMemberPickerComponent {
     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;
+    /**
+     * La navigazione del percorso corrente, dalla classe in giu'. Il testo digitato conta quanto il
+     * valore: mentre si scrive `Cliente.No` l'elenco deve già essere quello dei campi di `Cliente`.
+     */
+    private readonly navigation;
+    private readonly resolution;
     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[]>;
+    /** La tappa in cui si sta scrivendo: la classe di partenza, o quella in cui si e' entrati. */
+    private readonly tail;
+    /** Cio' che si premette al nome scelto: `''` sul primo segmento, `Cliente.` sul secondo. */
+    readonly prefix: _angular_core.Signal<string>;
     /**
-     * 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.
+     * Con `usage="writable"` i segmenti di sola lettura non si propongono affatto — con
+     * un'eccezione: quelli **navigabili** restano, perche' un membro record che non si sostituisce
+     * puo' avere campi aggiornabili, e nasconderlo chiuderebbe la strada a `Richiesta.Cliente.Email`.
+     */
+    readonly available: _angular_core.Signal<PathEntry[]>;
+    readonly options: _angular_core.Signal<PathEntry[]>;
+    /**
+     * Come chiamare la tappa: 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 o dell'entita'.
      */
     readonly classLabel: _angular_core.Signal<string>;
-    /** Elenco autorevole: solo qui un membro fuori elenco e' un errore (§4.7.1). */
+    /** `true` se la tappa in cui si scrive ha un elenco **autorevole** (§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. */
+    /** Nell'elenco dei campi di un'entita' il titolo lo dice: non sono membri di una classe. */
+    readonly isObjectLevel: _angular_core.Signal<boolean>;
+    private readonly rootStatus;
+    /** 404 sulla classe di partenza: 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;
+    /** Catalogo assente per un motivo che non riguarda la classe: "non lo so". */
+    readonly loadErrored: _angular_core.Signal<boolean>;
     readonly isUnknown: _angular_core.Signal<boolean>;
-    /** Il messaggio elenca i disponibili: dire solo "non esiste" non aiuta a correggere. */
+    /** §4.4, §4.7.1 — la catena si e' interrotta: avviso, non errore. */
+    readonly isNotVerifiable: _angular_core.Signal<boolean>;
+    /**
+     * Il messaggio elenca i disponibili: dire solo "non esiste" non aiuta a correggere. Su un
+     * percorso annidato il segmento che manca e' di **quella** tappa, e le parole cambiano con essa —
+     * un campo di un'entita' non e' un membro di una classe.
+     */
     readonly unknownMessage: _angular_core.Signal<string>;
+    readonly notVerifiableMessage: _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.
+     * Un segmento 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. Su un
+     * campo di record "scrivibile" vuol dire `createable` **oppure** `updateable` (§5.7).
      */
     readonly isNotWritable: _angular_core.Signal<boolean>;
+    readonly notWritableMessage: _angular_core.Signal<"Questo campo non si scrive ne’ creando ne’ aggiornando un record: assegnarlo e’ TARGET_NOT_WRITABLE." | "Questo membro e’ calcolato: si legge, ma assegnarlo e’ TARGET_NOT_WRITABLE.">;
     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;
+    choose(entry: PathEntry): void;
+    /**
+     * Scende dentro un membro composto invece di sceglierlo: e' l'equivalente di scrivere il punto, e
+     * infatti scrive il punto. Serve perche' `Richiesta.Cliente` puo' essere la destinazione che si
+     * vuole **oppure** la tappa da cui continuare.
+     */
+    descend(entry: PathEntry): void;
+    canDescend(entry: PathEntry): boolean;
     clear(): void;
-    describe(member: FlowStructureMember): string;
+    describe(entry: PathEntry): 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>;
 }
@@ -3305,7 +3623,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. */
@@ -3315,12 +3633,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>;
@@ -3524,6 +3855,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`. */
@@ -3606,5 +3945,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, 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 };
+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, describePathEntry, elementIcon, emptyFlowDefinition, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, loadPathLevel, moveCondition, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, resolvePath, 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, PathCatalog, PathContainer, PathContainerKind, PathEntry, PathLevel, PathLevelStatus, PathNavigation, PathNavigationRequest, PathResolution, PathStopReason, StructureMemberUsage, ValueMode };