@esfaenza/flow-builder 20.3.20 → 20.3.22

package/index.d.ts

@@ -1269,6 +1269,69 @@ interface FlowStartInterviewRequest {
     inputs?: Record<string, unknown>;
     debug?: boolean;
 }
+/**
+ * I comandi «Esegui» e «Debug» della barra dell'editor.
+ *
+ * Non e' una primitiva della §6.5: l'editor **non** esegue niente per conto suo. Raccoglie i
+ * valori di ingresso in una finestra e li consegna all'applicazione ospite, che sa dove gira il
+ * motore e con quale interfaccia lo si guarda — un runner suo, una scheda separata, un
+ * debugger. Senza implementazione il comando fallisce con `MissingService`, che e' la risposta
+ * onesta: un editor che finge di avviare un'esecuzione e' peggio di uno che dice di non poterlo
+ * fare.
+ *
+ * Il flow si identifica per **nome e versione**, non per documento: si esegue cio' che e'
+ * salvato, ed e' per questo che i due comandi sono spenti su un flow mai scritto e avvertono
+ * quando ci sono modifiche non salvate.
+ */
+interface FlowRunRequest {
+    flowName: string;
+    /** Assente → l'ospite decide (di norma l'attiva, altrimenti l'ultima), come in §6.1. */
+    version?: number;
+    /**
+     * I valori delle variabili `isInput`, per nome. Sono già convertiti al tipo dichiarato: un
+     * `Number` e' un numero, non la stringa digitata. Un'istanza di classe segue la forma della
+     * §4.7 (`{type, instance:{className, members}}`), la stessa in lettura e in scrittura.
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * `true` sul comando «Debug». L'ospite ne fa cio' che vuole — traccia, breakpoint, passo
+     * passo — ma il contratto ricorda che una traccia riporta i valori di **tutte** le risorse,
+     * dati personali compresi (§6.5).
+     */
+    debug: boolean;
+}
+/**
+ * Cio' che l'ospite puo' **restituire** da `runFlow`/`debugFlow`, e che l'editor mostra nel
+ * pannello «Debug».
+ *
+ * Esiste per un caso preciso: un flow che non ha schermate — un `AutoLaunched`, o
+ * un'orchestrazione che gira tutta in background — non ha nessuna interfaccia in cui guardare
+ * cosa e' successo. Non c'e' un form da compilare, non c'e' una finestra del runtime: c'e' solo
+ * la traccia, e il posto in cui la si vuole e' l'editor, accanto al grafo su cui si sta
+ * lavorando. Ogni voce della traccia porta un `elementName`, e il pannello lo usa per portare
+ * l'utente sull'elemento.
+ *
+ * Restituire qualcosa e' **facoltativo**: un ospite che apre un suo runner e ci mostra tutto lì
+ * risolve con `void`, e l'editor si limita a dire che l'esecuzione e' partita. Un ospite che
+ * parla già la §6.5 puo' restituire il suo `FlowInterviewResult` così com'e': i campi
+ * interattivi (token, `pendingScreen`) l'editor non li guarda, perche' non e' lui a condurre
+ * l'esecuzione.
+ *
+ * `trace` e `resources` arrivano solo con `debug: true` e riportano i valori di **tutte** le
+ * risorse, dati personali compresi (§6.5): il pannello lo dice in chiaro.
+ */
+interface FlowRunOutcome {
+    status?: FlowInterviewStatus;
+    steps?: number;
+    /** L'elemento su cui l'esecuzione si e' fermata: il pannello ci porta sopra. */
+    currentElementName?: string | null;
+    trace?: FlowTraceEntry[];
+    resources?: Record<string, FlowTypedValue>;
+    outputs?: Record<string, FlowTypedValue>;
+    /** `Failed` non e' un errore di trasporto: la chiamata e' riuscita, il flow e' fallito. */
+    errors?: string[];
+    fault?: string | null;
+}
 interface FlowScreenResponseRequest {
     continuationToken: string;
     screenElementName?: string;
@@ -1564,6 +1627,29 @@ declare abstract class FlowBuilderApi {
      * escluso quello corrente (§5.10).
      */
     abstract listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
+    /**
+     * «Esegui»: avvia il flow **salvato** con i valori raccolti dalla finestra.
+     *
+     * Chi integra l'editor la implementa. Non c'e' un default che «prova» il flow: l'editor non
+     * ha un motore, e nascondere l'assenza dietro un'esecuzione finta e' il modo piu' veloce di
+     * far credere che un flow funzioni.
+     *
+     * Il ritorno e' **facoltativo** ed e' l'unica cosa che l'editor sa dell'esecuzione: un
+     * {@link FlowRunOutcome} finisce nel pannello «Debug» — stato, traccia, risorse, output —
+     * mentre `void` significa «guardo altrove», e l'editor dice solo che e' partita. Serve
+     * soprattutto ai flow **senza schermate**: lì non c'e' nessuna interfaccia del runtime in cui
+     * vedere cos'e' successo, e la traccia accanto al grafo e' tutto cio' che si ha.
+     */
+    runFlow(request: FlowRunRequest): Promise<FlowRunOutcome | void>;
+    /**
+     * «Debug»: come {@link runFlow}, ma `request.debug` e' `true` — ed e' il caso in cui il
+     * ritorno conta davvero, perche' `trace` e `resources` esistono solo in debug (§6.5).
+     *
+     * Sono due metodi e non un flag perche' quasi sempre sono due strade diverse dell'ospite —
+     * l'una avvia e basta, l'altra apre un ispettore — e perche' un ambiente puo' esporre l'una
+     * senza l'altra: due `MissingService` distinti dicono quale delle due manca.
+     */
+    debugFlow(request: FlowRunRequest): Promise<FlowRunOutcome | void>;
     /**
      * `POST /interviews` — avvia. Ricorda: `status: 'Failed'` **non** e' un errore
      * di trasporto, e `debug: true` popola `trace` e `resources` con dati che
@@ -2676,15 +2762,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 +2814,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 +3392,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 +3410,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 +3521,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). */
@@ -3432,7 +3758,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<"member" | "empty" | "unknown" | "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;
@@ -3776,7 +4102,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 +4662,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;
@@ -4972,24 +5322,24 @@ declare class VersionPanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<VersionPanelComponent, "fb-version-panel", never, {}, { "closed": "closed"; "versionOpened": "versionOpened"; "notice": "notice"; }, never, never, true, never>;
 }
 
-declare class DebugPanelComponent {
-    private readonly api;
+declare class RunDialogComponent {
     private readonly store;
-    private readonly session;
     private readonly dictionaries;
     private readonly catalog;
-    constructor();
-    readonly closed: _angular_core.OutputEmitterRef<void>;
-    /** Chiede all'host di evidenziare l'elemento corrente dell'esecuzione. */
-    readonly elementFocused: _angular_core.OutputEmitterRef<string>;
-    readonly result: _angular_core.WritableSignal<FlowInterviewResult | null>;
-    readonly isRunning: _angular_core.WritableSignal<boolean>;
-    readonly errorMessage: _angular_core.WritableSignal<string | null>;
-    readonly debugEnabled: _angular_core.WritableSignal<boolean>;
-    /** I valori che l'utente compila nel piccolo form generato dalle variabili di input. */
-    readonly inputValues: _angular_core.WritableSignal<Record<string, string>>;
-    /** I valori raccolti per lo screen corrente, per nome di `outputParameters`. */
-    readonly screenOutputs: _angular_core.WritableSignal<Record<string, string>>;
+    /** `debug` cambia il titolo, l'avviso sui dati e quale primitiva verra' chiamata. */
+    readonly mode: _angular_core.InputSignal<"run" | "debug">;
+    /** Il flow che verra' eseguito: e' quello **salvato**, non il documento in mano. */
+    readonly flowName: _angular_core.InputSignal<string | null>;
+    readonly version: _angular_core.InputSignal<number | null>;
+    /** Con modifiche non salvate si esegue la versione salvata: dirlo evita la sorpresa. */
+    readonly isDirty: _angular_core.InputSignal<boolean>;
+    /** L'ospite sta ancora rispondendo: il bottone resta spento invece di ripartire. */
+    readonly isBusy: _angular_core.InputSignal<boolean>;
+    readonly confirmed: _angular_core.OutputEmitterRef<Record<string, unknown>>;
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly isDebug: _angular_core.Signal<boolean>;
+    /** I valori compilati, come stringhe: la conversione al tipo avviene alla conferma. */
+    private readonly rawValues;
     /** Le variabili `isInput` del flow: il contratto verso chi lo invoca (§4.6). */
     readonly inputVariables: _angular_core.Signal<FlowVariable[]>;
     /**
@@ -4997,27 +5347,45 @@ declare class DebugPanelComponent {
      * compila un membro alla volta: non c'e' un letterale con cui scriverla in un campo solo.
      */
     private readonly membersByClass;
-    /** I membri **scrivibili** di una classe: gli altri li calcola il backend. */
-    membersOf(className: string | undefined): FlowStructureMember[];
     /**
-     * §4.6 — i valori di un tipo di enumerazione, per nome del tipo. Elenco vuoto significa "non lo
-     * so" — tipo non indicato, primitiva assente, tipo senza valori dichiarati — e allora il valore
-     * si scrive a mano.
+     * §4.6 — i valori dei tipi `Enum` che compaiono fra gli input. Un insieme chiuso merita una
+     * tendina: qui si scrive un nome che il motore confrontera', e digitarlo e' il modo piu'
+     * facile di sbagliarlo.
      */
     private readonly valuesByEnumType;
+    constructor();
+    /** I membri **scrivibili** di una classe: gli altri li calcola il motore. */
+    membersOf(className: string | undefined): FlowStructureMember[];
     enumValuesOf(enumType: string | null | undefined): FlowEnumValue[];
     isStructureVariable(variable: FlowVariable): boolean;
-    readonly canRun: _angular_core.Signal<boolean>;
+    setValue(key: string, value: string): void;
+    /** Il valore di un campo del form: serve a ripopolarlo se la finestra si ridisegna. */
+    valueOf(key: string): string;
+    /** Converte un valore del form nel tipo dichiarato: il tipo vince, anche in scrittura (§6.5). */
+    private static coerce;
+    /**
+     * I valori da mandare. Un campo lasciato vuoto **non** si manda: mandare la stringa vuota
+     * significherebbe assegnare, e un input non valorizzato e' un'altra cosa da un input a "".
+     */
+    private collectInputs;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RunDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RunDialogComponent, "fb-run-dialog", never, { "mode": { "alias": "mode"; "required": true; "isSignal": true; }; "flowName": { "alias": "flowName"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "isDirty": { "alias": "isDirty"; "required": false; "isSignal": true; }; "isBusy": { "alias": "isBusy"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+declare class DebugPanelComponent {
+    /** L'esito dell'ultima esecuzione; `null` = non ne e' ancora stata lanciata una. */
+    readonly outcome: _angular_core.InputSignal<FlowRunOutcome | null>;
+    /** L'ultima esecuzione era in debug: senza, traccia e risorse non arrivano ed e' normale. */
+    readonly wasDebug: _angular_core.InputSignal<boolean>;
+    /** L'ospite sta ancora eseguendo: l'esito, se arriva, arriva dopo. */
+    readonly isRunning: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Chiede all'host di portare l'utente sull'elemento: e' l'ancora della traccia. */
+    readonly elementFocused: _angular_core.OutputEmitterRef<string>;
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
     readonly status: _angular_core.Signal<string | null>;
-    readonly pendingScreen: _angular_core.Signal<_esfaenza_flow_builder.FlowPendingScreen | null>;
-    readonly isWaitingForScreen: _angular_core.Signal<boolean>;
-    /** §5.14 — l'attesa e' su uno step assegnato a una persona, non su un evento. */
-    readonly isWaitingForStageStep: _angular_core.Signal<boolean>;
-    readonly stageSteps: _angular_core.Signal<FlowStageStepState[]>;
-    /** Lo step su cui c'e' un work item aperto: e' quello che si puo' concludere. */
-    readonly waitingStageSteps: _angular_core.Signal<FlowStageStepState[]>;
-    /** I valori con cui si conclude uno step, per nome di output. */
-    readonly stepOutputs: _angular_core.WritableSignal<Record<string, string>>;
     readonly trace: _angular_core.Signal<_esfaenza_flow_builder.FlowTraceEntry[]>;
     /** Le risorse come righe ordinate: il tipo dichiarato vince in lettura (§6.5). */
     readonly resourceRows: _angular_core.Signal<{
@@ -5030,49 +5398,19 @@ declare class DebugPanelComponent {
         type: string;
         value: string;
     }[]>;
-    /** Gli input che lo screen corrente riceve, per mostrarli accanto al form generico. */
-    readonly screenInputRows: _angular_core.Signal<{
-        name: string;
-        type: string;
-        value: string;
-    }[]>;
-    /** I nomi degli output dichiarati dallo screen, per generare i campi da compilare. */
-    readonly screenOutputNames: _angular_core.Signal<string[]>;
     /**
-     * §6.5 — il tipo dichiarato vince, e due tipi hanno una forma propria invece di `value`: un
-     * record e un'istanza di classe. Cercare `value` su un `Structure` mostrerebbe «—» pur avendo
-     * i dati sotto gli occhi (§4.7).
+     * L'ospite ha restituito qualcosa, ma niente di leggibile: nessuno stato, nessuna traccia,
+     * nessun valore. Va distinto dal «non e' stata lanciata nessuna esecuzione», perche' il
+     * rimedio e' diverso — lì si preme «Esegui», qui manca un pezzo dell'implementazione.
      */
-    private static render;
-    setDebugEnabled(value: boolean): void;
-    setInputValue(name: string, value: string): void;
-    setScreenOutput(name: string, value: string): void;
-    /** Converte un valore del form nel tipo dichiarato: il tipo vince, anche in scrittura (§6.5). */
-    private static coerce;
-    /** Converte i valori del form nel tipo dichiarato dalla variabile. */
-    private coerceInputs;
-    start(): Promise<void>;
-    respond(navigation: FlowScreenNavigation): Promise<void>;
-    setStepOutput(name: string, value: string): void;
-    /** Gli output dichiarati dallo step, per generare i campi da compilare. */
-    stepOutputNames(stepName: string | undefined): string[];
-    /**
-     * Conclude uno step come farebbe l'assegnatario. `Rejected` non e' un errore: e' l'esito che
-     * prende il ramo «Step rifiutato» dello stage — e se quel ramo non c'e', l'interview fallisce.
-     */
-    completeStep(stepName: string | undefined, status: FlowStageStepStatus): Promise<void>;
-    private apply;
-    private handleError;
-    reset(): void;
+    readonly isEmptyOutcome: _angular_core.Signal<boolean>;
     close(): void;
-    /** L'etichetta dello stato, che non e' un errore anche quando dice "Failed" (§6.5). */
+    clear(): void;
+    /** L'etichetta dello stato, che non e' un errore anche quando dice «Fallita» (§6.5). */
     statusLabel(): string;
     statusNote(): string | null;
-    canGoBack(): boolean;
-    canFinish(): boolean;
-    canPause(): boolean;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DebugPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DebugPanelComponent, "fb-debug-panel", never, {}, { "closed": "closed"; "elementFocused": "elementFocused"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DebugPanelComponent, "fb-debug-panel", never, { "outcome": { "alias": "outcome"; "required": false; "isSignal": true; }; "wasDebug": { "alias": "wasDebug"; "required": false; "isSignal": true; }; "isRunning": { "alias": "isRunning"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "elementFocused": "elementFocused"; "cleared": "cleared"; }, never, never, true, never>;
 }
 
 type SidePanel = 'inspector' | 'resources' | 'versions' | 'debug';
@@ -5082,6 +5420,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 +5515,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). */
@@ -5187,9 +5526,9 @@ declare class FlowBuilderComponent {
     openSelectedElement(): void;
     closeDialog(): void;
     /**
-     * Evidenzia l'elemento sul canvas senza cambiare pannello.
-     * Serve durante la prova: l'esecuzione segnala su quale elemento e' ferma, ma sostituire
-     * il pannello con l'inspector farebbe sparire il form da compilare a metà interview.
+     * Evidenzia l'elemento sul canvas **senza** cambiare pannello.
+     * Serve alla traccia del debug: portare l'utente sull'elemento e' il punto del pannello, ma
+     * sostituirlo con l'inspector farebbe sparire la traccia che si stava leggendo.
      */
     highlightElement(name: string): void;
     /** Rilascio dalla palette: il punto di rilascio diventa `locationX`/`locationY` (§11). */
@@ -5209,6 +5548,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;
@@ -5243,6 +5621,38 @@ declare class FlowBuilderComponent {
     setCopyLabel(value: string): void;
     /** Scrive la copia e continua a lavorare su di essa (§6.2). */
     confirmCopy(): Promise<void>;
+    /** Quale delle due finestre e' aperta; `null` = nessuna. */
+    readonly runMode: _angular_core.WritableSignal<"run" | "debug" | null>;
+    /** La chiamata all'ospite e' in volo: il bottone della finestra resta spento. */
+    readonly isStartingRun: _angular_core.WritableSignal<boolean>;
+    /**
+     * L'esito dell'ultima esecuzione, se l'ospite ne ha restituito uno.
+     *
+     * È tutto cio' che l'editor sa di un'esecuzione, e serve soprattutto ai flow **senza
+     * schermate**: lì non si apre nessuna interfaccia del runtime, quindi senza questo pannello
+     * non ci sarebbe **nessun** posto in cui vedere quali elementi sono stati eseguiti.
+     */
+    readonly runOutcome: _angular_core.WritableSignal<FlowRunOutcome | null>;
+    /** L'ultima esecuzione era in debug: senza, traccia e risorse non arrivano ed e' normale. */
+    readonly wasRunInDebug: _angular_core.WritableSignal<boolean>;
+    /**
+     * Si esegue cio' che e' **salvato**: su un flow mai scritto non c'e' niente da avviare, e il
+     * titolo del bottone lo dice invece di lasciare un comando che non risponde.
+     */
+    readonly canRun: _angular_core.Signal<boolean>;
+    openRun(mode: 'run' | 'debug'): void;
+    closeRun(): void;
+    /** Svuota il pannello: l'esito di prima non riguarda piu' il documento che si sta editando. */
+    clearRunOutcome(): void;
+    /**
+     * Consegna gli ingressi all'ospite.
+     *
+     * La finestra si chiude **subito**, prima che la chiamata risponda: un'esecuzione puo' durare
+     * quanto vuole — con schermate da compilare puo' finire minuti dopo — e tenere aperto il form
+     * degli ingressi per tutto quel tempo coprirebbe proprio il grafo che si sta guardando. Il
+     * pannello «Debug» prende il posto dell'attesa, e l'esito ci arriva quando arriva.
+     */
+    confirmRun(inputs: Record<string, unknown>): Promise<void>;
     createNewVersion(): Promise<void>;
     activate(): Promise<void>;
     /** §9.3 — prima opzione davanti a un conflitto. */
@@ -5278,5 +5688,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, RunDialogComponent, 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, FlowRunOutcome, FlowRunRequest, 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 };