@esfaenza/dpe-builder 20.0.1

package/index.d.ts

@@ -0,0 +1,2424 @@
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, EnvironmentProviders, Signal, AfterViewChecked } from '@angular/core';
+import * as _esfaenza_dpe_builder from '@esfaenza/dpe-builder';
+import { EFMarkerType, EFConnectableSide } from '@foblex/flow';
+
+/**
+ * Modello della definizione DPE — traduzione **letterale** dei record C# di
+ * `docs/domain-model.md`.
+ *
+ * Questi tipi sono allineati **a mano** ai record di `Jace.DPE.Model` (ADR 0007: nessun
+ * generatore di tipi, nessuno JSON Schema). Sono due modelli in due linguaggi e il
+ * compilatore non dira' mai quando divergono: la fonte di verita' e' `docs/contracts.md` +
+ * `docs/domain-model.md`, e chi cambia un record C# aggiorna questo file nello stesso
+ * momento.
+ *
+ * Convenzioni, tutte conseguenza del contratto:
+ *
+ * - proprieta' in **camelCase**, perche' il JSON prodotto dal backend e' camelCase
+ *   (`domain-model.md`, convenzioni generali);
+ * - gli enum C# diventano **unioni di stringhe letterali** con i nomi esatti dei valori: un
+ *   `enum` TypeScript non e' assegnabile da una stringa arrivata dalla rete, e un valore
+ *   numerico non e' cio' che il backend serializza;
+ * - le collezioni nel backend non sono mai nulle, ma il JSON le **omette quando vuote**
+ *   (ADR 0003): qui sono opzionali e chi legge non presume che esistano;
+ * - `extensionData` esiste su **ogni** record (**I7**): sono proprieta' JSON non riconosciute,
+ *   con valori **opachi**. L'editor le trasporta senza interpretarle.
+ *
+ * Nessuna regola di dominio vive qui: obbligatorieta' condizionali, unicita' dei nomi e
+ * compatibilita' dei tipi sono del backend. Le note `condiz.` nei commenti sono descrittive
+ * e servono a chi costruira' gli ispettori, non sono validazione.
+ */
+/** Proprieta' JSON non riconosciute, conservate verbatim (**I7**). Valori opachi. */
+type DpeExtensionData = Record<string, unknown>;
+/** Base di ogni record del modello: `ExtensionData` sta su tutti, non solo sulla radice. */
+interface DpeExtensible {
+    extensionData?: DpeExtensionData;
+}
+/** I sei tipi logici, nessun altro valore mai (ADR 0002). */
+type LogicalType = 'String' | 'Number' | 'Integer' | 'DateTime' | 'Boolean' | 'Enum';
+interface ColumnType extends DpeExtensible {
+    kind: LogicalType;
+    /** Condiz.: richiesto per `String` nei campi dichiarati. */
+    length?: number;
+    /** Solo `Number`. */
+    precision?: number;
+    /** Condiz.: richiesto per `Number` nei campi dichiarati. */
+    scale?: number;
+    /** Condiz.: non vuoto quando `kind === 'Enum'`. */
+    allowedValues?: string[];
+}
+type SortDirection = 'Ascending' | 'Descending';
+interface OrderByField extends DpeExtensible {
+    /** Alias della colonna a monte. */
+    columnName: string;
+    /** Default `Ascending`. */
+    direction?: SortDirection;
+}
+type AggregateFunction = 'Count' | 'CountDistinct' | 'Sum' | 'Min' | 'Max' | 'Avg' | 'StdDev' | 'StdDevPop' | 'Variance' | 'VariancePop';
+/** Base di tutti i nodi. `name` e' univoco nell'intera definizione (**I1**). */
+interface DpeNode extends DpeExtensible {
+    name: string;
+    label: string;
+    description?: string;
+}
+/**
+ * I riferimenti a un nodo a monte sono dichiarati **opzionali** anche dove
+ * `domain-model.md` li marca obbligatori, e non e' un ammorbidimento del contratto: e' cio'
+ * che il contratto dice. In C# sono `string` con default `null`, l'obbligatorieta' e'
+ * verificata dalla validazione e "un modello incompleto e' un fatto normale (l'editor ne
+ * produce uno a ogni tasto)". Un nodo appena creato o appena scollegato **non ha** una
+ * sorgente: rappresentarla con la stringa vuota sarebbe un valore magico che il backend
+ * legge diversamente da un'assenza.
+ */
+type SqlDialectKind = 'Sqlite' | 'SqlServer' | 'PostgreSql' | 'Oracle';
+type DefinitionStatus = 'Active' | 'Inactive';
+type DefinitionRunMode = 'Batch' | 'OnDemand';
+interface DpeDefinition extends DpeExtensible {
+    /** Default `1`, sempre serializzato per primo. */
+    formatVersion: number;
+    name: string;
+    label: string;
+    description?: string;
+    /** Il dialetto e' **parte della definizione** (ADR 0009): cambiarlo e' una migrazione. */
+    dialect: SqlDialectKind;
+    /** Default `Inactive`. */
+    status?: DefinitionStatus;
+    /** Default `Batch`. */
+    runMode?: DefinitionRunMode;
+    /** Default `false`. */
+    isTemplate?: boolean;
+    parameters?: DpeParameter[];
+    /** Obbligatoria (>=1) in una definizione valida; assente in una in lavorazione. */
+    dataSources?: DataSourceNode[];
+    filters?: FilterNode[];
+    joins?: JoinNode[];
+    aggregates?: AggregateNode[];
+    transforms?: TransformNode[];
+    appends?: AppendNode[];
+    hierarchyPaths?: HierarchyPathNode[];
+    /** Modellati, non compilabili in v1 (`DPE_NODE_NOT_COMPILABLE`). */
+    forecasts?: ForecastNode[];
+    /** Modellati, non compilabili in v1. */
+    customNodes?: CustomNode[];
+    /** Obbligatoria (>=1) in una definizione valida. */
+    writebacks?: WritebackNode[];
+    atomicWritebacks?: AtomicWritebackNode[];
+}
+type ParameterRole = 'Value' | 'Filter' | 'Expression';
+interface DpeParameter extends DpeExtensible {
+    name: string;
+    label: string;
+    description?: string;
+    role: ParameterRole;
+    /** Condiz.: richiesto quando `role === 'Value'`. */
+    valueType?: ColumnType;
+    /** Testo, interpretato secondo `valueType`, cultura invariante. */
+    defaultValue?: string;
+    /** Default `false`; ammesso solo per `role === 'Value'`. */
+    isMultiValue?: boolean;
+}
+type DataSourceKind = 'Table' | 'Csv' | 'ExternalDataset';
+type CsvDelimiter = 'Comma' | 'Semicolon' | 'Tab' | 'Pipe' | 'Caret' | 'Backquote';
+interface CsvSourceOptions extends DpeExtensible {
+    /** Default `Comma`. */
+    delimiter?: CsvDelimiter;
+    /** Default `true`. */
+    hasHeaderRow?: boolean;
+    /** Identificatore opaco risolto dall'host. */
+    location: string;
+}
+interface DataSourceField extends DpeExtensible {
+    /** Nome del campo nella tabella/file di origine. */
+    name: string;
+    /** Quando assente l'alias **e'** `name`: la normalizzazione e' del backend. */
+    alias?: string;
+    /** Condiz.: richiesto per `Csv`/`ExternalDataset`; per `Table` **ignorato**. */
+    declaredType?: ColumnType;
+    /** Default `false`. */
+    isPrimaryKey?: boolean;
+}
+interface DataSourceNode extends DpeNode {
+    kind: DataSourceKind;
+    /** Condiz.: richiesto per `kind === 'Table'`; nome noto al provider di metadati. */
+    tableName?: string;
+    /** Obbligatorio (>=1) in un nodo valido. */
+    fields?: DataSourceField[];
+    /** Condiz.: richiesto per `kind === 'Csv'`. */
+    csvOptions?: CsvSourceOptions;
+    /** Condiz.: richiesto per `kind === 'ExternalDataset'`. */
+    externalDatasetName?: string;
+}
+type FilterOperator = 'Equals' | 'NotEquals' | 'GreaterThan' | 'GreaterThanOrEqual' | 'LessThan' | 'LessThanOrEqual' | 'StartsWith' | 'EndsWith' | 'Contains' | 'DoesNotContain' | 'IsNull' | 'IsNotNull' | 'In' | 'NotIn';
+interface FilterCriterion extends DpeExtensible {
+    /** >=1, univoco nel nodo, referenziato da `condition`. */
+    sequence: number;
+    /** Alias a monte. */
+    sourceFieldName: string;
+    operator: FilterOperator;
+    /** Condiz.: richiesto salvo `IsNull`/`IsNotNull` e salvo `inputVariable` presente. */
+    value?: string;
+    /** Nome di un `DpeParameter` con `role === 'Value'`; esclusivo con `value`. */
+    inputVariable?: string;
+}
+interface FilterNode extends DpeNode {
+    sourceName?: string;
+    /** Default `false`. */
+    isDynamic?: boolean;
+    /** Condiz.: richiesto (>=1) quando `isDynamic` e' falso. */
+    criteria?: FilterCriterion[];
+    /**
+     * Condiz.: richiesto quando `isDynamic` e' falso. Combinazione booleana dei `sequence`
+     * dei criteri (`1 AND (2 OR 3)`), **non** un'espressione SQL: e' l'unico linguaggio che il
+     * backend parsifica davvero.
+     */
+    condition?: string;
+    /** Condiz.: richiesto quando `isDynamic`; riferisce un parametro con `role === 'Filter'`. */
+    filterParameterName?: string;
+}
+type JoinKind = 'Inner' | 'LeftOuter' | 'RightOuter' | 'FullOuter' | 'Lookup';
+interface JoinKey extends DpeExtensible {
+    primaryFieldName: string;
+    secondaryFieldName: string;
+}
+interface JoinResultField extends DpeExtensible {
+    /** Deve essere `primarySourceName` o `secondarySourceName` del nodo. */
+    sourceName: string;
+    sourceFieldName: string;
+    /** Univoco nel nodo (**I1**). */
+    alias: string;
+}
+interface JoinNode extends DpeNode {
+    primarySourceName?: string;
+    secondarySourceName?: string;
+    kind: JoinKind;
+    /** Obbligatorio (>=1) in un nodo valido. */
+    keys?: JoinKey[];
+    /** Lo schema di output e' **esplicito**: solo questi campi. */
+    fields?: JoinResultField[];
+    /** Default `false`; significativo solo per `kind === 'Lookup'`. */
+    allowsMultipleLookupValues?: boolean;
+}
+interface AggregateField extends DpeExtensible {
+    /** Alias a monte; assente **solo** per `Count` (conteggio righe). */
+    sourceFieldName?: string;
+    function: AggregateFunction;
+    alias: string;
+}
+interface AggregateNode extends DpeNode {
+    sourceName?: string;
+    /** Alias a monte; vuoto = aggregazione globale su una riga. */
+    groupBy?: string[];
+    /** Obbligatorio (>=1) in un nodo valido. */
+    fields?: AggregateField[];
+}
+type TransformKind = 'Expression' | 'Slice' | 'ComputeRelative';
+interface ExpressionField extends DpeExtensible {
+    alias: string;
+    /** **SQL nativo del dialetto della definizione** (ADR 0006): passa verbatim. */
+    expression: string;
+    /** **Autorevole e non verificato** (ADR 0006). */
+    declaredType: ColumnType;
+}
+interface TransformNode extends DpeNode {
+    sourceName?: string;
+    kind: TransformKind;
+    /** Condiz.: richiesto (>=1) per `Expression`/`ComputeRelative`, vuoto per `Slice`. */
+    expressionFields?: ExpressionField[];
+    /** Condiz.: richiesto (>=1) per `Slice`, vuoto altrimenti. */
+    droppedFields?: string[];
+    /** Solo `ComputeRelative`. */
+    partitionBy?: string[];
+    /** Solo `ComputeRelative`. */
+    orderBy?: OrderByField[];
+}
+interface AppendNode extends DpeNode {
+    /** Obbligatorio (>=2) in un nodo valido. */
+    sources?: string[];
+    /** Default `false`. */
+    allowsDisjointSchema?: boolean;
+}
+interface HierarchyPathNode extends DpeNode {
+    sourceName?: string;
+    /** Chiave del nodo corrente. */
+    selfFieldName?: string;
+    /** Riferimento al padre. */
+    parentFieldName?: string;
+    /** Alias della colonna di percorso prodotta (`String`). */
+    pathFieldName?: string;
+    /** Default `true`. */
+    includesSelfValue?: boolean;
+    /** Condiz.: richiesto (>=1) quando `isAggregationRequired`. */
+    aggregateFields?: AggregateField[];
+    /** Default `false`. */
+    isAggregationRequired?: boolean;
+    rollupPercentageFieldName?: string;
+}
+type ForecastPeriodType = 'Year' | 'YearQuarter' | 'YearMonth' | 'YearWeek' | 'YearMonthDay' | 'FiscalYear' | 'FiscalYearQuarter' | 'FiscalYearMonth' | 'FiscalYearWeek';
+type ForecastModelType = 'Auto' | 'Additive' | 'Multiplicative';
+type ForecastAccuracy = 'None' | 'Eighty' | 'NinetyFive';
+type DatePart = 'Second' | 'Minute' | 'Hour' | 'Day' | 'Week' | 'Month' | 'Quarter' | 'Year';
+interface ForecastAggregationField extends DpeExtensible {
+    fieldName: string;
+    function: AggregateFunction;
+    resultAlias: string;
+}
+interface ForecastGroupField extends DpeExtensible {
+    fieldName: string;
+    /** Condiz.: richiesto quando il campo e' `DateTime`. */
+    datePart?: DatePart;
+}
+/** Modellato per intero, **non compilabile in v1** (`DPE_NODE_NOT_COMPILABLE`). */
+interface ForecastNode extends DpeNode {
+    sourceName?: string;
+    dateFieldName?: string;
+    periodType?: ForecastPeriodType;
+    /** Default `1`, ammesso 1..100. */
+    periodCount?: number;
+    /** Alias della colonna di inizio periodo prodotta. */
+    periodStartFieldName?: string;
+    /** Default `Auto`. */
+    modelType?: ForecastModelType;
+    /** `null`/assente = automatica; ammesso 2..24. */
+    seasonality?: number;
+    /** Default `None`. */
+    accuracyPercent?: ForecastAccuracy;
+    /** Default `false`. */
+    excludesLastPeriod?: boolean;
+    /** Obbligatorio (>=1) in un nodo valido. */
+    aggregationFields?: ForecastAggregationField[];
+    groupFields?: ForecastGroupField[];
+}
+/** Usato dove uno schema si **dichiara** invece di derivarlo. */
+interface DeclaredField extends DpeExtensible {
+    name: string;
+    type: ColumnType;
+}
+interface CustomNodeParameter extends DpeExtensible {
+    name: string;
+    value: string;
+}
+/** Modellato per intero, **non compilabile in v1**. */
+interface CustomNode extends DpeNode {
+    /** Obbligatorio (>=1) in un nodo valido. */
+    sources?: string[];
+    extensionName: string;
+    extensionNamespace?: string;
+    parameters?: CustomNodeParameter[];
+    /**
+     * Obbligatorio (>=1): senza schema dichiarato la propagazione (**I4**) si interrompe e
+     * tutto cio' che sta a valle diventa invalidabile.
+     */
+    outputFields?: DeclaredField[];
+}
+type WritebackTargetKind = 'Database' | 'Json' | 'Csv';
+type WritebackOperation = 'Insert' | 'Update' | 'Upsert' | 'Delete';
+type WritebackFieldRole = 'Value' | 'PrimaryKey' | 'QualifierKey';
+interface WritebackFieldMapping extends DpeExtensible {
+    /** Condiz.: alias a monte; assente quando `runtimeParameterName` e' presente. */
+    sourceFieldName?: string;
+    targetFieldName: string;
+    /** Il valore viene da un parametro, non dalla riga; esclusivo con `sourceFieldName`. */
+    runtimeParameterName?: string;
+    /** Default `Value`. */
+    role?: WritebackFieldRole;
+    relationshipName?: string;
+    /** Condiz.: richiesto quando `relationshipName` e' presente. */
+    parentName?: string;
+    /** Default `false`; se `true`, `sourceFieldName` non e' richiesto. */
+    isAutoGenerated?: boolean;
+}
+/**
+ * Opzioni dell'artefatto JSON (`contracts.md` §2, «Opzioni degli artefatti»). Sono **solo**
+ * scelte di formato, mai di destinazione (ADR 0010).
+ */
+interface JsonArtifactOptions extends DpeExtensible {
+    /** Default `false`: JSON compatto, array di oggetti. */
+    indented?: boolean;
+}
+/**
+ * Opzioni dell'artefatto CSV. Il quoting **non e' configurabile** di proposito: si quota
+ * quando serve e si raddoppiano le virgolette, perche' un quoting opzionale produce file che
+ * qualcuno non riesce a rileggere.
+ */
+interface CsvArtifactOptions extends DpeExtensible {
+    /** Default `Comma`. */
+    delimiter?: CsvDelimiter;
+    /** Default `true`. */
+    includesHeaderRow?: boolean;
+}
+interface WritebackNode extends DpeNode {
+    sourceName?: string;
+    /** **Determina l'artefatto prodotto**. */
+    target: WritebackTargetKind;
+    /** >=1, univoco fra tutti i writeback e gli atomic writeback. */
+    sequence: number;
+    /** Condiz.: richiesto per `target === 'Database'`. */
+    tableName?: string;
+    /** Condiz.: richiesto per `target === 'Database'`; assente per `Json`/`Csv`. */
+    operation?: WritebackOperation;
+    /** Obbligatorio (>=1) in un nodo valido. */
+    fields?: WritebackFieldMapping[];
+    /** Espressione SQL nativa applicata al risultato (ADR 0006). */
+    filterCondition?: string;
+    /** Condiz.: richiesto per `operation === 'Upsert'`. */
+    externalIdFieldName?: string;
+    /** Default `false`. */
+    onlyChangedRows?: boolean;
+    /** Solo `target === 'Json'`. */
+    jsonOptions?: JsonArtifactOptions;
+    /** Solo `target === 'Csv'`. */
+    csvOptions?: CsvArtifactOptions;
+}
+interface AtomicWritebackRelationship extends DpeExtensible {
+    /** Nome di un `WritebackNode` con `target === 'Database'`. */
+    parentWritebackName?: string;
+    parentFieldName?: string;
+    childWritebackName?: string;
+    childFieldName?: string;
+    relationshipName?: string;
+    /** Ordine dentro il gruppo atomico. */
+    sequence: number;
+}
+interface AtomicWritebackNode extends DpeNode {
+    /** Nello stesso spazio di numerazione dei `WritebackNode`. */
+    sequence: number;
+    /** Obbligatorio (>=1) in un nodo valido. */
+    relationships?: AtomicWritebackRelationship[];
+}
+/**
+ * Le collezioni di nodi della radice, con il tipo che ciascuna contiene.
+ *
+ * Esiste perche' ogni utility che cammina il documento (derivazione degli archi, rinomina,
+ * catalogo della palette) deve nominare le collezioni **una volta sola**: una collezione
+ * dimenticata in uno dei tre posti non produce nessun errore, produce un arco che non
+ * compare o un riferimento che resta rotto dopo una rinomina.
+ */
+interface DpeNodeCollectionMap {
+    dataSources: DataSourceNode;
+    filters: FilterNode;
+    joins: JoinNode;
+    aggregates: AggregateNode;
+    transforms: TransformNode;
+    appends: AppendNode;
+    hierarchyPaths: HierarchyPathNode;
+    forecasts: ForecastNode;
+    customNodes: CustomNode;
+    writebacks: WritebackNode;
+    atomicWritebacks: AtomicWritebackNode;
+}
+type DpeNodeCollectionName = keyof DpeNodeCollectionMap;
+/** Qualunque nodo della definizione. */
+type DpeAnyNode = DpeNodeCollectionMap[DpeNodeCollectionName];
+/**
+ * L'elenco dei nomi di collezione in forma di valore, nell'ordine in cui i nodi si leggono
+ * (sorgenti -> trasformazioni -> sink). `keyof` non produce un array a runtime: questo
+ * elenco e' l'unico posto in cui vive l'ordine.
+ */
+declare const DPE_NODE_COLLECTIONS: readonly DpeNodeCollectionName[];
+
+/**
+ * Diagnostiche — traduzione letterale di `Jace.DPE.Diagnostics` (`docs/contracts.md` §1).
+ *
+ * Tipi allineati **a mano** ai record C# (ADR 0007). L'editor **consuma** queste
+ * diagnostiche e non ne produce: nessuna regola di dominio vive nel frontend, quindi in
+ * questo file non ci sono ne' codici inventati ne' messaggi ricomposti. Il `message` arriva
+ * dal backend, che e' l'unico posto in cui un messaggio viene composto.
+ */
+type DiagnosticSeverity = 'Info' | 'Warning' | 'Error';
+interface DiagnosticPathSegment {
+    /** `"filters"`, `"criteria"`, `"fields"`, ... */
+    collection?: string;
+    /** Nome del nodo/alias, se applicabile. */
+    name?: string;
+    /** Indice nella collezione, se applicabile. */
+    index?: number;
+}
+/**
+ * Percorso strutturato del rilievo.
+ *
+ * **Due forme, entrambe da gestire** (`contracts.md` §1, limite dichiarato): in
+ * deserializzazione i nomi dei nodi non sono ancora noti e i segmenti portano solo l'indice
+ * (`filters[0].sourceName`); dalla validazione portano il nome (`filters/OnlyActive`). Chi
+ * naviga fino al campo deve accettare tutt'e due, altrimenti le diagnostiche del caricamento
+ * di un file non sono cliccabili.
+ */
+interface DiagnosticPath {
+    segments?: DiagnosticPathSegment[];
+    /** Nome della proprieta' in causa, camelCase. */
+    field?: string;
+}
+/**
+ * `arguments` e' un dizionario di stringhe con **chiavi canoniche** (`contracts.md` §1):
+ * `node`, `field`, `column`, `alias`, `name`, `table`, `parameter`, `dialect`, `construct`,
+ * `expected`, `actual`, `value`, `sequence`, `condition`, `token`, `truncated`. L'editor le
+ * legge per costruire etichette, non per riscrivere il messaggio.
+ */
+interface Diagnostic {
+    /** `DiagnosticCodes.*` del backend. Il frontend non ne dichiara l'elenco: e' del backend. */
+    code: string;
+    severity: DiagnosticSeverity;
+    path?: DiagnosticPath;
+    arguments?: Record<string, string>;
+    /** Derivato da `code` + `arguments`, cultura invariante. */
+    message: string;
+}
+/**
+ * L'unico codice che significa "hai fatto bene, siamo noi": nodo valido ma non ancora
+ * compilabile (`Forecast`, `CustomNode`, costrutto non supportato — **I10**). Va distinto
+ * visivamente dai `DPE_MODEL_*`, che invece l'utente deve correggere.
+ *
+ * E' l'unica costante di codice diagnostico che la libreria dichiara, e non e' una
+ * duplicazione del dominio: e' la sola distinzione che cambia **come si rende** un rilievo.
+ */
+declare const DPE_NODE_NOT_COMPILABLE = "DPE_NODE_NOT_COMPILABLE";
+/** Rappresentazione testuale del percorso, nella forma usata dai messaggi del backend. */
+declare function diagnosticPathToString(path: DiagnosticPath | undefined): string;
+
+/**
+ * Tipi di richiesta/risposta del service DPE — traduzione letterale di `docs/contracts.md`
+ * §2 (provider di metadati), §3 (SQL emesso) e §5 (il service).
+ *
+ * Allineati **a mano** ai record C# (ADR 0007). Cio' che non e' trasportabile non c'e':
+ * `DpeContext` porta i provider dell'host (`ITableMetadataProvider`, `IDataQueryProvider`,
+ * `IArtifactSink`, `ILogger`, `IClock`) e vive **dentro** il backend, quindi non ha un
+ * corrispettivo TypeScript. Lo stesso vale per `Execute`: l'editor non esegue, non
+ * materializza artefatti e non ha bisogno di `DpeExecuteResult`.
+ */
+
+/**
+ * Cio' che l'ambiente ospite **dichiara** all'editor. Non e' un tipo del backend C#: `IDpeService`
+ * non cambia (ADR 0017), e l'host lo compone con cio' che gia' sa della propria installazione.
+ *
+ * Nasce con un solo campo e si estende **per aggiunta**: e' il posto previsto per i fatti
+ * dell'ambiente, non un contenitore da riempire in anticipo.
+ */
+interface DpeEnvironment {
+    /** Il dialetto del database di destinazione. Dichiarato, mai scelto dall'utente dell'editor. */
+    readonly dialect: SqlDialectKind;
+}
+/**
+ * Riga di catalogo: identita' e fatti che l'ospite conosce **senza** caricare la definizione.
+ *
+ * Distinto da `DpeDefinition` per costruzione, e non per comodita': elencare non deve costare N
+ * caricamenti completi. Non ha un corrispettivo in `IDpeService` e non deve averlo — il service
+ * valida, compila ed esegue; dove le definizioni vivano e' dell'ospite (ADR 0007), che non ha
+ * ne' orologio ne' archiviazione lato libreria.
+ *
+ * I quattro campi in coda sono facoltativi in senso pieno: assenti, la riga **non li mostra e
+ * non li stima**. Contare i nodi lato client vorrebbe dire caricare tutte le definizioni per
+ * disegnare un elenco, e dedurre `updatedAt` e' impossibile.
+ */
+interface DpeDefinitionSummary {
+    /** La chiave. Non esiste un id distinto dal nome (ADR 0019): rinominare e' cambiare chiave. */
+    name: string;
+    label: string;
+    description?: string;
+    dialect: SqlDialectKind;
+    status?: DefinitionStatus;
+    runMode?: DefinitionRunMode;
+    isTemplate?: boolean;
+    /** ISO 8601. Lo scrive l'ospite: la libreria non ha orologio. Assente = non mostrato. */
+    updatedAt?: string;
+    updatedBy?: string;
+    /** Numero di nodi. Lo conta l'ospite, **mai** il client. Assente = non mostrato. */
+    nodeCount?: number;
+    /**
+     * Esito dell'ultima validazione **noto all'ospite**: riportato, non ricalcolato. Puo' essere
+     * vecchio, quindi la riga lo mostra come stato noto e non come verita' — il frontend non
+     * valida nulla, e dedurlo qui sarebbe una validazione fatta dal client per interposta persona.
+     */
+    hasErrors?: boolean;
+}
+/**
+ * Tre esiti, **non due** (ADR 0004): "dichiarata", "dichiarata senza campi" e
+ * "sconosciuta" sono situazioni diverse e l'editor le mostra diverse. Chi implementa
+ * l'interfaccia non appiattisce `Unknown` in una lista di campi vuota.
+ */
+type TableLookupOutcome = 'Declared' | 'DeclaredWithoutFields' | 'Unknown';
+interface TableSummary {
+    name: string;
+    description?: string;
+}
+interface FieldRelationship {
+    targetTableName: string;
+    targetFieldName: string;
+}
+interface FieldDescriptor {
+    name: string;
+    description?: string;
+    type: ColumnType;
+    isKey: boolean;
+    isNullable: boolean;
+    /** Assente quando il campo non e' una relazione. */
+    relationship?: FieldRelationship;
+}
+interface TableDescriptor {
+    name: string;
+    description?: string;
+    fields?: FieldDescriptor[];
+}
+interface TableLookupResult {
+    outcome: TableLookupOutcome;
+    /** Presente solo con `outcome === 'Declared'`. */
+    table?: TableDescriptor;
+}
+interface SqlParameterValue {
+    /** Senza prefisso di dialetto: `"p0"`, `"param_StartDate"`. */
+    name: string;
+    type: LogicalType;
+    /** `null` ammesso. Valore opaco per l'editor, che lo mostra e non lo interpreta. */
+    value: unknown;
+}
+interface SqlStatement {
+    /** Porta i marcatori nella forma del dialetto (`@p0`, `:p0`, `$1`). */
+    text: string;
+    parameters?: SqlParameterValue[];
+}
+interface DpeColumnInfo {
+    name: string;
+    type: ColumnType;
+    /**
+     * Informativa (**I4**): serve alla vista dello schema, non blocca la compilazione. Il
+     * frontend non la calcola — arriva da qui.
+     */
+    isNullable: boolean;
+}
+interface DpeNodeSchemaInfo {
+    nodeName: string;
+    columns?: DpeColumnInfo[];
+    /**
+     * `false` = nodo **valido ma non compilabile** (**I10**): e' un limite nostro, non un
+     * errore dell'utente, e va reso diverso da un nodo invalido.
+     */
+    isCompilable: boolean;
+}
+interface DpeWritebackStep {
+    writebackName: string;
+    sequence: number;
+    target: WritebackTargetKind;
+    /** Assente per i target `Json`/`Csv`. */
+    operation?: WritebackOperation;
+    tableName?: string;
+    /**
+     * Campo di corrispondenza dell'`Upsert`; assente per ogni altra operazione. E' un
+     * `targetFieldName`: si ritrova in `targetMapping` per risalire alla colonna del result set
+     * (ADR 0016).
+     */
+    externalIdFieldName?: string;
+    /** Presente se il writeback appartiene a un gruppo atomico. */
+    atomicGroupName?: string;
+    /**
+     * Dichiarato, **non implementato dalla libreria**: il change tracking e' dell'host
+     * (ADR 0011) e non influenza l'SQL generato. Va mostrato come una dichiarazione che l'host
+     * deve onorare, non come una cosa che il motore fa.
+     */
+    onlyChangedRows?: boolean;
+}
+interface DpeValidateResult {
+    hasErrors: boolean;
+    /** Esaustive (**I6**): l'elenco completo, non il primo rilievo. */
+    diagnostics?: Diagnostic[];
+    /** Ordine topologico. */
+    schemas?: DpeNodeSchemaInfo[];
+    executionOrder?: string[];
+    writebackSequence?: DpeWritebackStep[];
+}
+/**
+ * Valore di un parametro di runtime per una compilazione (`DpeParameterValue`).
+ *
+ * `value` e' **opaco**: il tipo dichiarato del parametro lo conosce il backend, che lo
+ * interpreta secondo `ColumnType` in cultura invariante. L'editor lo trasporta e lo mostra,
+ * non lo converte.
+ */
+interface DpeParameterValue {
+    name: string;
+    value: unknown;
+}
+/**
+ * Cio' che serve all'host per **eseguire** la scrittura che la libreria non esegue
+ * (`contracts.md` §2, «`DpeFieldMappingInfo`»): senza, l'host riceve un result set e non sa
+ * quale colonna va in quale campo ne' quale sia la chiave.
+ */
+interface DpeFieldMappingInfo {
+    /** Nome della colonna nel result set dello `SqlStatement`. */
+    resultColumnName?: string;
+    targetFieldName: string;
+    role: WritebackFieldRole;
+    /** Presente: il valore viene da un parametro, non dalla riga. */
+    runtimeParameterName?: string;
+    /** La destinazione genera il valore: non e' nel result set. */
+    isAutoGenerated?: boolean;
+    relationshipName?: string;
+    parentName?: string;
+}
+interface DpeCompiledWriteback {
+    writebackName: string;
+    sequence: number;
+    statement: SqlStatement;
+    resultColumns?: DpeColumnInfo[];
+    /** Vedi {@link DpeFieldMappingInfo}: forma provvisoria. */
+    targetMapping?: DpeFieldMappingInfo[];
+}
+interface DpeCompileResult {
+    hasErrors: boolean;
+    diagnostics?: Diagnostic[];
+    databaseWritebacks?: DpeCompiledWriteback[];
+    /** SQL di lettura, non ancora eseguito. */
+    fileWritebacks?: DpeCompiledWriteback[];
+    writebackSequence?: DpeWritebackStep[];
+}
+
+/**
+ * Quali primitive **opzionali** l'ospite implementa davvero — `contracts.md` §7, normativo.
+ *
+ * La rilevazione e' per **identita' del metodo**: se il metodo dell'istanza e' ancora quello del
+ * prototipo di `DpeBuilderApi`, l'ospite non lo ha sovrascritto e la primitiva non c'e'. E'
+ * esatta, non richiede una primitiva di interrogazione e non aggiunge un giro di rete.
+ *
+ * Perche' un solo posto: la disponibilita' va saputa **prima del clic**. Lo schema precedente —
+ * partire da «disponibile» e scoprire l'assenza dal primo `MissingService` — mostra un comando
+ * attivo che fallisce alla pressione, cioe' insegna a non fidarsi dei bottoni, e per giunta
+ * costringe ogni consumatore a ripetere lo stesso trattamento dell'errore.
+ *
+ * Regola per chi implementa un host (normativa, `contracts.md` §7): **chi non supporta una
+ * primitiva non la sovrascrive**. Una sovrascrittura che lancia subito non equivale all'assenza —
+ * l'editor la considera disponibile e mostra il comando attivo.
+ *
+ * **Dichiarazione sottrattiva (ADR 0020).** Da quando la libreria spedisce un client HTTP che
+ * implementa tutte e dieci le primitive, l'identita' da sola non basta: chi eredita quel client
+ * non puo' dis-sovrascrivere un metodo. Disponibile diventa quindi «**sovrascritta** e **non
+ * elencata** in `unsupportedPrimitives`». La seconda meta' e' solo sottrattiva — non rende
+ * disponibile cio' che non e' implementato — e resta calcolata in questo file e in nessun altro.
+ */
+
+/** Le primitive che un ambiente ospite puo' legittimamente non offrire. */
+type DpeOptionalPrimitive = 'compilePreview' | 'load' | 'save' | 'getEnvironment' | 'listDefinitions' | 'createDefinition' | 'deleteDefinition';
+declare function dpeIsPrimitiveAvailable(api: DpeBuilderApi, primitive: DpeOptionalPrimitive): boolean;
+/** L'insieme delle primitive disponibili: comodo per fotografarlo una volta alla costruzione. */
+interface DpeCapabilities {
+    readonly compilePreview: boolean;
+    readonly load: boolean;
+    readonly save: boolean;
+    readonly getEnvironment: boolean;
+    readonly listDefinitions: boolean;
+    readonly createDefinition: boolean;
+    readonly deleteDefinition: boolean;
+}
+declare function dpeReadCapabilities(api: DpeBuilderApi): DpeCapabilities;
+/**
+ * Disponibilita' di un comando, con **il motivo** quando manca: un bottone disabilitato che non
+ * dice perche' manda a cercare un guasto che non c'e'.
+ */
+interface DpeCommandAvailability {
+    readonly isAvailable: boolean;
+    /** Presente **solo** quando il comando non e' disponibile. Va nel `title` del bottone. */
+    readonly reason?: string;
+}
+/**
+ * Il comando di **creazione** e' l'unico che dipende da **due** primitive
+ * (`contracts.md` §7, normativo): `createDefinition` per scrivere, e `getEnvironment` perche' il
+ * dialetto della definizione nuova viene dall'ambiente (ADR 0017).
+ *
+ * Perche' senza `getEnvironment` si disabilita invece di ripiegare su un dialetto qualsiasi: una
+ * definizione creata per il dialetto sbagliato porta espressioni SQL native (ADR 0006) da
+ * riscrivere tutte, e chiederlo all'utente e' proprio la scelta che l'ADR 0017 ha tolto. Un
+ * comando disabilitato che dice perche' e' meglio di entrambe; il rimedio per l'ospite e' una
+ * riga, implementare `getEnvironment`.
+ *
+ * Sta qui e non dentro un componente per la stessa ragione delle altre: la disponibilita' si sa
+ * **prima del clic**, e in un solo posto.
+ */
+declare function dpeCreateCommandAvailability(capabilities: DpeCapabilities): DpeCommandAvailability;
+
+/**
+ * L'unica porta verso il backend — `docs/contracts.md` §7.
+ *
+ * **Non esiste un documento di endpoint: il contratto e' questa classe astratta** (ADR 0007).
+ * Fa anche da token di dependency injection: chi integra l'editor fornisce una
+ * implementazione e la registra come provider di `DpeBuilderApi`.
+ *
+ * Due conseguenze da non aggirare:
+ *
+ * 1. **questo file non conosce HTTP.** Nessun `HttpClient`, nessun `fetch`, nessun URL qui ne'
+ *    in nessuno store o componente. L'ADR 0020 ha spostato il client HTTP **dentro** la libreria
+ *    (`lib/api/http-dpe-builder-api.ts`), quindi la regola non e' piu' «zero HTTP in
+ *    `projects/dpe-builder`» ma «zero HTTP fuori da quel file»: e' *una* implementazione fra le
+ *    possibili, non la definizione del contratto, che resta questa classe;
+ * 2. **un dato nuovo dal backend e' un metodo nuovo qui**, mai una chiamata dentro un
+ *    componente.
+ *
+ * I metodi con implementazione di default rifiutano con `DpeApiError('MissingService', ...)`:
+ * un ambiente che non li espone lascia l'editor funzionante con il singolo comando
+ * disabilitato. Un'anteprima SQL non disponibile disabilita l'anteprima, non l'editor.
+ *
+ * I metodi restituiscono `Observable` perche' l'I/O del frontend e' asincrono per natura. Il
+ * vincolo di sincronia della libreria C# riguarda il backend: qui si traduce solo nel fatto
+ * che una chiamata occupa il chiamante finche' non termina, quindi chi la invoca mostra
+ * l'attesa e non incatena una validazione a ogni battitura senza debounce.
+ */
+
+declare abstract class DpeBuilderApi {
+    /**
+     * Primitive opzionali che **questo ambiente non serve**, dichiarate dall'ospite (ADR 0020,
+     * `contracts.md` §7).
+     *
+     * Perche' esiste, dato che la rilevazione per identita' del metodo bastava: da quando la
+     * libreria spedisce un client HTTP che implementa **tutte** le primitive
+     * (`HttpDpeBuilderApi`), chi lo eredita non ha modo di *dis*-sovrascrivere un metodo. Si
+     * ritroverebbe comandi attivi su endpoint che il suo backend non serve — esattamente il
+     * difetto che la regola dell'identita' esisteva per prevenire.
+     *
+     * E' **solo sottrattiva**: non rende disponibile cio' che non e' implementato, e il tipo
+     * `DpeOptionalPrimitive` le impedisce di nominare le tre primitive obbligatorie. Vuoto per
+     * default, cosi' un'implementazione che non la tocca conserva esattamente il comportamento
+     * di prima.
+     *
+     * Chi la usa deve anche rigettare la primitiva con `DpeApiError('MissingService', ...)`
+     * **senza emettere la richiesta**: sapere in anticipo che un servizio non c'e' e chiederglielo
+     * comunque e' il difetto che questa dichiarazione evita.
+     */
+    readonly unsupportedPrimitives: readonly DpeOptionalPrimitive[];
+    /**
+     * `IDpeService.Validate` — **non produce SQL e non legge dati** (`contracts.md` §5). E' la
+     * primitiva del feedback durante l'editing: diagnostiche, schemi di ogni nodo, ordine di
+     * esecuzione e sequenza dei writeback in una sola risposta.
+     *
+     * Prende la definizione **in lavorazione**, non quella salvata: cio' che l'editor mostra
+     * deve riferirsi a cio' che l'utente sta scrivendo. Va invocata con debounce.
+     */
+    abstract validate(definition: DpeDefinition): Observable<DpeValidateResult>;
+    /**
+     * `IDpeService.GetTables` — passaggio diretto al provider di metadati dell'host, **non ai
+     * cataloghi del database** (`contracts.md` §2). L'elenco puo' essere grande: chi lo consuma
+     * carica in modo asincrono e filtra, non lo riversa in un `<select>`.
+     */
+    abstract getTables(): Observable<TableSummary[]>;
+    /**
+     * `IDpeService.GetTable` — i **tre** esiti dell'ADR 0004 restano distinti fino alla UI:
+     * `Declared`, `DeclaredWithoutFields` ("la tabella c'e', i campi non li so") e `Unknown`.
+     * Appiattirli e' esattamente cio' che il contratto vieta.
+     */
+    abstract getTable(tableName: string): Observable<TableLookupResult>;
+    /**
+     * `IDpeService.Compile` — l'anteprima dell'SQL generato, in sola lettura.
+     *
+     * Opzionale: senza di essa il comando di anteprima si disabilita e il resto dell'editor
+     * continua a funzionare.
+     *
+     * `parameterValues` e' opzionale e corrisponde a `DpeCompileRequest.ParameterValues`.
+     * Ometterlo e' un comportamento **dichiarato**, non un ripiego: l'anteprima usa allora i
+     * `defaultValue` dei parametri. Passarli serve perche' senza di essi l'anteprima resterebbe
+     * muta proprio sui parametri **privi** di default, cioe' quelli che l'utente vuole provare.
+     */
+    compilePreview(definition: DpeDefinition, parameterValues?: DpeParameterValue[]): Observable<DpeCompileResult>;
+    /**
+     * Caricamento di una definizione per nome. Opzionale: dove non c'e', l'editor lavora sulla
+     * definizione che gli viene passata dall'ospite.
+     *
+     * La deserializzazione (`IDpeService.Deserialize`) resta del backend: qui arriva un
+     * documento già letto, con le sue eventuali diagnostiche già emesse.
+     */
+    load(name: string): Observable<DpeDefinition>;
+    /** Salvataggio. Opzionale: un editor in sola lettura e' un uso legittimo. */
+    save(definition: DpeDefinition): Observable<void>;
+    /**
+     * La dichiarazione dell'ambiente (ADR 0017). Oggi porta **solo** il dialetto del database di
+     * destinazione, che e' un fatto dell'installazione e non una preferenza dell'autore della
+     * definizione: per questo l'editor non offre nessun comando per cambiarlo.
+     *
+     * Cosa l'editor fa con la risposta, e cosa non fa: mostra il dialetto in sola lettura e, se
+     * differisce da quello della definizione (ADR 0009: e' li' che vive, ed e' da li' che il
+     * backend lo legge), **lo segnala senza correggere**. Riscrivere `definition.dialect` sarebbe
+     * una migrazione silenziosa di tutte le espressioni SQL native (ADR 0006), per giunta eseguita
+     * all'apertura e capace di marcare come «modificata» una definizione che nessuno ha toccato.
+     *
+     * Opzionale come le altre: dove manca, l'editor mostra il dialetto della definizione e non
+     * dice nient'altro.
+     */
+    getEnvironment(): Observable<DpeEnvironment>;
+    /**
+     * Elenco delle definizioni disponibili — **catalogo** (ADR 0019). Opzionale: dove manca, un
+     * catalogo montato dall'ospite mostra il perche' invece di un elenco vuoto.
+     *
+     * **Nessun oggetto di interrogazione**, di proposito: niente ricerca, niente paginazione. Il
+     * filtro di testo del catalogo e' locale sui sommari ricevuti, e aggiungere una query in
+     * seguito e' additivo. Un parametro che nessuno esercita e' un parametro che nessuno verifica.
+     *
+     * L'ospite e' tenuto a restituire i sommari in un **ordine stabile**: il catalogo non riordina,
+     * perche' riordinare lato client combatterebbe una scelta che l'ospite ha gia' fatto.
+     */
+    listDefinitions(): Observable<DpeDefinitionSummary[]>;
+    /**
+     * Creazione di una definizione. Opzionale.
+     *
+     * **Restituisce il sommario, non `void`**: l'ospite puo' aver normalizzato il nome, e chi crea
+     * apre **il nome tornato**, non quello digitato. Il risultato di una scrittura non si crede
+     * sulla parola.
+     *
+     * Distinta da `save` per una ragione di merito: `save(definition)` significa «scrivi questa
+     * definizione» e non distingue inserimento da aggiornamento, quindi farle significare anche
+     * «creala» toglierebbe all'ospite l'unico posto in cui puo' **rifiutare un nome duplicato**.
+     *
+     * Non esiste una primitiva di duplicazione: duplicare e' `load` piu' `createDefinition`, e il
+     * comando vive nel catalogo.
+     */
+    createDefinition(definition: DpeDefinition): Observable<DpeDefinitionSummary>;
+    /**
+     * Cancellazione per nome. Opzionale: un catalogo di sola lettura e' un uso legittimo.
+     *
+     * Non esiste una primitiva di rinomina: rinominare cambia la chiave, quindi e'
+     * creare-e-cancellare, cioe' una decisione di storage che e' dell'ospite (ADR 0019).
+     */
+    deleteDefinition(name: string): Observable<void>;
+}
+
+/**
+ * Errore categorizzato del contratto verso il backend.
+ *
+ * L'editor si comporta in base alla **categoria**, mai leggendo il messaggio: chi implementa
+ * {@link DpeBuilderApi} traduce l'errore di trasporto (status HTTP, payload, timeout) in un
+ * `DpeApiError`, e da lì in poi nella libreria non esiste piu' nessuna nozione di HTTP
+ * (ADR 0007).
+ */
+/**
+ * Le categorie sono **tre** e chiuse, perche' sono tre comportamenti diversi della UI:
+ *
+ * - `MissingService`: la primitiva non e' implementata su questo ambiente. Degrada il
+ *   **singolo comando** (l'anteprima SQL si disabilita), non l'editor;
+ * - `Transport`: la chiamata non e' arrivata o non e' tornata. Si puo' ritentare;
+ * - `Backend`: il backend ha risposto rifiutando. Non si ritenta da soli.
+ *
+ * Un errore di validazione **non e'** una categoria: le diagnostiche sono un *risultato*
+ * (`DpeValidateResult.diagnostics`), non un fallimento — e' la stessa regola del backend,
+ * dove il fallimento previsto e' un risultato e non un'eccezione.
+ */
+type DpeApiErrorCategory = 'MissingService' | 'Transport' | 'Backend';
+declare class DpeApiError extends Error {
+    readonly category: DpeApiErrorCategory;
+    /** Payload di dettaglio dell'host, opaco per la libreria. */
+    readonly details?: unknown | undefined;
+    constructor(category: DpeApiErrorCategory, message: string, 
+    /** Payload di dettaglio dell'host, opaco per la libreria. */
+    details?: unknown | undefined);
+    static is(value: unknown): value is DpeApiError;
+    /** Vero quando il comando corrispondente va disabilitato invece che segnalato. */
+    static isMissingService(value: unknown): boolean;
+}
+/** Messaggi di ripiego: il `message` dell'host, quando c'e', ha la precedenza. */
+declare const DPE_API_ERROR_FALLBACK_MESSAGE: Record<DpeApiErrorCategory, string>;
+
+/**
+ * Implementazione HTTP di {@link DpeBuilderApi}, sulle rotte **normative** di
+ * `docs/contracts.md` §7-bis.
+ *
+ * Vive nella libreria per decisione del committente (ADR 0020, che revisiona la sola clausola
+ * dell'ADR 0007 sulla collocazione): l'integrazione e' due righe invece che un file da copiare.
+ * Il prezzo, accettato e scritto: **le rotte sono contratto pubblico**, e cambiarne una e' un
+ * breaking change. Da qui in poi questa classe non e' «un esempio» — una classe esportata da una
+ * libreria viene usata in produzione a prescindere da come la chiamiamo nel commento, e chiamarla
+ * esempio servirebbe solo a esentarla dai test.
+ *
+ * Resta vero cio' che conta dell'ADR 0007: **il contratto e' la classe astratta**, non questo
+ * client. Nessun componente e nessuno store della libreria lo importa. Chi ha rotte diverse ha due
+ * strade, e nessuna tocca l'editor:
+ *
+ * 1. **estendere questa classe** e sovrascrivere i soli metodi divergenti. I punti di estensione
+ *    sono `protected` di proposito: `url()` per il prefisso e la forma del percorso, `segment()`
+ *    per la codifica, i quattro verbi per il trasporto, `fail()` per la traduzione degli errori,
+ *    `request()` per cio' che avvolge ogni chiamata;
+ * 2. **scrivere un'altra implementazione di `DpeBuilderApi` da zero** — legittima e supportata.
+ *
+ * Le tre cose che chi legge questo file deve sapere, e che nessun compilatore gli dira':
+ *
+ * 1. **il corpo e' il documento nudo** dove il backend analizza o archivia la definizione
+ *    (`validate`, `createDefinition`, `save`). L'unico involucro e' `compilePreview`, perche' li'
+ *    il corpo porta anche i valori dei parametri. Sbagliare involucro **non produce nessun
+ *    errore**: un backend che deserializza una `DpeDefinition` da `{definition: …}` non riconosce
+ *    nessuna proprieta', risponde `200`, e l'editor mostra la validazione di una definizione
+ *    vuota;
+ * 2. **la serializzazione e' camelCase.** I tipi TypeScript sono allineati a mano ai record C#: un
+ *    backend che risponde in PascalCase non produce nessun errore, produce campi `undefined`;
+ * 3. **l'errore di trasporto diventa una categoria.** L'editor si comporta in base alla categoria
+ *    e non legge mai il messaggio: `MissingService` disabilita un comando, `Transport` e'
+ *    ritentabile, `Backend` no.
+ *
+ * Cosa questo client **non** fa, e non per dimenticanza: nessun `retry`, nessun `shareReplay`,
+ * nessuna cache, nessun debounce, nessuna intestazione propria. Traduce trasporto ed errori e
+ * nient'altro — la cache vive negli store, il debounce nel chiamante, i tentativi e
+ * l'autenticazione negli interceptor dell'ospite. E non tocca `definition.dialect` in nessun
+ * metodo (ADR 0009 e 0017): sarebbe una migrazione silenziosa delle espressioni SQL native.
+ */
+
+/**
+ * Configurazione del client. Iniettata e non cablata: in una libreria una costante non e' una
+ * scelta, e `const BASE = '/api/dpe'` in un file di libreria toglierebbe all'ospite la sua.
+ */
+interface DpeBuilderHttpConfig {
+    /** Prefisso comune degli endpoint, es. `/api/dpe` o `https://host/api/dpe`. Senza slash finale. */
+    baseUrl?: string;
+    /**
+     * Primitive opzionali che questo ambiente **non serve** (`contracts.md` §7, dichiarazione
+     * sottrattiva). E' l'unico modo che ha l'ospite di spegnere una primitiva che questo client
+     * implementa per forza: conoscendo tutti e dieci gli endpoint, li dichiarerebbe altrimenti tutti
+     * disponibili, e un comando attivo su un endpoint non servito fallisce alla pressione.
+     */
+    unsupported?: readonly DpeOptionalPrimitive[];
+}
+declare const DPE_BUILDER_HTTP_CONFIG: InjectionToken<DpeBuilderHttpConfig>;
+declare class HttpDpeBuilderApi extends DpeBuilderApi {
+    protected readonly http: HttpClient;
+    protected readonly config: DpeBuilderHttpConfig;
+    /**
+     * Deriva da `DpeBuilderHttpConfig.unsupported`: e' il ponte fra la configurazione e la regola
+     * di `contracts.md` §7. Non e' un doppione della configurazione — e' il campo che
+     * `core/dpe-capabilities.ts` legge, e leggerlo dal token li' significherebbe portare la
+     * configurazione HTTP dentro il calcolo delle capacita'.
+     */
+    readonly unsupportedPrimitives: readonly DpeOptionalPrimitive[];
+    /**
+     * Composizione dell'URL. Sovrascriverlo basta a spostare tutte e dieci le rotte sotto un altro
+     * prefisso senza toccare un metodo.
+     *
+     * `?? ''` e non un default: `baseUrl: ''` e' una configurazione **valida** e significa «rotte
+     * relative alla radice», quindi non va rimpiazzata dal default del token. Il percorso porta
+     * sempre lo slash iniziale, cosi' non nasce un doppio slash.
+     */
+    protected url(path: string): string;
+    /** Codifica di un segmento variabile. Un nome di definizione puo' contenere `/`, spazi, `&`. */
+    protected segment(value: string): string;
+    /**
+     * Cio' che avvolge **ogni** chiamata, e l'unico posto in cui si decide se una chiamata parte.
+     *
+     * `defer` non e' un vezzo: rende l'`Observable` **freddo** anche per il controllo delle
+     * primitive non servite, cosi' chi non sottoscrive non valuta nulla e chi si disiscrive annulla
+     * davvero la richiesta HTTP. E' la proprieta' per cui il contratto §7 e' `Observable` e non
+     * `Promise` — l'editor la usa per non accumulare validazioni in volo.
+     *
+     * Il rigetto per primitiva non servita sta **fuori** dal `catchError`: passandogli dentro, un
+     * `DpeApiError('MissingService')` verrebbe riclassificato `Transport` da `fail()`, che tratta
+     * come guasto di rete tutto cio' che non e' una `HttpErrorResponse`.
+     */
+    protected request<T>(primitive: DpeOptionalPrimitive | string, call: () => Observable<T>): Observable<T>;
+    /** Vero se l'ospite ha dichiarato di non servire questa primitiva. */
+    protected isUnsupported(primitive: string): boolean;
+    /**
+     * Rigetto di una primitiva dichiarata non servita, **senza toccare la rete**: sapere in anticipo
+     * che un servizio non c'e' e chiederglielo comunque e' il difetto che `unsupportedPrimitives`
+     * esiste per evitare, ed e' il motivo per cui il `501` -> `MissingService` non basta da solo.
+     */
+    protected missing(primitive: string): Observable<never>;
+    /**
+     * `501 Not Implemented` diventa `MissingService`: e' cosi' che un ambiente incompleto degrada
+     * **un comando** invece di rompere l'editor. Uno `0` (rete assente, CORS) e' `Transport`, come
+     * qualunque errore che non sia una `HttpErrorResponse`; tutto il resto e' `Backend`.
+     *
+     * Il `404` resta deliberatamente `Backend` e non ha un ramo suo: qui non e' «primitiva assente»
+     * ma «risorsa assente» — una definizione cancellata da altri, un nome che non esiste piu'. Chi
+     * volesse distinguerlo lo mappi su una categoria propria, non su `MissingService`: disabilitare
+     * un comando perche' un singolo nome non e' stato trovato sarebbe la reazione sbagliata.
+     *
+     * Il messaggio si prende in ordine — corpo dell'errore, messaggio della risposta, ripiego che
+     * nomina la primitiva — e serve solo all'umano: l'editor guarda la categoria.
+     */
+    protected fail(error: unknown, primitive: string): Observable<never>;
+    protected httpGet<T>(path: string): Observable<T>;
+    protected httpPost<T>(path: string, body: unknown): Observable<T>;
+    protected httpPut<T>(path: string, body: unknown): Observable<T>;
+    protected httpDelete<T>(path: string): Observable<T>;
+    validate(definition: DpeDefinition): Observable<DpeValidateResult>;
+    getTables(): Observable<TableSummary[]>;
+    getTable(tableName: string): Observable<TableLookupResult>;
+    /** L'**unica** rotta con involucro: il corpo porta anche i valori dei parametri (§7-bis). */
+    compilePreview(definition: DpeDefinition, parameterValues?: DpeParameterValue[]): Observable<DpeCompileResult>;
+    load(name: string): Observable<DpeDefinition>;
+    save(definition: DpeDefinition): Observable<void>;
+    /**
+     * La dichiarazione dell'ambiente (ADR 0017). Questo client la implementa perche' conosce
+     * l'endpoint, non perche' sappia se l'ospite lo serve — ed e' precisamente la ragione per cui
+     * l'ADR 0020 ha aggiunto `unsupportedPrimitives`.
+     *
+     * Non e' un dettaglio: l'abilitazione della creazione nel catalogo (ADR 0019) dipende da questa
+     * primitiva, quindi un ambiente che non la serve deve lasciare il comando disabilitato **con il
+     * motivo**. Da qui i **tre** rami, che sono tre cose diverse e vanno tenute distinte:
+     *
+     * - **primitiva non implementata**: il metodo non viene sovrascritto, e il `MissingService` lo
+     *   produce l'identita' stessa del metodo. E' la strada di chi scrive la propria
+     *   implementazione di `DpeBuilderApi`, non di chi eredita questo client;
+     * - **primitiva implementata ma non servita da questo ambiente**: e' il ramo centrale, quello
+     *   che questo file rende necessario. L'ospite mette `'getEnvironment'` in
+     *   `DpeBuilderHttpConfig.unsupported`, il comando resta disabilitato con il motivo, e **nessuna
+     *   richiesta parte**. Un metodo ereditato non si puo' dis-sovrascrivere: senza questa
+     *   dichiarazione il comando risulterebbe attivo;
+     * - **primitiva servita che fallisce**: l'endpoint risponde male, e l'errore e' `Transport` o
+     *   `Backend`. Un ambiente rotto, non un ambiente incompleto.
+     *
+     * Rispondere `501` da questo endpoint per significare «non lo dichiaro» arriva allo stesso posto
+     * nel modo sbagliato: costa un giro di rete a ogni apertura dell'editor per comunicare un fatto
+     * che si conosce a tempo di configurazione.
+     *
+     * Cio' che l'editor fa della risposta resta suo: mostra il dialetto in sola lettura e segnala
+     * senza correggere se differisce da quello della definizione.
+     */
+    getEnvironment(): Observable<DpeEnvironment>;
+    /** Nessun parametro di interrogazione: il filtro del catalogo e' locale, di proposito. */
+    listDefinitions(): Observable<DpeDefinitionSummary[]>;
+    /**
+     * `POST` e non `PUT`: e' una **creazione**, quindi il backend puo' rifiutare un nome duplicato —
+     * ed e' l'unica ragione per cui questa primitiva esiste separata da `save`. La risposta e' il
+     * **sommario**, che chi crea deve adottare: il nome puo' essere stato normalizzato.
+     */
+    createDefinition(definition: DpeDefinition): Observable<DpeDefinitionSummary>;
+    deleteDefinition(name: string): Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HttpDpeBuilderApi, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HttpDpeBuilderApi>;
+}
+/**
+ * Registra il client e la sua configurazione: l'integrazione in una riga che l'ADR 0020 chiedeva.
+ *
+ * **Non** chiama `provideHttpClient()`, e non e' una dimenticanza: il backend (`withFetch`), gli
+ * interceptor, l'autenticazione e i cookie sono scelte dell'applicazione ospite, e una libreria
+ * che le prende al posto suo la costringe a disfarle.
+ *
+ * `baseUrl` omesso ricade sul default, `baseUrl: ''` **no**: la stringa vuota e' una
+ * configurazione valida («rotte relative alla radice») e un `||` la scambierebbe per assente.
+ */
+declare function provideDpeBuilderHttpApi(config?: DpeBuilderHttpConfig): EnvironmentProviders;
+
+declare class DpeCatalogStore {
+    private readonly api;
+    private readonly destroyRef;
+    /**
+     * Le primitive disponibili, fotografate **alla costruzione** per identita' del metodo
+     * (`dpe-capabilities.ts`). La disponibilita' si sa prima del clic: un comando che sembra attivo
+     * e fallisce alla pressione insegna a non fidarsi dei bottoni.
+     */
+    readonly capabilities: _esfaenza_dpe_builder.DpeCapabilities;
+    /** Il comando di creazione dipende da **due** primitive, e il motivo va mostrato. */
+    readonly createCommand: _esfaenza_dpe_builder.DpeCommandAvailability;
+    private readonly _summaries;
+    private readonly _isLoading;
+    private readonly _isMutating;
+    private readonly _error;
+    private readonly _hasLoaded;
+    private readonly _environmentDialect;
+    /** Nell'ordine restituito dall'ospite, mai riordinato. */
+    readonly summaries: _angular_core.Signal<readonly DpeDefinitionSummary[]>;
+    /**
+     * Due stati distinti e non uno: **elencare** e **scrivere** si vedono diversi. Un unico
+     * "occupato" farebbe lampeggiare l'elenco a ogni cancellazione, e nasconderebbe il fatto che
+     * dopo una scrittura l'elenco si ricarica.
+     */
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly isMutating: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<DpeApiError | null>;
+    /** Vero dopo la prima risposta: prima, un elenco vuoto non significa «nessuna definizione». */
+    readonly hasLoaded: _angular_core.Signal<boolean>;
+    /**
+     * Il dialetto **dichiarato dall'ambiente** (ADR 0017), che e' quello con cui nasce una
+     * definizione creata da qui. Non si chiede all'utente e non si sceglie per ripiego: senza
+     * dichiarazione il comando di creazione resta spento (`createCommand`).
+     */
+    readonly environmentDialect: _angular_core.Signal<SqlDialectKind | undefined>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Ricarica l'elenco. Senza `listDefinitions` non e' un errore: e' un ambiente che non offre il
+     * catalogo, e chi rende lo dice guardando `capabilities.listDefinitions`.
+     */
+    refresh(): void;
+    /**
+     * Crea una definizione **subito**, non al primo salvataggio: `save` significa «scrivi questa
+     * definizione» e non distingue inserimento da aggiornamento, quindi solo `createDefinition` da'
+     * all'ospite il punto in cui rifiutare un nome duplicato. Una definizione che esiste solo nel
+     * browser e' inoltre uno stato che l'elenco non puo' mostrare.
+     *
+     * Il dialetto arriva dall'ambiente e non dall'utente (ADR 0017): lo passa il chiamante, che lo
+     * legge da `environmentDialect`.
+     *
+     * L'osservabile e' **freddo**: chi comanda si iscrive **una volta** e riceve il sommario che
+     * l'ospite ha restituito — non quello costruito qui, perche' il nome puo' essere stato
+     * normalizzato.
+     */
+    create(name: string, label: string, dialect: SqlDialectKind): Observable<DpeDefinitionSummary>;
+    /**
+     * Duplica: `load` **e poi** `createDefinition`. Non esiste una primitiva di duplicazione sul
+     * contratto, e non deve esistere — si comporrebbe di queste due comunque, e una primitiva
+     * dedicata dovrebbe ridecidere lato host cosa cambia.
+     *
+     * Il dialetto e' quello della **definizione di partenza**, non quello dell'ambiente: le
+     * espressioni sono SQL nativo (ADR 0006) e cambiare dialetto duplicando sarebbe una migrazione
+     * silenziosa.
+     */
+    duplicate(sourceName: string, name: string, label: string): Observable<DpeDefinitionSummary>;
+    /** Cancella per nome e ricarica l'elenco. La conferma e' della schermata, non dello store. */
+    remove(name: string): void;
+    dismissError(): void;
+    /**
+     * Il tratto comune delle due scritture: stato di attesa, **`refresh` dopo il successo** — un
+     * elenco che omette cio' che l'utente ha appena creato e' un elenco che mente — ed errore nel
+     * signal invece che propagato. Chi comanda non deve trattare l'errore due volte.
+     */
+    private mutate;
+    /** Un errore del provider finisce in `error()` e **non lancia**: nessuno lo raccoglierebbe. */
+    private fail;
+    /** Cio' che l'host non categorizza diventa `Transport`, la categoria "riprovabile". */
+    private toApiError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeCatalogStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeCatalogStore>;
+}
+
+/**
+ * Il grafo della definizione: **un solo posto** costruisce gli id di nodi, porte e archi, e
+ * **un solo elenco** descrive dove vivono i riferimenti fra nodi.
+ *
+ * Perche' sta tutto qui. Un id di porta costruito in due modi diversi (canvas da un lato,
+ * derivazione degli archi dall'altro) fa sparire un arco **senza nessun errore**: e' il
+ * difetto piu' difficile da trovare in un editor a canvas. Allo stesso modo, un riferimento
+ * dimenticato nell'elenco degli slot fa restare incoerente il documento dopo una rinomina,
+ * anche lì in silenzio.
+ *
+ * Cosa **non** sta qui: nessuna regola di dominio. Questo file dice *dove* stanno i nomi dei
+ * nodi a monte, non se un riferimento e' valido, se il grafo ha cicli (**I2**), se un nodo e'
+ * a valle (**I3**) o quali colonne produca (**I4**). Quelle risposte arrivano da
+ * `DpeBuilderApi.validate`.
+ */
+
+declare function dpeNodeId(nodeName: string): string;
+/**
+ * Porta di ingresso. Una porta **per slot** (e per indice, sugli slot a lista): un `JoinNode`
+ * ha due ingressi distinti e attaccare l'arco alla porta sbagliata scambia primaria e
+ * secondaria, che e' un join diverso.
+ */
+declare function dpeInputPortId(nodeName: string, slot: string, index?: number): string;
+/** Porta di uscita: una sola per nodo, lo schema prodotto e' uno. */
+declare function dpeOutputPortId(nodeName: string): string;
+/**
+ * Id dell'arco: identifica la **destinazione** (nodo, slot, indice), non la coppia di nodi.
+ * Due archi possono unire gli stessi due nodi su slot diversi — la primaria e la secondaria
+ * di un self-join — e con un id per coppia uno dei due sparirebbe.
+ */
+declare function dpeEdgeId(targetNodeName: string, slot: string, index?: number): string;
+/**
+ * Gli inversi. Stanno **accanto** ai costruttori e non nel canvas: la libreria di canvas
+ * restituisce gli id nei suoi eventi, e chi li legge deve tornare al nome del nodo con la
+ * stessa convenzione con cui li ha scritti. Separarli e' il modo con cui un giorno cambierebbe
+ * uno solo dei due.
+ */
+declare function dpeParseNodeId(id: string): string | undefined;
+declare function dpeParseOutputPortId(id: string): string | undefined;
+declare function dpeParseInputPortId(id: string): {
+    nodeName: string;
+    slot: string;
+    index?: number;
+} | undefined;
+/**
+ * Uno slot e' un punto del nodo che contiene il nome di **un altro nodo**.
+ *
+ * `read` e `write` sono **posizionali e di lunghezza stabile**: `write(node, read(node))` non
+ * cambia il nodo. E' la proprieta' che permette di implementare la rinomina come
+ * `write(node, read(node).map(rinomina))` — cioe' con un solo cammino di codice, invece di
+ * due elenchi (uno per leggere gli archi, uno per rinominare) che al primo campo aggiunto
+ * diventano due elenchi diversi.
+ */
+interface DpeSourceSlot<TNode> {
+    readonly slot: string;
+    /**
+     * `true` quando lo slot e' un **arco del DAG** (il flusso dei dati). `false` per i
+     * riferimenti che sono altro: i `sourceName` dei `JoinResultField` ripetono le sorgenti del
+     * join, e le relazioni di un gruppo atomico dichiarano una transazione dell'host, non un
+     * flusso di dati (l'ordinamento dei sink e' esplicito e separato dal DAG).
+     */
+    readonly isEdge: boolean;
+    read(node: TNode): readonly (string | undefined)[];
+    write(node: TNode, names: readonly (string | undefined)[]): TNode;
+}
+/** Gli slot di ogni collezione. Aggiungere un nodo significa aggiungere una riga qui. */
+declare const DPE_SOURCE_SLOTS: {
+    readonly [K in DpeNodeCollectionName]: readonly DpeSourceSlot<DpeNodeCollectionMap[K]>[];
+};
+/** Un nodo con la collezione da cui viene: senza, non si sa quali slot leggere. */
+interface DpeLocatedNode<K extends DpeNodeCollectionName = DpeNodeCollectionName> {
+    collection: K;
+    index: number;
+    node: DpeNodeCollectionMap[K];
+}
+/** Tutti i nodi, nell'ordine delle collezioni (sorgenti -> trasformazioni -> sink). */
+declare function dpeAllNodes(definition: DpeDefinition): DpeLocatedNode[];
+declare function dpeFindNode(definition: DpeDefinition, nodeName: string): DpeLocatedNode | undefined;
+interface DpeSourceReference {
+    /** Nodo che contiene il riferimento (la destinazione dell'arco). */
+    targetNodeName: string;
+    collection: DpeNodeCollectionName;
+    slot: string;
+    /** Presente solo sugli slot a lista. */
+    index?: number;
+    isEdge: boolean;
+    /** Nome riferito; assente quando lo slot e' vuoto (nodo non collegato). */
+    sourceName?: string;
+}
+/** I riferimenti di un singolo nodo, in ordine di slot. */
+declare function dpeNodeSourceReferences(located: DpeLocatedNode): DpeSourceReference[];
+interface DpeGraphNode {
+    id: string;
+    name: string;
+    collection: DpeNodeCollectionName;
+    outputPortId: string;
+}
+interface DpeGraphEdge {
+    id: string;
+    /** Nome del nodo a monte, come scritto nel documento. */
+    fromNodeName: string;
+    toNodeName: string;
+    slot: string;
+    index?: number;
+    fromPortId: string;
+    toPortId: string;
+    /**
+     * `false` quando il nome a monte non corrisponde a nessun nodo della definizione. L'arco
+     * **si mostra comunque**: la topologia mostrata e' quella reale, e un riferimento rotto va
+     * visto, non nascosto. La diagnostica che lo qualifica (`DPE_REF_UNKNOWN_NODE`) arriva dal
+     * backend.
+     */
+    isResolved: boolean;
+}
+interface DpeGraph {
+    nodes: DpeGraphNode[];
+    edges: DpeGraphEdge[];
+}
+/**
+ * Deriva nodi e archi dalla definizione, per riferimento di nome. Funzione pura: nessuna
+ * lettura di stato, nessuna dipendenza da Angular, testabile senza DOM.
+ */
+declare function dpeBuildGraph(definition: DpeDefinition): DpeGraph;
+/** Le porte di ingresso di un nodo, nell'ordine in cui vanno disegnate. */
+interface DpeInputPort {
+    id: string;
+    slot: string;
+    index?: number;
+    /** Nome collegato, assente se la porta e' libera. */
+    sourceName?: string;
+}
+declare function dpeInputPorts(located: DpeLocatedNode): DpeInputPort[];
+/**
+ * Riscrive un riferimento in **uno** slot di **un** nodo. E' il mattone di `connect` e
+ * `disconnect` dello store: passando `undefined` la porta torna libera.
+ */
+declare function dpeWriteSourceReference<K extends DpeNodeCollectionName>(collection: K, node: DpeNodeCollectionMap[K], slotName: string, index: number | undefined, sourceName: string | undefined): DpeNodeCollectionMap[K];
+/**
+ * **Rinominare un nodo e' un refactoring globale, non locale** (**I5**).
+ *
+ * Questa e' l'unica funzione che rinomina: aggiorna il `name` del nodo e **ogni** riferimento
+ * a valle, passando dall'unico elenco di slot — `sourceName`, `sources`,
+ * `primarySourceName`/`secondarySourceName`, i `sourceName` dei `JoinResultField` e i nomi
+ * dentro i gruppi atomici. Se una collezione di riferimenti sfuggisse, il documento
+ * diventerebbe silenziosamente incoerente: e' il difetto che questa funzione esiste per non
+ * avere.
+ *
+ * Cosa **non** fa, di proposito: non rinomina gli **alias di colonna** (sono un altro spazio
+ * di nomi) e non decide se il nuovo nome sia lecito o già usato — l'unicita' e' **I1**, la
+ * verifica il backend.
+ *
+ * Il confronto e' **esatto**, non case-insensitive: `domain-model.md` dichiara il confronto
+ * `OrdinalIgnoreCase` per gli **alias di colonna** e non dice nulla sui nomi dei nodi.
+ * Rinominare anche le occorrenze con capitalizzazione diversa significherebbe, se il backend
+ * risolvesse i nomi in modo esatto, riscrivere il riferimento a un nodo **diverso**.
+ */
+declare function dpeRenameNode(definition: DpeDefinition, oldName: string, newName: string): DpeDefinition;
+/** Quante occorrenze toccherebbe una rinomina: serve a dirlo prima, non dopo. */
+declare function dpeCountReferences(definition: DpeDefinition, nodeName: string): number;
+
+/**
+ * Utility pure sulle diagnostiche **ricevute** dal backend: raggruppamento per nodo, gravita'
+ * peggiore, e la distinzione fra "da correggere" e "non ancora compilabile".
+ *
+ * Qui non nasce nessuna diagnostica e non si giudica nessuna definizione: si legge cio' che il
+ * backend ha detto e si decide **come renderlo**. La sola informazione interpretata e' il
+ * `DiagnosticPath`, che il contratto pubblica in **due forme** (con nome del nodo dalla
+ * validazione, con solo indice dalla deserializzazione): chi legge deve accettarle entrambe,
+ * altrimenti le diagnostiche del caricamento di un file non sono navigabili.
+ */
+
+/**
+ * Il nodo a cui una diagnostica si riferisce, se ricavabile.
+ *
+ * Tre strade, nell'ordine: il nome nel primo segmento del percorso; l'argomento canonico
+ * `node`; l'indice del primo segmento risolto nella collezione corrispondente della
+ * definizione — che e' il caso della deserializzazione, dove i nomi non sono ancora noti.
+ * Senza la terza, un `filters[0].sourceName` resterebbe una riga non cliccabile.
+ */
+declare function dpeDiagnosticNodeName(diagnostic: Diagnostic, definition?: DpeDefinition): string | undefined;
+/** Il campo in causa, per evidenziarlo nell'ispettore. */
+declare function dpeDiagnosticField(diagnostic: Diagnostic): string | undefined;
+/**
+ * `true` per l'unico codice che significa "hai fatto bene, siamo noi" (**I10**, ADR 0005):
+ * `Forecast`, `CustomNode`, costrutto non supportato dal dialetto scelto. Non va mescolato
+ * con i `DPE_MODEL_*`, che l'utente deve correggere.
+ */
+declare function dpeIsNotCompilable(diagnostic: Diagnostic): boolean;
+/**
+ * `true` quando la diagnostica riguarda le **capacita' del dialetto** e non la definizione in
+ * se': l'interfaccia deve dire «questo dialetto non lo supporta», perche' lo stesso documento
+ * su un altro dialetto sarebbe compilabile.
+ */
+declare function dpeIsDialectDiagnostic(diagnostic: Diagnostic): boolean;
+interface DpeNodeDiagnostics {
+    /** Diagnostiche ancorate al nodo, nell'ordine ricevuto (**I6**: l'elenco e' esaustivo). */
+    diagnostics: Diagnostic[];
+    /** La gravita' peggiore fra quelle presenti. */
+    severity?: DiagnosticSeverity;
+    /**
+     * Il nodo e' **valido ma non compilabile**: stato distinto da "non valido", e l'unico per
+     * cui la UI non deve chiedere all'utente di correggere niente.
+     */
+    isNotCompilable: boolean;
+}
+declare function dpeWorstSeverity(diagnostics: readonly Diagnostic[]): DiagnosticSeverity | undefined;
+/** Raggruppa per nodo. Le diagnostiche non ancorabili a un nodo non si perdono: vedi sotto. */
+declare function dpeGroupDiagnosticsByNode(diagnostics: readonly Diagnostic[], definition?: DpeDefinition): Map<string, DpeNodeDiagnostics>;
+/**
+ * Le diagnostiche che **non** appartengono a nessun nodo (radice, parametri, sequenza dei
+ * writeback, grafo intero). Esistono come funzione a se' perche' il pannello deve mostrarle:
+ * un `DPE_GRAPH_NO_WRITEBACK` che scompare perche' non ha un nodo a cui attaccarsi sarebbe la
+ * diagnostica piu' importante di tutte a non arrivare all'utente.
+ */
+declare function dpeDefinitionLevelDiagnostics(diagnostics: readonly Diagnostic[], definition?: DpeDefinition): Diagnostic[];
+/** Testo leggibile del percorso, per la riga del pannello. */
+declare function dpeDiagnosticLocationLabel(diagnostic: Diagnostic, definition?: DpeDefinition): string;
+/** I nomi dei nodi presenti nella definizione: serve a chi naviga dal pannello al canvas. */
+declare function dpeKnownNodeNames(definition: DpeDefinition): Set<string>;
+
+/**
+ * Le coordinate di un nodo sul canvas — ADR 0013.
+ *
+ * Vivono in `extensionData` sotto la chiave namespaced `dpe:layout`, forma `{x, y}`. Il
+ * backend le conserva senza interpretarle (**I7**), la validazione non le guarda, il
+ * compilatore non le vede: l'unico livello che gli da' significato e' l'editor.
+ *
+ * Due regole dell'ADR sono implementate qui, e sono le sole che contano:
+ *
+ * - le coordinate sono **opzionali**: una definizione scritta a mano non le ha e resta
+ *   valida; in loro assenza si esegue dagre;
+ * - un `dpe:layout` **malformato o parziale si ignora**. Un documento arrivato da un'altra
+ *   versione non deve poter rompere il canvas, e "meta' coordinata" non e' una posizione:
+ *   accettarla metterebbe il nodo a `x` giusta e `y` zero, cioe' in un posto che nessuno ha
+ *   scelto.
+ */
+
+/** La chiave e' namespaced perche' `extensionData` e' anche dove atterrano i campi futuri. */
+declare const DPE_LAYOUT_KEY = "dpe:layout";
+interface DpeNodePosition {
+    x: number;
+    y: number;
+}
+/** Legge la posizione, oppure `undefined` se assente o non utilizzabile. */
+declare function dpeReadNodePosition(node: DpeAnyNode): DpeNodePosition | undefined;
+/** Scrive la posizione producendo un nuovo nodo: il documento resta immutabile. */
+declare function dpeWriteNodePosition<TNode extends DpeAnyNode>(node: TNode, position: DpeNodePosition): TNode;
+/** Vero quando **tutti** i nodi hanno una posizione: se no, il canvas rifa' il layout. */
+declare function dpeHasCompleteLayout(nodes: readonly DpeAnyNode[]): boolean;
+
+/** Una definizione vuota ma **leggibile**: `formatVersion` e `dialect` non sono opzionali. */
+declare function dpeEmptyDefinition(name: string, label: string, dialect: SqlDialectKind): DpeDefinition;
+declare class DpeDocumentStore {
+    private readonly _definition;
+    private readonly _validateResult;
+    private readonly _compileResult;
+    /**
+     * I nodi selezionati, in ordine di gesto. E' una **lista** e non un nome singolo perche' il
+     * canvas sa selezionare piu' nodi (riquadro, `Ctrl+A`) e trascinarli insieme: tenere qui un solo
+     * nome costringerebbe la libreria a conservare gli altri, cioe' a essere di nuovo autorevole
+     * sulla selezione.
+     */
+    private readonly _selectedNodeNames;
+    private readonly _past;
+    private readonly _future;
+    /**
+     * Istantanea di riferimento: l'ultimo stato **salvato**. Non e' un contatore di operazioni.
+     * Contare le mutazioni sembra equivalente e non lo e': dopo un `undo` il contatore sale, cioe'
+     * dichiara piu' modifiche di prima proprio quando l'utente ne ha disfatta una. Serve a decidere
+     * se salvare, quindi deve rispondere alla domanda giusta — "differisce da cio' che e' salvato?"
+     * — e tornare a "no" quando si annulla fino allo stato di partenza.
+     */
+    private readonly _savedSnapshot;
+    /** La definizione corrente: unica fonte di verita' per canvas, ispettori e pannelli. */
+    readonly definition: _angular_core.Signal<DpeDefinition>;
+    /** Nodi e archi derivati dalla definizione. Ricalcolati solo quando la definizione cambia. */
+    readonly graph: _angular_core.Signal<DpeGraph>;
+    readonly selectedNodeNames: _angular_core.Signal<readonly string[]>;
+    /** Insieme dei selezionati: il canvas lo interroga una volta per nodo a ogni render. */
+    readonly selectedNodeNameSet: _angular_core.Signal<ReadonlySet<string>>;
+    /**
+     * Il nodo che l'ispettore mostra: il **primo** della selezione. Un ispettore per piu' nodi
+     * insieme mostrerebbe campi che appartengono a nodi diversi, che e' peggio di non mostrarne.
+     */
+    readonly selectedNodeName: _angular_core.Signal<string | undefined>;
+    readonly selectedNode: _angular_core.Signal<DpeAnyNode | undefined>;
+    readonly validateResult: _angular_core.Signal<DpeValidateResult | undefined>;
+    readonly compileResult: _angular_core.Signal<DpeCompileResult | undefined>;
+    readonly diagnostics: _angular_core.Signal<readonly Diagnostic[]>;
+    readonly schemas: _angular_core.Signal<readonly DpeNodeSchemaInfo[]>;
+    readonly executionOrder: _angular_core.Signal<readonly string[]>;
+    readonly writebackSequence: _angular_core.Signal<readonly DpeWritebackStep[]>;
+    /** Schema per nome di nodo: la vista dello schema lo cerca per nodo, non per posizione. */
+    readonly schemaByNode: _angular_core.Signal<ReadonlyMap<string, DpeNodeSchemaInfo>>;
+    /**
+     * Diagnostiche raggruppate per nodo, piu' quelle che **non** appartengono a nessun nodo
+     * (radice, parametri, grafo intero): tenerle separate e' l'unico modo perche' un
+     * `DPE_GRAPH_NO_WRITEBACK` non scompaia solo perche' non ha un nodo a cui attaccarsi.
+     */
+    readonly diagnosticsByNode: _angular_core.Signal<ReadonlyMap<string, DpeNodeDiagnostics>>;
+    readonly definitionDiagnostics: _angular_core.Signal<readonly Diagnostic[]>;
+    /** Posizioni lette da `dpe:layout` (ADR 0013): assenti dove il documento non le porta. */
+    readonly positions: _angular_core.Signal<ReadonlyMap<string, DpeNodePosition>>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    /**
+     * Vero quando il documento differisce dall'ultimo salvataggio. Il confronto e' fra istantanee
+     * JSON — la stessa moneta dell'undo/redo — e **non** un conteggio di differenze: un elenco di
+     * differenze costa quanto un diff strutturale, e nessuno lo legge come numero.
+     *
+     * Confronto testuale, quindi sensibile all'ordine delle chiavi. Le mutazioni producono nuovi
+     * valori per spread, che l'ordine lo conserva, e l'undo riparte dalla stessa serializzazione:
+     * l'unico esito possibile di una divergenza d'ordine sarebbe un falso "modificata", cioe' un
+     * salvataggio in piu' e mai una perdita.
+     */
+    readonly isDirty: _angular_core.Signal<boolean>;
+    /**
+     * Sostituisce la definizione. Azzera la cronologia: le istantanee della definizione
+     * precedente non sono passi di quella nuova, e un undo che riportasse a un altro documento
+     * sarebbe una perdita di dati che l'utente non ha chiesto.
+     */
+    load(definition: DpeDefinition): void;
+    /** Deposita il risultato della validazione. Nessuna interpretazione: si mostra cio' che c'e'. */
+    applyValidateResult(result: DpeValidateResult | undefined): void;
+    applyCompileResult(result: DpeCompileResult | undefined): void;
+    /**
+     * L'ospite ha salvato: da qui in poi il riferimento e' il documento **effettivamente
+     * persistito**, che si passa come argomento.
+     *
+     * Il parametro non e' un vezzo: un salvataggio e' asincrono, e nel frattempo l'utente puo'
+     * avere continuato a scrivere. Fissando il riferimento sullo stato *corrente* si dichiarerebbe
+     * salvato anche cio' che e' stato scritto dopo l'invio, cioe' esattamente il lavoro che si
+     * perderebbe. Omesso, vale lo stato corrente: e' il caso di chi salva in modo sincrono.
+     */
+    markSaved(saved?: DpeDefinition): void;
+    /**
+     * **L'unico** punto che decide quale nodo e' selezionato. La selezione ha una sola fonte di
+     * verita', come la definizione: la classe nel DOM e lo stato di selezione della libreria di
+     * canvas ne **derivano**, non la stabiliscono. Due scritture indipendenti sullo stesso fatto
+     * producono due nodi selezionati insieme e un utente che non sa su cosa sta agendo.
+     */
+    select(nodeName: string | undefined): void;
+    /** Selezione multipla (riquadro, `Ctrl+A`): la lista che arriva dal gesto, senza duplicati. */
+    selectMany(nodeNames: readonly string[]): void;
+    /** Proprieta' della radice: etichetta, descrizione, dialetto, parametri. */
+    patchDefinition(patch: Partial<DpeDefinition>): void;
+    addNode<K extends DpeNodeCollectionName>(collection: K, node: DpeNodeCollectionMap[K]): void;
+    updateNode<K extends DpeNodeCollectionName>(collection: K, nodeName: string, patch: Partial<DpeNodeCollectionMap[K]>): void;
+    /**
+     * Rimuove un nodo. I riferimenti a valle **restano** e diventano riferimenti rotti: e' cio'
+     * che il documento dice davvero, e il backend li segnala (`DPE_REF_UNKNOWN_NODE`). Pulirli
+     * qui vorrebbe dire decidere al posto dell'utente che quel filtro non serve piu'.
+     */
+    removeNode(nodeName: string): void;
+    /**
+     * L'**unico** punto che rinomina un nodo (**I5**): delega alla funzione pura, che aggiorna
+     * ogni riferimento a valle passando dall'unico elenco di slot.
+     */
+    renameNode(oldName: string, newName: string): void;
+    /** Quante occorrenze toccherebbe una rinomina: si dice prima, non dopo. */
+    countReferences(nodeName: string): number;
+    /**
+     * Crea un nodo della categoria data nella posizione indicata e restituisce il nome
+     * assegnato, cosi' chi lo ha creato puo' selezionarlo subito.
+     */
+    createNodeAt<K extends DpeNodeCollectionName>(collection: K, position: DpeNodePosition): string;
+    /**
+     * Sposta un nodo scrivendo `dpe:layout`. `silent` non aggiunge un passo di cronologia:
+     * trascinare cinque nodi insieme e' **un** gesto, e cinque passi di undo per un solo
+     * trascinamento sono cinque passi che l'utente non ha fatto.
+     */
+    moveNode(nodeName: string, position: DpeNodePosition, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Applica un layout calcolato **su comando dell'utente** («Riordina»): un passo di cronologia
+     * per l'intero riordino, e il documento risulta modificato, perche' lo e'.
+     */
+    applyPositions(positions: ReadonlyMap<string, DpeNodePosition>): void;
+    /**
+     * Layout **iniziale** di un documento che non porta coordinate (ADR 0013: sono opzionali).
+     *
+     * Non e' una modifica dell'utente: non entra nella cronologia e **ri-fissa l'istantanea di
+     * riferimento**, cosi' aprire un documento non produce «modificata». Un indicatore che dice
+     * «modificata» appena si apre insegna a ignorarlo, e un indicatore ignorato e' peggio di
+     * nessun indicatore. Il prezzo accettato: chi chiude senza salvare perde le coordinate
+     * calcolate, che dagre rigenera in modo deterministico.
+     *
+     * Il riferimento si sposta **solo** se il documento non era gia' modificato: se l'utente ha
+     * scritto qualcosa, un layout non puo' dichiarare salvato il suo lavoro.
+     */
+    applyInitialPositions(positions: ReadonlyMap<string, DpeNodePosition>): void;
+    /**
+     * Collega una porta di ingresso di `targetNodeName` al nodo `sourceName`. Non verifica che
+     * il collegamento sia lecito: cicli (**I2**) e riferimenti a valle (**I3**) li rifiuta il
+     * backend, e l'errore compare subito perche' la validazione parte dopo la mutazione.
+     */
+    connect(targetNodeName: string, slot: string, sourceName: string, index?: number): void;
+    /** Scollega una porta: lo slot torna vuoto, non a stringa vuota. */
+    disconnect(targetNodeName: string, slot: string, index?: number): void;
+    undo(): void;
+    redo(): void;
+    private writeReference;
+    /** Scrive le posizioni su tutte le collezioni producendo una nuova definizione. */
+    private withPositions;
+    /**
+     * Sostituisce una collezione producendo una nuova definizione. Il cast e' confinato qui:
+     * TypeScript non correla la chiave di collezione con il tipo di nodo dentro un accesso
+     * dinamico, e la mappa dei tipi serve ai chiamanti, non a questa riga.
+     */
+    private withCollection;
+    private commit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeDocumentStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeDocumentStore>;
+}
+
+interface DpeLayoutNodeInput {
+    name: string;
+    width: number;
+    height: number;
+}
+interface DpeLayoutEdgeInput {
+    /** Nome del nodo a monte. */
+    from: string;
+    /** Nome del nodo a valle. */
+    to: string;
+    /** Identificatore dell'arco: dagre ne ha bisogno per ammettere archi paralleli. */
+    id: string;
+}
+interface DpeLayoutPosition {
+    x: number;
+    y: number;
+}
+type DpeLayoutDirection = 'TB' | 'LR';
+interface DpeLayoutOptions {
+    /** Default `TB`: i dati scendono dalle sorgenti ai sink. */
+    direction?: DpeLayoutDirection;
+    /** Distanza fra i livelli. */
+    rankSeparation?: number;
+    /** Distanza fra i nodi dello stesso livello. */
+    nodeSeparation?: number;
+    /** Angolo in alto a sinistra del grafo risultante. */
+    origin?: DpeLayoutPosition;
+}
+declare class DpeLayoutService {
+    /**
+     * Calcola le posizioni. La chiave della mappa e' il **nome** del nodo, non il suo id sul
+     * canvas: il nome e' cio' che identifica un nodo nel documento, e passare dall'id
+     * costringerebbe questo servizio a conoscere la costruzione degli id.
+     */
+    layout(nodes: readonly DpeLayoutNodeInput[], edges: readonly DpeLayoutEdgeInput[], options?: DpeLayoutOptions): Map<string, DpeLayoutPosition>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeLayoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeLayoutService>;
+}
+
+interface DpeTableState {
+    outcome: TableLookupOutcome;
+    table?: TableDescriptor;
+}
+declare class DpeMetadataStore {
+    private readonly api;
+    private readonly _tables;
+    private readonly _isLoadingTables;
+    private readonly _tablesRequested;
+    private readonly _byName;
+    private readonly pending;
+    readonly tables: _angular_core.Signal<readonly TableSummary[]>;
+    readonly isLoadingTables: _angular_core.Signal<boolean>;
+    /** Idempotente: la prima chiamata carica, le successive non fanno nulla. */
+    loadTables(): void;
+    /** Stato noto di una tabella, se già richiesta. */
+    stateOf(tableName: string): DpeTableState | undefined;
+    /** Chiede la descrizione di una tabella una sola volta per nome. */
+    describe(tableName: string): void;
+    private put;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeMetadataStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeMetadataStore>;
+}
+
+/**
+ * Catalogo delle categorie di nodo: etichetta italiana, collezione JSON di appartenenza,
+ * numero di sorgenti ammesse.
+ *
+ * **Descrittivo, non normativo.** Serve alla palette e alle etichette dell'interfaccia. Non
+ * e' validazione: che un `AppendNode` con una sola sorgente sia sbagliato lo dice il backend,
+ * non questo file, e i due non devono mai diventare due fonti di verita' in disaccordo. I
+ * conteggi qui sotto servono a decidere **quante porte disegnare**, che e' una domanda di
+ * rendering.
+ */
+
+interface DpeNodeCategory {
+    /** Collezione JSON della radice: e' anche la chiave con cui si legge il documento. */
+    collection: DpeNodeCollectionName;
+    /** Etichetta breve, per la palette e per l'intestazione della card sul canvas. */
+    label: string;
+    /** Una riga di spiegazione, per il tooltip della palette. */
+    description: string;
+    /** Numero minimo di sorgenti che il nodo dichiara (0 per i punti d'ingresso). */
+    minSources: number;
+    /** Numero massimo, `undefined` = illimitato (`Append`, `CustomNode`). */
+    maxSources?: number;
+    /** Vero per i punti d'ingresso del grafo. */
+    isSource: boolean;
+    /** Vero per i sink: producono l'artefatto, non uno schema. */
+    isSink: boolean;
+    /**
+     * Vero dove il backend rifiuta la compilazione pur accettando il modello (**I10**): la UI
+     * deve poter avvisare **prima** che l'utente costruisca la pipeline intorno a un nodo che
+     * non arrivera' all'SQL. Non e' una regola di dominio riprodotta: e' l'informazione che
+     * `docs/domain-model.md` dichiara esplicitamente per queste due categorie, e la
+     * diagnostica autorevole resta `DPE_NODE_NOT_COMPILABLE` del backend.
+     */
+    isNotCompilableInV1: boolean;
+}
+declare const DPE_NODE_CATEGORIES: readonly DpeNodeCategory[];
+declare function dpeNodeCategory(collection: DpeNodeCollectionName): DpeNodeCategory;
+/** Nomi dei dialetti per il selettore. La libreria conosce **solo** il nome (ADR 0009). */
+declare const DPE_DIALECT_LABELS: Readonly<Record<string, string>>;
+
+/**
+ * I tracciati SVG delle icone di categoria, uno per collezione di nodi.
+ *
+ * **Perche' tracciati e non glifi Unicode** (divergenza motivata dal progetto di riferimento,
+ * `frontend.md` §3-ter): i glifi non hanno metriche ne' linea di base coerenti fra loro e su
+ * alcune piattaforme diventano emoji a colori — cioe' proprio la resa sbagliata quando stanno
+ * in colonna in una palette. Un tracciato disegnato su una griglia 24x24 con `currentColor` si
+ * colora con una sola regola CSS e vale identico in tema chiaro e scuro.
+ *
+ * **Nessun asset e nessuna dipendenza**: sono stringhe, e il componente che le rende le lega con
+ * `[attr.d]` senza mai toccare `innerHTML` — quindi niente `bypassSecurityTrust*`.
+ *
+ * Il disegno e' pensato per la resa a **16px**: pochi tratti, nessun dettaglio sotto i 2 px di
+ * griglia, e sagome che restano distinguibili l'una dall'altra quando sono incolonnate.
+ */
+
+/**
+ * La famiglia cromatica di una categoria. **Non e' una tassonomia nuova**: si deriva per intero
+ * da `isSource`/`isSink`/`isNotCompilableInV1` del catalogo, che restano l'unica descrizione dei
+ * tipi di nodo. Serve solo a scegliere un colore.
+ */
+type DpeNodeIconFamily = 'source' | 'transform' | 'sink' | 'uncompilable';
+declare function dpeNodeIconFamily(collection: DpeNodeCollectionName): DpeNodeIconFamily;
+/** Classe CSS della famiglia: un solo posto la costruisce, cosi' i fogli restano allineati. */
+declare function dpeNodeIconFamilyClass(collection: DpeNodeCollectionName): string;
+/**
+ * I tracciati, per collezione. Ogni voce e' l'elenco degli attributi `d` di un `<path>`; il
+ * contorno e' `stroke`, mai `fill`, cosi' l'icona pesa uguale su qualunque sfondo.
+ */
+declare const DPE_NODE_ICON_PATHS: Readonly<Record<DpeNodeCollectionName, readonly string[]>>;
+/**
+ * I tracciati di una collezione. Il ripiego vuoto non e' pigrizia: una collezione aggiunta al
+ * modello e non ancora disegnata deve produrre una pastiglia vuota, non un errore in console
+ * ne' un `undefined` dentro `[attr.d]`.
+ */
+declare function dpeNodeIconPaths(collection: DpeNodeCollectionName): readonly string[];
+
+/**
+ * Creazione di un nodo nuovo: nome candidato e valori iniziali per categoria.
+ *
+ * Non e' validazione e non e' dominio. Serve a una cosa sola: un nodo appena rilasciato sul
+ * canvas deve essere **rappresentabile** e distinguibile, cioe' avere un nome e un'etichetta.
+ * Tutto il resto lo compila l'utente nell'ispettore, e cosa sia obbligatorio lo dice il
+ * backend.
+ *
+ * Il nome candidato e' unico rispetto ai nomi già presenti con confronto **esatto**
+ * (`contracts.md` §2: unicita' verificata `OrdinalIgnoreCase`, risoluzione `Ordinal`). Qui il
+ * confronto e' insensibile al caso di proposito: proporre `Filtro2` accanto a un `filtro2`
+ * esistente creerebbe un `DPE_MODEL_NAME_DUPLICATE` a nome dell'editor, non dell'utente.
+ */
+
+/** Il primo nome libero della forma `<radice><n>`. */
+declare function dpeProposeNodeName(definition: DpeDefinition, collection: DpeNodeCollectionName): string;
+/**
+ * Il nodo iniziale di una categoria. I campi obbligatori senza un valore sensato restano
+ * **assenti**, non riempiti con un segnaposto: un `tableName` finto passerebbe la forma e
+ * fallirebbe sul provider di metadati con un errore che l'utente non ha causato.
+ */
+declare function dpeCreateNode<K extends DpeNodeCollectionName>(definition: DpeDefinition, collection: K): DpeNodeCollectionMap[K];
+/**
+ * La sequenza dei sink e' univoca fra writeback e gruppi atomici: si propone la prima libera.
+ * L'unicita' la verifica il backend (`DPE_WRITEBACK_SEQUENCE_DUPLICATE`) — questo e' solo un
+ * valore iniziale che non collide, non un controllo.
+ */
+declare function dpeProposeWritebackSequence(definition: DpeDefinition): number;
+/** Etichetta di sintesi mostrata sulla card del nodo, sotto il nome. */
+declare function dpeNodeSubtitle(collection: DpeNodeCollectionName, node: DpeAnyNode): string | null;
+
+declare class DpeValidationService {
+    private readonly api;
+    private readonly store;
+    private readonly destroyRef;
+    private readonly _isValidating;
+    private readonly _isCompiling;
+    private readonly _error;
+    /**
+     * Le primitive opzionali si sanno **alla costruzione**, per identita' del metodo
+     * (`dpe-capabilities.ts`, `contracts.md` §7). Prima si partiva da «disponibile» e si scopriva
+     * l'assenza dal primo `MissingService`: il comando sembrava attivo e falliva alla pressione,
+     * che e' peggio di un comando disabilitato che ne dice il motivo.
+     */
+    private readonly capabilities;
+    private readonly _isPreviewAvailable;
+    private readonly _isSaving;
+    /** Come l'anteprima: un host senza `save` disabilita il comando, non rompe l'editor. */
+    private readonly _isSaveAvailable;
+    /** Esito dell'ultimo salvataggio: transitorio al successo, persistente al fallimento. */
+    private readonly _justSaved;
+    private readonly _saveError;
+    /**
+     * Il dialetto **dichiarato dall'ambiente** (ADR 0017), quando l'host espone `getEnvironment`.
+     * Non e' il dialetto con cui si compila — quello sta nella definizione — ed e' esattamente per
+     * questo che i due si tengono separati: il confronto e' l'unica cosa che l'editor puo' dire.
+     */
+    private readonly _environmentDialect;
+    readonly isValidating: _angular_core.Signal<boolean>;
+    readonly isCompiling: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<DpeApiError | undefined>;
+    readonly isPreviewAvailable: _angular_core.Signal<boolean>;
+    readonly isSaving: _angular_core.Signal<boolean>;
+    readonly isSaveAvailable: _angular_core.Signal<boolean>;
+    readonly justSaved: _angular_core.Signal<boolean>;
+    readonly saveError: _angular_core.Signal<DpeApiError | undefined>;
+    readonly environmentDialect: _angular_core.Signal<SqlDialectKind | undefined>;
+    /** Vero finche' non e' arrivata la prima risposta: la UI non deve dire "nessun problema". */
+    readonly hasResult: _angular_core.Signal<boolean>;
+    constructor();
+    /** Anteprima dell'SQL. Opzionale sull'host: assente, il comando resta disabilitato. */
+    requestPreview(parameterValues?: DpeParameterValue[]): void;
+    /**
+     * Salvataggio attraverso `DpeBuilderApi.save` (opzionale, `contracts.md` §7). Al successo
+     * **l'editor dichiara da se'** lo stato salvato: quando l'ospite espone il metodo, e' questo il
+     * punto che sa se e' andato a buon fine.
+     *
+     * Si passa a `markSaved` **il documento inviato**, non quello corrente: se l'utente scrive
+     * mentre il salvataggio e' in volo, quelle modifiche non sono state salvate e l'indicatore deve
+     * continuare a dirlo.
+     */
+    save(): void;
+    dismissError(): void;
+    dismissSaveError(): void;
+    private saveNoticeTimer;
+    private showSaveNotice;
+    private clearSaveNotice;
+    /**
+     * Un host che non usa `DpeApiError` non deve far esplodere l'editor: cio' che non e'
+     * categorizzato diventa `Transport`, che e' la categoria "riprovabile".
+     */
+    private toApiError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeValidationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeValidationService>;
+}
+
+/**
+ * Geometria della viewport: funzioni pure, nessun DOM.
+ *
+ * Serve a una sola domanda, che si pone quando si naviga da una diagnostica al nodo: **il nodo
+ * e' interamente in vista?** Se lo e', non si sposta niente — una panoramica non richiesta
+ * disorienta quanto la sua assenza. Se non lo e', si centra la **vista**, non il nodo: le
+ * coordinate del documento non si toccano.
+ *
+ * Sta qui e non nel componente perche' e' esattamente il tipo di logica che si sbaglia in
+ * silenzio (un `>` al posto di un `>=`, un margine dimenticato) e che si verifica senza browser.
+ */
+/** Rettangolo in coordinate di schermo, la forma che `getBoundingClientRect` restituisce. */
+interface DpeRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Vero quando `target` sta **interamente** dentro `view`, lasciando `margin` pixel di respiro su
+ * ogni lato. Il margine non e' un vezzo: un nodo tangente al bordo e' tecnicamente visibile e
+ * praticamente illeggibile, e senza respiro il criterio "e' visibile" scatterebbe anche quando
+ * dell'ombra e del connettore di uscita non si vede nulla.
+ */
+declare function dpeIsRectFullyVisible(target: DpeRect, view: DpeRect, margin?: number): boolean;
+
+/** Le tre viste in basso: una alla volta, perche' guardano la stessa cosa da tre angoli. */
+type DpeBottomTab = 'diagnostics' | 'schema' | 'sql';
+declare class DpeBuilderComponent {
+    protected readonly store: DpeDocumentStore;
+    protected readonly validation: DpeValidationService;
+    private readonly layout;
+    /** La definizione da editare. Cambiarne l'identita' ricarica il documento. */
+    readonly definition: _angular_core.InputSignal<DpeDefinition>;
+    readonly isEditable: _angular_core.InputSignal<boolean>;
+    /**
+     * Emessa a ogni mutazione. L'ospite **non deve** rimandarla dentro `definition`: sarebbe un
+     * ciclo, e ricaricare azzera la cronologia. Serve per salvare, non per pilotare l'editor.
+     */
+    readonly definitionChange: _angular_core.OutputEmitterRef<DpeDefinition>;
+    protected readonly dialectLabels: Readonly<Record<string, string>>;
+    protected readonly bottomTab: _angular_core.WritableSignal<DpeBottomTab>;
+    private readonly canvas;
+    /**
+     * Il dialetto **della definizione**: e' quello con cui il backend compilera' (ADR 0009), quindi
+     * e' quello che il badge mostra. In sola lettura: nessun comando dell'interfaccia lo cambia
+     * (ADR 0017), perche' il database di destinazione e' un fatto dell'ambiente e non una
+     * preferenza dell'autore.
+     */
+    protected readonly dialect: Signal<SqlDialectKind>;
+    /**
+     * Disallineamento fra cio' che l'ambiente dichiara e cio' che la definizione porta. Si
+     * **segnala** e non si corregge: correggere vorrebbe dire migrare le espressioni SQL native
+     * (ADR 0006), che e' dell'host. Assente `getEnvironment`, non c'e' niente da confrontare.
+     */
+    protected readonly dialectMismatch: Signal<SqlDialectKind | undefined>;
+    protected readonly canSave: Signal<boolean>;
+    protected readonly nodeCount: Signal<number>;
+    constructor();
+    /** Comando «Riordina»: e' un'azione dell'utente, quindi annullabile e "modifica". */
+    protected runAutoLayout(): void;
+    /**
+     * `isInitial` distingue due cose che dagre calcola allo stesso modo e che l'editor deve trattare
+     * in modo opposto: disporre un documento che **non porta** coordinate non e' una modifica
+     * dell'utente; riordinare su richiesta lo e'.
+     */
+    private runLayout;
+    protected onNodeDropped(event: {
+        collection: DpeNodeCollectionName;
+        x: number;
+        y: number;
+    }): void;
+    /** Clic sulla palette (via tastiera compresa): il nodo nasce in un punto libero e prevedibile. */
+    protected onNodeRequested(collection: DpeNodeCollectionName): void;
+    /**
+     * `Ctrl+S` (e `Cmd+S`): stesse condizioni di abilitazione del bottone. `preventDefault` sempre
+     * che la scorciatoia sia nostra, anche quando il salvataggio non e' possibile: lasciare passare
+     * il «salva pagina» del browser proprio dentro un editor sarebbe la risposta sbagliata a un
+     * gesto giusto.
+     */
+    protected onKeyDown(event: KeyboardEvent): void;
+    /**
+     * Navigazione da una diagnostica: **selezione e vista**. Il `DiagnosticPath` promette di portare
+     * sul nodo e sul campo; selezionare senza inquadrare mantiene meta' della promessa, e il nodo
+     * resta fuori schermo mentre l'ispettore parla di lui.
+     */
+    protected onNavigate(event: {
+        nodeName: string;
+    }): void;
+    /**
+     * Stato **sporco** del documento, per l'ospite che deve decidere se lasciar navigare via
+     * (ADR 0019). Delega a `DpeDocumentStore.isDirty`.
+     *
+     * Si legge tramite `viewChild` **quando serve**, non si rispecchia in uno stato dell'ospite: un
+     * mirror di stato sporco che va fuori sincrono e' peggio del problema che risolve. La conferma
+     * prima di abbandonare le modifiche e' dell'ospite, perche' e' l'ospite che naviga — la libreria
+     * non sa se andare via significhi cambiare schermata, scheda o applicazione.
+     */
+    readonly isDirty: Signal<boolean>;
+    /**
+     * Da chiamare dopo un salvataggio riuscito: da quel momento il documento risulta "senza
+     * modifiche". Lo decide l'ospite, perche' solo lui sa se il salvataggio e' andato a buon fine.
+     */
+    markSaved(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeBuilderComponent, "dpe-builder", never, { "definition": { "alias": "definition"; "required": true; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "definitionChange": "definitionChange"; }, never, never, true, never>;
+}
+
+/**
+ * View model del canvas.
+ *
+ * Gli **id** non si costruiscono qui: vengono da `core/dpe-graph.ts`, che e' l'unico posto che
+ * li conosce. Qui stanno solo le misure, e stanno qui perche' servono a due consumatori che
+ * devono concordare: il CSS che disegna la card e dagre che calcola il layout. Se divergono,
+ * il layout automatico lascia i nodi sovrapposti.
+ */
+
+/** Altezza nominale della card: non cambia con il numero di porte, che stanno in fila sopra. */
+declare const DPE_NODE_HEIGHT = 104;
+declare function dpeNodeWidth(portCount: number): number;
+declare function dpeNodeWidthClass(portCount: number): string;
+interface DpeCanvasPort {
+    id: string;
+    slot: string;
+    index?: number;
+    /** Etichetta della porta: si mostra solo dove le porte sono piu' di una. */
+    label: string;
+    /** Nome collegato, assente se la porta e' libera. */
+    sourceName?: string;
+    /** Il nome collegato non corrisponde a nessun nodo: si dice sulla porta. */
+    isBroken: boolean;
+}
+interface DpeCanvasNode {
+    /** Nome nel documento: l'identita', anche per la selezione. */
+    name: string;
+    /** Id per il canvas, costruito da `dpeNodeId`. */
+    id: string;
+    collection: DpeNodeCollectionName;
+    categoryLabel: string;
+    label: string;
+    subtitle: string | null;
+    position: {
+        x: number;
+        y: number;
+    };
+    ports: DpeCanvasPort[];
+    showsPortLabels: boolean;
+    widthClass: string;
+    /**
+     * Classe della famiglia cromatica (`dpe-cat--*`): la calcola `core/dpe-node-icons.ts` dai
+     * flag del catalogo. Sta nel view model e non nel template perche' e' la stessa che usa la
+     * palette, e due modi di derivarla sarebbero due colori diversi per lo stesso tipo di nodo.
+     */
+    familyClass: string;
+    outputPortId: string;
+    /** I sink non producono uno schema: la porta di uscita non si disegna... */
+    hasOutput: boolean;
+    /** Gravita' peggiore fra le diagnostiche del nodo. */
+    severity: DiagnosticSeverity | null;
+    diagnosticCount: number;
+    /**
+     * Nodo **valido ma non compilabile** (**I10**): stato distinto da "non valido", con un
+     * colore proprio. Sono due situazioni diverse e l'utente deve capire subito quale guarda.
+     */
+    isNotCompilable: boolean;
+    /** Numero di colonne dello schema di uscita, quando il backend lo ha detto. */
+    columnCount: number | null;
+}
+interface DpeCanvasEdge {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    slot: string;
+}
+
+declare class DpeCanvasComponent {
+    private readonly store;
+    /** Serve per misurare l'area disponibile prima di decidere la scala d'apertura. */
+    private readonly host;
+    /** Marker "all states": senza, l'arco selezionato perde la punta. */
+    readonly markerEnd = EFMarkerType.END_ALL_STATES;
+    /**
+     * Ingressi in alto, uscita in basso, **dichiarati**. Lasciando calcolare il lato, un arco
+     * che risale (un nodo posizionato sopra la sua sorgente) esce di fianco e il grafo diventa
+     * illeggibile.
+     */
+    readonly sides: typeof EFConnectableSide;
+    readonly isEditable: _angular_core.InputSignal<boolean>;
+    readonly nodeOpened: _angular_core.OutputEmitterRef<string>;
+    readonly nodeDropped: _angular_core.OutputEmitterRef<{
+        collection: DpeNodeCollectionName;
+        x: number;
+        y: number;
+    }>;
+    private readonly canvas;
+    /**
+     * Serve solo a **riallineare** la selezione della libreria a quella dello store: e' l'unico
+     * punto che scrive nello stato di selezione di @foblex/flow.
+     */
+    private readonly flow;
+    private hasFramedOnce;
+    /**
+     * Visibilita' del comando «Inquadra». Non e' piu' «l'utente ha spostato la vista»: lo diventa
+     * anche all'apertura quando l'editor rinuncia a inquadrare per non scendere sotto
+     * `MIN_INITIAL_SCALE`. In quel caso la vista d'insieme non e' stata data, quindi il comando che
+     * la offre deve essere raggiungibile — nasconderlo significherebbe toglierla e basta.
+     */
+    private readonly _isFitCommandVisible;
+    readonly isFitCommandVisible: _angular_core.Signal<boolean>;
+    readonly nodes: _angular_core.Signal<DpeCanvasNode[]>;
+    /**
+     * Solo gli archi con **entrambi** i capi risolti diventano `<f-connection>`: un capo che non
+     * esiste non ha un connettore, e una connessione verso un id inesistente si attacca a un
+     * punto arbitrario del canvas. Il riferimento rotto si vede sulla porta del nodo.
+     */
+    readonly edges: _angular_core.Signal<DpeCanvasEdge[]>;
+    constructor();
+    /**
+     * Porta il nodo in vista **muovendo la vista**, non il nodo: le coordinate del documento non si
+     * toccano (una navigazione non e' una modifica). Se il nodo e' gia' interamente visibile non fa
+     * nulla, perche' una panoramica non richiesta disorienta quanto la sua assenza.
+     */
+    revealNode(name: string): void;
+    /**
+     * Il nodo nel DOM. Si scorre l'elenco invece di comporre un selettore con il valore
+     * dell'attributo: il nome del nodo arriva dal documento e puo' contenere qualunque carattere,
+     * e un selettore costruito per concatenazione su un dato del documento e' un errore in attesa.
+     */
+    private findNodeElement;
+    /** Misure per il layout automatico: le stesse che il CSS applica con le classi. */
+    layoutInput(): {
+        name: string;
+        width: number;
+        height: number;
+    }[];
+    /**
+     * `fitToScreen` va chiamato **dopo** il render dei nodi: prima, la libreria non conosce
+     * ancora le loro dimensioni e inquadra la vista sbagliata. Solo la prima volta: rifarlo
+     * combatterebbe con l'utente che ha spostato la vista.
+     */
+    onNodesRendered(): void;
+    /** Vero quando inquadrare tutto il grafo richiederebbe una scala sotto la soglia leggibile. */
+    private wouldFitBelowMinimumScale;
+    onCanvasChange(): void;
+    resetViewport(): void;
+    /**
+     * Creazione di un arco: si scrive il **riferimento** sulla porta di destinazione. La
+     * direzione del gesto e' irrilevante — cio' che conta e' quale slot riceve il nome, ed e'
+     * per questo che le porte di ingresso sono una per slot.
+     */
+    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: un solo passo di cronologia 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;
+    /**
+     * Il gesto di selezione della libreria entra **nello store** e non altrove: e' l'unico verso in
+     * cui la selezione di @foblex/flow conta, come rilevazione del gesto. Cio' che si vede lo decide
+     * lo store, attraverso l'effect del costruttore.
+     */
+    onSelectionChange(event: {
+        nodeIds: string[];
+    }): void;
+    onDeleteSelected(event: {
+        nodeIds: string[];
+    }): void;
+    /**
+     * Rilascio di una voce trascinata dalla palette. `externalItemRect` e' già nel sistema di
+     * coordinate del canvas: convertirlo a mano dal viewport sarebbe rifare la trasformazione
+     * di zoom e panoramica della libreria.
+     */
+    onCreateNode(event: {
+        data: unknown;
+        externalItemRect: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    onNodeDoubleClick(name: string): void;
+    onEditClick(event: Event, name: string): void;
+    onRemoveClick(event: Event, name: string): void;
+    /** La classe nel DOM **deriva** dallo store: non e' una seconda registrazione della selezione. */
+    isSelected(node: DpeCanvasNode): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeCanvasComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeCanvasComponent, "dpe-canvas", never, { "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "nodeOpened": "nodeOpened"; "nodeDropped": "nodeDropped"; }, never, never, true, never>;
+}
+
+declare class DpeCatalogComponent {
+    protected readonly store: DpeCatalogStore;
+    private readonly injector;
+    /**
+     * Il **nome** della definizione da aprire. Non la definizione: caricarla e' dell'ospite, che
+     * potrebbe volerlo fare per vie proprie.
+     */
+    readonly open: _angular_core.OutputEmitterRef<string>;
+    protected readonly dialectLabels: Readonly<Record<string, string>>;
+    /** Filtro **locale** sui sommari gia' ricevuti: non e' una query al backend (ADR 0019). */
+    protected readonly filter: _angular_core.WritableSignal<string>;
+    protected readonly newName: _angular_core.WritableSignal<string>;
+    protected readonly newLabel: _angular_core.WritableSignal<string>;
+    /**
+     * Conferma in **due passi**: un elenco in cui un clic distratto cancella non e' un elenco.
+     * Tiene il nome invece di un booleano perche' la conferma appartiene a **quella** riga.
+     */
+    protected readonly pendingDelete: _angular_core.WritableSignal<string | null>;
+    /** Riga in duplicazione, con i due campi del nome e dell'etichetta nuovi. */
+    protected readonly duplicateSource: _angular_core.WritableSignal<string | null>;
+    protected readonly duplicateName: _angular_core.WritableSignal<string>;
+    protected readonly duplicateLabel: _angular_core.WritableSignal<string>;
+    private readonly duplicateNameField;
+    /**
+     * Il filtro non tocca l'ordine: si tolgono righe, non si riordinano. `toLocaleLowerCase` e non
+     * `toLowerCase` perche' un elenco di definizioni italiane si filtra anche per lettere accentate.
+     */
+    protected readonly visible: _angular_core.Signal<readonly DpeDefinitionSummary[]>;
+    /** Vero quando il filtro ha nascosto tutto: e' un messaggio diverso da «nessuna definizione». */
+    protected readonly isFilteredEmpty: _angular_core.Signal<boolean>;
+    /**
+     * Duplicare richiede **due** primitive, `load` e `createDefinition`: non esiste una primitiva
+     * di duplicazione, il comando si compone da queste.
+     */
+    protected readonly canDuplicate: _angular_core.Signal<boolean>;
+    protected readonly duplicateReason: _angular_core.Signal<"Duplica: carica questa definizione e la ricrea con un nome nuovo" | "Duplicazione non disponibile: questo ambiente non implementa load e createDefinition.">;
+    /** Validazione **di forma**, l'unica ammessa nel frontend: due campi non vuoti. */
+    protected readonly canSubmitNew: _angular_core.Signal<boolean>;
+    protected readonly canSubmitDuplicate: _angular_core.Signal<boolean>;
+    protected onOpen(name: string): void;
+    protected refresh(): void;
+    /**
+     * Crea e **apre il nome tornato dall'ospite**, non quello digitato: l'ospite puo' averlo
+     * normalizzato, e aprire quello digitato aprirebbe una definizione che non esiste.
+     */
+    protected createNew(): void;
+    protected startDuplicate(summary: DpeDefinitionSummary): void;
+    protected cancelDuplicate(): void;
+    protected confirmDuplicate(): void;
+    protected askDelete(name: string): void;
+    protected cancelDelete(): void;
+    protected confirmDelete(name: string): void;
+    /** Solo la data, senza ora: un elenco non e' un registro di audit. */
+    protected formatDate(value: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeCatalogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeCatalogComponent, "dpe-catalog", never, {}, { "open": "open"; }, never, never, true, never>;
+}
+
+/** Un gruppo dell'elenco: intestazione e voci. Presentazione, non semantica. */
+interface DpeNodePaletteGroup {
+    key: 'sources' | 'transforms' | 'sinks';
+    label: string;
+    categories: readonly DpeNodeCategory[];
+}
+declare class DpeNodePaletteComponent {
+    /** Clic sulla voce: il nodo si crea al centro dell'area, non dove stava il puntatore. */
+    readonly nodeRequested: _angular_core.OutputEmitterRef<keyof _esfaenza_dpe_builder.DpeNodeCollectionMap>;
+    protected readonly filter: _angular_core.WritableSignal<string>;
+    readonly visible: _angular_core.Signal<readonly DpeNodeCategory[]>;
+    /**
+     * Tre gruppi, nell'ordine in cui si costruisce una pipeline: da dove entrano i dati, cosa ci
+     * si fa, dove finiscono. I gruppi vuoti non compaiono, altrimenti una ricerca lascerebbe sullo
+     * schermo intestazioni senza voci.
+     */
+    readonly groups: _angular_core.Signal<readonly DpeNodePaletteGroup[]>;
+    protected familyClass(category: DpeNodeCategory): string;
+    /** Il testo che la descrizione non mostra piu' nel corpo della voce. */
+    protected titleOf(category: DpeNodeCategory): string;
+    protected text(event: Event): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeNodePaletteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeNodePaletteComponent, "dpe-node-palette", never, {}, { "nodeRequested": "nodeRequested"; }, never, never, true, never>;
+}
+
+declare class DpeNodeInspectorComponent {
+    private readonly store;
+    /**
+     * Il riordino richiede le misure delle card, che le conosce il canvas: l'ispettore **chiede**,
+     * non calcola. Componente stupido, orchestrazione fuori.
+     */
+    readonly layoutRequested: _angular_core.OutputEmitterRef<void>;
+    readonly selectedNames: _angular_core.Signal<readonly string[]>;
+    readonly located: _angular_core.Signal<_esfaenza_dpe_builder.DpeLocatedNode<keyof _esfaenza_dpe_builder.DpeNodeCollectionMap> | undefined>;
+    readonly nameDraft: _angular_core.WritableSignal<string>;
+    readonly categoryLabel: _angular_core.Signal<string>;
+    /** La classe di famiglia dell'icona: la stessa funzione che usano palette e canvas. */
+    readonly familyClass: _angular_core.Signal<string>;
+    readonly columns: _angular_core.Signal<_esfaenza_dpe_builder.DpeColumnInfo[]>;
+    readonly diagnostics: _angular_core.Signal<_esfaenza_dpe_builder.Diagnostic[]>;
+    readonly referenceCount: _angular_core.Signal<number>;
+    readonly canRename: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Elimina i nodi selezionati. Si itera su una **copia** dei nomi: `removeNode` pota la selezione
+     * a ogni giro, e scorrere il signal mentre lo si svuota salterebbe la meta' dei nodi.
+     */
+    protected removeSelected(): void;
+    protected rename(currentName: string): void;
+    protected setCommon(field: 'label' | 'description', value: string): void;
+    protected valueOf(event: Event): string;
+    protected asDataSource(node: unknown): DataSourceNode;
+    protected asFilter(node: unknown): FilterNode;
+    protected asJoin(node: unknown): JoinNode;
+    protected asAggregate(node: unknown): AggregateNode;
+    protected asTransform(node: unknown): TransformNode;
+    protected asAppend(node: unknown): AppendNode;
+    protected asHierarchy(node: unknown): HierarchyPathNode;
+    protected asForecast(node: unknown): ForecastNode;
+    protected asCustom(node: unknown): CustomNode;
+    protected asWriteback(node: unknown): WritebackNode;
+    protected asAtomic(node: unknown): AtomicWritebackNode;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeNodeInspectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeNodeInspectorComponent, "dpe-node-inspector", never, {}, { "layoutRequested": "layoutRequested"; }, never, never, true, never>;
+}
+
+declare abstract class DpeNodeInspectorBase<TNode extends DpeAnyNode = DpeAnyNode> {
+    protected readonly store: DpeDocumentStore;
+    readonly nodeName: _angular_core.InputSignal<string>;
+    readonly node: _angular_core.InputSignal<TNode>;
+    /** La collezione di appartenenza: la sa l'ispettore, serve per scrivere nello store. */
+    abstract readonly collection: DpeNodeCollectionName;
+    /** Le diagnostiche ancorate a questo nodo, come le ha date il backend (**I6**). */
+    readonly diagnostics: _angular_core.Signal<readonly Diagnostic[]>;
+    /**
+     * Il nodo e' valido ma non compilabile (**I10**): l'ispettore lo dice in testa, perche' e'
+     * l'informazione che spiega perche' non compare nessun SQL — e non c'e' niente da correggere.
+     */
+    readonly isNotCompilable: _angular_core.Signal<boolean>;
+    /** Colonne prodotte dal nodo, secondo il backend. Mai calcolate qui (**I4**). */
+    readonly outputColumns: _angular_core.Signal<readonly DpeColumnInfo[]>;
+    /**
+     * Colonne disponibili **in ingresso**: l'unione degli schemi dei nodi a monte, nell'ordine.
+     * Arrivano dal backend; se la validazione non e' ancora tornata l'elenco e' vuoto e i campi
+     * si digitano a mano — che e' meglio di un elenco indovinato in locale.
+     */
+    readonly inputColumns: _angular_core.Signal<readonly DpeColumnInfo[]>;
+    /** I parametri dichiarati sulla radice: servono a filtri e mapping dei writeback. */
+    readonly parameters: _angular_core.Signal<_esfaenza_dpe_builder.DpeParameter[]>;
+    /** Le diagnostiche su un campo preciso, per mostrarle **accanto** al controllo. */
+    issuesOn(field: string): Diagnostic[];
+    hasIssueOn(field: string): boolean;
+    /** Applica una modifica al nodo. */
+    protected patch(patch: Partial<TNode>): void;
+    /**
+     * Campo semplice: valore vuoto → chiave **rimossa**, non stringa vuota. Il backend
+     * distingue assente da vuoto (`DPE_MODEL_REQUIRED_MISSING` contro un valore non valido), e
+     * su Oracle la stringa vuota **e'** `NULL`: scriverla al posto di un'assenza cambia la
+     * semantica invece di ripulire il campo.
+     */
+    protected setField(field: keyof TNode & string, value: unknown): void;
+    /** Numero da un campo di testo: vuoto o non numerico → assente, non `0`. */
+    protected toNumber(value: string): number | undefined;
+    /** Lettura tipizzata di un valore da un evento di input, senza `any` nei template. */
+    protected valueOf(event: Event): string;
+    protected checkedOf(event: Event): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeNodeInspectorBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DpeNodeInspectorBase<any>, never, never, { "nodeName": { "alias": "nodeName"; "required": true; "isSignal": true; }; "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface DpeDiagnosticRow {
+    diagnostic: Diagnostic;
+    location: string;
+    /** Nodo a cui navigare, se il percorso permette di ricavarlo. */
+    nodeName?: string;
+    field?: string;
+    isNotCompilable: boolean;
+    isDialect: boolean;
+}
+declare class DpeDiagnosticsPanelComponent {
+    private readonly store;
+    /** Emesso quando la riga porta a un nodo: chi ascolta apre l'ispettore e inquadra il nodo. */
+    readonly navigate: _angular_core.OutputEmitterRef<{
+        nodeName: string;
+        field?: string;
+    }>;
+    readonly hasResult: _angular_core.Signal<boolean>;
+    readonly dialectLabel: _angular_core.Signal<string>;
+    readonly rows: _angular_core.Signal<DpeDiagnosticRow[]>;
+    readonly counts: _angular_core.Signal<{
+        errors: number;
+        warnings: number;
+        infos: number;
+        notCompilable: number;
+    }>;
+    /**
+     * Emette **soltanto** l'intenzione: chi la riceve seleziona e inquadra. Selezionare anche da qui
+     * significherebbe due scritture della selezione per un solo clic — la strada per due nodi
+     * selezionati insieme — e un pannello che pilota il canvas invece di chiederglielo.
+     */
+    protected navigateTo(row: DpeDiagnosticRow): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeDiagnosticsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeDiagnosticsPanelComponent, "dpe-diagnostics-panel", never, {}, { "navigate": "navigate"; }, never, never, true, never>;
+}
+
+interface DpeSchemaRow {
+    nodeName: string;
+    categoryLabel: string;
+    isSelected: boolean;
+    isCompilable: boolean;
+    hasSchema: boolean;
+    inputColumns: readonly DpeColumnInfo[];
+    outputColumns: readonly DpeColumnInfo[];
+    /** Colonne in uscita che non esistono in ingresso: alias nuovi o colonne prodotte dal nodo. */
+    introduced: ReadonlySet<string>;
+    /** Colonne in ingresso che non arrivano in uscita: eliminate o rinominate. */
+    dropped: readonly string[];
+}
+declare class DpeSchemaPanelComponent {
+    private readonly store;
+    readonly hasResult: _angular_core.Signal<boolean>;
+    readonly rows: _angular_core.Signal<DpeSchemaRow[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeSchemaPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeSchemaPanelComponent, "dpe-schema-panel", never, {}, {}, never, never, true, never>;
+}
+
+interface DpeSqlSection {
+    title: string;
+    hint: string;
+    writebacks: readonly DpeCompiledWriteback[];
+}
+declare class DpeSqlPreviewComponent {
+    private readonly store;
+    protected readonly validation: DpeValidationService;
+    readonly result: _angular_core.Signal<_esfaenza_dpe_builder.DpeCompileResult | undefined>;
+    readonly sections: _angular_core.Signal<DpeSqlSection[]>;
+    readonly isEmpty: _angular_core.Signal<boolean>;
+    /** Il valore di un parametro e' opaco: si mostra, non si converte. */
+    protected display(value: unknown): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeSqlPreviewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeSqlPreviewComponent, "dpe-sql-preview", never, {}, {}, never, never, true, never>;
+}
+
+declare class DpeExpressionEditorComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly dialect: _angular_core.InputSignal<SqlDialectKind>;
+    /**
+     * I nomi delle colonne a monte, **come suggerimento** e non come elenco chiuso: sono cio'
+     * che il backend ha propagato, ma dentro l'espressione si puo' scrivere qualunque SQL.
+     */
+    readonly columns: _angular_core.InputSignal<readonly string[]>;
+    readonly controlId: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    readonly dialectLabel: _angular_core.Signal<string>;
+    /** Elenco troncato: dieci nomi sono un aiuto, cinquanta sono un muro di testo. */
+    readonly columnHint: _angular_core.Signal<string>;
+    protected text(event: Event): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeExpressionEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeExpressionEditorComponent, "dpe-expression-editor", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dialect": { "alias": "dialect"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class DpeColumnTypeEditorComponent {
+    readonly value: _angular_core.InputSignal<ColumnType | undefined>;
+    readonly controlId: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<ColumnType>;
+    protected readonly types: readonly LogicalType[];
+    readonly kind: _angular_core.Signal<LogicalType>;
+    readonly allowedValues: _angular_core.Signal<string>;
+    protected onKind(kind: string): void;
+    protected onNumber(field: 'length' | 'precision' | 'scale', raw: string): void;
+    protected onAllowedValues(raw: string): void;
+    protected text(event: Event): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeColumnTypeEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeColumnTypeEditorComponent, "dpe-column-type-editor", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class DpeSelectValueDirective implements AfterViewChecked {
+    private readonly element;
+    readonly dpeValue: _angular_core.InputSignal<string | number | null | undefined>;
+    ngAfterViewChecked(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeSelectValueDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DpeSelectValueDirective, "select[dpeValue]", never, { "dpeValue": { "alias": "dpeValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DpeNodeIconComponent {
+    readonly collection: _angular_core.InputSignal<keyof _esfaenza_dpe_builder.DpeNodeCollectionMap>;
+    protected readonly paths: _angular_core.Signal<readonly string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeNodeIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeNodeIconComponent, "dpe-node-icon", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DPE_API_ERROR_FALLBACK_MESSAGE, DPE_BUILDER_HTTP_CONFIG, DPE_DIALECT_LABELS, DPE_LAYOUT_KEY, DPE_NODE_CATEGORIES, DPE_NODE_COLLECTIONS, DPE_NODE_HEIGHT, DPE_NODE_ICON_PATHS, DPE_NODE_NOT_COMPILABLE, DPE_SOURCE_SLOTS, DpeApiError, DpeBuilderApi, DpeBuilderComponent, DpeCanvasComponent, DpeCatalogComponent, DpeCatalogStore, DpeColumnTypeEditorComponent, DpeDiagnosticsPanelComponent, DpeDocumentStore, DpeExpressionEditorComponent, DpeLayoutService, DpeMetadataStore, DpeNodeIconComponent, DpeNodeInspectorBase, DpeNodeInspectorComponent, DpeNodePaletteComponent, DpeSchemaPanelComponent, DpeSelectValueDirective, DpeSqlPreviewComponent, DpeValidationService, HttpDpeBuilderApi, diagnosticPathToString, dpeAllNodes, dpeBuildGraph, dpeCountReferences, dpeCreateCommandAvailability, dpeCreateNode, dpeDefinitionLevelDiagnostics, dpeDiagnosticField, dpeDiagnosticLocationLabel, dpeDiagnosticNodeName, dpeEdgeId, dpeEmptyDefinition, dpeFindNode, dpeGroupDiagnosticsByNode, dpeHasCompleteLayout, dpeInputPortId, dpeInputPorts, dpeIsDialectDiagnostic, dpeIsNotCompilable, dpeIsPrimitiveAvailable, dpeIsRectFullyVisible, dpeKnownNodeNames, dpeNodeCategory, dpeNodeIconFamily, dpeNodeIconFamilyClass, dpeNodeIconPaths, dpeNodeId, dpeNodeSourceReferences, dpeNodeSubtitle, dpeNodeWidth, dpeNodeWidthClass, dpeOutputPortId, dpeParseInputPortId, dpeParseNodeId, dpeParseOutputPortId, dpeProposeNodeName, dpeProposeWritebackSequence, dpeReadCapabilities, dpeReadNodePosition, dpeRenameNode, dpeWorstSeverity, dpeWriteNodePosition, dpeWriteSourceReference, provideDpeBuilderHttpApi };
+export type { AggregateField, AggregateFunction, AggregateNode, AppendNode, AtomicWritebackNode, AtomicWritebackRelationship, ColumnType, CsvArtifactOptions, CsvDelimiter, CsvSourceOptions, CustomNode, CustomNodeParameter, DataSourceField, DataSourceKind, DataSourceNode, DatePart, DeclaredField, DefinitionRunMode, DefinitionStatus, Diagnostic, DiagnosticPath, DiagnosticPathSegment, DiagnosticSeverity, DpeAnyNode, DpeApiErrorCategory, DpeBuilderHttpConfig, DpeCanvasEdge, DpeCanvasNode, DpeCanvasPort, DpeCapabilities, DpeColumnInfo, DpeCommandAvailability, DpeCompileResult, DpeCompiledWriteback, DpeDefinition, DpeDefinitionSummary, DpeEnvironment, DpeExtensible, DpeExtensionData, DpeFieldMappingInfo, DpeGraph, DpeGraphEdge, DpeGraphNode, DpeInputPort, DpeLayoutDirection, DpeLayoutEdgeInput, DpeLayoutNodeInput, DpeLayoutOptions, DpeLayoutPosition, DpeLocatedNode, DpeNode, DpeNodeCategory, DpeNodeCollectionMap, DpeNodeCollectionName, DpeNodeDiagnostics, DpeNodeIconFamily, DpeNodePaletteGroup, DpeNodePosition, DpeNodeSchemaInfo, DpeOptionalPrimitive, DpeParameter, DpeParameterValue, DpeRect, DpeSourceReference, DpeSourceSlot, DpeTableState, DpeValidateResult, DpeWritebackStep, ExpressionField, FieldDescriptor, FieldRelationship, FilterCriterion, FilterNode, FilterOperator, ForecastAccuracy, ForecastAggregationField, ForecastGroupField, ForecastModelType, ForecastNode, ForecastPeriodType, HierarchyPathNode, JoinKey, JoinKind, JoinNode, JoinResultField, JsonArtifactOptions, LogicalType, OrderByField, ParameterRole, SortDirection, SqlDialectKind, SqlParameterValue, SqlStatement, TableDescriptor, TableLookupOutcome, TableLookupResult, TableSummary, TransformKind, TransformNode, WritebackFieldMapping, WritebackFieldRole, WritebackNode, WritebackOperation, WritebackTargetKind };