@esfaenza/flow-builder 20.3.14 → 20.3.16

package/index.d.ts

@@ -2,6 +2,7 @@ import * as _angular_core 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';
+import { CdkDragMove, CdkDragEnd } from '@angular/cdk/drag-drop';
 
 /**
  * Modello del documento Flow — FRONTEND.md §3, §4, §5.
@@ -131,7 +132,11 @@ interface FlowFormula {
     description?: string;
     dataType?: FlowDataType;
     scale?: number;
-    /** Passata verbatim al motore di regole: il backend non la valida (§4.6). */
+    /**
+     * Passata verbatim al motore di regole: il backend non la interpreta, ma la fa **verificare**
+     * al motore — `POST /flows/validate-formula` mentre si digita, e la stessa cosa durante la
+     * validazione del documento (§4.6, §6.3).
+     */
     expression?: string;
 }
 interface FlowTextTemplate {
@@ -188,6 +193,91 @@ interface FlowScreen extends FlowNodeBase {
     outputParameters?: FlowOutputParameter[];
     connector?: FlowConnector;
 }
+/**
+ * §5.2 — il tipo di un campo di screen dinamico. L'elenco autoritativo e' il dizionario
+ * `screenFieldTypes`, che porta anche i flag (`storesValue`, `isContainer`, …) con cui
+ * l'editor decide quali campi mostrare: qui il tipo e' aperto proprio per quello.
+ */
+type FlowScreenFieldType = 'DisplayText' | 'InputField' | 'LargeTextArea' | 'PasswordField' | 'RadioButtons' | 'DropdownBox' | 'MultiSelectCheckboxes' | 'MultiSelectPicklist' | 'ComponentInstance' | 'Region' | 'RegionContainer' | 'ObjectProvided' | string;
+/** §5.2 — la sezione con o senza intestazione. */
+type FlowRegionContainerType = 'SectionWithHeader' | 'SectionWithoutHeader' | string;
+/** §5.2 — cosa succede ai valori quando si torna sulla schermata. */
+type FlowScreenFieldInputsRevisited = 'UseStoredValues' | 'ResetValues' | string;
+/** §5.2 — regola di validazione di un campo: espressione piu' messaggio d'errore. */
+interface FlowScreenValidationRule {
+    formulaExpression?: string;
+    errorMessage?: string;
+}
+/**
+ * §5.2 — un campo di uno screen dinamico.
+ *
+ * Due cose che il tipo non dice da solo:
+ *  - un campo che raccoglie un valore **e' una risorsa del flow**, referenziabile per nome e di
+ *    sola lettura (`kind: "ScreenField"`, §4.6): il suo `name` vive nello stesso spazio dei nomi
+ *    di node e risorse (§3.3), e un Assignment che ci scrive e' `TARGET_NOT_WRITABLE`;
+ *  - `fields` esiste solo sui contenitori (`Region`, `RegionContainer`) e l'annidamento previsto
+ *    e' **sezione → colonne → campi**: piu' profondo di così e' un avviso.
+ */
+interface FlowScreenField {
+    name?: string;
+    /** Obbligatorio: senza, `SCREEN_FIELD_TYPE_MISSING`. */
+    fieldType?: FlowScreenFieldType;
+    /** La label; per `DisplayText` e' il testo stesso. Supporta i merge field `{!...}`. */
+    fieldText?: string;
+    helpText?: string;
+    /** Obbligatorio dove il tipo `storesValue`, tranne `ObjectProvided` (§5.2). */
+    dataType?: FlowDataType;
+    objectType?: string;
+    isRequired?: boolean;
+    /** Default `true`. A `false` il runtime **ignora** cio' che il client rimanda indietro. */
+    isEditable?: boolean;
+    defaultValue?: FlowValue;
+    /** Nome di una choice; fuori da `choiceReferences` e' un avviso. */
+    defaultSelectedChoiceReference?: string;
+    /** Nomi di `FlowChoice` o `FlowDynamicChoiceSet`, **nell'ordine di presentazione**. */
+    choiceReferences?: string[];
+    scale?: number;
+    maxLength?: number;
+    /** 1..12 nella griglia della schermata: il frontend puo' ignorarla. */
+    width?: number;
+    /** Solo sui contenitori: sezione → colonne → campi. */
+    fields?: FlowScreenField[];
+    regionContainerType?: FlowRegionContainerType;
+    /** `ComponentInstance`: il componente del frontend, dal catalogo dei form. */
+    extensionName?: string;
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    /** Insieme a `outputParameters` e' `OUTPUT_CONFIGURATION_CONFLICT` (§5.2). */
+    storeOutputAutomatically?: boolean;
+    /** `ObjectProvided`: forma `<Oggetto>.<Campo>`. */
+    objectFieldReference?: string;
+    inputsOnNextNavToAssocScrn?: FlowScreenFieldInputsRevisited;
+    validationRule?: FlowScreenValidationRule;
+    /** Come una regola di Decision: rivalutata sui valori appena inviati (§5.2). */
+    visibilityRule?: FlowConditionHolder;
+}
+/**
+ * §5.2 — lo screen dinamico: **descrive i propri campi**, invece di referenziare un form.
+ *
+ * E' il complemento dello Screen a form (§5.1), non il suo sostituto: convivono nello stesso
+ * flow e il motore li tratta allo stesso modo. Cambia chi decide il layout.
+ */
+interface FlowDynamicScreen extends FlowNodeBase {
+    helpText?: string;
+    allowBack?: boolean;
+    allowFinish?: boolean;
+    allowPause?: boolean;
+    pausedText?: string;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    backButtonLabel?: string;
+    nextOrFinishButtonLabel?: string;
+    pauseButtonLabel?: string;
+    /** Nome di uno stage dichiarato: alimenta l'indicatore di avanzamento. */
+    stageReference?: string;
+    fields?: FlowScreenField[];
+    connector?: FlowConnector;
+}
 type FlowAssignmentOperator = 'Assign' | 'Add' | 'Subtract' | 'AddAtStart' | 'AssignCount' | 'RemoveFirst' | 'RemoveAll' | 'RemovePosition' | 'RemoveAfterFirst' | 'RemoveBeforeFirst' | 'RemoveUncommon' | string;
 interface FlowAssignmentItem {
     assignToReference?: string;
@@ -504,6 +594,7 @@ interface FlowDefinition {
     dynamicChoiceSets?: FlowDynamicChoiceSet[];
     stages?: FlowStage[];
     screens?: FlowScreen[];
+    dynamicScreens?: FlowDynamicScreen[];
     assignments?: FlowAssignment[];
     decisions?: FlowDecision[];
     loops?: FlowLoop[];
@@ -530,13 +621,13 @@ interface FlowDefinition {
     customProperties?: FlowCustomProperty[];
 }
 /** Le collection di node: `metadataProperty` del dizionario `elementTypes` (§3.2). */
-declare const FLOW_NODE_COLLECTIONS: readonly ["screens", "assignments", "decisions", "loops", "collectionProcessors", "recordLookups", "recordCreates", "recordUpdates", "recordDeletes", "recordRollbacks", "actionCalls", "scriptPluginCalls", "subflows", "transforms", "waits", "customErrors", "orchestratedStages", "steps", "experiments"];
+declare const FLOW_NODE_COLLECTIONS: readonly ["screens", "dynamicScreens", "assignments", "decisions", "loops", "collectionProcessors", "recordLookups", "recordCreates", "recordUpdates", "recordDeletes", "recordRollbacks", "actionCalls", "scriptPluginCalls", "subflows", "transforms", "waits", "customErrors", "orchestratedStages", "steps", "experiments"];
 type FlowNodeCollection = (typeof FLOW_NODE_COLLECTIONS)[number];
 /** Le collection di risorse (§4.6). Condividono lo spazio dei nomi con i node (§3.3). */
 declare const FLOW_RESOURCE_COLLECTIONS: readonly ["variables", "constants", "formulas", "textTemplates", "choices", "dynamicChoiceSets", "stages"];
 type FlowResourceCollection = (typeof FLOW_RESOURCE_COLLECTIONS)[number];
 /** Il discriminatore `value` del dizionario `elementTypes`. */
-type FlowElementType = 'Screen' | 'Assignment' | 'Decision' | 'Loop' | 'CollectionProcessor' | 'CustomError' | 'Wait' | 'RecordLookup' | 'RecordCreate' | 'RecordUpdate' | 'RecordDelete' | 'RecordRollback' | 'ActionCall' | 'ScriptCall' | 'Subflow' | 'Transform' | 'OrchestratedStage' | 'Step' | 'Experiment' | string;
+type FlowElementType = 'Screen' | 'DynamicScreen' | 'Assignment' | 'Decision' | 'Loop' | 'CollectionProcessor' | 'CustomError' | 'Wait' | 'RecordLookup' | 'RecordCreate' | 'RecordUpdate' | 'RecordDelete' | 'RecordRollback' | 'ActionCall' | 'ScriptCall' | 'Subflow' | 'Transform' | 'OrchestratedStage' | 'Step' | 'Experiment' | string;
 /** Un node qualunque, come lo vede il canvas. */
 type FlowAnyNode = FlowNodeBase & Record<string, unknown>;
 
@@ -629,6 +720,27 @@ interface FlowStageStepTypeEntry extends FlowDictionaryEntry {
     /** `true` → il rifiuto e' un esito previsto, e prende il `faultConnector` dello stage. */
     supportsRejection?: boolean;
 }
+/**
+ * §5.2, §6.4 — un tipo di campo di screen dinamico.
+ *
+ * E' l'unica voce di dizionario che porta piu' di `value`/`label`/`description`, e i flag non
+ * sono un di piu': sono **gli stessi** che applica il runtime. Reimplementarli lato editor
+ * porta prima o poi a proporre una configurazione che il motore rifiuta — un `dataType` su un
+ * `DisplayText`, delle choice su una textarea.
+ */
+interface FlowScreenFieldTypeEntry extends FlowDictionaryEntry {
+    value: FlowScreenFieldType;
+    /** Il campo raccoglie un valore: e' una risorsa del flow, e vuole `dataType`, default, … */
+    storesValue?: boolean;
+    /** Il valore raccolto e' una **collection**, non una stringa con i valori concatenati. */
+    isCollection?: boolean;
+    /** Il campo si configura con `choiceReferences`. */
+    acceptsChoices?: boolean;
+    /** Il campo contiene altri campi (`Region`, `RegionContainer`). */
+    isContainer?: boolean;
+    /** `dataType` obbligatorio: senza, `DATA_TYPE_MISSING`. */
+    requiresDataType?: boolean;
+}
 interface FlowResourceKindEntry extends FlowDictionaryEntry {
     /** Solo le variabili sono scrivibili (§4.6). */
     isWritable?: boolean;
@@ -667,6 +779,12 @@ interface FlowDictionaries {
     assigneeTypes?: FlowDictionaryEntry[];
     conditionLogicModes?: FlowDictionaryEntry[];
     screenNavigations?: FlowDictionaryEntry[];
+    /** §5.2 — i tipi di campo di uno screen dinamico, con i flag che guidano il form. */
+    screenFieldTypes?: FlowScreenFieldTypeEntry[];
+    /** §5.2 — `SectionWithHeader` | `SectionWithoutHeader`. */
+    regionContainerTypes?: FlowDictionaryEntry[];
+    /** §5.2 — `UseStoredValues` | `ResetValues` (`inputsOnNextNavToAssocScrn`). */
+    screenFieldInputsRevisited?: FlowDictionaryEntry[];
 }
 interface FlowObjectSummary {
     name: string;
@@ -840,6 +958,50 @@ interface FlowValidationResult {
     warningCount: number;
     isValid: boolean;
 }
+/**
+ * Dove comparira' l'espressione. Non e' cosmesi: e' cio' che permette al motore di dire
+ * «qui serve un booleano» invece di accettare un'espressione che poi fallira' a runtime (§6.3).
+ */
+type FlowFormulaUsage = 'Resource' | 'Condition' | 'ValidationRule' | 'Value' | string;
+/**
+ * L'unica primitiva della §6.3 che **avvolge** il documento invece di prenderlo nudo: oltre al
+ * flow deve portare l'espressione e cosa ci si aspetta che produca (§6.4, ultimo capoverso).
+ * Il documento va mandato **in lavorazione**: una formula cita le variabili appena aggiunte, e
+ * verificarla contro la versione salvata la direbbe sbagliata.
+ */
+interface FlowFormulaValidationRequest {
+    flow: FlowDefinition;
+    expression: string;
+    /** `Boolean` per una condizione o una validation rule, il tipo dichiarato per una risorsa. */
+    expectedDataType?: FlowDataType;
+    usage?: FlowFormulaUsage;
+    /** Solo dove il tipo atteso e' `Number` o `Integer` (§4.6). */
+    scale?: number;
+}
+/**
+ * Come {@link FlowValidationIssue}, piu' la **posizione del tratto sbagliato** dentro
+ * l'espressione: e' il motivo per cui questa primitiva esiste accanto a `POST /flows/validate`.
+ * `code` resta del motore: l'elenco della §7 non lo comprende, quindi si mostra e non si
+ * interpreta.
+ */
+interface FlowFormulaIssue extends FlowValidationIssue {
+    /** Indice del primo carattere, 0-based. Puo' mancare: non ogni rilievo ha una posizione. */
+    position?: number | null;
+    length?: number | null;
+}
+interface FlowFormulaValidationResult {
+    issues: FlowFormulaIssue[];
+    /** Il tipo che l'espressione produce, quando il motore sa dirlo. Puo' mancare. */
+    resultDataType?: FlowDataType | null;
+    isCollection?: boolean;
+    /**
+     * `false` significa «nessun motore di validazione configurato»: nessun rilievo, ma nemmeno
+     * una conferma. **Non e' una promozione** — una spunta verde su un'espressione mai
+     * controllata e' peggio di nessuna spunta (§6.3).
+     */
+    isVerified: boolean;
+    isValid: boolean;
+}
 interface FlowCreateRequest {
     definition: FlowDefinition;
     flowName?: string;
@@ -1191,6 +1353,21 @@ declare abstract class FlowBuilderApi {
     abstract validateDefinition(definition: FlowDefinition): Promise<FlowValidationResult>;
     /** `GET /flows/{name}/versions/{v}/validate` — valida una versione già salvata. */
     validateVersion(flowName: string, version: number): Promise<FlowValidationResult>;
+    /**
+     * `POST /flows/validate-formula` — verifica **una sola** espressione mentre l'utente la
+     * scrive (§6.3). È l'editor di formule, non il pannello dei problemi: i rilievi portano la
+     * `position` del tratto sbagliato, che la validazione dell'intero documento non ha.
+     *
+     * Unica primitiva di analisi con un involucro: il documento sta sotto `flow` perche' il body
+     * deve portare anche l'espressione e il tipo atteso (§6.4).
+     *
+     * Opzionale come tutte le primitive che dipendono da un servizio dell'host: senza motore di
+     * validazione delle formule l'editor deve restare usabile. Ci sono **due** modi in cui manca,
+     * e sono diversi — il rifiuto `MissingService` (la primitiva non c'e') e la risposta con
+     * `isVerified: false` (la primitiva c'e', il motore no): in entrambi i casi l'espressione non
+     * si accompagna a una conferma, mai a una spunta verde.
+     */
+    validateFormula(request: FlowFormulaValidationRequest): Promise<FlowFormulaValidationResult>;
     /**
      * `GET /flows/dictionaries?processType=` — le tendine in una risposta.
      *
@@ -1386,6 +1563,11 @@ declare class HttpFlowBuilderApi extends FlowBuilderApi {
      * validazione di un flow vuoto, cioe' «manca lo Start».
      */
     validateDefinition(definition: FlowDefinition): Promise<FlowValidationResult>;
+    /**
+     * L'eccezione alla regola del documento nudo: qui l'involucro c'e' e il flow sta sotto
+     * `flow`, perche' il body porta anche l'espressione e cosa deve produrre (§6.3, §6.4).
+     */
+    validateFormula(request: FlowFormulaValidationRequest): Promise<FlowFormulaValidationResult>;
     validateVersion(flowName: string, version: number): Promise<FlowValidationResult>;
     getDictionaries(processType?: string): Promise<FlowDictionaries>;
     /**
@@ -1742,6 +1924,77 @@ declare function stageStepOutputReferenced(reference: string | undefined, steps:
  */
 declare const ORCHESTRATION_CONDITION_OUTPUT = "isOrchestrationConditionMet";
 
+/**
+ * L'albero dei campi di uno screen dinamico — FRONTEND.md §5.2.
+ *
+ * Un campo puo' contenerne altri (`Region` dentro `RegionContainer`), quindi «il campo
+ * selezionato» non e' un indice ma un **percorso di indici**: `[1, 0, 2]` e' il terzo campo
+ * della prima colonna della seconda sezione. Tutto cio' che cammina l'albero sta qui, perche'
+ * inspector, store e outline lo fanno con la stessa regola e sbagliarne una copia significa
+ * scrivere in un campo diverso da quello che l'utente vede selezionato.
+ *
+ * L'altra ragione per cui questo file esiste: **i campi che raccolgono un valore sono risorse
+ * del flow** (§5.2). I loro nomi vivono nello stesso spazio dei nomi di node e risorse (§3.3),
+ * quindi `usedNames` dello store deve comprenderli — un campo omonimo di una variabile e'
+ * `NAME_DUPLICATED`, non una stranezza tollerata.
+ */
+
+/** Il percorso di un campo nell'albero: indici dalla radice alla foglia. */
+type FlowScreenFieldPath = number[];
+/** Un campo con il suo percorso e la sua profondita': e' cio' che l'albero mostra. */
+interface FlowScreenFieldNode {
+    field: FlowScreenField;
+    path: FlowScreenFieldPath;
+    depth: number;
+}
+/** Uguaglianza fra percorsi: due array diversi con gli stessi indici sono lo stesso campo. */
+declare function samePath(a: FlowScreenFieldPath | null, b: FlowScreenFieldPath | null): boolean;
+/** `true` se `parent` e' un antenato di `path` (o lo stesso campo). */
+declare function isPathInside(parent: FlowScreenFieldPath, path: FlowScreenFieldPath): boolean;
+/** Chiave stabile di un percorso: serve al `track` e agli id delle liste di trascinamento. */
+declare function pathKey(path: FlowScreenFieldPath): string;
+/** Il campo a un percorso, o `undefined` se il percorso non esiste piu'. */
+declare function fieldAt(fields: FlowScreenField[] | undefined, path: FlowScreenFieldPath): FlowScreenField | undefined;
+/** L'albero appiattito in ordine di visita, con profondita': e' l'elenco che si disegna. */
+declare function flattenFields(fields: FlowScreenField[] | undefined, parentPath?: FlowScreenFieldPath): FlowScreenFieldNode[];
+/** Tutti i campi di uno screen, in ordine di visita. */
+declare function allFieldsOf(screen: FlowDynamicScreen | undefined): FlowScreenField[];
+/**
+ * I nomi dei campi di tutti gli screen dinamici del documento.
+ *
+ * Contenitori compresi: un `Region` non e' una risorsa — non raccoglie un valore — ma il suo
+ * nome resta un nome, e due campi omonimi nella stessa schermata sono comunque un problema.
+ * Chi vuole i **soli** riferimenti proponibili usa `isFieldResource`.
+ */
+declare function screenFieldNames(definition: FlowDefinition | undefined): string[];
+/**
+ * §5.2 — il campo e' una risorsa del flow (`kind: "ScreenField"`), quindi referenziabile
+ * per nome ovunque e **di sola lettura**.
+ *
+ * Un `ComponentInstance` non lo e' pur essendo un campo: non ha un valore proprio, ce l'hanno
+ * i suoi output. Il flag `storesValue` arriva dal dizionario, che e' l'unica fonte autoritativa:
+ * senza la voce del dizionario si risponde `false`, cioe' "non lo so" — proporre un riferimento
+ * che il backend non conosce e' peggio che non proporlo.
+ */
+declare function isFieldResource(field: FlowScreenField | undefined, entry: FlowScreenFieldTypeEntry | undefined): boolean;
+/** Inserisce un campo dentro `parentPath` alla posizione indicata (in fondo se assente). */
+declare function insertField(screen: FlowDynamicScreen, parentPath: FlowScreenFieldPath, field: FlowScreenField, index?: number): FlowScreenFieldPath | undefined;
+/** Rimuove il campo a un percorso, e con esso tutto cio' che conteneva. */
+declare function removeField(screen: FlowDynamicScreen, path: FlowScreenFieldPath): void;
+/**
+ * Sposta un campo dentro un'altra lista, a una posizione precisa.
+ *
+ * `toIndex` e' l'indice **dopo** l'estrazione, cioe' la stessa convenzione di
+ * `moveItemInArray` del CDK: e' l'indice che il drop del trascinamento consegna, e riallinearlo
+ * qui sposterebbe di uno ogni trascinamento verso il basso nella stessa lista.
+ *
+ * Uno spostamento dentro se stesso e' rifiutato: sposterebbe un contenitore dentro il proprio
+ * sottoalbero, e il sottoalbero sparirebbe con lui.
+ */
+declare function moveField(screen: FlowDynamicScreen, from: FlowScreenFieldPath, toParent: FlowScreenFieldPath, toIndex: number): FlowScreenFieldPath | undefined;
+/** Duplica un campo accanto all'originale, rinominandolo: i nomi restano unici (§3.3). */
+declare function duplicateField(screen: FlowDynamicScreen, path: FlowScreenFieldPath, newName: string): FlowScreenFieldPath | undefined;
+
 /**
  * La gravita' di un rilievo, ridotta a tre secchi — FRONTEND.md §7.
  *
@@ -1816,6 +2069,27 @@ declare class FlowDictionaryStore {
     readonly stageStepTypes: _angular_core.Signal<FlowStageStepTypeEntry[]>;
     readonly assigneeTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
     readonly conditionLogicModes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly regionContainerTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly screenFieldInputsRevisited: _angular_core.Signal<FlowDictionaryEntry[]>;
+    /** §5.2 — i tipi di campo di uno screen dinamico, con i flag che guidano il form. */
+    readonly screenFieldTypes: _angular_core.Signal<FlowScreenFieldTypeEntry[]>;
+    /**
+     * La voce di un tipo di campo. **Non c'e' un fallback cablato**, di proposito: i flag sono gli
+     * stessi che applica il runtime (§5.2, §6.4), e indovinarli qui vorrebbe dire proporre una
+     * configurazione che il motore rifiuta. Voce assente = nessun flag, cioe' il form mostra i soli
+     * campi comuni e lascia decidere al backend.
+     */
+    screenFieldType(value: string | undefined | null): FlowScreenFieldTypeEntry | undefined;
+    /** §5.2 — il campo raccoglie un valore: e' una risorsa, e vuole tipo, default, … */
+    screenFieldStoresValue(value: string | undefined | null): boolean;
+    /** §5.2 — il campo contiene altri campi: `Region`, `RegionContainer`. */
+    screenFieldIsContainer(value: string | undefined | null): boolean;
+    /** §5.2 — il campo si configura con `choiceReferences`. */
+    screenFieldAcceptsChoices(value: string | undefined | null): boolean;
+    /** §5.2 — `dataType` obbligatorio: senza, `DATA_TYPE_MISSING`. */
+    screenFieldRequiresDataType(value: string | undefined | null): boolean;
+    /** §5.2 — il valore raccolto e' una collection: contano gli operatori di collection. */
+    screenFieldIsCollection(value: string | undefined | null): boolean;
     readonly elementTypes: _angular_core.Signal<FlowElementTypeEntry[]>;
     /**
      * I tipi mostrabili nella palette: `isSupported: false` va nascosto (§3.2, §13.9).
@@ -2229,10 +2503,12 @@ declare class FlowDocumentStore {
     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).
+     * §3.3 — l'insieme dei nomi già usati: node, risorse, step di orchestrazione **e campi di
+     * screen dinamico**, 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 (§5.13); quello che dimentica i campi
+     * lascia passare un campo omonimo di una variabile, che e' `NAME_DUPLICATED` come gli altri
+     * — e lì il danno e' peggiore, perche' un campo **e' un riferimento** (§5.2).
      */
     readonly usedNames: _angular_core.Signal<string[]>;
     /** Gli archi derivati dal documento, Start incluso. */
@@ -2289,6 +2565,15 @@ declare class FlowDocumentStore {
      * riferimenti a output automatico (`Vecchio.Campo` → `Nuovo.Campo`).
      */
     renameNode(oldName: string, newName: string): void;
+    /**
+     * §5.2 — rinomina un campo di screen dinamico riscrivendo i riferimenti che lo usano.
+     *
+     * Un campo che raccoglie un valore **e' una risorsa** referenziabile per nome: rinominarlo
+     * senza riscrivere le condizioni e le assegnazioni che lo citano lascia dei
+     * `REFERENCE_UNKNOWN` che si scoprono solo alla validazione. Vale la stessa regola dei node
+     * (§13.8): nessuna primitiva del backend lo fa, lo fa l'editor.
+     */
+    renameScreenField(nodeName: string, path: FlowScreenFieldPath, newName: string): void;
     /** Rinomina una risorsa, riscrivendo i riferimenti che la usano. */
     renameResource(collection: FlowResourceCollection, index: number, newName: string): void;
     /**
@@ -2378,6 +2663,29 @@ declare class FlowValidationStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowValidationStore>;
 }
 
+declare class FormulaValidationService {
+    private readonly api;
+    private readonly _isSupported;
+    private readonly _lastError;
+    /**
+     * `false` quando la primitiva non e' esposta da questo ambiente. Diverso da
+     * `isVerified: false` nella risposta, che dice «primitiva sì, motore no»: per l'utente
+     * l'effetto e' lo stesso — nessuna conferma — ma il secondo caso lo dice il backend e lo si
+     * riferisce, il primo e' silenzio (§6.3).
+     */
+    readonly isSupported: _angular_core.Signal<boolean>;
+    readonly lastError: _angular_core.Signal<string | null>;
+    /** Ci si puo' provare: la primitiva c'e' e l'ultima chiamata non e' esplosa. */
+    readonly canValidate: _angular_core.Signal<boolean>;
+    /**
+     * Verifica l'espressione. `null` significa «non lo so»: primitiva assente o richiesta
+     * fallita. Non e' «formula valida» — chi chiama non deve mostrare una conferma su un `null`.
+     */
+    validate(request: FlowFormulaValidationRequest): Promise<FlowFormulaValidationResult | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormulaValidationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormulaValidationService>;
+}
+
 interface FlowLayoutNodeInput {
     name: string;
     width: number;
@@ -2789,7 +3097,11 @@ declare class ElementPaletteComponent {
     readonly isEmpty: _angular_core.Signal<boolean>;
     onFilter(value: string): void;
     pick(item: PaletteItem): void;
-    /** Uno screen in un flow che non mostra nulla: si segnala, non si nasconde (§3.1). */
+    /**
+     * Uno screen in un flow che non mostra nulla: si segnala, non si nasconde (§3.1). Vale per
+     * entrambi i tipi di screen — quello a form e quello dinamico sono la stessa interazione con
+     * l'utente, e in un flow `AutoLaunched` non c'e' nessuno a cui mostrarli.
+     */
     isIncompatible(item: PaletteItem): boolean;
     /**
      * Il testo del tooltip. Su una voce che nasce da una variante ci va anche il nome del tipo:
@@ -2935,7 +3247,7 @@ declare class ReferencePickerComponent {
      *    percorso inesistente di uno scope che i percorsi li dichiara, perche' lì il backend
      *    risponderebbe `GLOBAL_UNKNOWN`.
      */
-    readonly valueState: _angular_core.Signal<"member" | "empty" | "unknown" | "known" | "navigated" | "host" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid">;
+    readonly valueState: _angular_core.Signal<"empty" | "unknown" | "member" | "known" | "navigated" | "host" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid">;
     /** Le parole cambiano con la tappa: un campo di un'entita' non e' un membro di una classe. */
     private readonly tailIsObject;
     private readonly tailContainer;
@@ -3087,7 +3399,7 @@ declare class NamePickerComponent {
      * **errori** che bloccano l'attivazione (`ACTION_UNKNOWN`, `FORM_UNKNOWN`), mentre un flow
      * senza versione attiva e' un avviso. Mostrarli con lo stesso colore direbbe il falso.
      */
-    readonly unknownSeverity: _angular_core.InputSignal<"warn" | "error">;
+    readonly unknownSeverity: _angular_core.InputSignal<"error" | "warn">;
     /** Cosa dire quando l'elenco e' vuoto: e' il caso "non lo so", non un errore. */
     readonly emptyMessage: _angular_core.InputSignal<string>;
     /** Testo monospazio: i nomi tecnici si leggono meglio, ed e' come li mostra il resto del form. */
@@ -3237,6 +3549,114 @@ declare class EnumValuePickerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<EnumValuePickerComponent, "fb-enum-value-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "enumType": { "alias": "enumType"; "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>;
 }
 
+declare class FormulaEditorComponent {
+    private readonly store;
+    private readonly api;
+    private readonly service;
+    private readonly destroyRef;
+    readonly expression: _angular_core.InputSignal<string>;
+    /** Dove comparira': e' cio' che dice al motore cosa pretendere (§6.3). */
+    readonly usage: _angular_core.InputSignal<string>;
+    /** `Boolean` per condizioni e validation rule, il tipo dichiarato per una risorsa. */
+    readonly expectedDataType: _angular_core.InputSignal<string | undefined>;
+    readonly scale: _angular_core.InputSignal<number | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly rows: _angular_core.InputSignal<number>;
+    /**
+     * Quando propagare al documento. `input` a ogni tasto, `change` all'uscita dal campo: la
+     * seconda serve dove mutare il documento ridisegna mezza schermata — l'anteprima dello screen
+     * dinamico — e riscriverla a ogni tasto costa. La **verifica** parte comunque durante la
+     * digitazione: usa la bozza locale, non cio' che e' arrivato al documento.
+     */
+    readonly commitOn: _angular_core.InputSignal<"input" | "change">;
+    readonly expressionChange: _angular_core.OutputEmitterRef<string>;
+    private readonly area;
+    /**
+     * Il testo che si sta scrivendo. Non e' legato al DOM — la casella tiene il suo valore e la
+     * `[value]` resta quella del documento — perche' riscrivere l'attributo a ogni tasto sposta il
+     * cursore quando si corregge in mezzo all'espressione.
+     */
+    private readonly draft;
+    private readonly _result;
+    private readonly _isChecking;
+    private timer?;
+    /** Cresce a ogni richiesta: scarta le risposte di verifiche già superate. */
+    private sequence;
+    readonly result: _angular_core.Signal<FlowFormulaValidationResult | null>;
+    readonly isChecking: _angular_core.Signal<boolean>;
+    readonly isSupported: _angular_core.Signal<boolean>;
+    /**
+     * I nomi citabili, per l'autocompletamento (§6.3): li da' `POST /flows/references`, cioe' la
+     * stessa fonte del reference picker — compresi gli **output automatici**, che sono riferimenti
+     * validi pur non essendo dichiarati in nessuna collection (§4.5, §13.3). Qui non si filtra per
+     * tipo: dentro un'espressione il tipo lo decide il motore, non il campo.
+     */
+    private readonly references;
+    /** Il documento per cui l'elenco e' stato chiesto: evita una richiesta a ogni focus. */
+    private loadedFor;
+    /** La parola sotto il cursore, che e' cio' che si sta completando. */
+    private readonly token;
+    protected readonly highlighted: _angular_core.WritableSignal<number>;
+    readonly suggestions: _angular_core.Signal<FlowReference[]>;
+    readonly issues: _angular_core.Signal<FlowFormulaIssue[]>;
+    readonly hasErrors: _angular_core.Signal<boolean>;
+    /**
+     * L'esito e' una conferma **solo** se un motore ha davvero guardato l'espressione: senza
+     * `isVerified` non si mostra la spunta, perche' una spunta verde su un'espressione mai
+     * controllata e' peggio di nessuna spunta (§6.3).
+     */
+    readonly isConfirmed: _angular_core.Signal<boolean>;
+    /** Il motore c'e' come primitiva ma non come motore: si dice, non si tace (§6.3). */
+    readonly isUnverified: _angular_core.Signal<boolean>;
+    /**
+     * Il tipo prodotto quando il motore sa dirlo. Serve a segnalare una formula dichiarata
+     * `String` che restituisce una data — ma il rilievo lo fa il motore: se l'ha già emesso,
+     * qui non si ripete lo stesso avviso con parole diverse.
+     */
+    readonly resultDataType: _angular_core.Signal<string | null>;
+    readonly typeMismatch: _angular_core.Signal<{
+        expected: string;
+        produced: string;
+    } | null>;
+    constructor();
+    onInput(value: string): void;
+    onCommit(value: string): void;
+    onFocus(): void;
+    /** Il cursore si sposta anche senza digitare: la parola sotto il cursore va riletta. */
+    onCaretMove(): void;
+    onBlur(): void;
+    /**
+     * Le frecce scorrono l'elenco e Invio inserisce. Senza, l'elenco sarebbe una decorazione: chi
+     * scrive una formula ha le mani sulla tastiera e non va a cercare il mouse.
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Sostituisce la parola sotto il cursore col nome scelto. Si scrive nel DOM e poi si propaga:
+     * la casella e' la sorgente del testo mentre si digita, e riscrivere solo il documento
+     * lascerebbe indietro il cursore.
+     */
+    insert(name: string): void;
+    private loadReferences;
+    /** La parola sotto il cursore: identificatore o percorso puntato, com'e' in un riferimento. */
+    private refreshToken;
+    severityOf(issue: FlowFormulaIssue): string;
+    hasPosition(issue: FlowFormulaIssue): boolean;
+    /** Il tratto citato dal rilievo, così il messaggio dice *dove* anche senza il salto. */
+    excerptOf(issue: FlowFormulaIssue): string;
+    /**
+     * Porta il cursore sul tratto segnalato. È il payoff di `position`: un indice di carattere
+     * che l'utente dovrebbe contare a mano non aiuta nessuno.
+     */
+    goToIssue(issue: FlowFormulaIssue): void;
+    private schedule;
+    private run;
+    private cancel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormulaEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormulaEditorComponent, "fb-formula-editor", never, { "expression": { "alias": "expression"; "required": false; "isSignal": true; }; "usage": { "alias": "usage"; "required": false; "isSignal": true; }; "expectedDataType": { "alias": "expectedDataType"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "commitOn": { "alias": "commitOn"; "required": false; "isSignal": true; }; }, { "expressionChange": "expressionChange"; }, never, ["*"], true, never>;
+}
+
 /** Le modalita' offerte: una per campo del modello. */
 type ValueMode = 'reference' | 'literal' | 'formula' | 'globalConstant' | 'empty';
 declare class ValueEditorComponent {
@@ -3363,7 +3783,7 @@ declare class ConditionEditorComponent {
      */
     hasTypeMismatch(condition: FlowCondition): boolean;
     typeMismatchMessage(condition: FlowCondition): string;
-    readonly logicMode: _angular_core.Signal<"formula" | "and" | "or" | "custom">;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
     readonly customLogic: _angular_core.Signal<string>;
     /** Feedback immediato sull'espressione: la verita' resta della validazione backend. */
     readonly customLogicError: _angular_core.Signal<string | null>;
@@ -3431,7 +3851,7 @@ declare class RecordFilterEditorComponent {
      * (§5.7, §13.10).
      */
     readonly emptyWarning: _angular_core.InputSignal<string | null>;
-    readonly emptyWarningSeverity: _angular_core.InputSignal<"warn" | "error">;
+    readonly emptyWarningSeverity: _angular_core.InputSignal<"error" | "warn">;
     readonly changed: _angular_core.OutputEmitterRef<(holder: FilterHolder) => void>;
     /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.7). */
     private readonly allFields;
@@ -3454,7 +3874,7 @@ declare class RecordFilterEditorComponent {
      * 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<"formula" | "and" | "or" | "custom">;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
     readonly customLogic: _angular_core.Signal<string>;
     readonly showEmptyWarning: _angular_core.Signal<boolean>;
     addFilter(): void;
@@ -3828,6 +4248,225 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrchestratedStageInspectorComponent, "fb-orchestrated-stage-inspector", never, {}, {}, never, never, true, never>;
 }
 
+/** Il punto di inserimento calcolato dal trascinamento: dove, e in che posizione. */
+interface DropTarget {
+    parent: FlowScreenFieldPath;
+    index: number;
+}
+declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
+    private readonly catalog;
+    private readonly document;
+    protected readonly dictionary: FlowDictionaryStore;
+    readonly elementType: FlowElementType;
+    readonly screen: _angular_core.Signal<FlowDynamicScreen>;
+    /** Il percorso del campo selezionato: `null` = nessuno, e a destra ci sono le proprieta'
+     * della **schermata** — lo stesso gesto del cliccare fuori da un campo. */
+    private readonly selection;
+    readonly selectedPath: _angular_core.Signal<FlowScreenFieldPath | null>;
+    readonly selectedField: _angular_core.Signal<FlowScreenField | undefined>;
+    /** La voce di dizionario del campo selezionato: e' lei a decidere il form di destra. */
+    readonly selectedType: _angular_core.Signal<FlowScreenFieldTypeEntry | undefined>;
+    /**
+     * Due elenchi e non uno: un **componente** si sceglie per tipo (che cosa fa), un **campo di
+     * un'entita'** si sceglie per nome (quale dato), e da lì tipo, etichetta, obbligatorieta' e
+     * opzioni arrivano dallo schema (§5.2). Metterli insieme costringerebbe a scegliere prima
+     * `ObjectProvided` e poi il campo, che e' il contrario dell'ordine in cui si pensa.
+     */
+    readonly paletteTab: _angular_core.WritableSignal<"fields" | "components">;
+    /** L'entita' di cui elencare i campi nella seconda scheda. */
+    readonly fieldsObject: _angular_core.WritableSignal<string | undefined>;
+    private readonly objectFields;
+    readonly fieldsOfObject: _angular_core.Signal<FlowFieldDescription[]>;
+    iconOf(type: string | undefined): string;
+    setPaletteTab(tab: 'components' | 'fields'): void;
+    setFieldsObject(object: string | undefined): void;
+    /** Componenti e form sono la stessa domanda al frontend, e lo stesso catalogo (§5.2). */
+    private readonly components;
+    private readonly componentParameters;
+    /** I tipi di enumerazione: dizionario chiuso, quindi `<select>` e non combo (§4.6). */
+    private readonly enumTypes;
+    constructor();
+    readonly componentOptions: _angular_core.Signal<NamePickerOption[]>;
+    readonly enumOptions: _angular_core.Signal<FlowCatalogEntry[]>;
+    readonly componentParameterList: _angular_core.Signal<FlowCatalogParameter[]>;
+    /**
+     * Le choice proponibili: **solo** `choices` e `dynamicChoiceSets` (§5.2). Un elenco costruito
+     * dai riferimenti in generale farebbe scegliere una variabile, che e'
+     * `SCREEN_FIELD_CHOICE_UNKNOWN`.
+     */
+    readonly choiceOptions: _angular_core.Signal<NamePickerOption[]>;
+    /** Gli stage dichiarati: `stageReference` alimenta l'indicatore di avanzamento (§5.2). */
+    readonly stageOptions: _angular_core.Signal<NamePickerOption[]>;
+    isSelected(path: FlowScreenFieldPath): boolean;
+    isContainer(field: FlowScreenField | undefined): boolean;
+    /** `true` sulla sezione, che dispone i figli **in riga**: le colonne stanno una accanto all'altra. */
+    isSection(field: FlowScreenField | undefined): boolean;
+    childPath(parent: FlowScreenFieldPath, index: number): FlowScreenFieldPath;
+    /** L'etichetta da disegnare: `fieldText`, poi il nome, poi un segnaposto esplicito. */
+    captionOf(field: FlowScreenField): string;
+    typeLabelOf(field: FlowScreenField): string;
+    /**
+     * La larghezza in dodicesimi: assente = tutta la riga, che e' il default del runtime. È anche
+     * il numero di colonne che il campo occupa nella griglia dell'anteprima, limitato a 1..12
+     * perche' un valore fuori scala romperebbe la griglia invece di segnalarsi.
+     */
+    widthOf(field: FlowScreenField): number;
+    /** `true` dove il tipo non e' nel dizionario: si dice, invece di indovinare un disegno. */
+    isUnknownType(field: FlowScreenField | undefined): boolean;
+    /**
+     * Le etichette delle opzioni, per disegnarle nell'anteprima: il `choiceText` di una
+     * `FlowChoice`, il nome del choice set (le sue opzioni sono una query, e non esistono finche'
+     * la schermata non viene presentata — §5.2).
+     */
+    choiceLabelsOf(field: FlowScreenField): string[];
+    /** Il testo mostrato dentro il controllo inerte: il default, se ce n'e' uno leggibile. */
+    placeholderOf(field: FlowScreenField): string;
+    /** Il campo che si sta trascinando: la sua anteprima si sbiadisce e non intercetta il mouse. */
+    readonly dragging: _angular_core.WritableSignal<FlowScreenFieldPath | null>;
+    /** Il punto di inserimento corrente, disegnato come una barra fra i campi. */
+    readonly dropTarget: _angular_core.WritableSignal<DropTarget | null>;
+    isDragging(path: FlowScreenFieldPath): boolean;
+    /** `true` se la barra di inserimento va disegnata qui. */
+    isDropAt(parent: FlowScreenFieldPath, index: number): boolean;
+    onFieldDragStarted(path: FlowScreenFieldPath): void;
+    onFieldDragMoved(event: CdkDragMove): void;
+    onFieldDragEnded(event: CdkDragEnd, path: FlowScreenFieldPath): void;
+    /** Trascinamento **dalla palette**: non sposta niente, crea. */
+    onPaletteDragMoved(event: CdkDragMove): void;
+    onComponentDragEnded(event: CdkDragEnd, type: string): void;
+    onObjectFieldDragEnded(event: CdkDragEnd, field: FlowFieldDescription): void;
+    /**
+     * Il documento si muta **dopo** che il gesto e' finito, non dentro `cdkDragEnded`: lì
+     * l'anteprima si ridisegnerebbe mentre il CDK sta ancora chiudendo il trascinamento
+     * sull'elemento che Angular in quel momento riusa per un altro campo. Un rinvio al task
+     * successivo basta, e per chi guarda lo spostamento resta istantaneo.
+     */
+    private afterDrag;
+    /**
+     * Il bersaglio del rilascio, calcolato dal **DOM** e non dalle drop list del CDK.
+     *
+     * Le drop list annidate qui sono ambigue per costruzione: il rettangolo di una sezione
+     * contiene quello delle sue colonne, e a ricevere il rilascio finisce sempre la lista
+     * registrata per prima, cioe' la radice. Interrogando `elementFromPoint` si prende invece il
+     * contenitore **piu' interno** sotto il puntatore, che e' esattamente quello che si vede.
+     *
+     * L'indice viene dal confronto con la mezzeria dei fratelli, sull'asse del contenitore: le
+     * colonne di una sezione stanno in riga, tutto il resto in colonna.
+     */
+    private hitTest;
+    /** `"0.2"` → `[0, 2]`; la radice e' la stringa vuota. */
+    private static parsePath;
+    /** Il valore dell'attributo che marca un contenitore di rilascio. */
+    dropId(path: FlowScreenFieldPath): string;
+    /**
+     * Dove finisce un campo aggiunto **con un clic**: dentro il contenitore selezionato, oppure
+     * accanto al campo selezionato, oppure in fondo alla schermata. È l'ordine in cui uno se lo
+     * aspetta dopo aver cliccato una colonna.
+     */
+    private clickTarget;
+    addComponentAtSelection(type: string): void;
+    addObjectFieldAtSelection(field: FlowFieldDescription): void;
+    /**
+     * Un componente nuovo. Una sezione nasce **con una colonna dentro**: una sezione vuota e'
+     * `SCREEN_CONTAINER_EMPTY` e non ha nemmeno un posto in cui rilasciare i campi, quindi il
+     * primo gesto sarebbe sempre lo stesso.
+     */
+    private addComponent;
+    /**
+     * §5.2 — un campo dell'entita': `objectFieldReference` fa arrivare tipo, label,
+     * obbligatorieta', scala e le opzioni **dallo schema**, invece di ridichiararli qui.
+     */
+    private addObjectField;
+    select(path: FlowScreenFieldPath): void;
+    /** Cliccare la schermata fuori da un campo: a destra tornano le proprieta' della schermata. */
+    selectScreen(): void;
+    removeSelected(): void;
+    duplicateSelected(): void;
+    /**
+     * Spostamento con i tasti: la stessa operazione del trascinamento, per chi non trascina e
+     * perche' spostare di una posizione con il mouse e' piu' difficile che con una freccia.
+     */
+    moveSelected(direction: -1 | 1): void;
+    /** Estrae il campo dal proprio contenitore e lo mette subito dopo di esso. */
+    outdentSelected(): void;
+    readonly canOutdent: _angular_core.Signal<boolean>;
+    /**
+     * `preRemoval` distingue le due convenzioni sull'indice di arrivo: i comandi (su, giu', porta
+     * fuori) ragionano sulla lista **dopo** l'estrazione, il rilascio su cio' che si vedeva
+     * **prima**. Confonderle sposta di uno ogni trascinamento verso il basso.
+     */
+    private applyMove;
+    /** Il campo raccoglie un valore, quindi e' referenziabile per nome nel resto del flow (§5.2). */
+    readonly selectedIsResource: _angular_core.Signal<boolean>;
+    /**
+     * §5.2 — uno screen senza campi non ha niente da mostrare (`SCREEN_WITHOUT_FIELDS`), e uno
+     * senza destinazione che non consente «fine» e' un vicolo cieco (`SCREEN_DEAD_END`). Si dicono
+     * qui prima che lo dica la validazione.
+     */
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    readonly isDeadEnd: _angular_core.Signal<boolean>;
+    allowBack: _angular_core.Signal<boolean>;
+    allowFinish: _angular_core.Signal<boolean>;
+    allowPause: _angular_core.Signal<boolean>;
+    showHeader: _angular_core.Signal<boolean>;
+    showFooter: _angular_core.Signal<boolean>;
+    /** §5.2 — `isEditable` ha default `true`: a `false` il runtime ignora cio' che torna. */
+    readonly selectedIsEditable: _angular_core.Signal<boolean>;
+    readonly selectedIsRequired: _angular_core.Signal<boolean>;
+    /**
+     * §5.2 — `storeOutputAutomatically` **insieme** a `outputParameters` e'
+     * `OUTPUT_CONFIGURATION_CONFLICT`: la coppia si mostra come esclusiva, non come due caselle.
+     */
+    readonly hasOutputConflict: _angular_core.Signal<boolean>;
+    /** §5.2 — la choice di default fuori dall'elenco e' un avviso, non un errore. */
+    readonly defaultChoiceIsForeign: _angular_core.Signal<boolean>;
+    /** §5.2 — `scale` su un campo non numerico e' `SCALE_NOT_APPLICABLE`. */
+    readonly scaleApplies: _angular_core.Signal<boolean>;
+    readonly requiresObjectType: _angular_core.Signal<boolean>;
+    readonly objectTypeIsStructure: _angular_core.Signal<boolean>;
+    /** L'oggetto di un `ObjectProvided`, cioe' la parte prima del punto (§5.2). */
+    readonly providedObject: _angular_core.Signal<string>;
+    readonly providedField: _angular_core.Signal<string>;
+    /** Scrive una proprieta' del campo selezionato; valore vuoto → chiave omessa (§2). */
+    private patchField;
+    setFieldProperty(property: keyof FlowScreenField, value: unknown): void;
+    /**
+     * Il nome si applica sull'uscita dal campo e passa da `renameScreenField`: il campo e' una
+     * risorsa, quindi la rinomina deve riscrivere i riferimenti che lo citano (§5.2, §13.8).
+     */
+    setFieldName(value: string): void;
+    /**
+     * Cambiare tipo **ripulisce** cio' che il tipo nuovo non prevede: choice su una textarea o un
+     * `dataType` su un `DisplayText` sono `SCREEN_FIELD_CONFIGURATION_INVALID`, e lasciarli nel
+     * documento significa lasciare un errore invisibile nell'editor.
+     */
+    setFieldType(type: string): void;
+    setDefaultValue(value: FlowValue | undefined): void;
+    setNumberProperty(property: 'scale' | 'maxLength' | 'width', raw: string): void;
+    /** `isRequired` si scrive solo quando e' vero: il default e' facoltativo. */
+    setRequired(value: boolean): void;
+    /** `isEditable` ha default `true`: si scrive solo il `false`, che e' la scelta significativa. */
+    setEditable(value: boolean): void;
+    addChoice(name: string | undefined): void;
+    removeChoice(index: number): void;
+    moveChoice(index: number, direction: -1 | 1): void;
+    setValidationRule(part: 'formulaExpression' | 'errorMessage', value: string): void;
+    /** La regola di visibilita' e' un blocco condizioni come quello di una Decision (§5.2). */
+    onVisibilityChanged(mutate: (holder: FlowConditionHolder) => void): void;
+    /** Il blocco passato all'editor delle condizioni: mai `undefined`, altrimenti non si apre. */
+    readonly visibilityRule: _angular_core.Signal<FlowConditionHolder>;
+    onComponentParametersChanged(mutate: (holder: ParameterHolder) => void): void;
+    setStoreOutputAutomatically(value: boolean): void;
+    /** `ObjectProvided`: oggetto e campo si scrivono in un unico `<Oggetto>.<Campo>` (§5.2). */
+    setProvidedObject(value: string | undefined): void;
+    setProvidedField(value: string | undefined): void;
+    setScreenText(property: string, value: string): void;
+    /** I flag con default `true` si scrivono solo quando si nega, per non sporcare il diff. */
+    setScreenFlag(flag: 'allowBack' | 'allowFinish' | 'allowPause' | 'showHeader' | 'showFooter', value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicScreenInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicScreenInspectorComponent, "fb-dynamic-screen-inspector", never, {}, {}, never, never, true, never>;
+}
+
 interface ResourceKindDescriptor {
     collection: FlowResourceCollection;
     label: string;
@@ -4088,7 +4727,7 @@ declare class FlowBuilderComponent {
      * troppo. `panel` tiene il form nel pannello laterale, che e' piu' comodo quando si
      * modificano molti elementi di fila perche' non c'e' niente da aprire e chiudere.
      */
-    readonly inspectorMode: _angular_core.InputSignal<"panel" | "dialog">;
+    readonly inspectorMode: _angular_core.InputSignal<"dialog" | "panel">;
     readonly saved: _angular_core.OutputEmitterRef<FlowSaveResult>;
     readonly activated: _angular_core.OutputEmitterRef<FlowSaveResult>;
     readonly closeRequested: _angular_core.OutputEmitterRef<void>;
@@ -4138,6 +4777,12 @@ declare class FlowBuilderComponent {
      * mancante; qui si decide solo se serve.
      */
     readonly isProcessTypeOutOfCatalog: _angular_core.Signal<boolean>;
+    /**
+     * Quante schermate ha il flow. **Entrambi** i tipi di screen contano: quello a form e quello
+     * dinamico sono la stessa interazione con l'utente, e contarne uno solo faceva comparire
+     * «questo flow Screen non ha screen» su un flow fatto di soli screen dinamici (§5.2).
+     */
+    private readonly screenCount;
     /** `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`. */
@@ -4220,5 +4865,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, EnumValuePickerComponent, 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, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, 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, filterReferences, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isEmptyReferenceFilter, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, resolvePath, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, valuedFieldOf, valuedFieldsOf, 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, FlowEnumValue, 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, FlowReferenceFilter, FlowReferenceKind, 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, FlowTypedEntry, 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 };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, DynamicScreenInspectorComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, 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, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, 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, allFieldsOf, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, insertField, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, moveField, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, removeField, resolvePath, samePath, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, valuedFieldOf, valuedFieldsOf, 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, FlowDynamicScreen, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowEnumValue, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormula, FlowFormulaIssue, FlowFormulaUsage, FlowFormulaValidationRequest, FlowFormulaValidationResult, 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, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, FlowScreenValidationRule, 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, FlowTypedEntry, 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 };