@esfaenza/flow-builder 20.3.13 → 20.3.15

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 { CdkDragDrop } from '@angular/cdk/drag-drop';
 
 /**
  * Modello del documento Flow — FRONTEND.md §3, §4, §5.
@@ -188,6 +189,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 +590,7 @@ interface FlowDefinition {
     dynamicChoiceSets?: FlowDynamicChoiceSet[];
     stages?: FlowStage[];
     screens?: FlowScreen[];
+    dynamicScreens?: FlowDynamicScreen[];
     assignments?: FlowAssignment[];
     decisions?: FlowDecision[];
     loops?: FlowLoop[];
@@ -530,13 +617,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 +716,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 +775,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;
@@ -1673,6 +1787,43 @@ declare function areTypesComparable(left: FlowDataType | undefined | null, right
  */
 declare function parseInvariantNumber(raw: string): number | undefined;
 
+/**
+ * Quale campo di un `FlowElementReferenceOrValue` porta davvero il valore — FRONTEND.md §4.2.
+ *
+ * La regola del contratto e' "uno e un solo campo valorizzato", e la §2 dice che cio' che non c'e'
+ * si **omette**. Un backend che serializza tutte le proprieta' — `System.Text.Json` senza
+ * `IgnoreNullValues` lo fa di default — rispetta il contratto nella sostanza e lo viola nella forma:
+ * arriva `{"enumValue": "InIstruttoria", "formulaExpression": null, ...}`, cioe' un solo valore e
+ * sette caselle piene di niente.
+ *
+ * Il campo si sceglieva con `!== undefined`, e un `null` passava: la prima casella letta —
+ * `formulaExpression` — vinceva, l'editor apriva la formula (vuota) e il valore, pur presente nel
+ * documento, spariva dalla vista. Da qui questa funzione sola: **`null` e' assente quanto
+ * `undefined`**, e chi interpreta un valore la usa invece di confrontare con `undefined`.
+ *
+ * Sta in `core/` perche' i chiamanti sono piu' d'uno — l'editor del valore, l'editor delle
+ * condizioni — e la regola non deve divergere fra loro.
+ */
+
+/**
+ * I campi che possono portare il valore, **nell'ordine in cui si interpretano**: `formulaExpression`
+ * per primo perche' e' l'unico a due campi, poi il riferimento, poi i letterali. `formulaDataType`
+ * non c'e': accompagna l'espressione, non e' un valore da solo.
+ */
+declare const FLOW_VALUE_FIELDS: readonly (keyof FlowValue)[];
+/** I soli campi letterali: quelli che l'editor mostra sotto la modalita' «Valore». */
+declare const FLOW_VALUE_LITERAL_FIELDS: readonly (keyof FlowValue)[];
+/**
+ * `true` se il campo porta un valore. Attenzione ai falsi legittimi: `booleanValue: false`,
+ * `numberValue: 0` e `stringValue: ''` sono valori, quindi il confronto e' con `null`/`undefined`
+ * e non una verifica di verita'.
+ */
+declare function isValued(field: unknown): boolean;
+/** I campi valorizzati, nell'ordine di interpretazione: piu' di uno e' `VALUE_AMBIGUOUS` (§4.2). */
+declare function valuedFieldsOf(value: FlowValue | undefined | null): (keyof FlowValue)[];
+/** Il campo che l'editor considera **il** valore, cioe' il primo valorizzato nell'ordine sopra. */
+declare function valuedFieldOf(value: FlowValue | undefined | null): keyof FlowValue | undefined;
+
 /**
  * Gli step di uno stage di orchestrazione — FRONTEND.md §5.13.
  *
@@ -1705,6 +1856,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.
  *
@@ -1779,6 +2001,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).
@@ -2192,10 +2435,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. */
@@ -2252,6 +2497,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;
     /**
@@ -2752,7 +3006,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:
@@ -2898,7 +3156,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<"empty" | "unknown" | "member" | "known" | "navigated" | "host" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid">;
+    readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "member" | "containerRoot" | "memberUnknown" | "memberNotWritable" | "pathUnverified" | "globalPathUntyped" | "globalPathInvalid" | "unknown">;
     /** Le parole cambiano con la tappa: un campo di un'entita' non e' un membro di una classe. */
     private readonly tailIsObject;
     private readonly tailContainer;
@@ -3791,6 +4049,159 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrchestratedStageInspectorComponent, "fb-orchestrated-stage-inspector", never, {}, {}, never, never, true, never>;
 }
 
+/** Il payload della lista di rilascio: l'albero appiattito, cioe' le righe che si vedono. */
+type DropData = FlowScreenFieldNode[];
+declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
+    private readonly catalog;
+    protected readonly dictionary: FlowDictionaryStore;
+    readonly elementType: FlowElementType;
+    readonly screen: _angular_core.Signal<FlowDynamicScreen>;
+    /** Il percorso del campo selezionato: `null` = nessuno, e il pannello destro lo dice. */
+    private readonly selection;
+    /** L'albero appiattito: e' anche cio' che serve per capire quali percorsi esistono ancora. */
+    readonly tree: _angular_core.Signal<FlowScreenFieldNode[]>;
+    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>;
+    /** 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[]>;
+    readonly icon: string;
+    isSelected(path: FlowScreenFieldPath): boolean;
+    isContainer(field: FlowScreenField | undefined): boolean;
+    /** L'etichetta mostrata nell'albero: `fieldText`, poi il nome, poi un segnaposto. */
+    captionOf(field: FlowScreenField): string;
+    typeLabelOf(field: FlowScreenField): string;
+    /** La larghezza in dodicesimi: assente = tutta la riga, che e' il comportamento di default. */
+    widthOf(field: FlowScreenField): number;
+    /** `true` dove il tipo non e' nel dizionario: il form di destra lo dice invece di indovinare. */
+    isUnknownType(field: FlowScreenField | undefined): boolean;
+    /** 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>;
+    select(path: FlowScreenFieldPath): void;
+    /** Aggiunge un campo dentro il contenitore selezionato, o in fondo alla schermata. */
+    addField(type: string): void;
+    /**
+     * Dove finisce un campo nuovo: dentro il contenitore selezionato (o dentro il contenitore
+     * che contiene il campo selezionato), altrimenti in fondo alla schermata. È il gesto che
+     * l'utente si aspetta dopo aver cliccato una colonna.
+     */
+    private parentForNewField;
+    removeSelected(): void;
+    duplicateSelected(): void;
+    /**
+     * Spostamento con i tasti: la stessa operazione del trascinamento, per chi non trascina e per
+     * i casi in cui la lista e' piu' alta del pannello.
+     */
+    moveSelected(direction: -1 | 1): void;
+    /**
+     * Sposta il campo dentro il contenitore che lo precede. È la controparte esplicita del
+     * trascinamento: dove l'albero e' lungo, mirare la riga giusta costa piu' di un clic.
+     */
+    indentSelected(): void;
+    /** Il contenitore in cui «porta dentro» metterebbe il campo, o `null` se non ce n'e' uno. */
+    readonly indentTarget: _angular_core.Signal<FlowScreenFieldPath | null>;
+    /** Estrae il campo dal proprio contenitore e lo mette subito dopo di esso. */
+    outdentSelected(): void;
+    /**
+     * Rilascio del trascinamento sulla lista **piatta**.
+     *
+     * Il contenitore di arrivo non lo dice il CDK — c'e' una sola lista — ma si deduce dalla riga
+     * che **precede** il punto di rilascio, che e' anche cio' che l'utente vede: rilasciare subito
+     * sotto una sezione o una colonna significa «mettilo dentro»; rilasciare sotto un campo
+     * normale significa «mettilo accanto». Sono le due sole intenzioni possibili.
+     */
+    onDrop(event: CdkDragDrop<DropData>): void;
+    /**
+     * `preRemoval` distingue le due convenzioni sull'indice di arrivo: i comandi (su, giu',
+     * porta fuori) ragionano sulla lista **dopo** l'estrazione, il rilascio ragiona su cio' che
+     * si vedeva **prima**. Confonderle sposta di uno ogni trascinamento verso il basso.
+     */
+    private applyMove;
+    /** 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;
@@ -4051,7 +4462,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>;
@@ -4101,6 +4512,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`. */
@@ -4183,5 +4600,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, 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, 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, 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, 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, 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 };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@esfaenza/flow-builder",
-  "version": "20.3.13",
+  "version": "20.3.15",
   "peerDependencies": {
+    "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.25",
     "@angular/core": "^20.3.25",
     "@foblex/flow": ">=19.0.0",

package/styles/flow-builder.css

@@ -506,3 +506,36 @@ f-flow .fb-edge--goto .f-connection-path {
   background: color-mix(in srgb, var(--fb-warning, #b7791f) 8%, transparent);
   font-size: 11px;
 }
+
+/* ------------------------------------------------ trascinamento (CDK) */
+/*
+ * L'anteprima del trascinamento e' l'unico pezzo di UI che il CDK sposta **fuori** dal
+ * componente: la aggancia a `body` (o al piu' vicino contenitore con overlay), dove il CSS
+ * incapsulato dell'inspector non arriva. Senza queste regole il campo trascinato si vede
+ * come testo nudo senza sfondo — lo stesso motivo per cui gli archi stanno qui.
+ */
+.cdk-drag-preview {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  box-sizing: border-box;
+  padding: 4px 6px;
+  border: 1px solid var(--fb-accent, #4f6ef7);
+  border-radius: var(--fb-radius-xs, 6px);
+  background: var(--fb-surface, #fff);
+  box-shadow: var(--fb-shadow-md, 0 6px 18px rgb(16 24 40 / 10%));
+  font-size: 12px;
+  color: var(--fb-text, #1a1c23);
+}
+
+/* L'anteprima resta essenziale: il tipo e la barra della larghezza sono contorno, e in un
+   riquadro che segue il puntatore rubano l'attenzione al punto di rilascio. */
+.cdk-drag-preview .fb-dyn__type,
+.cdk-drag-preview .fb-dyn__width {
+  display: none;
+}
+
+.cdk-drag-animating,
+.cdk-drop-list-dragging .cdk-drag {
+  transition: transform 180ms cubic-bezier(0, 0, 0.2, 1);
+}