@esfaenza/flow-builder 20.0.0

package/index.d.ts

@@ -0,0 +1,2666 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, AfterViewChecked } from '@angular/core';
+import * as _esfaenza_flow_builder from '@esfaenza/flow-builder';
+import { EFMarkerType, EFConnectableSide } from '@foblex/flow';
+
+/**
+ * Modello del documento Flow — FRONTEND.md §3, §4, §5.
+ *
+ * Regole del contratto rispettate qui:
+ *  - camelCase su ogni proprieta';
+ *  - ogni campo e' opzionale (una definizione incompleta e' salvabile);
+ *  - nessun `$type`: il tipo di un node e' la collection in cui sta (§3.1);
+ *  - gli enum sono stringhe, ma i tipi sono aperti (`| string`) perche' gli elenchi
+ *    autoritativi arrivano da `GET /flows/dictionaries` e possono crescere (§13.11).
+ */
+/** §4.2 — i sette tipi del sistema. Aperto: il dizionario `dataTypes` e' autoritativo. */
+type FlowDataType = 'String' | 'Integer' | 'Number' | 'Date' | 'Boolean' | 'Enum' | 'Object' | string;
+type FlowProcessType = 'Screen' | 'AutoLaunched' | 'Evaluation' | 'Orchestration' | string;
+type FlowVersionStatus = 'Draft' | 'InvalidDraft' | 'UnderReview' | 'Active' | 'Obsolete' | string;
+type FlowTriggerType = 'None' | 'RecordBeforeSave' | 'RecordAfterSave' | 'RecordBeforeDelete' | 'Scheduled' | 'Event' | string;
+type FlowRecordTriggerType = 'Create' | 'Update' | 'CreateAndUpdate' | 'Delete' | string;
+type FlowSortOrder = 'Asc' | 'Desc' | string;
+type FlowOffsetUnit = 'Minutes' | 'Hours' | 'Days' | 'Months' | string;
+type FlowCollectionProcessorType = 'Sort' | 'Filter' | string;
+type FlowTransformType = 'Map' | 'Sum' | 'Count' | string;
+type FlowTransactionModel = 'Automatic' | 'CurrentTransaction' | 'NewTransaction' | string;
+/**
+ * §4.2 — un riferimento **oppure** un valore letterale.
+ * Va valorizzato **uno e un solo** campo; `formulaExpression` e' l'unica eccezione
+ * (espressione + tipo atteso). Piu' campi insieme = `VALUE_AMBIGUOUS`.
+ */
+interface FlowValue {
+    elementReference?: string;
+    stringValue?: string;
+    integerValue?: number;
+    numberValue?: number;
+    /** Formato roundtrip senza fuso: `2026-08-15T00:00:00` (§2, §4.2). */
+    dateValue?: string;
+    booleanValue?: boolean;
+    enumValue?: string;
+    formulaExpression?: string;
+    formulaDataType?: FlowDataType;
+}
+/** §3.5 — un connector e' sempre la stessa forma; cambia solo il campo in cui vive. */
+interface FlowConnector {
+    targetReference?: string;
+    /** Solo suggerimento di disegno: la semantica di esecuzione e' identica (§3.5). */
+    isGoTo?: boolean;
+}
+/** §4.3 — condizione su risorse. Per gli operatori unari `rightValue` e' l'esito atteso. */
+interface FlowCondition {
+    leftValueReference?: string;
+    operator?: FlowComparisonOperator;
+    rightValue?: FlowValue;
+}
+type FlowComparisonOperator = 'EqualTo' | 'NotEqualTo' | 'GreaterThan' | 'GreaterThanOrEqualTo' | 'LessThan' | 'LessThanOrEqualTo' | 'Contains' | 'StartsWith' | 'EndsWith' | 'In' | 'NotIn' | 'IsNull' | 'IsBlank' | 'IsEmpty' | 'IsChanged' | 'WasSet' | 'WasVisited' | 'HasError' | 'None' | string;
+/** §4.4 — filtro su campi di un'entita': struttura **diversa** dalle condizioni. */
+interface FlowRecordFilter {
+    field?: string;
+    operator?: FlowRecordFilterOperator;
+    value?: FlowValue;
+}
+type FlowRecordFilterOperator = 'EqualTo' | 'NotEqualTo' | 'GreaterThan' | 'GreaterThanOrEqualTo' | 'LessThan' | 'LessThanOrEqualTo' | 'StartsWith' | 'EndsWith' | 'Contains' | 'IsNull' | string;
+/** §4.3 — `and` | `or` | espressione sugli indici 1-based | `Formula`. */
+type FlowConditionLogic = 'and' | 'or' | 'Formula' | string;
+/** Blocco condizioni riusato da Decision rule, Wait event, Collection Processor, Start. */
+interface FlowConditionHolder {
+    conditionLogic?: FlowConditionLogic;
+    conditions?: FlowCondition[];
+    /** Usato quando `conditionLogic === 'Formula'`; in quel caso `conditions` e' ignorato. */
+    formula?: string;
+}
+/** Parametro di input verso form / action / script / wait event. */
+interface FlowInputParameter {
+    name?: string;
+    value?: FlowValue;
+}
+/** Parametro di output: `assignToReference` deve essere una destinazione scrivibile (§4.6). */
+interface FlowOutputParameter {
+    name?: string;
+    assignToReference?: string;
+}
+/** Campo di un record → valore (Create/Update). */
+interface FlowInputFieldAssignment {
+    field?: string;
+    value?: FlowValue;
+}
+/** Campo di un record → variabile (Get Records con output esplicito). */
+interface FlowOutputFieldAssignment {
+    field?: string;
+    assignToReference?: string;
+}
+interface FlowVariable {
+    name?: string;
+    description?: string;
+    dataType?: FlowDataType;
+    /** Obbligatorio per `Object` ed `Enum`: nome dell'entita' o del tipo di enum. */
+    objectType?: string;
+    isCollection?: boolean;
+    isInput?: boolean;
+    isOutput?: boolean;
+    /** Solo per `Number` e `Integer`; altrove e' `SCALE_NOT_APPLICABLE`. */
+    scale?: number;
+    value?: FlowValue;
+}
+interface FlowConstant {
+    name?: string;
+    description?: string;
+    dataType?: FlowDataType;
+    /** Non puo' referenziare altre risorse: `CONSTANT_REFERENCES_RESOURCE`. */
+    value?: FlowValue;
+}
+interface FlowFormula {
+    name?: string;
+    description?: string;
+    dataType?: FlowDataType;
+    scale?: number;
+    /** Passata verbatim al motore di regole: il backend non la valida (§4.6). */
+    expression?: string;
+}
+interface FlowTextTemplate {
+    name?: string;
+    description?: string;
+    text?: string;
+    isViewedAsPlainText?: boolean;
+}
+interface FlowChoice {
+    name?: string;
+    description?: string;
+    dataType?: FlowDataType;
+    choiceText?: string;
+    value?: FlowValue;
+}
+interface FlowDynamicChoiceSet {
+    name?: string;
+    description?: string;
+    dataType?: FlowDataType;
+    object?: string;
+    displayField?: string;
+    valueField?: string;
+    sortField?: string;
+    sortOrder?: FlowSortOrder;
+    limit?: number;
+    /** Sempre in AND: nessun `filterLogic` qui (§4.4). */
+    filters?: FlowRecordFilter[];
+}
+interface FlowStage {
+    name?: string;
+    label?: string;
+    description?: string;
+    /** Devono essere distinti: `STAGE_ORDER_DUPLICATED`. */
+    stageOrder?: number;
+    isActive?: boolean;
+}
+/** Campi comuni a ogni node. `locationX`/`locationY` sono l'unico layout persistito (§3.5). */
+interface FlowNodeBase {
+    name?: string;
+    label?: string;
+    description?: string;
+    locationX?: number;
+    locationY?: number;
+}
+/** §5.1 — lo screen dichiara *quale* form mostrare, non i suoi campi. */
+interface FlowScreen extends FlowNodeBase {
+    formName?: string;
+    helpText?: string;
+    allowBack?: boolean;
+    allowFinish?: boolean;
+    allowPause?: boolean;
+    pausedText?: string;
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    connector?: FlowConnector;
+}
+type FlowAssignmentOperator = 'Assign' | 'Add' | 'Subtract' | 'AddAtStart' | 'AssignCount' | 'RemoveFirst' | 'RemoveAll' | 'RemovePosition' | 'RemoveAfterFirst' | 'RemoveBeforeFirst' | 'RemoveUncommon' | string;
+interface FlowAssignmentItem {
+    assignToReference?: string;
+    operator?: FlowAssignmentOperator;
+    value?: FlowValue;
+}
+/** §5.2 — le operazioni sono eseguite nell'ordine dichiarato. */
+interface FlowAssignment extends FlowNodeBase {
+    assignmentItems?: FlowAssignmentItem[];
+    connector?: FlowConnector;
+}
+/** §5.3 — una regola per ramo; l'ordine e' semantico. */
+interface FlowDecisionRule extends FlowConditionHolder {
+    name?: string;
+    label?: string;
+    description?: string;
+    connector?: FlowConnector;
+}
+interface FlowDecision extends FlowNodeBase {
+    rules?: FlowDecisionRule[];
+    defaultConnector?: FlowConnector;
+    defaultConnectorLabel?: string;
+}
+/** §5.4 */
+interface FlowLoop extends FlowNodeBase {
+    collectionReference?: string;
+    assignNextValueToReference?: string;
+    iterationOrder?: FlowSortOrder;
+    nextValueConnector?: FlowConnector;
+    noMoreValuesConnector?: FlowConnector;
+}
+interface FlowSortOption {
+    sortField?: string;
+    sortOrder?: FlowSortOrder;
+    doesPutEmptyStringAndNullFirst?: boolean;
+}
+/** §5.5 — `assignNextValueToReference` e' l'elemento in esame, non la destinazione. */
+interface FlowCollectionProcessor extends FlowNodeBase, FlowConditionHolder {
+    collectionProcessorType?: FlowCollectionProcessorType;
+    collectionReference?: string;
+    assignNextValueToReference?: string;
+    limit?: number;
+    sortOptions?: FlowSortOption[];
+    connector?: FlowConnector;
+}
+/** §5.6 */
+interface FlowRecordLookup extends FlowNodeBase {
+    object?: string;
+    filterLogic?: FlowConditionLogic;
+    filters?: FlowRecordFilter[];
+    filterFormula?: string;
+    sortField?: string;
+    sortOrder?: FlowSortOrder;
+    getFirstRecordOnly?: boolean;
+    queriedFields?: string[];
+    limit?: number;
+    /** Alternativo a `outputReference`/`outputAssignments`: `OUTPUT_CONFIGURATION_CONFLICT`. */
+    storeOutputAutomatically?: boolean;
+    outputReference?: string;
+    outputAssignments?: FlowOutputFieldAssignment[];
+    /** Modellato ma non tradotto in query (§5.6). */
+    relatedRecords?: unknown[];
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+}
+/** §5.7 */
+interface FlowRecordCreate extends FlowNodeBase {
+    object?: string;
+    inputReference?: string;
+    inputAssignments?: FlowInputFieldAssignment[];
+    filterLogic?: FlowConditionLogic;
+    filters?: FlowRecordFilter[];
+    doesUpsert?: boolean;
+    upsertExternalIdField?: string;
+    upsertStandardIdField?: string;
+    storeOutputAutomatically?: boolean;
+    assignRecordIdToReference?: string;
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+}
+interface FlowRecordUpdate extends FlowNodeBase {
+    object?: string;
+    inputReference?: string;
+    /** Nessun `filterLogic` qui: i filtri sono sempre in AND (§4.4). */
+    filters?: FlowRecordFilter[];
+    filterFormula?: string;
+    inputAssignments?: FlowInputFieldAssignment[];
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+}
+interface FlowRecordDelete extends FlowNodeBase {
+    object?: string;
+    inputReference?: string;
+    /** Senza filtri e' un **errore**, non un avviso (§5.7). */
+    filters?: FlowRecordFilter[];
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+}
+interface FlowRecordRollback extends FlowNodeBase {
+    connector?: FlowConnector;
+}
+/** §5.8 */
+interface FlowActionCall extends FlowNodeBase {
+    actionType?: string;
+    actionName?: string;
+    flowTransactionModel?: FlowTransactionModel;
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    storeOutputAutomatically?: boolean;
+    isWaitUntilCompleted?: boolean;
+    offset?: number;
+    offsetUnit?: FlowOffsetUnit;
+    /** Il ramo di timeout esiste solo con `EnableTimeoutPath`. */
+    timeoutPathUsage?: 'EnableTimeoutPath' | 'NoTimeoutPath' | string;
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+    timeoutConnector?: FlowConnector;
+}
+interface FlowScriptPluginCall extends FlowNodeBase {
+    scriptName?: string;
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    storeOutputAutomatically?: boolean;
+    connector?: FlowConnector;
+    faultConnector?: FlowConnector;
+}
+/** §5.9 — i `name` sono le variabili isInput/isOutput del flow **invocato**. */
+interface FlowSubflowInputAssignment {
+    name?: string;
+    value?: FlowValue;
+}
+interface FlowSubflowOutputAssignment {
+    name?: string;
+    assignToReference?: string;
+}
+interface FlowSubflow extends FlowNodeBase {
+    flowName?: string;
+    inputAssignments?: FlowSubflowInputAssignment[];
+    outputAssignments?: FlowSubflowOutputAssignment[];
+    storeOutputAutomatically?: boolean;
+    connector?: FlowConnector;
+}
+/** §5.10 */
+interface FlowWaitEvent extends FlowConditionHolder {
+    name?: string;
+    label?: string;
+    description?: string;
+    eventType?: string;
+    filterLogic?: FlowConditionLogic;
+    filters?: FlowRecordFilter[];
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    connector?: FlowConnector;
+}
+interface FlowWait extends FlowNodeBase {
+    waitEvents?: FlowWaitEvent[];
+    defaultConnector?: FlowConnector;
+    defaultConnectorLabel?: string;
+    faultConnector?: FlowConnector;
+}
+/** §5.11 */
+interface FlowCustomErrorMessage {
+    errorMessage?: string;
+    isFieldError?: boolean;
+    fieldSelection?: string;
+}
+interface FlowCustomError extends FlowNodeBase {
+    customErrorMessages?: FlowCustomErrorMessage[];
+}
+/** §5.12 */
+interface FlowTransformValueAction {
+    transformType?: FlowTransformType;
+    outputFieldApiName?: string;
+    value?: FlowValue;
+    inputParameters?: FlowInputParameter[];
+}
+interface FlowTransformValue {
+    transformValueActions?: FlowTransformValueAction[];
+}
+interface FlowTransform extends FlowNodeBase {
+    dataType?: FlowDataType;
+    objectType?: string;
+    isCollection?: boolean;
+    transformValues?: FlowTransformValue[];
+    /** **Array** per fedelta' storica: usa il primo (§3.5). */
+    connector?: FlowConnector[];
+}
+/** Non supportati dal motore: nascosti dalla palette (§3.2, §13.9). */
+interface FlowUnsupportedNode extends FlowNodeBase {
+    connector?: FlowConnector;
+    [key: string]: unknown;
+}
+interface FlowSchedule {
+    frequency?: 'Once' | 'Daily' | 'Weekly' | 'Monthly' | string;
+    /** Data senza fuso: `2026-08-01T00:00:00`. */
+    startDate?: string;
+    /** `08:00:00`. */
+    startTime?: string;
+}
+interface FlowScheduledPath {
+    name?: string;
+    label?: string;
+    offsetNumber?: number;
+    offsetUnit?: FlowOffsetUnit;
+    timeSource?: string;
+    recordField?: string;
+    connector?: FlowConnector;
+}
+interface FlowStart {
+    locationX?: number;
+    locationY?: number;
+    /** Sempre necessario: senza, `START_NO_ENTRY_POINT`. */
+    connector?: FlowConnector;
+    triggerType?: FlowTriggerType;
+    object?: string;
+    recordTriggerType?: FlowRecordTriggerType;
+    filterLogic?: FlowConditionLogic;
+    filters?: FlowRecordFilter[];
+    filterFormula?: string;
+    doesRequireRecordChangedToMeetCriteria?: boolean;
+    schedule?: FlowSchedule;
+    scheduledPaths?: FlowScheduledPath[];
+    inputs?: FlowInputParameter[];
+}
+interface FlowCustomProperty {
+    name?: string;
+    value?: string;
+}
+/**
+ * §3.1 — i node non stanno in un'unica lista: c'e' una collection per tipo.
+ * Il tipo di un node **e'** la collection in cui sta.
+ */
+interface FlowDefinition {
+    /** Identificatore. Rinominare passa da una primitiva dedicata, non dal JSON (§2). */
+    fullName?: string;
+    label?: string;
+    description?: string;
+    processType?: FlowProcessType;
+    /** Sola lettura per l'editor: lo governa il ciclo di vita (§8). */
+    status?: FlowVersionStatus;
+    interviewLabel?: string;
+    /** Array di uno per fedelta' storica: usa sempre il primo (§3.4). */
+    start?: FlowStart[];
+    variables?: FlowVariable[];
+    constants?: FlowConstant[];
+    formulas?: FlowFormula[];
+    textTemplates?: FlowTextTemplate[];
+    choices?: FlowChoice[];
+    dynamicChoiceSets?: FlowDynamicChoiceSet[];
+    stages?: FlowStage[];
+    screens?: FlowScreen[];
+    assignments?: FlowAssignment[];
+    decisions?: FlowDecision[];
+    loops?: FlowLoop[];
+    collectionProcessors?: FlowCollectionProcessor[];
+    recordLookups?: FlowRecordLookup[];
+    recordCreates?: FlowRecordCreate[];
+    recordUpdates?: FlowRecordUpdate[];
+    recordDeletes?: FlowRecordDelete[];
+    recordRollbacks?: FlowRecordRollback[];
+    actionCalls?: FlowActionCall[];
+    scriptPluginCalls?: FlowScriptPluginCall[];
+    subflows?: FlowSubflow[];
+    transforms?: FlowTransform[];
+    waits?: FlowWait[];
+    customErrors?: FlowCustomError[];
+    /** Non supportati: conservati nel round-trip ma non creabili dalla palette. */
+    steps?: FlowUnsupportedNode[];
+    experiments?: FlowUnsupportedNode[];
+    orchestratedStages?: FlowUnsupportedNode[];
+    apiVersion?: string;
+    timeZoneSidKey?: string;
+    triggerOrder?: number;
+    isTemplate?: boolean;
+    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"];
+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;
+/** Un node qualunque, come lo vede il canvas. */
+type FlowAnyNode = FlowNodeBase & Record<string, unknown>;
+
+/**
+ * Dizionari — FRONTEND.md §6.4.
+ *
+ * Sono statici: si caricano una volta e si tengono in cache. Nessun elenco di enum
+ * o di operatori va cablato nel frontend (§13.11): tutte le tendine leggono da qui.
+ */
+
+/** Ogni voce di dizionario ha almeno `value` (da scrivere) e `label` (da mostrare). */
+interface FlowDictionaryEntry {
+    value: string;
+    label: string;
+    description?: string | null;
+}
+interface FlowDataTypeEntry extends FlowDictionaryEntry {
+    value: FlowDataType;
+    /** `Object` ed `Enum` richiedono `objectType` (§4.6). */
+    requiresObjectType?: boolean;
+    /** `scale` si applica solo ai numerici (§4.6). */
+    supportsScale?: boolean;
+}
+/** §3.2 — la voce che descrive un tipo di elemento. */
+interface FlowElementTypeEntry extends FlowDictionaryEntry {
+    value: FlowElementType;
+    /** Categoria per raggruppare la palette: Interazione, Logica, Dati, Azione, Flow. */
+    category?: string | null;
+    /** La collection in cui scrivere il node (§3.1). */
+    metadataProperty?: FlowNodeCollection | string;
+    /** `false` → va nascosto dalla palette (§13.9). */
+    isSupported?: boolean;
+    hasFaultConnector?: boolean;
+    hasAutomaticOutput?: boolean;
+}
+/** §4.3 — operatore di confronto per le condizioni su risorse. */
+interface FlowComparisonOperatorEntry extends FlowDictionaryEntry {
+    /**
+     * Trappola numero uno (§13.1): per gli unari `rightValue` e' l'**esito atteso**,
+     * non il termine di confronto.
+     */
+    isUnary?: boolean;
+    /** A sinistra vuole il nome di un **node**, non di una risorsa (`WasVisited`, `HasError`). */
+    appliesToElements?: boolean;
+    /** Tipi a cui l'operatore si applica; vuoto o assente = qualunque tipo. */
+    appliesTo?: FlowDataType[] | null;
+}
+/** §5.2 — operatore di assegnazione. */
+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. */
+interface FlowGlobalVariableEntry extends FlowDictionaryEntry {
+    /** `$Flow`, `$GlobalConstant`, `$Record`, `$User`, … */
+    scope?: string;
+    /** Percorsi noti dello scope; per gli scope dell'host e' vuoto. */
+    paths?: string[] | null;
+    /** `true` → il backend non sa quali percorsi esistano e accetta qualunque cosa (§4.1). */
+    isResolvedByHost?: boolean;
+    /** Disponibile solo con un trigger su record (`$Record`, `$Record__Prior`). */
+    requiresRecordTrigger?: boolean;
+}
+interface FlowResourceKindEntry extends FlowDictionaryEntry {
+    /** Solo le variabili sono scrivibili (§4.6). */
+    isWritable?: boolean;
+    /** La collection del documento in cui vive la risorsa. */
+    metadataProperty?: string;
+}
+/**
+ * §6.4 — tutte le tendine statiche 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.
+ */
+interface FlowDictionaries {
+    dataTypes?: FlowDataTypeEntry[];
+    comparisonOperators?: FlowComparisonOperatorEntry[];
+    assignmentOperators?: FlowAssignmentOperatorEntry[];
+    recordFilterOperators?: FlowDictionaryEntry[];
+    elementTypes?: FlowElementTypeEntry[];
+    resourceKinds?: FlowResourceKindEntry[];
+    globalVariables?: FlowGlobalVariableEntry[];
+    processTypes?: FlowDictionaryEntry[];
+    versionStatuses?: FlowDictionaryEntry[];
+    triggerTypes?: FlowDictionaryEntry[];
+    recordTriggerTypes?: FlowDictionaryEntry[];
+    startFrequencies?: FlowDictionaryEntry[];
+    offsetUnits?: FlowDictionaryEntry[];
+    sortOrders?: FlowDictionaryEntry[];
+    collectionProcessorTypes?: FlowDictionaryEntry[];
+    transformTypes?: FlowDictionaryEntry[];
+    transactionModels?: FlowDictionaryEntry[];
+    waitEventTypes?: FlowDictionaryEntry[];
+    conditionLogicModes?: FlowDictionaryEntry[];
+    screenNavigations?: FlowDictionaryEntry[];
+}
+interface FlowObjectSummary {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+}
+interface FlowObjectDescription {
+    name: string;
+    label?: string | null;
+    fields?: FlowFieldDescription[];
+}
+interface FlowFieldDescription {
+    name: string;
+    label?: string | null;
+    dataType?: FlowDataType;
+    objectType?: string | null;
+    isFilterable?: boolean;
+    isSortable?: boolean;
+    isUpdateable?: boolean;
+    isRequired?: boolean;
+    /** `true` → i valori ammessi si chiedono a `.../fields/{field}/values`. */
+    hasClosedValueSet?: boolean;
+}
+/** `any` | `filterable` | `sortable` | `updateable` (§6.4). */
+type FlowFieldUsage = 'any' | 'filterable' | 'sortable' | 'updateable';
+interface FlowFieldValue {
+    value: string;
+    label?: string | null;
+}
+/** Voce di catalogo per action, script, form, eventi, tipi di enum. */
+interface FlowCatalogEntry {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+}
+/**
+ * Parametro dichiarato da un'action, uno script o un form.
+ * Con il catalogo popolato un parametro inesistente e' un **errore** (§5.8).
+ */
+interface FlowCatalogParameter {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+    dataType?: FlowDataType;
+    objectType?: string | null;
+    isCollection?: boolean;
+    isInput?: boolean;
+    isOutput?: boolean;
+    isRequired?: boolean;
+}
+
+/**
+ * Payload delle primitive — FRONTEND.md §6, §7, §8, §10.
+ */
+
+/** Una riga per **nome**, non per versione (§6.1). */
+interface FlowSummary {
+    flowName: string;
+    label?: string | null;
+    description?: string | null;
+    processType?: FlowProcessType;
+    activeVersion?: number | null;
+    latestVersion?: number;
+    versionCount?: number;
+    hasDraft?: boolean;
+    updatedAt?: string;
+    /** Esiste una versione attiva. Non ricalcolarlo lato client (§6.1). */
+    isRunnable?: boolean;
+}
+interface FlowVersionSummary {
+    flowName: string;
+    version: number;
+    status?: FlowVersionStatus;
+    label?: string | null;
+    description?: string | null;
+    processType?: FlowProcessType;
+    createdAt?: string;
+    /** Da conservare e rimandare come `expectedUpdatedAt` al salvataggio (§9). */
+    updatedAt?: string;
+    updatedBy?: string | null;
+    isActive?: boolean;
+    /** La versione e' una bozza. Non ricalcolarlo lato client (§6.1). */
+    isEditable?: boolean;
+}
+interface FlowListQuery {
+    search?: string;
+    processType?: FlowProcessType;
+    onlyActive?: boolean;
+}
+type FlowIssueSeverity = 'Error' | 'Warning' | 'Info' | string;
+interface FlowValidationIssue {
+    /** Stabile: usalo per decidere il comportamento. Non interpretare `message` (§7). */
+    code: string;
+    severity: FlowIssueSeverity;
+    message: string;
+    /** Ancora per portare l'utente sull'elemento con un clic. */
+    elementName?: string | null;
+    /** Campo dentro l'elemento, es. `rules[Approvato].connector.targetReference`. */
+    path?: string | null;
+}
+interface FlowValidationResult {
+    /** Ordinati per gravita' decrescente (§7). */
+    issues: FlowValidationIssue[];
+    errorCount: number;
+    warningCount: number;
+    isValid: boolean;
+}
+interface FlowCreateRequest {
+    definition: FlowDefinition;
+    flowName?: string;
+    author?: string;
+}
+interface FlowSaveRequest {
+    definition: FlowDefinition;
+    /** Se indicato **vince** sul `fullName` del documento: e' cosi' che si rinomina (§6.2). */
+    flowName?: string;
+    /** Mandare sempre la versione che si sta editando rende il risultato prevedibile (§8). */
+    version?: number;
+    /** Concorrenza ottimistica: facoltativo ma raccomandato (§9). */
+    expectedUpdatedAt?: string;
+    author?: string;
+    /** Salva **e** attiva. Fallisce senza scrivere nulla se ci sono errori. */
+    activate?: boolean;
+}
+interface FlowSaveResult {
+    flowName: string;
+    version: number;
+    status: FlowVersionStatus;
+    isNewVersion: boolean;
+    /** Da conservare per il salvataggio successivo (§9). */
+    updatedAt: string;
+    /** Il salvataggio riesce anche con errori: guarda qui, non l'esito HTTP (§6.2). */
+    validation?: FlowValidationResult;
+}
+interface FlowCloneRequest {
+    targetFlowName: string;
+    label?: string;
+    fromVersion?: number;
+    author?: string;
+}
+interface FlowNewVersionRequest {
+    /** Versione da copiare; se omessa, l'ultima. */
+    from?: number;
+    author?: string;
+}
+type FlowReferenceKind = 'Variable' | 'Constant' | 'Formula' | 'TextTemplate' | 'Choice' | 'DynamicChoiceSet' | 'Stage'
+/** Output automatico di un elemento: valido pur non essendo dichiarato (§4.5, §13.3). */
+ | 'ElementOutput' | 'Global' | string;
+interface FlowReference {
+    name: string;
+    label?: string | null;
+    kind: FlowReferenceKind;
+    dataType?: FlowDataType | null;
+    isCollection?: boolean;
+    objectType?: string | null;
+    /** Per i campi di destinazione: solo le variabili sono scrivibili (§4.6). */
+    isWritable?: boolean;
+    description?: string | null;
+}
+/** Filtro opzionale per non trasferire riferimenti che il campo non accetta. */
+interface FlowReferenceQuery {
+    definition: FlowDefinition;
+    dataType?: FlowDataType;
+    isCollection?: boolean;
+    objectType?: string;
+}
+interface FlowConnectorTarget {
+    name: string;
+    label?: string | null;
+    kind?: string;
+}
+type FlowConnectionKind = 'Start' | 'ScheduledPath' | 'Next' | 'Rule' | 'Default' | 'LoopNext' | 'LoopEnd' | 'WaitEvent' | 'Fault' | 'Timeout' | string;
+interface FlowOutlineNode {
+    name: string;
+    label?: string | null;
+    kind: string;
+    description?: string | null;
+    locationX?: number;
+    locationY?: number;
+    /** `false` → nessun percorso lo raggiunge dallo Start: va reso "scollegato" (§6.4). */
+    isReachable?: boolean;
+}
+interface FlowOutlineConnection {
+    /** `null` identifica gli archi uscenti dallo Start, che non ha nome (§6.4). */
+    from?: string | null;
+    /** `null` → il connector esiste ma non ha destinazione: ramo incompleto (§6.4). */
+    to?: string | null;
+    kind: FlowConnectionKind;
+    label?: string | null;
+    isGoTo?: boolean;
+}
+interface FlowOutline {
+    flowName?: string | null;
+    label?: string | null;
+    processType?: FlowProcessType;
+    triggerType?: string | null;
+    entryElementName?: string | null;
+    nodes: FlowOutlineNode[];
+    connections: FlowOutlineConnection[];
+}
+type FlowInterviewStatus = 'Completed' | 'WaitingForScreen' | 'Paused' | 'Suspended'
+/** **Non** e' un errore HTTP: la richiesta e' riuscita, il flow e' fallito (§6.5). */
+ | 'Failed'
+/** I criteri dello Start non erano soddisfatti: non e' un errore (§6.5). */
+ | 'NotStarted' | string;
+type FlowScreenNavigation = 'Next' | 'Previous' | 'Pause' | 'Finish' | string;
+/** Il tipo dichiarato **vince** in lettura: distingue `Integer` da `Number` (§6.5). */
+interface FlowTypedValue {
+    type?: FlowDataType;
+    value?: unknown;
+}
+interface FlowPendingScreen {
+    elementName?: string;
+    formName?: string;
+    label?: string | null;
+    helpText?: string | null;
+    inputs?: Record<string, FlowTypedValue>;
+    /** Piu' precisi dei flag del metadata: sono la verita' su cosa abilitare (§6.5). */
+    canGoBack?: boolean;
+    canFinish?: boolean;
+    canPause?: boolean;
+}
+interface FlowTraceEntry {
+    sequence?: number;
+    level?: string;
+    message?: string;
+    elementName?: string | null;
+}
+interface FlowInterviewResult {
+    interviewId?: string;
+    flowName?: string;
+    status: FlowInterviewStatus;
+    /** Opaco: da rimandare tale e quale (§6.5, §13.12). */
+    continuationToken?: string | null;
+    interviewKey?: string | null;
+    pendingScreen?: FlowPendingScreen | null;
+    outputs?: Record<string, FlowTypedValue>;
+    errors?: string[];
+    fault?: string | null;
+    currentElementName?: string | null;
+    steps?: number;
+    /** Popolato solo con `debug: true`. Puo' contenere dati personali (§6.5). */
+    trace?: FlowTraceEntry[];
+    /** Con `debug: true`: i valori di **tutte** le risorse, non solo gli output. */
+    resources?: Record<string, FlowTypedValue>;
+    isSuccess?: boolean;
+}
+interface FlowStartInterviewRequest {
+    flowName: string;
+    version?: number;
+    inputs?: Record<string, unknown>;
+    debug?: boolean;
+}
+interface FlowScreenResponseRequest {
+    continuationToken: string;
+    screenElementName?: string;
+    navigation?: FlowScreenNavigation;
+    outputs?: Record<string, unknown>;
+    debug?: boolean;
+}
+interface FlowResumeRequest {
+    interviewKey: string;
+    debug?: boolean;
+}
+interface FlowExportQuery {
+    version?: number;
+    indented?: boolean;
+}
+
+/**
+ * Errori categorizzati — FRONTEND.md §10.
+ *
+ * La UI si comporta in base alla **categoria**, non al messaggio. L'implementazione
+ * dell'interfaccia backend ha il compito di tradurre l'errore di trasporto
+ * (status HTTP, payload) in un `FlowApiError`: da lì in poi l'editor non conosce HTTP.
+ */
+
+/** Categorie di authoring (§10). */
+type FlowErrorCategory = 
+/** Bug del client: la richiesta e' incompleta. */
+'InvalidRequest'
+/** Il documento non e' leggibile: tipicamente l'import di un file sbagliato. */
+ | 'InvalidDefinition'
+/** Apri il pannello dei problemi: il payload contiene `validation`. */
+ | 'ValidationFailed' | 'FlowNotFound' | 'VersionNotFound'
+/** Nome già usato: chiedi un altro nome. */
+ | 'AlreadyExists'
+/** Versione non modificabile: proponi "Nuova versione" (§8.1). */
+ | 'NotEditable'
+/** Qualcun altro ha salvato: proponi ricarica (§9). */
+ | 'VersionConflict'
+/** Funzione non configurata su questo ambiente: disabilita il comando. */
+ | 'MissingService' | 'InvalidToken' | 'InterviewNotFound'
+/** Fallback per un errore di trasporto non categorizzato. */
+ | 'Unknown' | string;
+/** L'errore che ogni primitiva puo' rifiutare (§6, §10). */
+declare class FlowApiError extends Error {
+    readonly category: FlowErrorCategory;
+    /** Presente con `ValidationFailed`: l'elenco da aprire nel pannello (§8.3). */
+    readonly validation?: FlowValidationResult | undefined;
+    /** Con `VersionConflict`: chi ha modificato nel frattempo (§9). */
+    readonly conflictingAuthor?: string | undefined;
+    readonly details?: unknown | undefined;
+    constructor(category: FlowErrorCategory, message: string, 
+    /** Presente con `ValidationFailed`: l'elenco da aprire nel pannello (§8.3). */
+    validation?: FlowValidationResult | undefined, 
+    /** Con `VersionConflict`: chi ha modificato nel frattempo (§9). */
+    conflictingAuthor?: string | undefined, details?: unknown | undefined);
+    static is(value: unknown): value is FlowApiError;
+}
+/** Mappatura HTTP suggerita (§10). Usata dall'implementazione HTTP dell'interfaccia. */
+declare const FLOW_ERROR_HTTP_STATUS: Record<string, number>;
+/** Messaggi di fallback: `message` del backend, quando c'e', ha la precedenza. */
+declare const FLOW_ERROR_FALLBACK_MESSAGE: Record<string, string>;
+
+/**
+ * L'unica porta verso il backend.
+ *
+ * **Tutto** il traffico di dati da e verso il backend passa da qui: nessun componente
+ * e nessun servizio della libreria conosce HTTP, URL o formati di trasporto. Chi integra
+ * il builder fornisce una implementazione di questa classe astratta e la registra come
+ * provider — `FlowBuilderApi` e' anche il token di dependency injection.
+ *
+ * Contratto di errore: ogni metodo, in caso di rifiuto, deve fallire con un
+ * {@link FlowApiError} categorizzato (§10). L'editor si comporta in base alla categoria,
+ * mai leggendo il messaggio.
+ *
+ * Contratto di forma: i metodi restituiscono `Promise`. Le primitive marcate
+ * "prende il documento in lavorazione" ricevono la definizione non ancora salvata,
+ * perche' la risposta dipende da cio' che l'utente sta scrivendo (§6.4).
+ *
+ * I metodi con implementazione di default che lancia `MissingService` sono opzionali:
+ * un ambiente che non li espone lascia l'editor funzionante, con il comando corrispondente
+ * disabilitato (§10, categoria `MissingService`).
+ */
+
+declare abstract class FlowBuilderApi {
+    /** `GET /flows` — una riga per nome, non per versione. */
+    abstract listFlows(query?: FlowListQuery): Promise<FlowSummary[]>;
+    /** `GET /flows/{name}/versions` — dalla piu' recente. */
+    abstract listVersions(flowName: string): Promise<FlowVersionSummary[]>;
+    /**
+     * `GET /flows/{name}?version=` — senza `version` restituisce la versione attiva,
+     * altrimenti l'ultima.
+     */
+    abstract loadFlow(flowName: string, version?: number): Promise<FlowDefinition>;
+    /** `GET /flows/{name}/export` — il documento come stringa indentata. */
+    exportFlow(flowName: string, query?: FlowExportQuery): Promise<string>;
+    /**
+     * `POST /flows/parse` — normalizza un documento senza salvarlo.
+     * Serve all'import di un file: rifiuta con `InvalidDefinition` se non e' leggibile.
+     */
+    parseFlow(definition: unknown): Promise<FlowDefinition>;
+    /** `POST /flows` — crea la versione 1. `AlreadyExists` se il nome e' già usato. */
+    abstract createFlow(request: FlowCreateRequest): Promise<FlowSaveResult>;
+    /**
+     * `PUT /flows/{name}` — salva sulla bozza esistente o ne crea una nuova versione.
+     * Riesce **anche con errori** di validazione: l'esito sano si legge in
+     * `FlowSaveResult.validation`, non nell'assenza di eccezione (§6.2).
+     */
+    abstract saveFlow(flowName: string, request: FlowSaveRequest): Promise<FlowSaveResult>;
+    /** `POST /flows/{name}/versions?from=` — copia una versione in una nuova bozza. */
+    abstract createVersion(flowName: string, request?: FlowNewVersionRequest): Promise<FlowSaveResult>;
+    /** `POST /flows/{name}/clone` — copia il flow sotto un altro nome, versione 1. */
+    cloneFlow(flowName: string, request: FlowCloneRequest): Promise<FlowSaveResult>;
+    /**
+     * `POST /flows/{name}/versions/{v}/activate` — valida e attiva; la precedente
+     * diventa `Obsolete`. Con errori fallisce con `ValidationFailed` e il payload
+     * contiene l'elenco (§8.3).
+     */
+    abstract activateVersion(flowName: string, version: number): Promise<FlowSaveResult>;
+    /** `POST /flows/{name}/deactivate` — il flow non e' piu' eseguibile. */
+    abstract deactivateFlow(flowName: string): Promise<void>;
+    /** `DELETE /flows/{name}/versions/{v}` — rifiutata sulla versione attiva. */
+    deleteVersion(flowName: string, version: number): Promise<void>;
+    /** `DELETE /flows/{name}` — rifiutata se esiste una versione attiva. */
+    deleteFlow(flowName: string): Promise<void>;
+    /**
+     * `POST /flows/validate` — non scrive nulla. È la primitiva del pannello dei
+     * problemi, richiamabile a ogni pausa di digitazione (§11, debounce 300–500 ms).
+     */
+    abstract validateDefinition(definition: FlowDefinition): Promise<FlowValidationResult>;
+    /** `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).
+     */
+    abstract getDictionaries(): 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
+     * collection: e' il motivo per cui non va ricostruita lato client (§4.5, §13.3).
+     */
+    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.
+     */
+    abstract getWritableReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
+    /** `POST /flows/connector-targets?excluding=` — i node a cui un arco puo' puntare. */
+    abstract getConnectorTargets(definition: FlowDefinition, excluding?: string): Promise<FlowConnectorTarget[]>;
+    /**
+     * `POST /flows/outline` — node, archi e raggiungibilita' per il canvas.
+     * `isReachable` e' la fonte autoritativa dei node scollegati (§6.4).
+     */
+    abstract getOutline(definition: FlowDefinition): Promise<FlowOutline>;
+    /** `GET /catalog/objects` — le entita' su cui i flow possono operare. */
+    abstract listObjects(): Promise<FlowObjectSummary[]>;
+    /** `GET /schema/{object}` — label e campi. */
+    describeObject(object: string): Promise<FlowObjectDescription>;
+    /** `GET /schema/{object}/fields?usage=` — proponi solo i campi validi per l'uso (§4.4). */
+    abstract listFields(object: string, usage?: FlowFieldUsage): Promise<FlowObjectDescription['fields']>;
+    /** `GET /schema/{object}/fields/{field}/values` — per non far digitare i valori. */
+    listFieldValues(object: string, field: string): Promise<FlowFieldValue[]>;
+    /** `GET /catalog/action-types` */
+    abstract listActionTypes(): Promise<FlowCatalogEntry[]>;
+    /** `GET /catalog/actions?type=` */
+    abstract listActions(actionType?: string): Promise<FlowCatalogEntry[]>;
+    /** `GET /catalog/actions/{type}/{name}/parameters` */
+    abstract listActionParameters(actionType: string, actionName: string): Promise<FlowCatalogParameter[]>;
+    /** `GET /catalog/scripts` */
+    abstract listScripts(): Promise<FlowCatalogEntry[]>;
+    /** `GET /catalog/scripts/{name}/parameters` */
+    abstract listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
+    /** `GET /catalog/forms` — i form realizzati a mano nel frontend applicativo (§5.1). */
+    abstract listForms(): Promise<FlowCatalogEntry[]>;
+    /** `GET /catalog/forms/{name}/parameters` */
+    abstract listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
+    /** `GET /catalog/enum-types` — per `objectType` delle risorse `Enum`. */
+    abstract listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    /** `GET /catalog/events` — per gli eventi di un Wait. */
+    abstract listEvents(): Promise<FlowCatalogEntry[]>;
+    /**
+     * `GET /flows/subflow-candidates?excluding=` — solo i flow con una versione attiva,
+     * escluso quello corrente (§5.9).
+     */
+    abstract listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
+    /**
+     * `POST /interviews` — avvia. Ricorda: `status: 'Failed'` **non** e' un errore
+     * di trasporto, e `debug: true` popola `trace` e `resources` con dati che
+     * possono essere personali (§6.5).
+     */
+    startInterview(request: FlowStartInterviewRequest): Promise<FlowInterviewResult>;
+    /** `POST /interviews/screen` — il `continuationToken` va rimandato tale e quale (§13.12). */
+    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. */
+    inspectInterview(interviewKey: string): Promise<FlowInterviewResult>;
+    /** `DELETE /interviews/{key}` — abbandona. */
+    abandonInterview(interviewKey: string): Promise<void>;
+}
+
+/**
+ * Implementazione HTTP dell'interfaccia {@link FlowBuilderApi}, sulle rotte proposte
+ * dalla §6 di FRONTEND.md.
+ *
+ * I percorsi HTTP della specifica sono **una proposta**: le rotte definitive le decide
+ * chi scrive i controller. Se le vostre differiscono, ci sono due strade e nessuna
+ * tocca l'editor:
+ *   1. estendere questa classe e sovrascrivere i soli metodi con rotta diversa;
+ *   2. scrivere un'altra implementazione di `FlowBuilderApi` da zero.
+ *
+ * Qui vive l'unica conoscenza di HTTP della libreria, incluso il compito di tradurre
+ * status e payload in {@link FlowApiError} categorizzati (§10).
+ */
+
+interface FlowBuilderHttpConfig {
+    /** Prefisso comune, es. `/api` o `https://host/api`. Senza slash finale. */
+    baseUrl?: string;
+}
+declare const FLOW_BUILDER_HTTP_CONFIG: InjectionToken<FlowBuilderHttpConfig>;
+declare class HttpFlowBuilderApi extends FlowBuilderApi {
+    private readonly http;
+    private readonly config;
+    protected url(path: string): string;
+    /** Punto unico in cui un errore di trasporto diventa un errore di dominio. */
+    protected request<T>(call: Promise<T>): Promise<T>;
+    protected toApiError(error: unknown): FlowApiError;
+    private get;
+    private post;
+    private put;
+    private del;
+    private static params;
+    private static segment;
+    listFlows(query?: FlowListQuery): Promise<FlowSummary[]>;
+    listVersions(flowName: string): Promise<FlowVersionSummary[]>;
+    loadFlow(flowName: string, version?: number): Promise<FlowDefinition>;
+    exportFlow(flowName: string, query?: FlowExportQuery): Promise<string>;
+    parseFlow(definition: unknown): Promise<FlowDefinition>;
+    createFlow(request: FlowCreateRequest): Promise<FlowSaveResult>;
+    saveFlow(flowName: string, request: FlowSaveRequest): Promise<FlowSaveResult>;
+    createVersion(flowName: string, request?: FlowNewVersionRequest): Promise<FlowSaveResult>;
+    cloneFlow(flowName: string, request: FlowCloneRequest): Promise<FlowSaveResult>;
+    activateVersion(flowName: string, version: number): Promise<FlowSaveResult>;
+    deactivateFlow(flowName: string): Promise<void>;
+    deleteVersion(flowName: string, version: number): Promise<void>;
+    deleteFlow(flowName: string): Promise<void>;
+    validateDefinition(definition: FlowDefinition): Promise<FlowValidationResult>;
+    validateVersion(flowName: string, version: number): Promise<FlowValidationResult>;
+    getDictionaries(): Promise<FlowDictionaries>;
+    getReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
+    getWritableReferences(query: FlowReferenceQuery): Promise<FlowReference[]>;
+    getConnectorTargets(definition: FlowDefinition, excluding?: string): Promise<FlowConnectorTarget[]>;
+    getOutline(definition: FlowDefinition): Promise<FlowOutline>;
+    listObjects(): Promise<FlowObjectSummary[]>;
+    describeObject(object: string): Promise<FlowObjectDescription>;
+    listFields(object: string, usage?: FlowFieldUsage): Promise<FlowObjectDescription['fields']>;
+    listFieldValues(object: string, field: string): Promise<FlowFieldValue[]>;
+    listActionTypes(): Promise<FlowCatalogEntry[]>;
+    listActions(actionType?: string): Promise<FlowCatalogEntry[]>;
+    listActionParameters(actionType: string, actionName: string): Promise<FlowCatalogParameter[]>;
+    listScripts(): Promise<FlowCatalogEntry[]>;
+    listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
+    listForms(): Promise<FlowCatalogEntry[]>;
+    listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
+    listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    listEvents(): Promise<FlowCatalogEntry[]>;
+    listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
+    startInterview(request: FlowStartInterviewRequest): Promise<FlowInterviewResult>;
+    respondToScreen(request: FlowScreenResponseRequest): Promise<FlowInterviewResult>;
+    resumeInterview(request: FlowResumeRequest): Promise<FlowInterviewResult>;
+    inspectInterview(interviewKey: string): Promise<FlowInterviewResult>;
+    abandonInterview(interviewKey: string): Promise<void>;
+}
+
+/**
+ * Le uscite di ogni tipo di elemento — FRONTEND.md §3.5.
+ *
+ * Un connector e' sempre `{ targetReference, isGoTo }`. Quello che cambia e' **in quale
+ * campo** vive, e il campo dipende dal tipo di elemento. Questo file e' l'unica sede di
+ * quella mappa: canvas, inspector e outline locale la leggono da qui, invece di ripetere
+ * `node['faultConnector']` in venti punti.
+ *
+ * Ogni uscita e' descritta da una chiave stabile piu' due accessori. La chiave finisce
+ * nell'id del connettore sul canvas (`out:<node>:<key>`), quindi deve restare uguale fra
+ * un render e l'altro: per i rami indicizzati (regole, eventi, scheduled path) usa
+ * l'**indice** dentro la chiave.
+ *
+ * Nota: `Transform.connector` e' un array e `start` e' un array di uno, entrambi per
+ * fedelta' storica; gli accessori qui sotto lo nascondono al resto della libreria.
+ */
+
+/** Nome fittizio dello Start sul canvas: nel documento non ha `name` (§6.4, `from: null`). */
+declare const START_NODE_NAME = "$start";
+interface FlowOutlet {
+    /** Stabile fra i render: entra nell'id del connettore del canvas. */
+    key: string;
+    /** Determina lo stile dell'arco: `Fault` rosso, `Rule` etichettato, … (§6.4). */
+    kind: FlowConnectionKind;
+    /** Etichetta mostrata sul connettore e nel form. */
+    label: string;
+    /** Etichetta di ramo definita dall'autore (label della regola, dell'evento). */
+    branchLabel?: string | null;
+    /**
+     * `true` → l'assenza del connector e' un problema strutturale, non la fine legittima
+     * di un percorso: il corpo di un Loop (§3.5).
+     */
+    isStructural?: boolean;
+    read(node: FlowAnyNode): FlowConnector | undefined;
+    write(node: FlowAnyNode, connector: FlowConnector | undefined): void;
+}
+/**
+ * Le uscite di un node, nell'ordine in cui vanno mostrate.
+ * `type` e' il discriminatore di `elementTypes`; per lo Start passa `'Start'`.
+ */
+declare function outletsOf(type: FlowElementType, node: FlowAnyNode): FlowOutlet[];
+/** Trova un'uscita per chiave. */
+declare function outletByKey(type: FlowElementType, node: FlowAnyNode, key: string): FlowOutlet | undefined;
+/**
+ * Mappa di fallback tipo → collection, usata quando il dizionario `elementTypes` non e'
+ * disponibile. La fonte autoritativa resta `metadataProperty` del dizionario (§3.2).
+ */
+declare const FALLBACK_COLLECTION_BY_TYPE: Record<string, FlowNodeCollection>;
+/** Inverso della mappa: serve al flatten in lettura (§3.1). */
+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). */
+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>;
+
+/**
+ * Il glifo di ogni tipo di elemento.
+ *
+ * Sono caratteri Unicode, non icone: la libreria non porta asset e non dipende da un font di
+ * icone dell'applicazione ospite. Sta in `core` e non nel canvas perche' lo stesso glifo deve
+ * comparire sulla palette e sul node: se divergessero, l'elemento trascinato non
+ * assomiglierebbe a quello che compare sul canvas.
+ */
+declare const FLOW_ELEMENT_ICONS: Record<string, string>;
+/**
+ * Il glifo del tipo. Per un tipo che il dizionario del backend aggiunge e questa mappa non
+ * conosce, l'iniziale dell'etichetta e' un segnaposto migliore di un simbolo generico.
+ */
+declare function elementIcon(type: string, label?: string): string;
+
+/**
+ * Nomi — FRONTEND.md §3.3, §13.5.
+ *
+ * Tre regole, tutte e tre implementate qui:
+ *  1. `^[A-Za-z][A-Za-z0-9_]*$` — niente punti (i riferimenti si spezzano sul punto),
+ *     niente spazi, niente `$`;
+ *  2. node e risorse condividono **un unico** spazio di nomi;
+ *  3. il confronto e' **case-insensitive**.
+ */
+declare const FLOW_NAME_PATTERN: RegExp;
+type FlowNameProblem = 'empty' | 'pattern' | 'duplicate';
+interface FlowNameCheck {
+    isValid: boolean;
+    problem?: FlowNameProblem;
+    message?: string;
+}
+/** Verifica solo la forma. */
+declare function isValidFlowName(name: string | undefined | null): boolean;
+/**
+ * Verifica forma **e** unicita' contro l'insieme dei nomi già usati.
+ * `currentName` esclude se stesso dal controllo, per non segnalare un elemento in modifica.
+ */
+declare function checkFlowName(name: string | undefined | null, usedNames: Iterable<string>, currentName?: string | null): FlowNameCheck;
+/**
+ * Genera il nome tecnico da una label: `"Approva ordine"` → `Approva_Ordine` (§3.3).
+ * Va lasciato modificabile finche' l'elemento e' nuovo.
+ */
+declare function slugifyFlowName(label: string | undefined | null): string;
+/**
+ * Genera un nome libero a partire da una base, aggiungendo un suffisso numerico.
+ * `Decisione`, `Decisione_1`, `Decisione_2`, …
+ */
+declare function uniqueFlowName(base: string, usedNames: Iterable<string>): string;
+/**
+ * La prima parte di un riferimento, cioe' il nome che deve esistere.
+ * `Cliente.Email` → `Cliente`; `$Record.Stato` → `$Record`; `Importo` → `Importo`.
+ */
+declare function referenceRoot(reference: string | undefined | null): string;
+/** `true` se il riferimento e' una variabile globale (`$Record`, `$Flow`, `$User`, …). */
+declare function isGlobalReference(reference: string | undefined | null): boolean;
+
+/**
+ * `conditionLogic` — FRONTEND.md §4.3 e trappola §13.4.
+ *
+ * L'espressione custom referenzia gli **indici 1-based** delle condizioni. Se l'editor
+ * cancella o riordina una condizione, gli indici scalano e l'espressione va riscritta:
+ * senza, si ottiene un `CONDITION_LOGIC_INVALID` o — peggio — un'espressione valida che
+ * punta alla condizione sbagliata.
+ */
+
+/** Le tre forme non-espressione. `and` e' anche il default quando il campo e' assente. */
+declare function isCustomConditionLogic(logic: FlowConditionLogic | undefined): boolean;
+/**
+ * Riscrive un'espressione custom dopo che le condizioni sono state rimappate.
+ *
+ * `mapping[oldIndex0Based]` = nuovo indice 0-based, oppure `-1` se la condizione e' stata
+ * cancellata. Un indice cancellato non puo' essere rimpiazzato da niente di sensato: il
+ * termine viene sostituito da un segnaposto e la funzione lo segnala, così la UI puo'
+ * avvisare che l'espressione va rivista.
+ */
+declare function remapConditionLogic(logic: string, mapping: number[]): {
+    logic: string;
+    hasDroppedTerms: boolean;
+};
+/**
+ * Rimuove la condizione all'indice indicato e aggiorna `conditionLogic` di conseguenza.
+ * Muta l'oggetto passato (che nello store e' già una copia di lavoro).
+ */
+declare function removeCondition(holder: FlowConditionHolder, index: number): {
+    hasDroppedTerms: boolean;
+};
+/** Sposta una condizione e riscrive l'espressione perche' punti agli stessi termini. */
+declare function moveCondition(holder: FlowConditionHolder, from: number, to: number): void;
+/**
+ * Verifica che un'espressione custom sia sintatticamente accettabile e che ogni indice
+ * esista. Serve al feedback immediato nel form: la verita' resta della validazione
+ * del backend (`CONDITION_LOGIC_INVALID`).
+ */
+declare function checkConditionLogic(logic: string, conditionCount: number): string | null;
+
+/** Un node come lo vede l'editor: il node piu' da dove viene. */
+interface FlowNodeRef {
+    name: string;
+    type: FlowElementType;
+    collection: FlowNodeCollection;
+    index: number;
+    node: FlowAnyNode;
+}
+/** Un arco derivato dal documento, con la sua origine precisa. */
+interface FlowEdge {
+    /** Id stabile: `<sorgente>|<chiave uscita>`. */
+    id: string;
+    /** `$start` per gli archi uscenti dallo Start. */
+    from: string;
+    /** `undefined` → il connector esiste ma non ha destinazione: ramo incompleto (§6.4). */
+    to?: string;
+    outletKey: string;
+    kind: FlowConnectionKind;
+    label?: string | null;
+    isGoTo?: boolean;
+}
+/** Una risorsa come la vede l'editor. */
+interface FlowResourceRef {
+    name: string;
+    collection: FlowResourceCollection;
+    index: number;
+    resource: Record<string, unknown>;
+}
+/** Documento minimo per un flow nuovo (§11, "Creare un flow"). */
+declare function emptyFlowDefinition(fullName: string, label: string, processType: string): FlowDefinition;
+declare class FlowDocumentStore {
+    private readonly _document;
+    private readonly _isDirty;
+    private readonly _undoStack;
+    private readonly _redoStack;
+    /** Il documento in lavorazione. Sola lettura: si modifica con i metodi di questo store. */
+    readonly document: _angular_core.Signal<FlowDefinition>;
+    readonly isDirty: _angular_core.Signal<boolean>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /** §3.4 — l'elemento Start: array di uno, usa sempre il primo. */
+    readonly start: _angular_core.Signal<FlowStart>;
+    /** §3.1 — tutte le collection appiattite in un'unica lista di node. */
+    readonly nodes: _angular_core.Signal<FlowNodeRef[]>;
+    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).
+     */
+    readonly usedNames: _angular_core.Signal<string[]>;
+    /** Gli archi derivati dal documento, Start incluso. */
+    readonly edges: _angular_core.Signal<FlowEdge[]>;
+    /**
+     * Raggiungibilita' calcolata localmente, per un feedback immediato mentre si disegna.
+     * La fonte autoritativa resta `isReachable` di `POST /flows/outline` (§6.4): questa e'
+     * un'anticipazione, non un sostituto.
+     */
+    readonly reachableNames: _angular_core.Signal<ReadonlySet<string>>;
+    /** Carica un documento dal backend: azzera storico e flag di modifica. */
+    load(definition: FlowDefinition): void;
+    /** Dopo un salvataggio riuscito: il documento resta, la modifica non e' piu' pendente. */
+    markSaved(): void;
+    /**
+     * Applica una modifica al documento.
+     * Il mutatore riceve una **copia** e la modifica liberamente; lo store si occupa di
+     * storico e di sostituire il riferimento (nuovo oggetto → i signal derivati ricalcolano).
+     */
+    update(mutate: (draft: FlowDefinition) => void, options?: {
+        silent?: boolean;
+    }): void;
+    private pushHistory;
+    undo(): void;
+    redo(): void;
+    /** Inserisce un node nella collection indicata dal dizionario (`metadataProperty`). */
+    addNode(collection: FlowNodeCollection, node: FlowAnyNode): void;
+    /** Modifica un node per nome. Il mutatore riceve la copia di lavoro. */
+    updateNode(name: string, mutate: (node: FlowAnyNode) => void, options?: {
+        silent?: boolean;
+    }): void;
+    /** Modifica lo Start. */
+    updateStart(mutate: (start: FlowStart) => void, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Sposta un node sul canvas. `silent` per non riempire lo storico durante il drag:
+     * il chiamante registra un solo passo alla fine del gesto.
+     */
+    moveNode(name: string, x: number, y: number, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Rimuove un node **e** ogni connector che lo referenzia: un `targetReference` orfano
+     * e' `CONNECTOR_TARGET_UNKNOWN`, cioe' un errore che blocca l'attivazione (§7).
+     */
+    removeNode(name: string): void;
+    /** Azzera i connector che puntano a un node scomparso, Start compreso. */
+    private static clearReferencesTo;
+    /**
+     * Rinomina un node riscrivendo **tutti** i riferimenti che lo raggiungono.
+     * Nessuna primitiva del backend lo fa (§13.8): se l'editor offre la rinomina, la
+     * riscrittura la deve fare lui. Copre `targetReference`, i riferimenti a risorsa e i
+     * riferimenti a output automatico (`Vecchio.Campo` → `Nuovo.Campo`).
+     */
+    renameNode(oldName: string, newName: string): void;
+    /** Rinomina una risorsa, riscrivendo i riferimenti che la usano. */
+    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).
+     */
+    private static rewriteReferences;
+    /** Duplica un node con un nome nuovo, senza copiarne le uscite. */
+    duplicateNode(name: string, newName: string, offset?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Scrive la destinazione di un'uscita. `target` assente → il ramo resta incompleto. */
+    setConnector(fromName: string, outletKey: string, target: string | undefined, isGoTo?: boolean): void;
+    /** Rimuove un arco: il percorso finisce lì, che e' legittimo (§3.5). */
+    removeConnector(fromName: string, outletKey: string): void;
+    addResource(collection: FlowResourceCollection, resource: Record<string, unknown>): void;
+    updateResource(collection: FlowResourceCollection, index: number, mutate: (resource: Record<string, unknown>) => void): void;
+    removeResource(collection: FlowResourceCollection, index: number): void;
+    /** Modifica i campi del documento radice (label, description, processType, …). */
+    updateHeader(mutate: (definition: FlowDefinition) => void, options?: {
+        silent?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowDocumentStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDocumentStore>;
+}
+
+declare class FlowDictionaryStore {
+    private readonly api;
+    private readonly _dictionaries;
+    private readonly _isLoaded;
+    private loading?;
+    readonly dictionaries: _angular_core.Signal<FlowDictionaries>;
+    readonly isLoaded: _angular_core.Signal<boolean>;
+    /** Idempotente: chiamabile da ogni componente che ne ha bisogno. */
+    load(): Promise<void>;
+    readonly dataTypes: _angular_core.Signal<FlowDataTypeEntry[]>;
+    readonly comparisonOperators: _angular_core.Signal<FlowComparisonOperatorEntry[]>;
+    readonly assignmentOperators: _angular_core.Signal<_esfaenza_flow_builder.FlowAssignmentOperatorEntry[]>;
+    readonly recordFilterOperators: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly resourceKinds: _angular_core.Signal<_esfaenza_flow_builder.FlowResourceKindEntry[]>;
+    readonly globalVariables: _angular_core.Signal<FlowGlobalVariableEntry[]>;
+    readonly processTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly triggerTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly recordTriggerTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly startFrequencies: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly offsetUnits: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly sortOrders: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly collectionProcessorTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly transformTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly transactionModels: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly waitEventTypes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly conditionLogicModes: _angular_core.Signal<FlowDictionaryEntry[]>;
+    readonly elementTypes: _angular_core.Signal<FlowElementTypeEntry[]>;
+    /**
+     * I tipi mostrabili nella palette: `isSupported: false` va nascosto (§3.2, §13.9).
+     * Il filtro passa per la colonna del dizionario, non per una lista cablata; l'insieme
+     * locale {@link UNSUPPORTED_TYPES} interviene solo se il dizionario non dichiara il flag.
+     */
+    readonly paletteTypes: _angular_core.Signal<FlowElementTypeEntry[]>;
+    /** Le categorie della palette, nell'ordine di prima apparizione nel dizionario. */
+    readonly paletteCategories: _angular_core.Signal<string[]>;
+    elementType(value: string): FlowElementTypeEntry | undefined;
+    /** La collection in cui scrivere un node: `metadataProperty`, con fallback locale (§3.2). */
+    collectionOf(type: string): FlowNodeCollection | undefined;
+    /** Etichetta di un tipo, con fallback: un tipo sconosciuto mostra il proprio `value`. */
+    labelOf(type: string): string;
+    hasFaultConnector(type: string): boolean;
+    hasAutomaticOutput(type: string): boolean;
+    /** Etichetta di una voce di dizionario, con fallback sul valore grezzo. */
+    static labelIn(entries: FlowDictionaryEntry[], value: string | undefined | null): string;
+    operator(value: string | undefined | null): FlowComparisonOperatorEntry | undefined;
+    /**
+     * §13.1 — per gli operatori unari `rightValue` e' l'esito atteso, non un termine di
+     * confronto. Il flag arriva dal dizionario (`isUnary`).
+     */
+    isUnaryOperator(value: string | undefined | null): boolean;
+    /** §4.3 — `WasVisited` e `HasError` vogliono a sinistra il nome di un **node**. */
+    operatorAppliesToElements(value: string | undefined | null): boolean;
+    /** §5.2 — operatore che ha senso solo su destinazioni collection. */
+    assignmentExpectsCollection(value: string | undefined | null): boolean;
+    /**
+     * Operatori applicabili al tipo del lato sinistro: `appliesTo` vuoto = qualunque tipo (§4.3).
+     */
+    operatorsFor(dataType: FlowDataType | undefined): FlowComparisonOperatorEntry[];
+    dataType(value: string | undefined | null): FlowDataTypeEntry | undefined;
+    /** §4.6 — `Object` ed `Enum` richiedono `objectType`. */
+    requiresObjectType(dataType: string | undefined | null): boolean;
+    /** §4.6 — `scale` si applica solo ai numerici. */
+    supportsScale(dataType: string | undefined | null): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowDictionaryStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowDictionaryStore>;
+}
+declare class FlowCatalogStore {
+    private readonly api;
+    private readonly objectsCache;
+    private readonly fieldsCache;
+    private readonly fieldValuesCache;
+    private readonly entriesCache;
+    private readonly parametersCache;
+    /**
+     * Una lista vuota significa "non lo so", non "nessuno": con il catalogo non popolato la
+     * validazione salta i controlli invece di produrre falsi allarmi (§7). L'editor fa lo
+     * stesso: se la lista e' vuota, lascia il campo libero invece di bloccarlo.
+     */
+    listObjects(): Promise<FlowObjectSummary[]>;
+    listFields(object: string, usage?: FlowFieldUsage): Promise<FlowFieldDescription[]>;
+    listFieldValues(object: string, field: string): Promise<Array<{
+        value: string;
+        label?: string | null;
+    }>>;
+    listActionTypes(): Promise<FlowCatalogEntry[]>;
+    listActions(actionType?: string): Promise<FlowCatalogEntry[]>;
+    listActionParameters(actionType: string, actionName: string): Promise<FlowCatalogParameter[]>;
+    listScripts(): Promise<FlowCatalogEntry[]>;
+    listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
+    listForms(): Promise<FlowCatalogEntry[]>;
+    listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
+    listEnumTypes(): Promise<FlowCatalogEntry[]>;
+    listEvents(): Promise<FlowCatalogEntry[]>;
+    /** Da chiamare se lo schema cambia sotto i piedi (raro, ma il comando esiste). */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowCatalogStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowCatalogStore>;
+}
+
+declare class FlowValidationStore {
+    private readonly api;
+    private readonly destroyRef;
+    private readonly _result;
+    private readonly _isRunning;
+    private readonly _lastError;
+    private timer?;
+    /** Cresce a ogni richiesta: scarta le risposte di validazioni superate. */
+    private sequence;
+    readonly result: _angular_core.Signal<FlowValidationResult | null>;
+    readonly isRunning: _angular_core.Signal<boolean>;
+    readonly lastError: _angular_core.Signal<string | null>;
+    readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
+    readonly errorCount: _angular_core.Signal<number>;
+    readonly warningCount: _angular_core.Signal<number>;
+    readonly infoCount: _angular_core.Signal<number>;
+    /**
+     * `false` finche' non e' arrivata una validazione: non presentare l'assenza di rilievi
+     * come garanzia di correttezza (§7, ultimo capoverso).
+     */
+    readonly hasResult: _angular_core.Signal<boolean>;
+    /** Zero errori: e' la condizione che l'attivazione esige (§8.3). */
+    readonly canActivate: _angular_core.Signal<boolean>;
+    /** Rilievi raggruppati per elemento, per l'evidenziazione sul canvas. */
+    readonly issuesByElement: _angular_core.Signal<Map<string, FlowValidationIssue[]>>;
+    /** I rilievi non ancorati a un elemento: riguardano il documento (§7, famiglia Definizione). */
+    readonly documentIssues: _angular_core.Signal<FlowValidationIssue[]>;
+    constructor();
+    /** La gravita' peggiore su un elemento, per decidere il colore del node sul canvas. */
+    severityOf(elementName: string): 'Error' | 'Warning' | 'Info' | null;
+    /**
+     * I rilievi che riguardano un campo dentro un elemento.
+     * `path` e' del tipo `rules[Approvato].connector.targetReference`: il confronto e' per
+     * prefisso, così `rules[Approvato]` cattura anche i rilievi piu' profondi.
+     */
+    issuesAt(elementName: string | null, pathPrefix: string): FlowValidationIssue[];
+    /** Programma una validazione dopo la pausa di digitazione (§11.4). */
+    schedule(definition: FlowDefinition): void;
+    /** Valida subito, saltando il debounce: prima di attivare, o su richiesta esplicita. */
+    run(definition: FlowDefinition): Promise<FlowValidationResult | null>;
+    /**
+     * Sostituisce il risultato con quello arrivato da un'altra primitiva: il salvataggio
+     * restituisce `validation` (§6.2) e l'attivazione fallita lo porta nel payload
+     * dell'errore (§8.3). In entrambi i casi e' il risultato piu' fresco che esista.
+     */
+    adopt(result: FlowValidationResult | undefined | null): void;
+    clear(): void;
+    private cancel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowValidationStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowValidationStore>;
+}
+
+interface FlowLayoutNodeInput {
+    name: string;
+    width: number;
+    height: number;
+}
+interface FlowLayoutResult {
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+}
+type FlowLayoutDirection = 'TB' | 'LR';
+interface FlowLayoutOptions {
+    direction?: FlowLayoutDirection;
+    /** Distanza fra i livelli. */
+    rankSeparation?: number;
+    /** Distanza fra i node dello stesso livello. */
+    nodeSeparation?: number;
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+declare class FlowLayoutService {
+    /**
+     * Calcola le posizioni. Restituisce l'angolo in alto a sinistra di ogni node, perche'
+     * e' cio' che `locationX`/`locationY` significano nel modello, mentre dagre ragiona in
+     * centri.
+     */
+    layout(nodes: FlowLayoutNodeInput[], edges: FlowEdge[], options?: FlowLayoutOptions): FlowLayoutResult;
+    /**
+     * Peso dell'arco: piu' alto = piu' dritto. Il percorso principale resta in colonna,
+     * i rami di errore e di timeout si spostano di lato.
+     */
+    private static weightOf;
+    /** Lo Start apre sempre il grafo: utile per ordinare i node prima del layout. */
+    static isStart(name: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowLayoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowLayoutService>;
+}
+
+/** Cosa mostrare quando il salvataggio incontra una versione modificata da altri (§9). */
+interface FlowConflictState {
+    message: string;
+    conflictingAuthor?: string;
+}
+declare class FlowEditorSession {
+    private readonly api;
+    private readonly documentStore;
+    private readonly validation;
+    private readonly _flowName;
+    private readonly _version;
+    private readonly _versions;
+    /** Conservato al caricamento, rimandato al salvataggio (§9.1, §9.2). */
+    private readonly _expectedUpdatedAt;
+    private readonly _isBusy;
+    private readonly _lastSaveResult;
+    private readonly _conflict;
+    private readonly _author;
+    readonly flowName: _angular_core.Signal<string | null>;
+    readonly version: _angular_core.Signal<number | null>;
+    readonly versions: _angular_core.Signal<FlowVersionSummary[]>;
+    readonly isBusy: _angular_core.Signal<boolean>;
+    readonly lastSaveResult: _angular_core.Signal<FlowSaveResult | null>;
+    readonly conflict: _angular_core.Signal<FlowConflictState | null>;
+    readonly expectedUpdatedAt: _angular_core.Signal<string | undefined>;
+    /** `true` finche' il flow non e' mai stato salvato: il comando e' "Crea", non "Salva". */
+    readonly isNew: _angular_core.Signal<boolean>;
+    readonly currentVersionSummary: _angular_core.Signal<FlowVersionSummary | undefined>;
+    /**
+     * `isEditable` arriva dal backend e non va ricalcolato lato client (§6.1). Un flow nuovo,
+     * non ancora salvato, e' modificabile per definizione.
+     */
+    readonly isEditable: _angular_core.Signal<boolean>;
+    /** Su una versione non modificabile il comando primario diventa "Nuova versione" (§8.1). */
+    readonly primaryCommand: _angular_core.Signal<"create" | "save" | "newVersion">;
+    readonly isActiveVersion: _angular_core.Signal<boolean>;
+    /** Attivare esige zero errori (§8.3): il comando resta disabilitato finche' ce ne sono. */
+    readonly canActivate: _angular_core.Signal<boolean>;
+    setAuthor(author: string | undefined): void;
+    /** Prepara un flow nuovo, non ancora salvato (§11, "Creare un flow"). */
+    startNew(fullName: string, label: string, processType: string): void;
+    /**
+     * Carica una versione e conserva il suo `updatedAt` (§11, "Modificare", passo 1).
+     * `version` assente → la versione attiva se c'e', altrimenti l'ultima.
+     */
+    open(flowName: string, version?: number): Promise<void>;
+    /** Senza `version` il backend restituisce la versione attiva, altrimenti l'ultima (§6.1). */
+    private static pickVersion;
+    /** Ricarica l'elenco versioni: dopo un'attivazione la precedente e' `Obsolete` (§8.4). */
+    refreshVersions(): Promise<void>;
+    /**
+     * Crea o salva, a seconda dello stato. Non lancia su definizione invalida: il
+     * salvataggio riesce anche con errori e il chiamante legge `validation` (§8.2).
+     *
+     * Rilancia `VersionConflict` dopo aver popolato {@link conflict}, perche' la UI deve
+     * offrire "ricarica" o "salva come nuova versione" (§9.3).
+     */
+    save(options?: {
+        activate?: boolean;
+        flowName?: string;
+    }): Promise<FlowSaveResult>;
+    private applySaveResult;
+    /** Copia la versione corrente in una nuova bozza (§8.1): il comando delle versioni chiuse. */
+    createNewVersion(): Promise<FlowSaveResult>;
+    /**
+     * Attiva la versione corrente (§11, "Attivare").
+     * Valida prima in locale per un feedback immediato: se ci sono errori non chiama
+     * l'attivazione, perche' fallirebbe comunque.
+     */
+    activate(): Promise<FlowSaveResult>;
+    deactivate(): Promise<void>;
+    /**
+     * Elimina una versione. Da mettere dietro una conferma esplicita: il numero della versione
+     * piu' alta viene riassegnato dopo un'eliminazione, e un'esecuzione sospesa nata su quel
+     * numero riprenderebbe su una definizione diversa (§8, ultimo capoverso).
+     */
+    deleteVersion(version: number): Promise<void>;
+    /** Risoluzione del conflitto, prima opzione: ricarica e perde le modifiche locali (§9.3). */
+    reloadAfterConflict(): Promise<void>;
+    /**
+     * Risoluzione del conflitto, seconda opzione: salva come nuova versione, conservando
+     * le modifiche locali (§9.3). Il salvataggio senza `expectedUpdatedAt` e senza `version`
+     * lascia scegliere al backend, che crea una nuova versione se l'ultima non e' toccabile.
+     */
+    saveAsNewVersionAfterConflict(): Promise<FlowSaveResult>;
+    dismissConflict(): void;
+    /** L'ultima validazione conosciuta, da qualunque primitiva arrivi. */
+    get validationResult(): FlowValidationResult | null;
+    /** Il documento corrente, per chi deve mandarlo a una primitiva. */
+    get definition(): FlowDefinition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowEditorSession, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FlowEditorSession>;
+}
+
+/**
+ * Il view model del canvas.
+ *
+ * Gli id dei connettori sono stringhe costruite qui e in nessun altro posto: un mismatch
+ * fra l'id dichiarato su un connettore e quello usato da una connessione fa sparire l'arco
+ * **senza errori** — e' il fallimento silenzioso numero uno di @foblex/flow.
+ */
+
+/** Il connettore di ingresso di un node. Lo Start non ne ha. */
+declare function targetConnectorId(nodeName: string): string;
+/** Il connettore di uscita di un node, uno per ramo (§3.5). */
+declare function sourceConnectorId(nodeName: string, outletKey: string): string;
+/** Inverso di {@link sourceConnectorId}. */
+declare function parseSourceConnectorId(id: string): {
+    nodeName: string;
+    outletKey: string;
+} | null;
+/** Inverso di {@link targetConnectorId}. */
+declare function parseTargetConnectorId(id: string): string | null;
+/** L'id del node sul canvas: prefissato per non collidere con quello dei connettori. */
+declare function canvasNodeId(nodeName: string): string;
+declare function parseCanvasNodeId(id: string): string | null;
+interface FlowCanvasNode {
+    /** Nome nel documento; `$start` per lo Start, che nel modello non ha nome. */
+    name: string;
+    /** Id per il canvas. */
+    id: string;
+    /** `'Start'` oppure il discriminatore di `elementTypes`. */
+    type: FlowElementType | 'Start';
+    typeLabel: string;
+    label: string;
+    description?: string | null;
+    position: {
+        x: number;
+        y: number;
+    };
+    outlets: FlowOutlet[];
+    isStart: boolean;
+    /** Categoria del dizionario: decide il colore dell'icona del node. */
+    category?: string | null;
+    /** Glifo mostrato nel badge dell'icona: dipende dal tipo, non dalla categoria. */
+    icon: string;
+    /**
+     * La classe che porta la larghezza del node. Non e' costante: le uscite stanno in fila sul
+     * bordo inferiore, quindi un elemento con molti rami ha bisogno di piu' spazio perche' le
+     * etichette restino leggibili. E' una classe e non uno stile inline perche' @foblex/flow
+     * riscrive l'attributo `style` del node per posizionarlo.
+     */
+    widthClass: string;
+    /**
+     * Le etichette dei rami si mostrano solo quando i rami sono piu' di uno: su un `next`
+     * unico l'etichetta direbbe soltanto «Successivo».
+     */
+    showsOutletLabels: boolean;
+    /** `false` → nessun percorso lo raggiunge dallo Start: va reso "scollegato" (§6.4). */
+    isReachable: boolean;
+    /** La gravita' peggiore dei rilievi sull'elemento (§7). */
+    severity: FlowIssueSeverity | null;
+    /** Numero di rilievi, per il badge. */
+    issueCount: number;
+    /** L'elemento espone il proprio risultato sotto il proprio nome (§4.5). */
+    hasAutomaticOutput: boolean;
+    /** Sintesi di una riga mostrata sul node (l'oggetto letto, il form mostrato, …). */
+    subtitle?: string | null;
+    /** Rami dichiarati ma senza destinazione: mostrati come tali, non come archi (§6.4). */
+    danglingOutlets: FlowOutlet[];
+}
+interface FlowCanvasEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    kind: string;
+    label?: string | null;
+    isGoTo: boolean;
+}
+
+/**
+ * Dimensioni nominali di un node, usate dal layout automatico.
+ *
+ * Le uscite stanno in fila sul bordo **inferiore**: e' la larghezza a dipendere dal numero
+ * di rami, non l'altezza. L'altezza resta quella della card (intestazione, riga del nome
+ * tecnico e badge, striscia delle uscite) e non cambia con i rami.
+ */
+declare const FLOW_NODE_WIDTH = 240;
+declare const FLOW_NODE_HEIGHT = 116;
+declare function flowNodeWidth(outletCount: number): number;
+/** La classe che porta quella larghezza: unico modo di sopravvivere ai riposizionamenti. */
+declare function flowNodeWidthClass(outletCount: number): string;
+declare class FlowCanvasComponent {
+    private readonly store;
+    private readonly dictionaries;
+    private readonly validation;
+    /**
+     * Marker di fine arco: la variante "all states" crea sia quello normale sia quello
+     * selezionato, evitando che l'arco selezionato perda la punta.
+     */
+    readonly markerEnd = EFMarkerType.END_ALL_STATES;
+    /**
+     * I lati da cui gli archi partono e arrivano: uscite in basso, ingresso in alto.
+     * Dichiararli e' quello che rende il grafo leggibile dall'alto verso il basso; lasciando
+     * fare a foblex, il lato viene calcolato dalla posizione relativa e un ramo che risale
+     * uscirebbe di fianco.
+     */
+    readonly sides: typeof EFConnectableSide;
+    /** Il nome dell'elemento selezionato, `$start` per lo Start. */
+    readonly selectedName: _angular_core.InputSignal<string | null>;
+    /**
+     * L'outline del backend, quando disponibile: da' la raggiungibilita' autoritativa (§6.4).
+     * Assente → si usa il calcolo locale.
+     */
+    readonly outline: _angular_core.InputSignal<FlowOutline | null>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<string | null>;
+    readonly nodeOpened: _angular_core.OutputEmitterRef<string>;
+    readonly nodeRemoveRequested: _angular_core.OutputEmitterRef<string>;
+    readonly nodeDuplicateRequested: _angular_core.OutputEmitterRef<string>;
+    /** Rilascio di un elemento dalla palette: tipo + punto nel sistema del canvas. */
+    readonly elementDropped: _angular_core.OutputEmitterRef<{
+        type: FlowElementType;
+        x: number;
+        y: number;
+    }>;
+    /** Raggiungibilita': backend se c'e', locale altrimenti. */
+    private readonly reachability;
+    readonly nodes: _angular_core.Signal<FlowCanvasNode[]>;
+    private toCanvasNode;
+    /** Gli archi con destinazione: solo questi diventano `<f-connection>`. */
+    readonly edges: _angular_core.Signal<FlowCanvasEdge[]>;
+    /** Sintesi mostrata sul node: la cosa che serve sapere senza aprire l'inspector. */
+    private subtitleOf;
+    /** Sullo Start conta il trigger: e' cio' che decide quando il flow parte (§3.4). */
+    private startSubtitle;
+    /**
+     * Creazione di un arco. `targetId` assente significa rilascio nel vuoto: si lascia il
+     * ramo dichiarato ma senza destinazione, che e' esattamente il "ramo incompleto" del
+     * modello, invece di scartare il gesto.
+     */
+    onCreateConnection(event: {
+        sourceId: string;
+        targetId?: string;
+    }): void;
+    /** Riassegnazione di un arco già disegnato, da un capo o dall'altro. */
+    onReassignConnection(event: {
+        endpoint: string;
+        previousSourceId: string;
+        nextSourceId?: string;
+        previousTargetId: string;
+        nextTargetId?: string;
+    }): void;
+    /**
+     * Spostamento dei node. Un solo passo di storico per l'intero gesto: le posizioni
+     * intermedie non sono modifiche che l'utente vuole annullare una per una.
+     */
+    onMoveNodes(event: {
+        nodes: Array<{
+            id: string;
+            position: {
+                x: number;
+                y: number;
+            };
+        }>;
+    }): void;
+    onSelectionChange(event: {
+        nodeIds: string[];
+    }): void;
+    /** `Delete` sulla selezione: lo Start non e' cancellabile, e' uno per flow (§3.4). */
+    onDeleteSelected(event: {
+        nodeIds: string[];
+    }): void;
+    /** Rilascio di un elemento trascinato dalla palette. */
+    onCreateNode(event: {
+        data: unknown;
+        externalItemRect: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onNodeDoubleClick(name: string): void;
+    /**
+     * Il bottone «✎» sul node: apre il dettaglio senza aspettare il doppio click, che e' un
+     * gesto che non si vede. `stopPropagation` evita che il click valga anche come selezione
+     * dell'area sottostante.
+     */
+    onEditClick(event: Event, name: string): void;
+    connectorIdOf(node: FlowCanvasNode, outletKey: string): string;
+    targetIdOf(node: FlowCanvasNode): string;
+    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; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
+}
+
+interface PaletteGroup {
+    category: string;
+    entries: FlowElementTypeEntry[];
+}
+declare class ElementPaletteComponent {
+    private readonly dictionaries;
+    /**
+     * Il `processType` del flow: un flow `AutoLaunched` che contiene screen e' un errore di
+     * validazione, perche' non c'e' nessuno a cui mostrarli (§3.1). La palette lo segnala
+     * prima che l'utente lo scopra dal pannello dei problemi.
+     */
+    readonly processType: _angular_core.InputSignal<string | undefined>;
+    readonly elementPicked: _angular_core.OutputEmitterRef<string>;
+    private readonly filter;
+    readonly groups: _angular_core.Signal<PaletteGroup[]>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    onFilter(value: string): void;
+    pick(entry: FlowElementTypeEntry): void;
+    /** Uno screen in un flow che non mostra nulla: si segnala, non si nasconde (§3.1). */
+    isIncompatible(entry: FlowElementTypeEntry): boolean;
+    incompatibleHint(entry: FlowElementTypeEntry): string | null;
+    /** Lo stesso glifo che l'elemento avra' sul canvas, così il trascinamento e' prevedibile. */
+    iconOf(entry: FlowElementTypeEntry): string;
+    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>;
+}
+
+declare class ReferencePickerComponent {
+    private readonly api;
+    private readonly store;
+    private readonly dictionaries;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Filtra i riferimenti compatibili col campo che si sta compilando (§6.4). */
+    readonly dataType: _angular_core.InputSignal<string | undefined>;
+    readonly isCollection: _angular_core.InputSignal<boolean | undefined>;
+    readonly objectType: _angular_core.InputSignal<string | undefined>;
+    /**
+     * `true` → propone solo destinazioni scrivibili. Assegnare a una costante o a una
+     * 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).
+     */
+    readonly elementsOnly: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
+    private readonly references;
+    private readonly isLoading;
+    private readonly loadError;
+    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<{
+        kind: string;
+        label: string;
+        items: FlowReference[];
+    }[]>;
+    private static kindLabel;
+    /**
+     * Stato del valore corrente rispetto all'elenco.
+     *  - `known`: presente nell'elenco;
+     *  - `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.
+     */
+    readonly valueState: _angular_core.Signal<"empty" | "known" | "navigated" | "host" | "unknown">;
+    readonly hint: _angular_core.Signal<string | null>;
+    readonly errorMessage: _angular_core.Signal<string | null>;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    onQuery(value: string): void;
+    choose(reference: FlowReference): void;
+    /** Scrittura libera: indispensabile per i campi di un record e per gli scope dell'host. */
+    onManualInput(value: string): void;
+    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>;
+}
+
+/** Le modalita' offerte: una per campo del modello. */
+type ValueMode = 'reference' | 'literal' | 'formula' | 'globalConstant' | 'empty';
+declare class ValueEditorComponent {
+    private readonly dictionaries;
+    readonly value: _angular_core.InputSignal<FlowValue | undefined>;
+    readonly label: _angular_core.InputSignal<string>;
+    /** Il tipo atteso dalla destinazione: guida il controllo del letterale. */
+    readonly dataType: _angular_core.InputSignal<string | undefined>;
+    readonly objectType: _angular_core.InputSignal<string | undefined>;
+    readonly isCollection: _angular_core.InputSignal<boolean | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** Nasconde la modalita' formula dove il modello non la prevede. */
+    readonly allowFormula: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<FlowValue | undefined>;
+    /** La modalita' dedotta dal campo effettivamente valorizzato. */
+    readonly mode: _angular_core.Signal<ValueMode>;
+    /**
+     * Quanti campi di valore sono valorizzati: piu' di uno e' `VALUE_AMBIGUOUS` (§4.2).
+     * Puo' capitare su un documento arrivato da un altro editor: si segnala e si offre
+     * di normalizzarlo, invece di nasconderlo.
+     */
+    readonly filledFieldCount: _angular_core.Signal<number>;
+    readonly isAmbiguous: _angular_core.Signal<boolean>;
+    /** Il campo del valore che corrisponde al `dataType` (§4.2, tabella dei sette tipi). */
+    readonly literalField: _angular_core.Signal<keyof FlowValue>;
+    /**
+     * `Object` non ha un campo letterale: un record si passa per riferimento (§4.2).
+     * Lo stesso vale per una collection.
+     */
+    readonly literalAllowed: _angular_core.Signal<boolean>;
+    readonly literalInputType: _angular_core.Signal<string>;
+    readonly literalText: _angular_core.Signal<string>;
+    readonly booleanValue: _angular_core.Signal<boolean>;
+    readonly globalConstants: _angular_core.Signal<string[]>;
+    readonly numericScaleHint: _angular_core.Signal<"Usa Number per importi e quantita’: Integer troncherebbe i decimali." | null>;
+    setMode(mode: ValueMode): void;
+    onReferenceChange(reference: string | undefined): void;
+    onLiteralChange(raw: string): void;
+    onBooleanChange(checked: boolean): void;
+    onFormulaChange(expression: string): void;
+    onFormulaTypeChange(dataType: string): void;
+    onGlobalConstantChange(value: string): void;
+    /** Normalizza un valore ambiguo tenendo il campo della modalita' corrente. */
+    normalize(): void;
+    private emit;
+    readonly dataTypeOptions: _angular_core.Signal<_esfaenza_flow_builder.FlowDataTypeEntry[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ValueEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ValueEditorComponent, "fb-value-editor", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; "isCollection": { "alias": "isCollection"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "allowFormula": { "alias": "allowFormula"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class ConditionEditorComponent {
+    private readonly dictionaries;
+    /** 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>;
+    /** 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[]>;
+    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[]>;
+    isUnary(condition: FlowCondition): boolean;
+    appliesToElements(condition: FlowCondition): boolean;
+    /** L'esito atteso di un operatore unario: assente equivale a `true` (§4.3). */
+    unaryExpectation(condition: FlowCondition): boolean;
+    /**
+     * Testo che dice cosa e' stato scritto, in italiano. Serve perche' la differenza fra
+     * `IsNull` + `true` e `IsNull` + `false` e' invisibile nel JSON e capitale a runtime.
+     */
+    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. */
+    isPlaceholderOperator(condition: FlowCondition): boolean;
+    addCondition(): void;
+    removeCondition(index: number): void;
+    moveCondition(index: number, direction: -1 | 1): void;
+    setLogicMode(mode: 'and' | 'or' | 'custom' | 'formula'): void;
+    setCustomLogic(logic: string): void;
+    setFormula(formula: string): void;
+    setLeft(index: number, reference: string | undefined): void;
+    setOperator(index: number, operator: string): void;
+    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>;
+}
+
+/** Il contenitore dei filtri, qualunque elemento sia. */
+interface FilterHolder {
+    filters?: FlowRecordFilter[];
+    filterLogic?: string;
+    filterFormula?: string;
+}
+declare class RecordFilterEditorComponent {
+    private readonly catalog;
+    private readonly dictionaries;
+    readonly holder: _angular_core.InputSignal<FilterHolder>;
+    readonly object: _angular_core.InputSignal<string | undefined>;
+    readonly title: _angular_core.InputSignal<string>;
+    /** L'uso con cui chiedere i campi: `filterable` per i filtri, `updateable` altrove. */
+    readonly usage: _angular_core.InputSignal<FlowFieldUsage>;
+    /** `false` dove il modello non ha `filterLogic`: i filtri sono sempre in AND (§4.4). */
+    readonly supportsLogic: _angular_core.InputSignal<boolean>;
+    /** `true` dove esiste `filterFormula` come alternativa ai filtri. */
+    readonly supportsFormula: _angular_core.InputSignal<boolean>;
+    /**
+     * Avviso da mostrare quando la lista e' vuota. Un Delete senza filtri e' un **errore**,
+     * un Update senza filtri e' solo un avviso — ma aggiorna tutti i record dell'entita'
+     * (§5.7, §13.10).
+     */
+    readonly emptyWarning: _angular_core.InputSignal<string | null>;
+    readonly emptyWarningSeverity: _angular_core.InputSignal<"error" | "warn">;
+    readonly changed: _angular_core.OutputEmitterRef<(holder: FilterHolder) => void>;
+    private readonly fields;
+    readonly filters: _angular_core.Signal<FlowRecordFilter[]>;
+    readonly operators: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    constructor();
+    readonly fieldOptions: _angular_core.Signal<FlowFieldDescription[]>;
+    /** Catalogo vuoto = "non lo so": si lascia il campo libero, non si blocca (§7). */
+    readonly hasFieldCatalog: _angular_core.Signal<boolean>;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
+    readonly customLogic: _angular_core.Signal<string>;
+    readonly showEmptyWarning: _angular_core.Signal<boolean>;
+    addFilter(): void;
+    removeFilter(index: number): void;
+    setField(index: number, field: string): void;
+    setOperator(index: number, operator: string): void;
+    setValue(index: number, value: FlowValue | undefined): void;
+    isNullOperator(filter: FlowRecordFilter): boolean;
+    nullExpectation(filter: FlowRecordFilter): boolean;
+    setNullExpectation(index: number, expectation: boolean): void;
+    setLogicMode(mode: 'and' | 'or' | 'custom' | 'formula'): void;
+    setCustomLogic(logic: string): void;
+    setFormula(formula: string): void;
+    /** Il tipo del campo, per proporre il controllo giusto sul valore. */
+    fieldDataType(filter: FlowRecordFilter): string | undefined;
+    /** `true` se il campo referenzia una relazione: la validazione non lo verifica (§4.4). */
+    isRelationPath(filter: FlowRecordFilter): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecordFilterEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecordFilterEditorComponent, "fb-record-filter-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "object": { "alias": "object"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "usage": { "alias": "usage"; "required": false; "isSignal": true; }; "supportsLogic": { "alias": "supportsLogic"; "required": false; "isSignal": true; }; "supportsFormula": { "alias": "supportsFormula"; "required": false; "isSignal": true; }; "emptyWarning": { "alias": "emptyWarning"; "required": false; "isSignal": true; }; "emptyWarningSeverity": { "alias": "emptyWarningSeverity"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+/** Contenitore generico: gli input hanno `value`, gli output `assignToReference`. */
+interface ParameterHolder {
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+}
+declare class ParameterEditorComponent {
+    readonly holder: _angular_core.InputSignal<ParameterHolder>;
+    /** Parametri dichiarati dal catalogo; vuoto = catalogo non popolato. */
+    readonly catalogParameters: _angular_core.InputSignal<FlowCatalogParameter[]>;
+    readonly inputTitle: _angular_core.InputSignal<string>;
+    readonly outputTitle: _angular_core.InputSignal<string>;
+    readonly showInputs: _angular_core.InputSignal<boolean>;
+    readonly showOutputs: _angular_core.InputSignal<boolean>;
+    /** `true` → gli output vanno all'output automatico, e i parametri sono ignorati. */
+    readonly outputsDisabledReason: _angular_core.InputSignal<string | null>;
+    readonly changed: _angular_core.OutputEmitterRef<(holder: ParameterHolder) => void>;
+    readonly inputs: _angular_core.Signal<FlowInputParameter[]>;
+    readonly outputs: _angular_core.Signal<FlowOutputParameter[]>;
+    readonly hasCatalog: _angular_core.Signal<boolean>;
+    readonly inputCatalog: _angular_core.Signal<FlowCatalogParameter[]>;
+    readonly outputCatalog: _angular_core.Signal<FlowCatalogParameter[]>;
+    /** Parametri obbligatori dichiarati dal catalogo e non ancora presenti. */
+    readonly missingRequired: _angular_core.Signal<FlowCatalogParameter[]>;
+    /** Parametri presenti che il catalogo non conosce: sarebbero `PARAMETER_UNKNOWN`. */
+    unknownInput(parameter: FlowInputParameter): boolean;
+    unknownOutput(parameter: FlowOutputParameter): boolean;
+    describe(name: string | undefined): FlowCatalogParameter | undefined;
+    addInput(name?: string): void;
+    addOutput(name?: string): void;
+    removeInput(index: number): void;
+    removeOutput(index: number): void;
+    setInputName(index: number, name: string): void;
+    setInputValue(index: number, value: FlowValue | undefined): void;
+    setOutputName(index: number, name: string): void;
+    setOutputTarget(index: number, reference: string | undefined): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParameterEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ParameterEditorComponent, "fb-parameter-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "catalogParameters": { "alias": "catalogParameters"; "required": false; "isSignal": true; }; "inputTitle": { "alias": "inputTitle"; "required": false; "isSignal": true; }; "outputTitle": { "alias": "outputTitle"; "required": false; "isSignal": true; }; "showInputs": { "alias": "showInputs"; "required": false; "isSignal": true; }; "showOutputs": { "alias": "showOutputs"; "required": false; "isSignal": true; }; "outputsDisabledReason": { "alias": "outputsDisabledReason"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+interface FieldAssignmentHolder {
+    inputAssignments?: FlowInputFieldAssignment[];
+}
+declare class FieldAssignmentEditorComponent {
+    private readonly catalog;
+    readonly holder: _angular_core.InputSignal<FieldAssignmentHolder>;
+    readonly object: _angular_core.InputSignal<string | undefined>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly disabledReason: _angular_core.InputSignal<string | null>;
+    readonly changed: _angular_core.OutputEmitterRef<(holder: FieldAssignmentHolder) => void>;
+    private readonly fields;
+    readonly assignments: _angular_core.Signal<FlowInputFieldAssignment[]>;
+    readonly fieldOptions: _angular_core.Signal<FlowFieldDescription[]>;
+    readonly hasCatalog: _angular_core.Signal<boolean>;
+    /** Campi obbligatori dell'entita' non ancora valorizzati. */
+    readonly missingRequired: _angular_core.Signal<FlowFieldDescription[]>;
+    constructor();
+    add(field?: string): void;
+    remove(index: number): void;
+    setField(index: number, field: string): void;
+    setValue(index: number, value: FlowValue | undefined): void;
+    describe(name: string | undefined): FlowFieldDescription | undefined;
+    /** Il catalogo e' popolato ma non conosce questo campo: sarebbe `FIELD_UNKNOWN`. */
+    isUnknown(assignment: FlowInputFieldAssignment): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldAssignmentEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldAssignmentEditorComponent, "fb-field-assignment-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "object": { "alias": "object"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "disabledReason": { "alias": "disabledReason"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+}
+
+declare class ConnectorEditorComponent {
+    private readonly api;
+    private readonly store;
+    /** Il node di cui si editano le uscite; per lo Start passa il nome fittizio. */
+    readonly nodeName: _angular_core.InputSignal<string>;
+    readonly node: _angular_core.InputSignal<FlowAnyNode>;
+    readonly outlets: _angular_core.InputSignal<FlowOutlet[]>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly connectorChanged: _angular_core.OutputEmitterRef<{
+        outletKey: string;
+        target?: string;
+        isGoTo?: boolean;
+    }>;
+    private readonly targets;
+    constructor();
+    readonly targetOptions: _angular_core.Signal<FlowConnectorTarget[]>;
+    currentTarget(outlet: FlowOutlet): string;
+    isGoTo(outlet: FlowOutlet): boolean;
+    /** Il connector esiste ma non ha destinazione: ramo incompleto, da mostrare come tale. */
+    isDangling(outlet: FlowOutlet): boolean;
+    /** Nessun connector: il percorso finisce lì. Legittimo, tranne sui rami strutturali. */
+    isTerminal(outlet: FlowOutlet): boolean;
+    hintFor(outlet: FlowOutlet): string | null;
+    setTarget(outlet: FlowOutlet, target: string): void;
+    setGoTo(outlet: FlowOutlet, isGoTo: boolean): void;
+    clear(outlet: FlowOutlet): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConnectorEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConnectorEditorComponent, "fb-connector-editor", never, { "nodeName": { "alias": "nodeName"; "required": true; "isSignal": true; }; "node": { "alias": "node"; "required": true; "isSignal": true; }; "outlets": { "alias": "outlets"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, { "connectorChanged": "connectorChanged"; }, never, never, true, never>;
+}
+
+/**
+ * `@Directive()` senza selettore: e' il modo in cui Angular riconosce come input quelli
+ * dichiarati su una classe base ereditata da piu' componenti.
+ */
+declare abstract class NodeInspectorBase {
+    protected readonly store: FlowDocumentStore;
+    protected readonly dictionaries: FlowDictionaryStore;
+    protected readonly validation: FlowValidationStore;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly node: _angular_core.InputSignal<FlowAnyNode>;
+    /** Il tipo dell'elemento: ogni inspector sa il proprio, ma serve alle uscite. */
+    abstract readonly elementType: FlowElementType;
+    readonly outlets: _angular_core.Signal<FlowOutlet[]>;
+    /** I rilievi ancorati a questo elemento (§7). */
+    readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
+    /** I rilievi su un campo preciso, per evidenziarlo nel form. */
+    issuesAt(pathPrefix: string): FlowValidationIssue[];
+    hasIssueCode(code: string): boolean;
+    /** Applica una modifica al node. */
+    protected patch(mutate: (node: FlowAnyNode) => void): void;
+    /** Scorciatoia per i campi semplici: valore vuoto → chiave omessa (§2). */
+    protected setField(field: string, value: unknown): void;
+    /** Scrive la destinazione di un'uscita. */
+    onConnectorChanged(event: {
+        outletKey: string;
+        target?: string;
+        isGoTo?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NodeInspectorBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NodeInspectorBase, never, never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ElementInspectorComponent {
+    private readonly store;
+    private readonly dictionaries;
+    private readonly validation;
+    /** Il nome dell'elemento selezionato; `$start` per lo Start. */
+    readonly selectedName: _angular_core.InputSignal<string | null>;
+    /**
+     * `false` quando l'inspector e' dentro la dialog: lì il tipo e il titolo sono già
+     * nell'intestazione della dialog, e ripeterli sprecherebbe la riga piu' preziosa.
+     */
+    readonly showHeader: _angular_core.InputSignal<boolean>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly removeRequested: _angular_core.OutputEmitterRef<string>;
+    readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
+    readonly isStart: _angular_core.Signal<boolean>;
+    readonly reference: _angular_core.Signal<_esfaenza_flow_builder.FlowNodeRef | undefined>;
+    readonly node: _angular_core.Signal<FlowAnyNode | undefined>;
+    readonly type: _angular_core.Signal<string>;
+    readonly typeLabel: _angular_core.Signal<string>;
+    readonly isUnsupported: _angular_core.Signal<boolean>;
+    /** I rilievi ancorati all'elemento (§7). */
+    readonly issues: _angular_core.Signal<_esfaenza_flow_builder.FlowValidationIssue[]>;
+    /** Il nome tecnico in modifica: si applica con un comando esplicito, non a ogni tasto. */
+    readonly pendingName: _angular_core.WritableSignal<string | null>;
+    readonly nameError: _angular_core.Signal<string | null>;
+    /**
+     * Quanti riferimenti verrebbero riscritti dalla rinomina. Serve a rendere visibile che
+     * l'operazione tocca il resto del documento, non solo questo elemento.
+     */
+    readonly referenceCount: _angular_core.Signal<number>;
+    readonly canRename: _angular_core.Signal<boolean>;
+    startRename(): void;
+    onPendingNameInput(value: string): void;
+    cancelRename(): void;
+    /** Applica la rinomina riscrivendo tutti i riferimenti che raggiungono l'elemento. */
+    applyRename(): void;
+    setLabel(value: string): void;
+    setDescription(value: string): void;
+    /** Suggerisce il nome tecnico dalla label, come fa la creazione. */
+    suggestNameFromLabel(): void;
+    requestRemove(): void;
+    requestDuplicate(): void;
+    close(): void;
+    /** Le coordinate sono l'unica informazione di layout che il modello conserva (§3.5). */
+    readonly position: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementInspectorComponent, "fb-element-inspector", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; }, never, never, true, never>;
+}
+
+declare class ElementDialogComponent {
+    private readonly store;
+    private readonly dictionaries;
+    /** L'elemento da configurare; `$start` per lo Start. */
+    readonly selectedName: _angular_core.InputSignal<string | null>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly removeRequested: _angular_core.OutputEmitterRef<string>;
+    readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
+    private readonly panel;
+    readonly isStart: _angular_core.Signal<boolean>;
+    private readonly reference;
+    readonly typeLabel: _angular_core.Signal<string>;
+    readonly title: _angular_core.Signal<string>;
+    constructor();
+    close(): void;
+    onRemoveRequested(name: string): void;
+    onDuplicateRequested(name: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementDialogComponent, "fb-element-dialog", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; }, never, never, true, never>;
+}
+
+declare class StartInspectorComponent {
+    private readonly store;
+    private readonly dictionaries;
+    private readonly catalog;
+    private readonly validation;
+    readonly start: _angular_core.Signal<FlowStart>;
+    readonly startNode: _angular_core.Signal<FlowAnyNode>;
+    readonly outlets: _angular_core.Signal<_esfaenza_flow_builder.FlowOutlet[]>;
+    readonly triggerTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    readonly recordTriggerTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    readonly frequencies: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    readonly offsetUnits: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    private readonly objects;
+    constructor();
+    readonly objectOptions: _angular_core.Signal<FlowObjectSummary[]>;
+    readonly hasObjectCatalog: _angular_core.Signal<boolean>;
+    readonly triggerType: _angular_core.Signal<string>;
+    readonly isRecordTrigger: _angular_core.Signal<boolean>;
+    readonly isScheduled: _angular_core.Signal<boolean>;
+    readonly isEvent: _angular_core.Signal<boolean>;
+    readonly hasEntryPoint: _angular_core.Signal<boolean>;
+    readonly scheduledPaths: _angular_core.Signal<FlowScheduledPath[]>;
+    /** I rilievi sul documento, che e' dove finiscono quelli dello Start (§7). */
+    readonly issues: _angular_core.Signal<_esfaenza_flow_builder.FlowValidationIssue[]>;
+    setTriggerType(value: string): void;
+    setObject(value: string): void;
+    setRecordTriggerType(value: string): void;
+    setRequireChanged(value: boolean): void;
+    setFrequency(value: string): void;
+    setStartDate(value: string): void;
+    setStartTime(value: string): void;
+    /** La data arriva come `2026-08-01T00:00:00`; l'input `date` vuole solo la parte data. */
+    readonly startDateValue: _angular_core.Signal<string>;
+    readonly startTimeValue: _angular_core.Signal<string>;
+    addScheduledPath(): void;
+    removeScheduledPath(index: number): void;
+    setPathField(index: number, field: keyof FlowScheduledPath, value: unknown): void;
+    setPathOffsetNumber(index: number, value: string): void;
+    onFiltersChanged(mutate: (holder: FilterHolder) => void): void;
+    onConnectorChanged(event: {
+        outletKey: string;
+        target?: string;
+        isGoTo?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StartInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StartInspectorComponent, "fb-start-inspector", never, {}, {}, never, never, true, never>;
+}
+
+interface ResourceKindDescriptor {
+    collection: FlowResourceCollection;
+    label: string;
+    singular: string;
+    isWritable: boolean;
+    /** Cosa serve dichiarare, in una riga. */
+    note: string;
+}
+declare class ResourcePanelComponent {
+    private readonly store;
+    private readonly dictionaries;
+    private readonly catalog;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly kinds: ResourceKindDescriptor[];
+    readonly dataTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDataTypeEntry[]>;
+    readonly sortOrders: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    private readonly objects;
+    private readonly enumTypes;
+    /** La collection aperta nel pannello. */
+    readonly activeCollection: _angular_core.WritableSignal<"variables" | "constants" | "formulas" | "textTemplates" | "choices" | "dynamicChoiceSets" | "stages">;
+    /** L'indice della risorsa in modifica, o `null`. */
+    readonly editingIndex: _angular_core.WritableSignal<number | null>;
+    constructor();
+    readonly objectOptions: _angular_core.Signal<FlowObjectSummary[]>;
+    readonly enumOptions: _angular_core.Signal<FlowCatalogEntry[]>;
+    readonly activeKind: _angular_core.Signal<ResourceKindDescriptor>;
+    readonly items: _angular_core.Signal<FlowResourceRef[]>;
+    countOf(collection: FlowResourceCollection): number;
+    select(collection: FlowResourceCollection): void;
+    toggleEdit(index: number): void;
+    /** Nome valido e libero nello spazio dei nomi condiviso con i node (§3.3, §13.5). */
+    nameError(reference: FlowResourceRef): string | null;
+    add(): void;
+    remove(reference: FlowResourceRef): void;
+    rename(reference: FlowResourceRef, name: string): void;
+    setField(reference: FlowResourceRef, field: string, value: unknown): void;
+    setNumberField(reference: FlowResourceRef, field: string, raw: string): void;
+    setBooleanField(reference: FlowResourceRef, field: string, value: boolean): void;
+    setValue(reference: FlowResourceRef, value: FlowValue | undefined): void;
+    setDataType(reference: FlowResourceRef, dataType: string): void;
+    requiresObjectType(reference: FlowResourceRef): boolean;
+    supportsScale(reference: FlowResourceRef): boolean;
+    isEnum(reference: FlowResourceRef): boolean;
+    /** Una costante che referenzia una risorsa e' `CONSTANT_REFERENCES_RESOURCE`. */
+    constantReferencesResource(reference: FlowResourceRef): boolean;
+    /** `stageOrder` duplicati: quale stage sia il corrente all'avvio diventa arbitrario. */
+    duplicateStageOrder(reference: FlowResourceRef): boolean;
+    string(reference: FlowResourceRef, field: string): string;
+    boolean(reference: FlowResourceRef, field: string): boolean;
+    value(reference: FlowResourceRef): FlowValue | undefined;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourcePanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourcePanelComponent, "fb-resource-panel", never, {}, { "closed": "closed"; }, never, never, true, never>;
+}
+
+type SeverityFilter = 'all' | 'Error' | 'Warning' | 'Info';
+declare class ProblemsPanelComponent {
+    private readonly validation;
+    /** Chiede di selezionare l'elemento: `$start` per i rilievi sul documento. */
+    readonly elementFocused: _angular_core.OutputEmitterRef<string>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly filter: _angular_core.WritableSignal<SeverityFilter>;
+    readonly isRunning: _angular_core.Signal<boolean>;
+    readonly hasResult: _angular_core.Signal<boolean>;
+    readonly lastError: _angular_core.Signal<string | null>;
+    readonly errorCount: _angular_core.Signal<number>;
+    readonly warningCount: _angular_core.Signal<number>;
+    readonly infoCount: _angular_core.Signal<number>;
+    readonly issues: _angular_core.Signal<FlowValidationIssue[]>;
+    readonly isClean: _angular_core.Signal<boolean>;
+    setFilter(filter: SeverityFilter): void;
+    focus(issue: FlowValidationIssue): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProblemsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProblemsPanelComponent, "fb-problems-panel", never, {}, { "elementFocused": "elementFocused"; "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class VersionPanelComponent {
+    private readonly session;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly versionOpened: _angular_core.OutputEmitterRef<number>;
+    /** Comunica un esito all'host, che lo mostra come notifica. */
+    readonly notice: _angular_core.OutputEmitterRef<{
+        kind: "info" | "error";
+        message: string;
+    }>;
+    readonly versions: _angular_core.Signal<FlowVersionSummary[]>;
+    readonly currentVersion: _angular_core.Signal<number | null>;
+    readonly isBusy: _angular_core.Signal<boolean>;
+    readonly canActivate: _angular_core.Signal<boolean>;
+    /** La versione per cui e' stata chiesta l'eliminazione: conferma in due passi. */
+    readonly pendingDelete: _angular_core.WritableSignal<number | null>;
+    isCurrent(version: FlowVersionSummary): boolean;
+    statusLabel(version: FlowVersionSummary): string;
+    open(version: FlowVersionSummary): void;
+    activate(version: FlowVersionSummary): Promise<void>;
+    deactivate(): Promise<void>;
+    createNewVersion(): Promise<void>;
+    requestDelete(version: FlowVersionSummary): void;
+    cancelDelete(): void;
+    confirmDelete(version: number): Promise<void>;
+    readonly hasActiveVersion: _angular_core.Signal<boolean>;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VersionPanelComponent, never>;
+    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;
+    private readonly store;
+    private readonly session;
+    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>>;
+    /** Le variabili `isInput` del flow: il contratto verso chi lo invoca (§4.6). */
+    readonly inputVariables: _angular_core.Signal<FlowVariable[]>;
+    readonly canRun: _angular_core.Signal<boolean>;
+    readonly status: _angular_core.Signal<string | null>;
+    readonly pendingScreen: _angular_core.Signal<_esfaenza_flow_builder.FlowPendingScreen | null>;
+    readonly isWaitingForScreen: _angular_core.Signal<boolean>;
+    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<{
+        name: string;
+        type: string;
+        value: string;
+    }[]>;
+    readonly outputRows: _angular_core.Signal<{
+        name: string;
+        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[]>;
+    private static render;
+    setDebugEnabled(value: boolean): void;
+    setInputValue(name: string, value: string): void;
+    setScreenOutput(name: string, value: string): void;
+    /** Converte i valori del form nel tipo dichiarato dalla variabile. */
+    private coerceInputs;
+    start(): Promise<void>;
+    respond(navigation: FlowScreenNavigation): Promise<void>;
+    private apply;
+    private handleError;
+    reset(): void;
+    close(): void;
+    /** L'etichetta dello stato, che non e' un errore anche quando dice "Failed" (§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>;
+}
+
+type SidePanel = 'inspector' | 'resources' | 'versions' | 'debug';
+interface Notice {
+    kind: 'info' | 'error';
+    message: string;
+}
+declare class FlowBuilderComponent {
+    private readonly api;
+    private readonly destroyRef;
+    protected readonly store: FlowDocumentStore;
+    protected readonly dictionaries: FlowDictionaryStore;
+    protected readonly session: FlowEditorSession;
+    protected readonly validation: FlowValidationStore;
+    private readonly layout;
+    /** Il flow da aprire. Assente → si parte da un flow nuovo. */
+    readonly flowName: _angular_core.InputSignal<string | null>;
+    /** La versione da aprire; assente → l'attiva se c'e', altrimenti l'ultima (§6.1). */
+    readonly version: _angular_core.InputSignal<number | null>;
+    /** Registrato sulla versione e mostrato nell'elenco (§6.2). */
+    readonly author: _angular_core.InputSignal<string | undefined>;
+    /** `processType` iniziale di un flow nuovo. */
+    readonly defaultProcessType: _angular_core.InputSignal<string>;
+    /**
+     * Dove si configura l'elemento selezionato.
+     *
+     * `dialog` (predefinito) apre il form in una finestra sopra il canvas, come il flow builder
+     * di Salesforce: i form degli elementi sono grandi e in una colonna da 340px si scorreva
+     * troppo. `panel` tiene il form nel pannello laterale, che e' piu' comodo quando si
+     * modificano molti elementi di fila perche' non c'e' niente da aprire e chiudere.
+     */
+    readonly inspectorMode: _angular_core.InputSignal<"panel" | "dialog">;
+    readonly saved: _angular_core.OutputEmitterRef<FlowSaveResult>;
+    readonly activated: _angular_core.OutputEmitterRef<FlowSaveResult>;
+    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
+    readonly selectedName: _angular_core.WritableSignal<string | null>;
+    readonly activePanel: _angular_core.WritableSignal<SidePanel>;
+    /** La dialog del dettaglio e' aperta. Vale solo con `inspectorMode = 'dialog'`. */
+    readonly isDialogOpen: _angular_core.WritableSignal<boolean>;
+    readonly showProblems: _angular_core.WritableSignal<boolean>;
+    readonly notice: _angular_core.WritableSignal<Notice | null>;
+    readonly outline: _angular_core.WritableSignal<FlowOutline | null>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Il documento e' cambiato: usato per riscadenzare validazione e outline. */
+    private lastDocument?;
+    private outlineTimer?;
+    readonly isDialogMode: _angular_core.Signal<boolean>;
+    /**
+     * Il pannello effettivamente mostrato a lato. Con la dialog il tab «Elemento» non esiste:
+     * avere lo stesso form in due posti confonde su quale dei due sia quello vero.
+     */
+    readonly sidePanel: _angular_core.Signal<SidePanel>;
+    readonly document: _angular_core.Signal<FlowDefinition>;
+    readonly isDirty: _angular_core.Signal<boolean>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    readonly primaryCommand: _angular_core.Signal<"create" | "save" | "newVersion">;
+    readonly isEditable: _angular_core.Signal<boolean>;
+    readonly conflict: _angular_core.Signal<_esfaenza_flow_builder.FlowConflictState | null>;
+    readonly errorCount: _angular_core.Signal<number>;
+    readonly warningCount: _angular_core.Signal<number>;
+    readonly canActivate: _angular_core.Signal<boolean>;
+    readonly isBusy: _angular_core.Signal<boolean>;
+    readonly statusLabel: _angular_core.Signal<string>;
+    constructor();
+    private openOrCreate;
+    private scheduleOutline;
+    setLabel(value: string): void;
+    setFullName(value: string): void;
+    setDescription(value: string): void;
+    setInterviewLabel(value: string): void;
+    setProcessType(value: string): void;
+    readonly processTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
+    /** `AutoLaunched` + screen e' un errore di validazione: si segnala subito (§13.6). */
+    readonly hasScreensInAutoLaunched: _angular_core.Signal<boolean>;
+    /** Un flow `Screen` senza screen e' `SCREEN_FLOW_WITHOUT_SCREENS`. */
+    readonly hasNoScreensInScreenFlow: _angular_core.Signal<boolean>;
+    /** `Orchestration` non e' eseguibile dal motore. */
+    readonly isOrchestration: _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
+     * insopportabile. Nel pannello laterale, invece, mostrare subito il form non costa nulla.
+     */
+    onSelectionChange(name: string | null): 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). */
+    focusElement(name: string): void;
+    /** Apre il dettaglio dell'elemento, nella dialog o nel pannello secondo la modalita'. */
+    openElement(name: string): void;
+    /** Il comando della top bar: apre il dettaglio di cio' che e' selezionato. */
+    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.
+     */
+    highlightElement(name: string): void;
+    /** Rilascio dalla palette: il punto di rilascio diventa `locationX`/`locationY` (§11). */
+    onElementDropped(event: {
+        type: FlowElementType;
+        x: number;
+        y: number;
+    }): void;
+    /** Click sulla palette: l'elemento si posiziona in una zona libera. */
+    onElementPicked(type: FlowElementType): void;
+    private createElement;
+    onRemoveNode(name: string): void;
+    onDuplicateNode(name: string): void;
+    /** Riordina il grafo e **scrive** le coordinate nel documento (§3.5). */
+    autoLayout(): void;
+    undo(): void;
+    redo(): void;
+    save(): Promise<void>;
+    createNewVersion(): Promise<void>;
+    activate(): Promise<void>;
+    /** §9.3 — prima opzione davanti a un conflitto. */
+    reloadAfterConflict(): Promise<void>;
+    /** §9.3 — seconda opzione: conserva le modifiche locali in una nuova versione. */
+    saveAsNewVersionAfterConflict(): Promise<void>;
+    dismissConflict(): void;
+    /** Esporta il documento come JSON indentato, per un salvataggio fuori dal backend. */
+    exportJson(): string;
+    /**
+     * Importa un documento. Passa da `POST /flows/parse`, che lo normalizza o lo rifiuta con
+     * `InvalidDefinition`: e' l'unico modo di sapere se il file e' leggibile prima di caricarlo.
+     */
+    importJson(raw: string): Promise<void>;
+    onFileSelected(event: Event): void;
+    openVersion(version: number): Promise<void>;
+    /** Valida subito, senza attendere la pausa di digitazione. */
+    validateNow(): Promise<void>;
+    setPanel(panel: SidePanel): void;
+    toggleProblems(): void;
+    showNotice(notice: Notice): void;
+    dismissNotice(): void;
+    private showError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowBuilderComponent, "fb-flow-builder", never, { "flowName": { "alias": "flowName"; "required": false; "isSignal": true; }; "version": { "alias": "version"; "required": false; "isSignal": true; }; "author": { "alias": "author"; "required": false; "isSignal": true; }; "defaultProcessType": { "alias": "defaultProcessType"; "required": false; "isSignal": true; }; "inspectorMode": { "alias": "inspectorMode"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "activated": "activated"; "closeRequested": "closeRequested"; }, never, never, true, never>;
+}
+
+declare class SelectValueDirective implements AfterViewChecked {
+    private readonly element;
+    readonly fbValue: _angular_core.InputSignal<string | number | null | undefined>;
+    ngAfterViewChecked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectValueDirective, never>;
+    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 };