@esfaenza/flow-builder 20.0.0 → 20.3.1

package/index.d.ts

@@ -34,7 +34,11 @@ interface FlowValue {
     stringValue?: string;
     integerValue?: number;
     numberValue?: number;
-    /** Formato roundtrip senza fuso: `2026-08-15T00:00:00` (§2, §4.2). */
+    /**
+     * `2026-08-15T09:00:00Z` sono le 9 UTC, `2026-08-15T09:00:00` le 9 nel fuso
+     * dell'applicazione: sono **due istanti diversi**, e il motore converte prima di
+     * confrontare. Scrivere il fuso quando lo si conosce e' una scelta, non un dettaglio (§4.2).
+     */
     dateValue?: string;
     booleanValue?: boolean;
     enumValue?: string;
@@ -364,6 +368,67 @@ interface FlowUnsupportedNode extends FlowNodeBase {
     connector?: FlowConnector;
     [key: string]: unknown;
 }
+/**
+ * §5.13 — i tre tipi di step. `stepMuleSoft` non esiste in questo sistema
+ * (`ELEMENT_NOT_SUPPORTED`); l'elenco autoritativo e' il dizionario `stageStepTypes`.
+ */
+type FlowStageStepActionType = 'stepBackground' | 'stepInteractive' | 'stepApproval' | string;
+/** A chi e' assegnato uno step interattivo. `assigneeTypes` e' il dizionario (§6.4). */
+interface FlowStageStepAssignee {
+    assigneeType?: string;
+    assignee?: FlowValue;
+}
+/** Il nome di un *evaluation flow* che decide una condizione di ingresso o di uscita. */
+type FlowStageStepConditionActionType = 'EvaluationFlow' | string;
+/**
+ * §5.13 — uno step di uno stage.
+ *
+ * Due cose che non si vedono dal tipo:
+ *  - gli step **non hanno un ordine di esecuzione**: parte quello le cui `entryConditions`
+ *    sono vere, e l'ordine nell'array e' solo l'ordine d'esame;
+ *  - `name` sta nello **stesso spazio dei nomi** di node e risorse (§3.3), e l'output di uno
+ *    step e' sempre referenziabile come `<NomeStep>.<NomeOutput>`.
+ *
+ * I campi riservati (`runAsUser`, ignorato dal runtime, `canAssigneeEdit`, `shouldLock`,
+ * `requiresAsyncProcessing`) non sono modellati di proposito: non vanno esposti. Sopravvivono
+ * comunque al round-trip, perche' il documento viaggia come JSON.
+ */
+interface FlowStageStep {
+    name?: string;
+    label?: string;
+    description?: string;
+    actionType?: FlowStageStepActionType;
+    /** Obbligatorio su `stepBackground`: il flow che il motore esegue subito. */
+    actionName?: string;
+    /** Obbligatori su `stepInteractive` e `stepApproval`. */
+    assignees?: FlowStageStepAssignee[];
+    /** `"0"` o `"1"`: il modello lo porta come stringa. */
+    requiresMultiMemberApproval?: string;
+    /** *Se* lo step si applica: se non si avverano, viene saltato (§5.13). */
+    entryConditions?: FlowCondition[];
+    /** *Quando* lo step libera lo stage: se restano false, lo stage va in stallo (§5.13). */
+    exitConditions?: FlowCondition[];
+    /** Evaluation flow che decide l'ingresso: deve restituire `isOrchestrationConditionMet`. */
+    entryActionName?: string;
+    entryActionType?: FlowStageStepConditionActionType;
+    exitActionName?: string;
+    exitActionType?: FlowStageStepConditionActionType;
+    inputParameters?: FlowInputParameter[];
+    /** `assignToReference` e' facoltativo: l'output e' già referenziabile (§5.13). */
+    outputParameters?: FlowOutputParameter[];
+    /** `true` → usa `outputConfigParams` come output finti, senza eseguire lo step. */
+    debugSimulateStep?: boolean;
+    outputConfigParams?: FlowInputParameter[];
+}
+interface FlowOrchestratedStage extends FlowNodeBase {
+    stageSteps?: FlowStageStep[];
+    connector?: FlowConnector;
+    /**
+     * **Non** e' un ramo di guasto: e' il ramo percorso quando uno step viene rifiutato.
+     * Senza, un rifiuto fa fallire l'interview (§5.13).
+     */
+    faultConnector?: FlowConnector;
+}
 interface FlowSchedule {
     frequency?: 'Once' | 'Daily' | 'Weekly' | 'Monthly' | string;
     /** Data senza fuso: `2026-08-01T00:00:00`. */
@@ -438,10 +503,10 @@ interface FlowDefinition {
     transforms?: FlowTransform[];
     waits?: FlowWait[];
     customErrors?: FlowCustomError[];
+    orchestratedStages?: FlowOrchestratedStage[];
     /** Non supportati: conservati nel round-trip ma non creabili dalla palette. */
     steps?: FlowUnsupportedNode[];
     experiments?: FlowUnsupportedNode[];
-    orchestratedStages?: FlowUnsupportedNode[];
     apiVersion?: string;
     timeZoneSidKey?: string;
     triggerOrder?: number;
@@ -449,13 +514,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", "steps", "experiments", "orchestratedStages"];
+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"];
 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' | 'Step' | 'Experiment' | 'OrchestratedStage' | string;
+type FlowElementType = 'Screen' | '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>;
 
@@ -508,17 +573,37 @@ interface FlowAssignmentOperatorEntry extends FlowDictionaryEntry {
     /** Ha senso solo su destinazioni collection; altrove e' un avviso. */
     expectsCollection?: boolean;
 }
-/** §4.1 — variabile globale proponibile invece di farla digitare. */
+/**
+ * §4.1 — variabile globale proponibile invece di farla digitare.
+ *
+ * La verificabilita' e' **per scope**: se `paths` porta almeno una voce, un percorso che non
+ * c'e' e' `GLOBAL_UNKNOWN`; se `paths` e' vuoto, lo scope resta non verificabile — che
+ * significa "non lo so", non "non esiste".
+ */
 interface FlowGlobalVariableEntry extends FlowDictionaryEntry {
     /** `$Flow`, `$GlobalConstant`, `$Record`, `$User`, … */
     scope?: string;
-    /** Percorsi noti dello scope; per gli scope dell'host e' vuoto. */
+    /** Percorsi noti dello scope. Vuoto → lo scope non e' verificabile (§4.1). */
     paths?: string[] | null;
-    /** `true` → il backend non sa quali percorsi esistano e accetta qualunque cosa (§4.1). */
+    /** `true` → i percorsi li dichiara il sistema ospite, e solo quelli che dichiara. */
     isResolvedByHost?: boolean;
     /** Disponibile solo con un trigger su record (`$Record`, `$Record__Prior`). */
     requiresRecordTrigger?: boolean;
 }
+/**
+ * §5.13 — i tipi di step di uno stage di orchestrazione (`stageStepTypes`).
+ * Le colonne dicono cosa il tipo pretende: senza, l'editor dovrebbe cablare i tre nomi.
+ */
+interface FlowStageStepTypeEntry extends FlowDictionaryEntry {
+    /** `stepBackground`: il flow eseguito subito e' obbligatorio. */
+    requiresActionName?: boolean;
+    /** `stepInteractive` / `stepApproval`: gli assegnatari sono obbligatori. */
+    requiresAssignees?: boolean;
+    /** `true` → l'interview si **sospende** su questo step, in attesa di una persona. */
+    suspendsInterview?: boolean;
+    /** `true` → il rifiuto e' un esito previsto, e prende il `faultConnector` dello stage. */
+    supportsRejection?: boolean;
+}
 interface FlowResourceKindEntry extends FlowDictionaryEntry {
     /** Solo le variabili sono scrivibili (§4.6). */
     isWritable?: boolean;
@@ -526,9 +611,13 @@ interface FlowResourceKindEntry extends FlowDictionaryEntry {
     metadataProperty?: string;
 }
 /**
- * §6.4 — tutte le tendine statiche in una risposta.
+ * §6.4 — le tendine in una risposta.
  * I campi sono opzionali: un backend che non popola un dizionario non deve far
  * crollare l'editor, che degrada mostrando il valore grezzo.
+ *
+ * Sono **quasi** statici: `globalVariables` dipende dal `processType` con cui si sono
+ * chiesti, perche' `$Record` non esiste in uno screen flow (§4.1). Chi lavora su piu' tipi di
+ * flow ne tiene una copia per tipo — se ne occupa {@link FlowDictionaryStore}.
  */
 interface FlowDictionaries {
     dataTypes?: FlowDataTypeEntry[];
@@ -549,6 +638,8 @@ interface FlowDictionaries {
     transformTypes?: FlowDictionaryEntry[];
     transactionModels?: FlowDictionaryEntry[];
     waitEventTypes?: FlowDictionaryEntry[];
+    stageStepTypes?: FlowStageStepTypeEntry[];
+    assigneeTypes?: FlowDictionaryEntry[];
     conditionLogicModes?: FlowDictionaryEntry[];
     screenNavigations?: FlowDictionaryEntry[];
 }
@@ -706,7 +797,11 @@ interface FlowReference {
     dataType?: FlowDataType | null;
     isCollection?: boolean;
     objectType?: string | null;
-    /** Per i campi di destinazione: solo le variabili sono scrivibili (§4.6). */
+    /**
+     * Per i campi di destinazione. Scrivibili sono le variabili, `$Flow.CurrentStage`,
+     * `$Flow.ActiveStages` e le globali che il sistema ospite dichiara tali: la primitiva
+     * `POST /flows/references/writable` le comprende già, non vanno aggiunte lato client (§5.2).
+     */
     isWritable?: boolean;
     description?: string | null;
 }
@@ -773,6 +868,22 @@ interface FlowPendingScreen {
     canFinish?: boolean;
     canPause?: boolean;
 }
+/**
+ * §5.13 — lo stato che un assegnatario comunica concludendo uno step.
+ * `Pending` non e' accettato in scrittura: e' `INVALID_REQUEST`.
+ */
+type FlowStageStepStatus = 'Completed' | 'Rejected' | 'Cancelled' | 'Pending' | string;
+/** Lo stato di uno step, come lo riporta l'ispezione di una sospesa (§5.13, §6.5). */
+interface FlowStageStepState {
+    stepName?: string;
+    label?: string | null;
+    actionType?: string;
+    status?: FlowStageStepStatus;
+    /** `true` → c'e' un work item aperto: e' questo step a tenere sospesa l'interview. */
+    isWaiting?: boolean;
+    assignees?: string[];
+    outputs?: Record<string, FlowTypedValue>;
+}
 interface FlowTraceEntry {
     sequence?: number;
     level?: string;
@@ -796,6 +907,14 @@ interface FlowInterviewResult {
     trace?: FlowTraceEntry[];
     /** Con `debug: true`: i valori di **tutte** le risorse, non solo gli output. */
     resources?: Record<string, FlowTypedValue>;
+    /**
+     * `Suspended` copre due attese diverse, e questi due flag le distinguono: un evento
+     * oppure uno step di orchestrazione (§6.5).
+     */
+    isWaitingForEvent?: boolean;
+    isWaitingForStageStep?: boolean;
+    /** Con `isWaitingForStageStep`: lo stato di ogni step dello stage corrente (§5.13). */
+    stageSteps?: FlowStageStepState[];
     isSuccess?: boolean;
 }
 interface FlowStartInterviewRequest {
@@ -815,6 +934,19 @@ interface FlowResumeRequest {
     interviewKey: string;
     debug?: boolean;
 }
+/**
+ * §5.13 — `POST /interviews/{key}/stage-step`: un assegnatario conclude uno step.
+ * Se lo stage si sospende di nuovo, la risposta porta una `interviewKey` **nuova** e la
+ * vecchia non e' piu' valida.
+ */
+interface FlowStageStepRequest {
+    interviewKey: string;
+    stepName: string;
+    /** `Pending` viene rifiutato come `INVALID_REQUEST`. */
+    status: FlowStageStepStatus;
+    stepOutputs?: Record<string, unknown>;
+    debug?: boolean;
+}
 interface FlowExportQuery {
     version?: number;
     indented?: boolean;
@@ -936,10 +1068,14 @@ declare abstract class FlowBuilderApi {
     /** `GET /flows/{name}/versions/{v}/validate` — valida una versione già salvata. */
     validateVersion(flowName: string, version: number): Promise<FlowValidationResult>;
     /**
-     * `GET /flows/dictionaries` — tutte le tendine statiche in una risposta.
-     * Statiche: si caricano una volta e si tengono in cache (§6.4, §13.11).
+     * `GET /flows/dictionaries?processType=` — le tendine in una risposta.
+     *
+     * Quasi statiche: si caricano una volta e si tengono in cache (§6.4, §13.11). L'eccezione e'
+     * `globalVariables`, che dipende dal `processType`: `$Record` non esiste in uno screen flow,
+     * e referenziarlo lì e' un errore, non un avviso (§4.1). Chi lavora su piu' tipi di flow
+     * tiene una copia di dizionari per tipo.
      */
-    abstract getDictionaries(): Promise<FlowDictionaries>;
+    abstract getDictionaries(processType?: string): Promise<FlowDictionaries>;
     /**
      * `POST /flows/references` — i valori proponibili in un campo che accetta una risorsa.
      * Include gli **output automatici** degli elementi, che non sono dichiarati in nessuna
@@ -947,9 +1083,11 @@ declare abstract class FlowBuilderApi {
      */
     abstract getReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
     /**
-     * `POST /flows/references/writable` — solo le variabili, per i campi di destinazione.
-     * Ai campi `assignToReference` va aggiunto `$Flow.CurrentStage` / `$Flow.ActiveStages`
-     * se il flow dichiara stage (§5.2): quello lo fa l'editor, non la primitiva.
+     * `POST /flows/references/writable` — le variabili **piu' le globali assegnabili**, per i
+     * campi di destinazione: `$Flow.CurrentStage`, `$Flow.ActiveStages` e quelle che il sistema
+     * ospite dichiara `isWritable`. La primitiva le comprende già, l'editor non le aggiunge
+     * (§5.2). Restano fuori i campi di `$Record`, che dipendono dallo schema: quelli arrivano da
+     * `listFields(object, 'updateable')` (§6.4).
      */
     abstract getWritableReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
     /** `POST /flows/connector-targets?excluding=` — i node a cui un arco puo' puntare. */
@@ -1000,7 +1138,16 @@ declare abstract class FlowBuilderApi {
     respondToScreen(request: FlowScreenResponseRequest): Promise<FlowInterviewResult>;
     /** `POST /interviews/resume` — riprende un'esecuzione in pausa. */
     resumeInterview(request: FlowResumeRequest): Promise<FlowInterviewResult>;
-    /** `GET /interviews/{key}` — ispeziona una sospesa senza consumarla. */
+    /**
+     * `POST /interviews/{key}/stage-step` — un assegnatario conclude uno step (§5.13).
+     * Se lo stage si sospende di nuovo, la risposta porta una `interviewKey` **nuova**: la
+     * vecchia non e' piu' valida e va sostituita, non conservata.
+     */
+    completeStageStep(request: FlowStageStepRequest): Promise<FlowInterviewResult>;
+    /**
+     * `GET /interviews/{key}` — ispeziona una sospesa senza consumarla.
+     * Con `isWaitingForStageStep` porta `stageSteps` con lo stato di ognuno (§5.13).
+     */
     inspectInterview(interviewKey: string): Promise<FlowInterviewResult>;
     /** `DELETE /interviews/{key}` — abbandona. */
     abandonInterview(interviewKey: string): Promise<void>;
@@ -1053,7 +1200,7 @@ declare class HttpFlowBuilderApi extends FlowBuilderApi {
     deleteFlow(flowName: string): Promise<void>;
     validateDefinition(definition: FlowDefinition): Promise<FlowValidationResult>;
     validateVersion(flowName: string, version: number): Promise<FlowValidationResult>;
-    getDictionaries(): Promise<FlowDictionaries>;
+    getDictionaries(processType?: string): Promise<FlowDictionaries>;
     getReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
     getWritableReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
     getConnectorTargets(definition: FlowDefinition, excluding?: string): Promise<FlowConnectorTarget[]>;
@@ -1075,6 +1222,7 @@ declare class HttpFlowBuilderApi extends FlowBuilderApi {
     startInterview(request: FlowStartInterviewRequest): Promise<FlowInterviewResult>;
     respondToScreen(request: FlowScreenResponseRequest): Promise<FlowInterviewResult>;
     resumeInterview(request: FlowResumeRequest): Promise<FlowInterviewResult>;
+    completeStageStep(request: FlowStageStepRequest): Promise<FlowInterviewResult>;
     inspectInterview(interviewKey: string): Promise<FlowInterviewResult>;
     abandonInterview(interviewKey: string): Promise<void>;
 }
@@ -1131,7 +1279,7 @@ declare const FALLBACK_COLLECTION_BY_TYPE: Record<string, FlowNodeCollection>;
 declare const TYPE_BY_COLLECTION: Record<string, FlowElementType>;
 /** Etichette di fallback, se il dizionario non e' caricato. */
 declare const FALLBACK_TYPE_LABEL: Record<string, string>;
-/** I tre tipi che il motore rifiuta: nascosti dalla palette (§3.2, §13.9). */
+/** I due tipi che il motore rifiuta: nascosti dalla palette (§3.2, §13.9). */
 declare const UNSUPPORTED_TYPES: ReadonlySet<string>;
 /** Elementi che espongono il proprio risultato sotto il nome dell'elemento (§4.5). */
 declare const TYPES_WITH_AUTOMATIC_OUTPUT: ReadonlySet<string>;
@@ -1231,6 +1379,78 @@ declare function moveCondition(holder: FlowConditionHolder, from: number, to: nu
  */
 declare function checkConditionLogic(logic: string, conditionCount: number): string | null;
 
+/**
+ * Testo e numero non si confrontano — FRONTEND.md §4.3, §13.13.
+ *
+ * `Importo > "1000"` con `Importo` numerico e' `CONDITION_TYPE_MISMATCH`, un **errore** che
+ * blocca l'attivazione: la conversione implicita renderebbe l'esito dipendente dal formato
+ * del testo, e chi disegna il flow non ha modo di accorgersene.
+ *
+ * Il backend segnala solo quando conosce **entrambi** i tipi, e su un campo di un record o
+ * sull'output automatico di un elemento non li conosce: il posto giusto in cui fermare
+ * l'utente e' il picker, cioe' l'editor delle condizioni. Questo file e' la regola, in un
+ * posto solo.
+ *
+ * Vale per i soli operatori di uguaglianza e ordine. `Contains`, `StartsWith`, `EndsWith`,
+ * `In` e `NotIn` hanno una semantica propria e non sono soggetti alla regola; gli unari non
+ * hanno un secondo operando.
+ */
+
+/**
+ * `true` → per questo operatore i due lati devono essere compatibili.
+ * `isUnary` arriva dal dizionario: un unario non ha un termine di confronto.
+ */
+declare function isTypeCheckedOperator(operator: string | undefined | null, isUnary: boolean): boolean;
+declare function isNumericType(dataType: FlowDataType | undefined | null): boolean;
+/**
+ * `false` solo per la coppia vietata: testo con numero.
+ *
+ * È l'**unica** coppia vietata. Un `Enum` confrontato con un testo resta lecito, perche' un
+ * enum si confronta anche per nome; e con un tipo ignoto da un lato non si segnala nulla,
+ * perche' non sapere non e' sapere che e' sbagliato.
+ */
+declare function areTypesComparable(left: FlowDataType | undefined | null, right: FlowDataType | undefined | null): boolean;
+/**
+ * I numeri viaggiano in **cultura invariante**: il separatore decimale e' il punto, la virgola
+ * non e' accettata (§4.3). Un campo che mostra `1.234,50` deve scrivere `1234.50`.
+ *
+ * Accetta la virgola come separatore decimale digitato — e' quello che un utente italiano
+ * scrive — e la traduce, invece di lasciare che `parseFloat` tronchi silenziosamente a `1`.
+ */
+declare function parseInvariantNumber(raw: string): number | undefined;
+
+/**
+ * Gli step di uno stage di orchestrazione — FRONTEND.md §5.13.
+ *
+ * Tre regole del contratto che non si vedono guardando il tipo, e che qui stanno in un posto
+ * solo perche' le usano l'inspector, lo spazio dei nomi del documento e la validazione locale:
+ *
+ *  1. il `name` di uno step vive nello **stesso spazio dei nomi** di node e risorse (§3.3):
+ *     uno step omonimo di una variabile e' `NAME_DUPLICATED`;
+ *  2. l'output di uno step e' sempre referenziabile come `<NomeStep>.<NomeOutput>`, ma una
+ *     condizione **non** puo' referenziarlo: finche' lo step non ha girato il riferimento e'
+ *     irrisolvibile, e a runtime un riferimento irrisolvibile e' un errore;
+ *  3. gli step non sono una sequenza: l'ordine nell'array e' solo l'ordine d'esame.
+ */
+
+/** I nomi di tutti gli step del documento: entrano nello spazio dei nomi comune (§3.3). */
+declare function stageStepNames(definition: FlowDefinition): string[];
+/** Gli step di uno stage, con l'array assente trattato come vuoto. */
+declare function stepsOf(stage: FlowOrchestratedStage | undefined): FlowStageStep[];
+/**
+ * Il nome dello step il cui output un riferimento sta leggendo, se e' uno degli step passati.
+ * `undefined` quando il riferimento e' legittimo. Serve a impedire nell'editor la condizione
+ * che referenzia l'output di un altro step (§5.13, punto 4): la strada corretta e' scrivere
+ * quel risultato in una variabile con `outputParameters.assignToReference` e condizionare
+ * su quella.
+ */
+declare function stageStepOutputReferenced(reference: string | undefined, steps: FlowStageStep[]): string | undefined;
+/**
+ * L'unico output che il runtime legge da un evaluation flow di condizione. Dichiararne altri
+ * e' `STAGE_ACTION_INVALID` (§5.13, punto 7).
+ */
+declare const ORCHESTRATION_CONDITION_OUTPUT = "isOrchestrationConditionMet";
+
 /** Un node come lo vede l'editor: il node piu' da dove viene. */
 interface FlowNodeRef {
     name: string;
@@ -1278,9 +1498,10 @@ 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 **e** risorse, un unico spazio di nomi.
-     * Il controllo di unicita' che guarda solo le variabili lascia passare una variabile
-     * omonima di un node (§13.5).
+     * §3.3 — l'insieme dei nomi già usati: node, risorse **e** step di orchestrazione, un unico
+     * spazio di nomi. Il controllo di unicita' che guarda solo le variabili lascia passare una
+     * variabile omonima di un node (§13.5); quello che dimentica gli step lascia passare uno
+     * step omonimo di una variabile, che e' `NAME_DUPLICATED` allo stesso modo (§5.13).
      */
     readonly usedNames: _angular_core.Signal<string[]>;
     /** Gli archi derivati dal documento, Start incluso. */
@@ -1369,11 +1590,21 @@ declare class FlowDictionaryStore {
     private readonly api;
     private readonly _dictionaries;
     private readonly _isLoaded;
-    private loading?;
+    private readonly _processType;
+    /** Una copia per tipo di flow: le globali dipendono dal `processType` (§4.1, §6.4). */
+    private readonly cache;
+    /** Cresce a ogni `load`: scarta la risposta di un caricamento superato. */
+    private sequence;
     readonly dictionaries: _angular_core.Signal<FlowDictionaries>;
     readonly isLoaded: _angular_core.Signal<boolean>;
-    /** Idempotente: chiamabile da ogni componente che ne ha bisogno. */
-    load(): Promise<void>;
+    /** Il `processType` dei dizionari attualmente in uso. */
+    readonly processType: _angular_core.Signal<string | undefined>;
+    /**
+     * Idempotente: chiamabile da ogni componente che ne ha bisogno.
+     * Con un `processType` diverso da quello in uso ricarica — dalla cache se c'e' già —
+     * perche' cambiare tipo di flow cambia quali globali sono proponibili.
+     */
+    load(processType?: string): Promise<void>;
     readonly dataTypes: _angular_core.Signal<FlowDataTypeEntry[]>;
     readonly comparisonOperators: _angular_core.Signal<FlowComparisonOperatorEntry[]>;
     readonly assignmentOperators: _angular_core.Signal<_esfaenza_flow_builder.FlowAssignmentOperatorEntry[]>;
@@ -1390,6 +1621,8 @@ declare class FlowDictionaryStore {
     readonly transformTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
     readonly transactionModels: _angular_core.Signal<FlowDictionaryEntry[]>;
     readonly waitEventTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly stageStepTypes: _angular_core.Signal<FlowStageStepTypeEntry[]>;
+    readonly assigneeTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
     readonly conditionLogicModes: _angular_core.Signal<FlowDictionaryEntry[]>;
     readonly elementTypes: _angular_core.Signal<FlowElementTypeEntry[]>;
     /**
@@ -1423,6 +1656,22 @@ declare class FlowDictionaryStore {
      * Operatori applicabili al tipo del lato sinistro: `appliesTo` vuoto = qualunque tipo (§4.3).
      */
     operatorsFor(dataType: FlowDataType | undefined): FlowComparisonOperatorEntry[];
+    /** La voce di `globalVariables` di uno scope: `$User`, `$Flow`, … (§4.1). */
+    globalScope(scope: string | undefined | null): FlowGlobalVariableEntry | undefined;
+    /**
+     * §4.1 — la verificabilita' e' **per scope**: se lo scope dichiara almeno un percorso, uno
+     * che non c'e' e' `GLOBAL_UNKNOWN`; se non ne dichiara nessuno, resta non verificabile, che
+     * significa "non lo so", non "non esiste".
+     */
+    isGlobalScopeVerifiable(scope: string | undefined | null): boolean;
+    /** I percorsi noti di uno scope, già prefissati: `$User.Email`. */
+    globalPathsOf(scope: string | undefined | null): string[];
+    /** §5.13 — la voce di `stageStepTypes` di un `actionType`. */
+    stageStepType(value: string | undefined | null): FlowStageStepTypeEntry | undefined;
+    /** `stepBackground` vuole `actionName`; il fallback serve se il dizionario non lo dichiara. */
+    stageStepRequiresActionName(actionType: string | undefined | null): boolean;
+    /** `stepInteractive` e `stepApproval` vogliono gli assegnatari (§5.13). */
+    stageStepRequiresAssignees(actionType: string | undefined | null): boolean;
     dataType(value: string | undefined | null): FlowDataTypeEntry | undefined;
     /** §4.6 — `Object` ed `Enum` richiedono `objectType`. */
     requiresObjectType(dataType: string | undefined | null): boolean;
@@ -1868,6 +2117,12 @@ declare class ElementPaletteComponent {
     incompatibleHint(entry: FlowElementTypeEntry): string | null;
     /** Lo stesso glifo che l'elemento avra' sul canvas, così il trascinamento e' prevedibile. */
     iconOf(entry: FlowElementTypeEntry): string;
+    /**
+     * L'etichetta del ramo di fault, presa dalla mappa delle uscite invece di scrivere «ramo di
+     * errore» per tutti: su uno stage di orchestrazione quel ramo **non** e' un guasto, e' lo step
+     * rifiutato (§5.13). Un tipo nuovo eredita l'etichetta giusta senza toccare la palette.
+     */
+    faultLabel(entry: FlowElementTypeEntry): string | null;
     categoryClass(category: string): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementPaletteComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementPaletteComponent, "fb-element-palette", never, { "processType": { "alias": "processType"; "required": false; "isSignal": true; }; }, { "elementPicked": "elementPicked"; }, never, never, true, never>;
@@ -1890,11 +2145,6 @@ declare class ReferencePickerComponent {
      * formula e' `TARGET_NOT_WRITABLE` (§4.6).
      */
     readonly writableOnly: _angular_core.InputSignal<boolean>;
-    /**
-     * `true` → aggiunge `$Flow.CurrentStage` e `$Flow.ActiveStages` alle destinazioni.
-     * Sono le sole variabili globali scrivibili, e solo se il flow dichiara stage (§5.2).
-     */
-    readonly allowStageTargets: _angular_core.InputSignal<boolean>;
     /**
      * `true` → a sinistra ci va il nome di un **node**, non di una risorsa: e' il caso di
      * `WasVisited` e `HasError` (§4.3).
@@ -1907,8 +2157,6 @@ declare class ReferencePickerComponent {
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     readonly query: _angular_core.WritableSignal<string>;
     constructor();
-    /** Le due globali di stage, aggiunte alle destinazioni quando il flow dichiara stage. */
-    private readonly stageTargets;
     readonly options: _angular_core.Signal<FlowReference[]>;
     /** Le opzioni raggruppate per `kind`, così gli output automatici si distinguono. */
     readonly groups: _angular_core.Signal<{
@@ -1923,8 +2171,10 @@ declare class ReferencePickerComponent {
      *  - `navigated`: la radice e' nota ma c'e' un percorso dopo il punto (campo di record,
      *    output automatico navigato): la validazione non verifica i percorsi con il punto,
      *    quindi si accetta senza segnalare;
-     *  - `host`: scope dell'host, non verificabile per costruzione (§4.1);
-     *  - `unknown`: nessuna corrispondenza: si avvisa, senza bloccare.
+     *  - `host`: scope del sistema ospite che **non dichiara percorsi**: non verificabile (§4.1);
+     *  - `unknown`: nessuna corrispondenza: si avvisa, senza bloccare. Ci finisce anche il
+     *    percorso inesistente di uno scope che i percorsi li dichiara, perche' lì il backend
+     *    risponderebbe `GLOBAL_UNKNOWN`.
      */
     readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "unknown">;
     readonly hint: _angular_core.Signal<string | null>;
@@ -1939,7 +2189,7 @@ declare class ReferencePickerComponent {
     clear(): void;
     describe(reference: FlowReference): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReferencePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReferencePickerComponent, "fb-reference-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "isCollection": { "alias": "isCollection"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; "writableOnly": { "alias": "writableOnly"; "required": false; "isSignal": true; }; "allowStageTargets": { "alias": "allowStageTargets"; "required": false; "isSignal": true; }; "elementsOnly": { "alias": "elementsOnly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReferencePickerComponent, "fb-reference-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "isCollection": { "alias": "isCollection"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; "writableOnly": { "alias": "writableOnly"; "required": false; "isSignal": true; }; "elementsOnly": { "alias": "elementsOnly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 /** Le modalita' offerte: una per campo del modello. */
@@ -1975,12 +2225,24 @@ declare class ValueEditorComponent {
     readonly literalInputType: _angular_core.Signal<string>;
     readonly literalText: _angular_core.Signal<string>;
     readonly booleanValue: _angular_core.Signal<boolean>;
+    /** Il fuso dichiarato nel valore data: `Z`, un offset, oppure niente = ora locale (§4.2). */
+    readonly dateIsUtc: _angular_core.Signal<boolean>;
+    private static readonly ZONE_PATTERN;
+    private static hasZone;
+    private static stripZone;
     readonly globalConstants: _angular_core.Signal<string[]>;
-    readonly numericScaleHint: _angular_core.Signal<"Usa Number per importi e quantita’: Integer troncherebbe i decimali." | null>;
+    readonly numericHint: _angular_core.Signal<string | null>;
     setMode(mode: ValueMode): void;
     onReferenceChange(reference: string | undefined): void;
     onLiteralChange(raw: string): void;
     onBooleanChange(checked: boolean): void;
+    private withDateZone;
+    /**
+     * Cambia il fuso **dichiarato**, non l'istante: `09:00Z` e `09:00` sono le nove in due fusi
+     * diversi, e l'editor non converte al posto dell'utente. Riscrivere lo stesso orario con
+     * l'altro fuso e' esattamente cio' che serve quando il valore e' stato inserito sbagliato.
+     */
+    setDateZone(utc: boolean): void;
     onFormulaChange(expression: string): void;
     onFormulaTypeChange(dataType: string): void;
     onGlobalConstantChange(value: string): void;
@@ -1994,23 +2256,55 @@ declare class ValueEditorComponent {
 
 declare class ConditionEditorComponent {
     private readonly dictionaries;
+    private readonly api;
+    private readonly store;
     /** Il contenitore: porta `conditions`, `conditionLogic` e, se serve, `formula`. */
     readonly holder: _angular_core.InputSignal<FlowConditionHolder>;
     readonly title: _angular_core.InputSignal<string>;
     /** `false` dove il modello non prevede la modalita' formula sull'elemento. */
     readonly allowFormula: _angular_core.InputSignal<boolean>;
+    /**
+     * `false` dove il modello porta **solo** la lista di condizioni, senza un campo per la
+     * logica: gli `entryConditions` / `exitConditions` di uno step di orchestrazione (§5.13).
+     * Mostrare i pulsanti della logica lì scriverebbe un campo che il contratto non prevede.
+     */
+    readonly allowLogic: _angular_core.InputSignal<boolean>;
     /** Path per ancorare i rilievi di validazione, es. `rules[Approvato]`. */
     readonly issuePath: _angular_core.InputSignal<string>;
     /** Emesso a ogni modifica: il chiamante applica la mutazione allo store. */
     readonly changed: _angular_core.OutputEmitterRef<(holder: FlowConditionHolder) => void>;
     readonly conditions: _angular_core.Signal<FlowCondition[]>;
+    /**
+     * I riferimenti del documento, per conoscere il tipo del lato sinistro. Non e' un doppione
+     * del picker: serve **il tipo**, che e' l'unica cosa che permette di impedire il confronto
+     * fra testo e numero prima che lo dica la validazione (§4.3).
+     */
+    private readonly references;
+    constructor();
+    /** Il tipo di un riferimento, `undefined` se navigato o ignoto: lì non si segnala (§4.3). */
+    private typeOfReference;
+    /** Il tipo del lato sinistro: guida il secondo operando. */
+    leftDataType(condition: FlowCondition): FlowDataType | undefined;
+    /** Il tipo del lato destro, dedotto dal campo valorizzato o dal riferimento scelto. */
+    private rightDataType;
+    /**
+     * `true` quando i due lati sono incompatibili: e' `CONDITION_TYPE_MISMATCH`, un errore che
+     * blocca l'attivazione. L'unica coppia vietata e' testo con numero (§4.3).
+     */
+    hasTypeMismatch(condition: FlowCondition): boolean;
+    typeMismatchMessage(condition: FlowCondition): string;
     readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
     readonly customLogic: _angular_core.Signal<string>;
     /** Feedback immediato sull'espressione: la verita' resta della validazione backend. */
     readonly customLogicError: _angular_core.Signal<string | null>;
     /** Con `Formula` il campo `conditions` viene **ignorato** dal motore (§4.3). */
     readonly conditionsIgnored: _angular_core.Signal<boolean>;
-    readonly operators: _angular_core.Signal<_esfaenza_flow_builder.FlowComparisonOperatorEntry[]>;
+    /**
+     * Gli operatori applicabili al tipo del lato sinistro: `appliesTo` del dizionario, vuoto =
+     * qualunque tipo (§4.3). L'operatore già scritto si tiene comunque nell'elenco, altrimenti
+     * il `select` resterebbe vuoto pur avendo un valore.
+     */
+    operatorsFor(condition: FlowCondition): ReturnType<FlowDictionaryStore['operatorsFor']>;
     isUnary(condition: FlowCondition): boolean;
     appliesToElements(condition: FlowCondition): boolean;
     /** L'esito atteso di un operatore unario: assente equivale a `true` (§4.3). */
@@ -2022,8 +2316,13 @@ declare class ConditionEditorComponent {
     unarySummary(condition: FlowCondition): string;
     operatorLabel(operator: string | undefined): string;
     operatorDescription(operator: string | undefined): string | null;
-    /** `None` consente di salvare una condizione incompleta: a runtime vale sempre falso. */
+    /**
+     * `None` e' uno stato dell'editor, non un operatore: la **bozza si salva, l'attivazione no**
+     * (`CONDITION_INCOMPLETE`, errore). A runtime vale sempre falso (§4.3, §13.14).
+     */
     isPlaceholderOperator(condition: FlowCondition): boolean;
+    /** Quante condizioni sono da completare: si dice in testa, non solo riga per riga. */
+    readonly incompleteCount: _angular_core.Signal<number>;
     addCondition(): void;
     removeCondition(index: number): void;
     moveCondition(index: number, direction: -1 | 1): void;
@@ -2035,7 +2334,7 @@ declare class ConditionEditorComponent {
     setRightValue(index: number, value: FlowValue | undefined): void;
     setUnaryExpectation(index: number, expectation: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConditionEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConditionEditorComponent, "fb-condition-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "allowFormula": { "alias": "allowFormula"; "required": false; "isSignal": true; }; "issuePath": { "alias": "issuePath"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConditionEditorComponent, "fb-condition-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "allowFormula": { "alias": "allowFormula"; "required": false; "isSignal": true; }; "allowLogic": { "alias": "allowLogic"; "required": false; "isSignal": true; }; "issuePath": { "alias": "issuePath"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
 }
 
 /** Il contenitore dei filtri, qualunque elemento sia. */
@@ -2343,6 +2642,98 @@ declare class StartInspectorComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<StartInspectorComponent, "fb-start-inspector", never, {}, {}, never, never, true, never>;
 }
 
+/** I due contenitori di condizioni di uno step, come li vuole l'editor condiviso. */
+interface StepConditionHolders {
+    entry: FlowConditionHolder;
+    exit: FlowConditionHolder;
+}
+declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
+    private readonly api;
+    readonly elementType: FlowElementType;
+    readonly stage: _angular_core.Signal<FlowOrchestratedStage>;
+    readonly steps: _angular_core.Signal<FlowStageStep[]>;
+    /** I tre tipi di step: `stageStepTypes` e' l'elenco autoritativo (§6.4). */
+    readonly stepTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowStageStepTypeEntry[]>;
+    readonly assigneeTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    /** L'output che il runtime legge da un evaluation flow di condizione. */
+    readonly conditionOutputName = "isOrchestrationConditionMet";
+    /**
+     * I flow proponibili come step in background o come evaluation flow. Una lista vuota
+     * significa "non lo so": in quel caso il campo resta scrivibile a mano (§5.9, §7).
+     */
+    private readonly flowCandidates;
+    constructor();
+    readonly candidates: _angular_core.Signal<FlowSummary[]>;
+    /** L'id del `datalist`: dipende dall'elemento, per non collidere con un altro stage. */
+    readonly flowListId: _angular_core.Signal<string>;
+    /**
+     * I contenitori di condizioni, uno per step, calcolati **una volta** per documento: costruirli
+     * nel template creerebbe un oggetto nuovo a ogni ciclo di change detection.
+     */
+    readonly conditionHolders: _angular_core.Signal<StepConditionHolders[]>;
+    requiresActionName(step: FlowStageStep): boolean;
+    requiresAssignees(step: FlowStageStep): boolean;
+    /** Il rifiuto e' un esito previsto solo per l'approvazione: e' lì che serve il ramo. */
+    supportsRejection(step: FlowStageStep): boolean;
+    stepTypeDescription(step: FlowStageStep): string | null;
+    /** Un `actionType` che il dizionario non conosce: sarebbe `STAGE_STEP_TYPE_UNKNOWN`. */
+    isUnknownStepType(step: FlowStageStep): boolean;
+    /**
+     * Il nome dello step: stessa regola dei node, sullo spazio dei nomi comune (§3.3).
+     * L'unicita' si conta sulle occorrenze in `usedNames`, che gli step li comprende già: una
+     * sola occorrenza e' questo step, due sono un omonimo.
+     */
+    stepNameError(step: FlowStageStep): string | null;
+    /**
+     * Il nome dello step il cui output una condizione sta leggendo: e' irrisolvibile finche'
+     * quello step non ha girato (§5.13, punto 4). `undefined` quando va tutto bene.
+     */
+    stepOutputInConditions(step: FlowStageStep): string | undefined;
+    /** Lo step tiene un output senza destinazione: e' lecito, ma vale la pena dirlo. */
+    hasSimulatedOutputs(step: FlowStageStep): boolean;
+    addStep(): void;
+    removeStep(index: number): void;
+    /** Sposta lo step nell'ordine d'**esame**: non e' un ordine di esecuzione (§5.13). */
+    moveStep(index: number, direction: -1 | 1): void;
+    private patchStep;
+    setStepLabel(index: number, label: string): void;
+    setStepName(index: number, name: string): void;
+    setStepDescription(index: number, description: string): void;
+    /**
+     * Cambiare tipo cambia cosa lo step pretende: gli assegnatari non hanno senso su uno step in
+     * background, e `actionName` non ne ha su uno assegnato. I campi che il nuovo tipo non
+     * prevede si rimuovono, invece di restare nel documento a dire una cosa che non vale piu'.
+     */
+    setStepType(index: number, actionType: string): void;
+    setStepActionName(index: number, actionName: string): void;
+    setMultiMemberApproval(index: number, required: boolean): void;
+    isMultiMemberApproval(step: FlowStageStep): boolean;
+    setSimulateStep(index: number, simulate: boolean): void;
+    assigneesOf(step: FlowStageStep): FlowStageStepAssignee[];
+    addAssignee(index: number): void;
+    removeAssignee(stepIndex: number, assigneeIndex: number): void;
+    setAssigneeType(stepIndex: number, assigneeIndex: number, assigneeType: string): void;
+    setAssigneeValue(stepIndex: number, assigneeIndex: number, value: FlowValue | undefined): void;
+    /** Assegnatario senza tipo o senza valore: e' `STAGE_STEP_ASSIGNEE_INVALID`. */
+    isAssigneeIncomplete(assignee: FlowStageStepAssignee): boolean;
+    /**
+     * Le condizioni di uno step sono condizioni come le altre (§4.3), ma il modello porta solo
+     * la lista: `conditionLogic` e `formula` non esistono e non vanno scritti.
+     */
+    onEntryConditionsChanged(index: number, mutate: (holder: FlowConditionHolder) => void): void;
+    onExitConditionsChanged(index: number, mutate: (holder: FlowConditionHolder) => void): void;
+    private applyConditions;
+    setEntryActionName(index: number, actionName: string): void;
+    setExitActionName(index: number, actionName: string): void;
+    onParametersChanged(index: number, mutate: (holder: ParameterHolder) => void): void;
+    /** Il ramo del rifiuto e' disegnato: senza, un rifiuto fa fallire l'interview (§5.13). */
+    readonly hasRejectionBranch: _angular_core.Signal<boolean>;
+    /** C'e' almeno uno step il cui rifiuto e' un esito previsto. */
+    readonly hasApprovalStep: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrchestratedStageInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrchestratedStageInspectorComponent, "fb-orchestrated-stage-inspector", never, {}, {}, never, never, true, never>;
+}
+
 interface ResourceKindDescriptor {
     collection: FlowResourceCollection;
     label: string;
@@ -2471,6 +2862,13 @@ declare class DebugPanelComponent {
     readonly status: _angular_core.Signal<string | null>;
     readonly pendingScreen: _angular_core.Signal<_esfaenza_flow_builder.FlowPendingScreen | null>;
     readonly isWaitingForScreen: _angular_core.Signal<boolean>;
+    /** §5.13 — 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<{
@@ -2499,6 +2897,14 @@ declare class DebugPanelComponent {
     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;
@@ -2588,8 +2994,11 @@ declare class FlowBuilderComponent {
     readonly hasScreensInAutoLaunched: _angular_core.Signal<boolean>;
     /** Un flow `Screen` senza screen e' `SCREEN_FLOW_WITHOUT_SCREENS`. */
     readonly hasNoScreensInScreenFlow: _angular_core.Signal<boolean>;
-    /** `Orchestration` non e' eseguibile dal motore. */
-    readonly isOrchestration: _angular_core.Signal<boolean>;
+    /**
+     * Un flow `Orchestration` senza stage di orchestrazione e' un **avviso**
+     * (`ORCHESTRATION_WITHOUT_STAGES`): il tipo dichiara un'orchestrazione che non c'e' (§3.1).
+     */
+    readonly isOrchestrationWithoutStages: _angular_core.Signal<boolean>;
     /**
      * Click singolo sul canvas: seleziona. Con la dialog il form **non** si apre qui: un click
      * capita anche solo per spostare un node, e una finestra che si apre a ogni click sarebbe
@@ -2662,5 +3071,5 @@ declare class SelectValueDirective implements AfterViewChecked {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectValueDirective, "select[fbValue]", never, { "fbValue": { "alias": "fbValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_RESOURCE_COLLECTIONS, FieldAssignmentEditorComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NodeInspectorBase, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, canvasNodeId, checkConditionLogic, checkFlowName, elementIcon, emptyFlowDefinition, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isValidFlowName, moveCondition, outletByKey, outletsOf, parseCanvasNodeId, parseSourceConnectorId, parseTargetConnectorId, referenceRoot, remapConditionLogic, removeCondition, slugifyFlowName, sourceConnectorId, targetConnectorId, uniqueFlowName };
-export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormula, FlowGlobalVariableEntry, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowReference, FlowReferenceKind, FlowReferenceQuery, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenNavigation, FlowScreenResponseRequest, FlowScriptPluginCall, FlowSortOption, FlowSortOrder, FlowStage, FlowStart, FlowStartInterviewRequest, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, ParameterHolder, ValueMode };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_ELEMENT_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, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, HttpFlowBuilderApi, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, elementIcon, emptyFlowDefinition, flowNodeWidth, flowNodeWidthClass, isCustomConditionLogic, isGlobalReference, isNumericType, isTypeCheckedOperator, isValidFlowName, moveCondition, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, referenceRoot, remapConditionLogic, removeCondition, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName };
+export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormula, FlowGlobalVariableEntry, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOrchestratedStage, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowReference, FlowReferenceKind, FlowReferenceQuery, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenNavigation, FlowScreenResponseRequest, FlowScriptPluginCall, FlowSortOption, FlowSortOrder, FlowStage, FlowStageStep, FlowStageStepActionType, FlowStageStepAssignee, FlowStageStepConditionActionType, FlowStageStepRequest, FlowStageStepState, FlowStageStepStatus, FlowStageStepTypeEntry, FlowStart, FlowStartInterviewRequest, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, ParameterHolder, ValueMode };