@esfaenza/flow-builder 20.3.20 → 20.3.21

package/index.d.ts

@@ -2676,15 +2676,43 @@ declare class FlowDocumentStore {
     renameResource(collection: FlowResourceCollection, index: number, newName: string): void;
     /**
      * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti.
-     * Cammina l'intero documento: e' l'unico modo per non dimenticare un campo, dato che
-     * i riferimenti compaiono in una ventina di posti diversi (§4).
+     *
+     * L'implementazione sta in `core/flow-clipboard.ts` perche' la usa anche l'incolla, sul solo
+     * frammento invece che sul documento: l'elenco dei campi-riferimento deve essere **uno**.
      */
     private static rewriteReferences;
-    /** Duplica un node con un nome nuovo, senza copiarne le uscite. */
-    duplicateNode(name: string, newName: string, offset?: {
+    /**
+     * Duplica uno o piu' node, ritornando i nomi creati.
+     *
+     * E' un copia-e-incolla nello stesso documento, e passa dallo stesso motore: e' cio' che gli
+     * fa rinominare **tutto** cio' che collide — non solo il node, ma anche i suoi step, i campi
+     * di uno screen dinamico e le sue screen action, che stanno nello stesso spazio dei nomi
+     * (§3.3) — e riscrivere i riferimenti interni al blocco di conseguenza. Duplicare uno screen
+     * dinamico copiandolo e basta produceva un `NAME_DUPLICATED` per ogni campo.
+     *
+     * Le uscite **verso l'esterno** non si copiano (duplicherebbero rami che l'utente non ha
+     * disegnato); quelle interne al blocco sì, ed e' cio' che rende utile duplicare due elementi
+     * collegati invece che uno alla volta.
+     */
+    duplicateNodes(names: readonly string[], offset?: {
         x: number;
         y: number;
-    }): void;
+    }): string[];
+    /**
+     * Incolla gli appunti seguendo il piano già mostrato all'utente, in **un solo** passo di
+     * storico: un incolla che si annulla in sette volte — un elemento, una variabile, un altro
+     * elemento — non e' il gesto che l'utente ha compiuto.
+     *
+     * Ritorna i nomi creati, che sono cio' che va selezionato dopo: senza, la selezione resterebbe
+     * sull'elemento da cui si e' copiato e il blocco appena incollato non si saprebbe dov'e'.
+     */
+    pasteClipboard(payload: FlowClipboardPayload, plan: FlowPastePlan, options: {
+        createMissingResources: boolean;
+        offset?: {
+            x: number;
+            y: number;
+        };
+    }): string[];
     /** Scrive la destinazione di un'uscita. `target` assente → il ramo si stacca del tutto. */
     setConnector(fromName: string, outletKey: string, target: string | undefined, isGoTo?: boolean): void;
     /** Rimuove un arco: il percorso finisce lì, che e' legittimo (§3.5). */
@@ -2700,6 +2728,200 @@ declare class FlowDocumentStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDocumentStore>;
 }
 
+/**
+ * Copia e incolla di **elementi** — la logica pura, senza Angular e senza storage.
+ *
+ * Il gesto e' quello che ci si aspetta da un editor, ma il contratto lo rende meno banale di
+ * un `JSON.parse(JSON.stringify(...))`, e le tre cose che lo complicano sono tutte della §3.3:
+ *
+ *  1. **lo spazio dei nomi e' unico e case-insensitive.** Un elemento incollato non porta solo
+ *     il proprio nome: porta anche quelli dei suoi step di orchestrazione, dei campi di uno
+ *     screen dinamico e delle sue screen action, che sono nomi come gli altri (§5.2, §5.14).
+ *     Un omonimo e' `NAME_DUPLICATED`, quindi tutto cio' che collide va rinominato **prima**
+ *     di entrare nel documento;
+ *  2. **rinominare non aggiorna i riferimenti** e nessuna primitiva lo fa (§13.8). Se il nome
+ *     cambia all'ingresso, i riferimenti interni al blocco vanno riscritti qui: le condizioni
+ *     che guardano un campo, i target dei connector interni, gli output automatici
+ *     (`Leggi_Ordine.Numero`);
+ *  3. **un elemento non e' autosufficiente.** Referenzia risorse — variabili, formule, choice —
+ *     che nel flow di destinazione possono non esistere. Portarsele dietro e' il senso di
+ *     «copiare senza riconfigurare»; inventarle in silenzio no, ed e' per questo che
+ *     {@link planPaste} produce un **piano** che l'interfaccia mostra prima di applicarlo.
+ *
+ * Cio' che di proposito **non** si copia: le uscite che escono dal blocco. Un connector che
+ * punta a un elemento rimasto nell'altro flow sarebbe `CONNECTOR_TARGET_UNKNOWN`, cioe' un
+ * errore che blocca l'attivazione; quelle **interne** al blocco si conservano e si rimappano,
+ * ed e' cio' che rende utile copiare due elementi insieme invece che uno alla volta.
+ */
+
+/**
+ * I campi il cui valore e' un riferimento a un node o a una risorsa.
+ *
+ * Elenco unico, condiviso con la rinomina: due elenchi che devono restare uguali diventano due
+ * elenchi diversi al primo campo aggiunto, e il campo dimenticato non da' nessun errore —
+ * lascia un riferimento al nome vecchio che si scopre solo alla validazione (§13.8).
+ */
+declare const FLOW_REFERENCE_FIELDS: ReadonlySet<string>;
+/**
+ * Riscrive ogni occorrenza di un nome nei campi che contengono riferimenti.
+ *
+ * Cammina tutto cio' che gli si passa — un documento intero per la rinomina, il solo frammento
+ * copiato per l'incolla — perche' i riferimenti compaiono in una ventina di posti diversi (§4)
+ * e l'elenco dei posti sarebbe la cosa che si dimentica di aggiornare.
+ */
+declare function rewriteReferences(root: unknown, oldName: string, newName: string): void;
+/**
+ * Marcatore del formato. Sta scritto dentro il payload perche' gli appunti viaggiano anche
+ * fuori dall'editor (storage del browser, incolla di un JSON a mano): leggere qualcosa che non
+ * e' nostro deve fallire con un messaggio, non con un documento rovinato.
+ */
+declare const FLOW_CLIPBOARD_KIND = "flow-builder/elements";
+declare const FLOW_CLIPBOARD_VERSION = 1;
+interface FlowClipboardNode {
+    collection: FlowNodeCollection;
+    node: FlowAnyNode;
+}
+interface FlowClipboardResource {
+    collection: FlowResourceCollection;
+    resource: Record<string, unknown>;
+}
+interface FlowClipboardPayload {
+    kind: typeof FLOW_CLIPBOARD_KIND;
+    version: number;
+    /** Da dove viene: serve solo a dirlo nella finestra dell'incolla. */
+    flowName?: string;
+    /**
+     * Il `processType` di origine. Non blocca niente: serve ad avvisare quando si incolla in un
+     * flow di tipo diverso, dove le globali disponibili cambiano — `$Record` non esiste in uno
+     * screen flow (§4.1).
+     */
+    processType?: string;
+    nodes: FlowClipboardNode[];
+    /** Le risorse referenziate dal blocco, copiate per intero. */
+    resources: FlowClipboardResource[];
+    /**
+     * Le radici referenziate dal blocco che non sono ne' fra i node ne' fra le risorse copiate:
+     * globali (`$Flow`, `$Record`), elementi rimasti nel flow di origine, campi di uno screen non
+     * copiato. Sono cio' che l'incolla non puo' portarsi dietro, e quindi cio' che va detto.
+     */
+    externalReferences: string[];
+}
+declare function isClipboardPayload(value: unknown): value is FlowClipboardPayload;
+/**
+ * I nomi **dichiarati** dentro un node, oltre al suo: step di orchestrazione, campi di screen
+ * dinamico (contenitori compresi) e screen action. Stanno tutti nello stesso spazio dei nomi
+ * del node (§3.3), quindi collidono come lui e vanno rinominati come lui.
+ *
+ * Si cammina la struttura sapendo **dove** stanno, invece di cercare ogni `name` nell'albero:
+ * `inputParameters[].name` e' il nome di un parametro dell'action, non una risorsa del flow, e
+ * rinominarlo perche' per caso coincide con un campo copiato romperebbe la chiamata.
+ */
+declare function innerNamesOf(node: FlowAnyNode): string[];
+/**
+ * Le **radici** dei riferimenti presenti in un frammento: di `Leggi_Ordine.Numero` la radice e'
+ * `Leggi_Ordine`, ed e' quella che deve esistere nella destinazione (§6.4 — l'elenco dei
+ * riferimenti porta le radici, non i percorsi).
+ *
+ * I `targetReference` restano fuori: sono i connector, e quelli li tratta il taglio delle
+ * uscite. Contarli come riferimenti farebbe comparire fra le dipendenze l'elemento a valle,
+ * che e' esattamente cio' che copiare un blocco non si porta dietro.
+ */
+declare function referencedRootsOf(fragment: unknown): string[];
+/**
+ * Costruisce gli appunti a partire dalla selezione.
+ *
+ * Le uscite si tengono **solo** se restano dentro il blocco; le altre si tolgono del tutto e
+ * non si azzerano: un connector dichiarato senza destinazione e' `CONNECTOR_TARGET_MISSING`,
+ * un avviso che l'utente non ha nessun modo di far sparire se non riaprendo il ramo, mentre un
+ * ramo senza connector e' «il percorso finisce qui», che e' cio' che e' davvero successo (§3.5).
+ */
+declare function buildClipboardPayload(input: {
+    nodes: FlowNodeRef[];
+    resources: FlowResourceRef[];
+    /** I nomi selezionati. Lo Start non si copia: e' uno per flow (§3.4). */
+    names: readonly string[];
+    flowName?: string;
+    processType?: string;
+}): FlowClipboardPayload | null;
+interface FlowPasteRename {
+    /** Cosa e' il nome: serve a raccontarlo («l’elemento», «il campo»). */
+    kind: 'node' | 'inner' | 'resource';
+    from: string;
+    to: string;
+}
+interface FlowPasteResource {
+    collection: FlowResourceCollection;
+    name: string;
+    /** `reused`: nella destinazione esiste già un nome uguale, e si usa quello. */
+    status: 'new' | 'reused';
+}
+interface FlowPastePlan {
+    nodeCount: number;
+    renames: FlowPasteRename[];
+    resources: FlowPasteResource[];
+    /**
+     * Riferimenti che nella destinazione non esistono e che l'incolla non puo' creare: globali di
+     * un altro `processType`, elementi rimasti nel flow di origine. Diventeranno i normali
+     * `REFERENCE_UNKNOWN` del pannello dei problemi.
+     */
+    unresolved: string[];
+    /** Il flow di origine aveva un altro `processType`: le globali disponibili sono altre (§4.1). */
+    processTypeMismatch: string | null;
+}
+/**
+ * Decide **prima** di toccare il documento cosa cambierebbe: quali nomi vanno rinominati, quali
+ * risorse nascono e quali si riusano, cosa resta irrisolto. La finestra dell'incolla mostra
+ * questo, e `applyPaste` lo esegue senza deciderne piu' niente.
+ *
+ * Una risorsa il cui nome esiste già nella destinazione si **riusa**: e' quasi sempre la stessa
+ * variabile di prima (stesso flow, altra versione), e crearne una omonima sarebbe comunque
+ * `NAME_DUPLICATED`. Rinominarla d'ufficio sarebbe peggio: i riferimenti del blocco
+ * continuerebbero a puntare a quella esistente pur avendone appena creata una identica.
+ */
+declare function planPaste(payload: FlowClipboardPayload, target: {
+    usedNames: readonly string[];
+    processType?: string;
+}): FlowPastePlan;
+/**
+ * Applica gli appunti a un documento di lavoro, seguendo il piano.
+ *
+ * L'ordine conta: **prima** si rinomina dentro il frammento — nomi dichiarati e riferimenti —
+ * e **poi** si innesta. Riscrivere dopo l'innesto significherebbe camminare tutto il documento
+ * per ogni nome, e riscrivere anche i riferimenti degli elementi che c'erano già: un elemento
+ * di destinazione che citava `Priorita` finirebbe a citare `Priorita_copia`.
+ */
+declare function applyPaste(draft: FlowDefinition, payload: FlowClipboardPayload, plan: FlowPastePlan, options: {
+    createMissingResources: boolean;
+    offset?: {
+        x: number;
+        y: number;
+    };
+}): string[];
+/** Il tipo dell'elemento a partire dalla collection: serve solo a raccontare il blocco. */
+declare function typeOfCollection(collection: FlowNodeCollection): string;
+
+declare class FlowClipboardService {
+    /** La copia in memoria: fonte di verita' quando lo storage non c'e' o rifiuta. */
+    private memory;
+    private readonly _revision;
+    constructor();
+    private storage;
+    write(payload: FlowClipboardPayload): void;
+    read(): FlowClipboardPayload | null;
+    /**
+     * C'e' qualcosa da incollare. E' un signal e non un booleano calcolato al momento perche' il
+     * comando «Incolla» sta in una toolbar `OnPush`: senza un segnale che cambia, il pulsante
+     * resterebbe spento fino al successivo giro di change detection.
+     */
+    readonly hasContent: _angular_core.WritableSignal<boolean>;
+    /** Da chiamare dove serve il valore aggiornato: rilegge lo storage e aggiorna il signal. */
+    refresh(): boolean;
+    /** Cambia a ogni scrittura, anche da un'altra scheda: chi vuole reagire osservi questo. */
+    readonly revision: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowClipboardService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowClipboardService>;
+}
+
 declare class FlowValidationStore {
     private readonly api;
     private readonly destroyRef;
@@ -3084,6 +3306,13 @@ declare class FlowCanvasComponent {
     readonly sides: typeof EFConnectableSide;
     /** Il nome dell'elemento selezionato, `$start` per lo Start. */
     readonly selectedName: _angular_core.InputSignal<string | null>;
+    /**
+     * La selezione **intera**, quando ne fa parte piu' di un elemento: la libreria sa selezionare
+     * a rettangolo e con `Ctrl`+`A`, e i comandi che agiscono su un blocco (copia, duplica,
+     * elimina) devono vederli tutti. `selectedName` resta l'elemento «corrente», quello di cui si
+     * apre il form: un inspector che mostrasse cinque elementi insieme non saprebbe cosa mostrare.
+     */
+    readonly selectedNames: _angular_core.InputSignal<readonly string[]>;
     /**
      * L'outline del backend, quando disponibile: da' la raggiungibilita' autoritativa (§6.4).
      * Assente → si usa il calcolo locale.
@@ -3095,7 +3324,11 @@ declare class FlowCanvasComponent {
      * perche' il canvas resti montabile da solo.
      */
     readonly isEditable: _angular_core.InputSignal<boolean>;
-    readonly selectionChange: _angular_core.OutputEmitterRef<string | null>;
+    /**
+     * La selezione dopo il gesto: vuota se si e' cliccato nel vuoto. Il primo nome e' quello
+     * «corrente» — chi ascolta ne fa la selezione singola.
+     */
+    readonly selectionChange: _angular_core.OutputEmitterRef<string[]>;
     readonly nodeOpened: _angular_core.OutputEmitterRef<string>;
     readonly nodeRemoveRequested: _angular_core.OutputEmitterRef<string>;
     readonly nodeDuplicateRequested: _angular_core.OutputEmitterRef<string>;
@@ -3202,15 +3435,22 @@ declare class FlowCanvasComponent {
      * `removeNode` toglie anche i connector che lo puntavano.
      */
     onRemoveClick(event: Event, name: string): void;
+    /** Come ✎ e ×: `stopPropagation` perche' il clic non valga anche come selezione. */
+    onDuplicateClick(event: Event, name: string): void;
     connectorIdOf(node: FlowCanvasNode, outletKey: string): string;
     targetIdOf(node: FlowCanvasNode): string;
+    /**
+     * Selezionato = corrente **oppure** parte del blocco selezionato. Senza il secondo caso, un
+     * rettangolo che prende cinque elementi ne evidenziava uno, e i comandi che agiscono su tutti
+     * e cinque sembravano agire su quello.
+     */
     isSelected(node: FlowCanvasNode): boolean;
     /** Etichette dei rami dichiarati senza destinazione, per il tooltip del badge. */
     danglingLabels(node: FlowCanvasNode): string;
     /** Classe della fascia colorata, per categoria del dizionario. */
     categoryClass(node: FlowCanvasNode): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowCanvasComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "selectedNames": { "alias": "selectedNames"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
 }
 
 /** Il gesto scelto sulla palette: un tipo e, dove esiste, la sua variante (§5.6). */
@@ -3776,7 +4016,7 @@ declare class FormulaEditorComponent {
      * 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 commitOn: _angular_core.InputSignal<"change" | "input">;
     readonly expressionChange: _angular_core.OutputEmitterRef<string>;
     private readonly area;
     /**
@@ -4336,6 +4576,30 @@ declare class ElementDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementDialogComponent, "fb-element-dialog", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
 }
 
+declare class PasteDialogComponent {
+    readonly payload: _angular_core.InputSignal<FlowClipboardPayload>;
+    readonly plan: _angular_core.InputSignal<FlowPastePlan>;
+    readonly confirmed: _angular_core.OutputEmitterRef<{
+        createMissingResources: boolean;
+    }>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    /** Predefinito acceso: e' il motivo per cui si copia un elemento invece di rifarlo. */
+    readonly createMissingResources: _angular_core.WritableSignal<boolean>;
+    readonly elementLabel: _angular_core.Signal<string>;
+    readonly newResources: _angular_core.Signal<_esfaenza_flow_builder.FlowPasteResource[]>;
+    readonly reusedResources: _angular_core.Signal<_esfaenza_flow_builder.FlowPasteResource[]>;
+    /** I nomi degli elementi che cambiano: si distinguono da quelli interni perche' il rimedio e' diverso. */
+    readonly nodeRenames: _angular_core.Signal<_esfaenza_flow_builder.FlowPasteRename[]>;
+    readonly innerRenames: _angular_core.Signal<_esfaenza_flow_builder.FlowPasteRename[]>;
+    /** Fuori mappa si mostra il nome tecnico: meglio una parola strana che nessuna parola. */
+    resourceLabel(collection: FlowResourceCollection): string;
+    setCreateMissingResources(value: boolean): void;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasteDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasteDialogComponent, "fb-paste-dialog", never, { "payload": { "alias": "payload"; "required": true; "isSignal": true; }; "plan": { "alias": "plan"; "required": true; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
 declare class StartInspectorComponent {
     private readonly store;
     private readonly dictionaries;
@@ -5082,6 +5346,7 @@ interface Notice {
 }
 declare class FlowBuilderComponent {
     private readonly api;
+    private readonly clipboard;
     private readonly destroyRef;
     /** Serve a `afterNextRender` chiamato fuori dal costruttore. */
     private readonly injector;
@@ -5176,7 +5441,7 @@ declare class FlowBuilderComponent {
      * capita anche solo per spostare un node, e una finestra che si apre a ogni click sarebbe
      * insopportabile. Nel pannello laterale, invece, mostrare subito il form non costa nulla.
      */
-    onSelectionChange(name: string | null): void;
+    onSelectionChange(names: string[]): void;
     /** Doppio click o bottone «✎» sul node: qui il dettaglio si apre. */
     onNodeOpened(name: string): void;
     /** Porta l'utente sull'elemento **e** ne apre il form: e' l'ancora dei problemi (§7). */
@@ -5209,6 +5474,45 @@ declare class FlowBuilderComponent {
      */
     onNodeRenamed(newName: string): void;
     onDuplicateNode(name: string): void;
+    /** La selezione del canvas per intero; `selectedName` resta l'elemento «corrente». */
+    readonly selectedNames: _angular_core.WritableSignal<string[]>;
+    /** L'anteprima dell'incolla, mentre la finestra e' aperta. */
+    readonly pastePreview: _angular_core.WritableSignal<{
+        payload: FlowClipboardPayload;
+        plan: FlowPastePlan;
+    } | null>;
+    /**
+     * I nomi copiabili: la selezione meno lo Start (§3.4) e meno cio' che nel documento non c'e'
+     * piu'. Il secondo filtro non e' teorico: dopo un annulla la selezione resta sul nome di un
+     * elemento appena tolto, e senza il controllo il comando risultava attivo su niente.
+     */
+    private copyableNames;
+    readonly canCopy: _angular_core.Signal<boolean>;
+    /** Il comando «Incolla» si accende quando negli appunti c'e' qualcosa, anche di un altro flow. */
+    readonly canPaste: _angular_core.Signal<boolean>;
+    copySelection(): void;
+    /**
+     * Prepara l'incolla: calcola il piano e apre la finestra. Non tocca il documento — cosa
+     * cambierebbe si vede prima, ed e' l'unico momento in cui la scelta sulle risorse mancanti ha
+     * ancora senso.
+     */
+    startPaste(): void;
+    cancelPaste(): void;
+    confirmPaste(options: {
+        createMissingResources: boolean;
+    }): void;
+    /** Duplica in loco, senza passare dagli appunti: stesso motore, nessuna domanda da fare. */
+    duplicateSelection(): void;
+    private duplicateNames;
+    /** Porta la selezione sul blocco appena creato: senza, resterebbe su cio' da cui e' nato. */
+    private selectNames;
+    /**
+     * Le scorciatoie. L'ascoltatore sta sull'**host** del builder e non sul documento: la libreria
+     * si innesta in una pagina che non e' nostra, e `Ctrl`+`C` catturato globalmente ruberebbe la
+     * copia all'applicazione ospite. Per la stessa ragione il gesto si ignora quando il fuoco e'
+     * dentro un campo: lì `Ctrl`+`C` copia il testo, che e' cio' che l'utente si aspetta.
+     */
+    onKeyDown(event: KeyboardEvent): void;
     /** Riordina il grafo e **scrive** le coordinate nel documento (§3.5). */
     autoLayout(): void;
     undo(): void;
@@ -5278,5 +5582,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, 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, screenActionNames, 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, FlowFormKind, 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, FlowScreenAction, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, FlowScreenTrigger, FlowScreenTriggerInitBehavior, 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 };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, DynamicScreenInspectorComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_CLIPBOARD_KIND, FLOW_CLIPBOARD_VERSION, 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_REFERENCE_FIELDS, FLOW_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowClipboardService, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, PasteDialogComponent, 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, applyPaste, areTypesComparable, buildClipboardPayload, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, innerNamesOf, insertField, isClipboardPayload, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, moveField, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, planPaste, referenceRoot, referencedRootsOf, remapConditionLogic, removeCondition, removeField, resolvePath, rewriteReferences, samePath, screenActionNames, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, typeOfCollection, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
+export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowClipboardNode, FlowClipboardPayload, FlowClipboardResource, 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, FlowFormKind, 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, FlowPastePlan, FlowPasteRename, FlowPasteResource, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowReference, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenAction, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, FlowScreenTrigger, FlowScreenTriggerInitBehavior, 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,6 +1,6 @@
 {
   "name": "@esfaenza/flow-builder",
-  "version": "20.3.20",
+  "version": "20.3.21",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.25",