@uipath/maestro-builder-sdk 6.6.0 → 6.7.0

package/dist/check.js

@@ -116,7 +116,17 @@ function checkFlow(built, ancestors, opts = {}) {
     // decision waits until the expressions are collected (see
     // HITL_OUTCOMES_UNREACHABLE below).
     const hitlChoiceNoPorts = new Map();
-    const dataFabricUpdates = [];
+    // Data Fabric writes that target a record `{ fromRead: '<step>' }` — update and
+    // delete share the selector, so they share the check.
+    const dataFabricRefs = [];
+    // Delete step names. `core.datafabric.delete` is the one verb of the family
+    // whose definition declares NO outputDefinition, so `$vars.<delete>.output` is
+    // undefined at run time (see DATAFABRIC_DELETE_HAS_NO_OUTPUT below).
+    const dataFabricDeletes = new Set();
+    // Reads that return a LIST. A multi-record read is refused as a write target
+    // (see DATAFABRIC_FROMREAD_MULTIPLE below) — the serializer emits a plain
+    // no-op task for the write, and nothing at any rung reports it.
+    const dataFabricMultiReads = new Set();
     // Placeholder (`mock()`) step names. The platform's `core.logic.mock` declares
     // one output whose `source` is the literal `"null"` — it publishes nothing —
     // so `$vars.<mock>.output` is null at run time, always (see
@@ -435,24 +445,52 @@ function checkFlow(built, ancestors, opts = {}) {
                         });
                     }
                 }
-                if (s.spec.kind === 'dataFabricRead' || s.spec.kind === 'dataFabricUpdate') {
+                if (s.spec.kind === 'dataFabricRead' || s.spec.kind === 'dataFabricCreate'
+                    || s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
                     if (!String(s.spec.inputs.entity ?? '').trim()) {
                         diags.push({
                             level: 'error', code: 'DATAFABRIC_NO_ENTITY', step: s.name,
                             message: `"${s.name}" names no Data Fabric entity. Set { entity: '<entity name>' }.`,
                         });
                     }
+                    if (s.spec.kind === 'dataFabricRead') {
+                        dataFabricReads.add(s.name);
+                        if (s.spec.inputs.resultMode === 'multiple')
+                            dataFabricMultiReads.add(s.name);
+                        checkDataFabricQuery(s.name, s.spec.inputs, diags);
+                    }
+                    if (s.spec.kind === 'dataFabricCreate') {
+                        // Not the same failure as an empty update: a BLANK value is omitted
+                        // from the insert so the column default applies, so an all-blank
+                        // `fieldValues` serializes to an empty body and runs green having
+                        // inserted nothing. The node's schema rejects that — and the fix is
+                        // a real value, never a placeholder to satisfy the rule.
+                        const written = Object.values(s.spec.inputs.values ?? {})
+                            .filter((v) => (v instanceof Expr ? true : String(v ?? '').trim() !== ''));
+                        if (written.length === 0) {
+                            diags.push({
+                                level: 'error', code: 'DATAFABRIC_EMPTY_VALUES', step: s.name,
+                                message: `"${s.name}" sets no column to a non-blank value, so it would insert nothing and run green. `
+                                    + 'The node\'s schema rejects that — give a real column a real value rather than a placeholder.',
+                            });
+                        }
+                        checkDataFabricColumns(s.name, Object.keys(s.spec.inputs.values ?? {}), 'values', diags);
+                    }
                     if (s.spec.kind === 'dataFabricUpdate') {
-                        dataFabricUpdates.push({ step: s.name, inputs: s.spec.inputs });
                         if (Object.keys(s.spec.inputs.set ?? {}).length === 0) {
                             diags.push({
                                 level: 'error', code: 'DATAFABRIC_EMPTY_SET', step: s.name,
                                 message: `"${s.name}" writes no columns — { set } is empty, so the update would no-op green.`,
                             });
                         }
+                        checkDataFabricColumns(s.name, Object.keys(s.spec.inputs.set ?? {}), 'set', diags);
                     }
-                    else {
-                        dataFabricReads.add(s.name);
+                    checkDataFabricScope(s.name, s.spec.inputs, diags);
+                    if (s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
+                        const factory = s.spec.kind === 'dataFabricUpdate' ? 'dataFabricUpdate' : 'dataFabricDelete';
+                        dataFabricRefs.push({ step: s.name, factory, record: s.spec.inputs.record });
+                        if (s.spec.kind === 'dataFabricDelete')
+                            dataFabricDeletes.add(s.name);
                     }
                 }
                 if (s.spec.kind === 'ixpExtract')
@@ -729,12 +767,27 @@ function checkFlow(built, ancestors, opts = {}) {
         }
     }
     reportUnreachableHitlOutcomes(hitlChoiceNoPorts, exprs, diags);
-    for (const { step, inputs } of dataFabricUpdates) {
-        const fromRead = inputs.record?.fromRead;
-        if (typeof fromRead === 'string' && !dataFabricReads.has(fromRead)) {
+    for (const { step, factory, record } of dataFabricRefs) {
+        const fromRead = record?.fromRead;
+        if (typeof fromRead !== 'string')
+            continue;
+        if (!dataFabricReads.has(fromRead)) {
             diags.push({
                 level: 'error', code: 'DATAFABRIC_FROMREAD_UNKNOWN', step,
                 message: `"${step}" targets record: { fromRead: ${JSON.stringify(fromRead)} }, but no dataFabricRead step has that name.`,
+                suggestion: `${factory}({ …, record: { byId: '<record id>' } })`,
+            });
+            continue;
+        }
+        // A LIST is not a write target: the serializer refuses it and emits a plain
+        // no-op task, so the flow validates, runs green, and writes nothing.
+        if (dataFabricMultiReads.has(fromRead)) {
+            diags.push({
+                level: 'error', code: 'DATAFABRIC_FROMREAD_MULTIPLE', step,
+                message: `"${step}" targets record: { fromRead: ${JSON.stringify(fromRead)} }, but "${fromRead}" is a `
+                    + "resultMode: 'multiple' query. A multi-record read is refused as a write target — the step compiles to "
+                    + 'a no-op and the run goes green having written nothing.',
+                suggestion: `loop the results and target each record with ${factory}({ …, record: { byId: … } })`,
             });
         }
     }
@@ -1002,6 +1055,20 @@ function checkFlow(built, ancestors, opts = {}) {
                 });
                 continue;
             }
+            // A Data Fabric delete is the one verb of that family whose definition
+            // declares no outputDefinition at all — the record is gone, so there is
+            // nothing to publish. Read the record on the step that FOUND it instead,
+            // which on the `{ fromRead }` form is already in the flow.
+            if (dataFabricDeletes.has(name)) {
+                diags.push({
+                    level: 'error',
+                    code: 'DATAFABRIC_DELETE_HAS_NO_OUTPUT',
+                    message: `Delete "${name}" produces no output, but "$vars.${name}${field ? '.' + field : ''}" reads one in "${step}". `
+                        + 'A Data Fabric delete declares no outputs — take the value off the dataFabricRead step that found the record, before the delete.',
+                    step,
+                });
+                continue;
+            }
             if (delayNames.has(name)) {
                 diags.push({
                     level: 'error',
@@ -4635,6 +4702,102 @@ function checkCaseValueTypes(s, typeOf, diags, triggerId) {
  * `output` is the aggregate (after the loop) and `error` the failure detail.
  */
 const LOOP_FIELDS = new Set(['currentItem', 'currentIndex', 'collection', 'output', 'error']);
+/**
+ * Columns Data Fabric assigns and never accepts a write for.
+ *
+ * The canvas hides them from both write editors, but the serializer has no
+ * guard: a hand-authored `Id` row satisfies the node's own "at least one field"
+ * rule, ships in the body, and is rejected — and the rejection is only logged,
+ * so the row comes back unchanged and the run goes green.
+ */
+const DATAFABRIC_SYSTEM_COLUMNS = new Set(['Id', 'CreateTime', 'CreatedBy', 'UpdateTime', 'UpdatedBy']);
+function checkDataFabricColumns(step, columns, option, diags) {
+    const system = columns.filter((c) => DATAFABRIC_SYSTEM_COLUMNS.has(c));
+    if (system.length) {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_SYSTEM_COLUMN', step,
+            message: `"${step}" writes ${system.map((c) => JSON.stringify(c)).join(', ')} in { ${option} }. `
+                + 'Data Fabric assigns its system columns (Id, CreateTime, CreatedBy, UpdateTime, UpdatedBy) and rejects a '
+                + 'write to them — and it only LOGS the rejection, so the row comes back unchanged and the run goes green.',
+        });
+    }
+}
+/**
+ * A folder-scoped entity is portable only with its `Entity` bindings.
+ *
+ * `_folderKey` on its own still serializes — it falls back to a source-org
+ * literal and logs a warning — so the flow looks fine until it is deployed to
+ * another org. Refusing the half-authored pair here is the whole point: the
+ * alternative is a defect that only appears at deploy time, in a different org,
+ * to somebody else.
+ */
+function checkDataFabricScope(step, inputs, diags) {
+    if (inputs.folderKey !== undefined && inputs.resourceKey === undefined) {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_FOLDER_NO_RESOURCE_KEY', step,
+            message: `"${step}" sets { folderKey } without { resourceKey }. A folder-scoped entity needs both — with only `
+                + 'the folder key the entity serializes as a source-org literal, which validates, runs in this org, and '
+                + 'breaks on deploy to another one.',
+            suggestion: 'resolve the key with `uip solution resources list --kind Entity`, or drop { folderKey } and keep '
+                + 'the entity tenant-scoped',
+        });
+    }
+    if (inputs.resourceKey !== undefined && inputs.folderKey === undefined) {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_RESOURCE_KEY_NO_FOLDER', step,
+            message: `"${step}" sets { resourceKey } without { folderKey }. The pair exists to scope a FOLDER entity; a `
+                + 'tenant-scoped entity needs neither and serializes as a dotted literal.',
+        });
+    }
+}
+/**
+ * The query options, none of which the node's `inputDefinition` declares — they
+ * are `_`-prefixed extras, so `uip maestro flow validate` checks none of them
+ * and every mistake here is silent at run time.
+ */
+function checkDataFabricQuery(step, inputs, diags) {
+    const listOnly = ['limit', 'skip', 'sort', 'fields'].filter((k) => inputs[k] !== undefined);
+    if (listOnly.length && inputs.resultMode !== 'multiple') {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE', step,
+            message: `"${step}" sets { ${listOnly.join(', ')} }, which only a list query uses, but its resultMode is `
+                + `${inputs.resultMode ? JSON.stringify(inputs.resultMode) : 'unset (a single-record read)'}.`,
+            suggestion: "resultMode: 'multiple'",
+        });
+    }
+    // The emitted query ALWAYS carries a limit — omitted it resolves to 100 — and
+    // 1000 is a hard ceiling that TRUNCATES rather than erroring above it.
+    if (inputs.limit !== undefined && (!Number.isInteger(inputs.limit) || inputs.limit < 1 || inputs.limit > 1000)) {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_LIMIT_RANGE', step,
+            message: `"${step}": limit must be a whole number between 1 and 1000 (got ${inputs.limit}). 1000 is a hard `
+                + 'ceiling — a larger value truncates silently, so page with { skip } instead.',
+        });
+    }
+    // `in` is honoured only on a list query; on a single read the row compiles
+    // away, and a read whose filters compiled away returns EVERY record.
+    if (inputs.resultMode !== 'multiple' && (inputs.filters ?? []).some((f) => f.operator === 'in')) {
+        diags.push({
+            level: 'error', code: 'DATAFABRIC_IN_REQUIRES_MULTIPLE', step,
+            message: `"${step}" filters with the 'in' operator, which is honoured only when resultMode is 'multiple'. `
+                + 'On a single-record read that row compiles away — and a read whose filters compiled away matches every record.',
+        });
+    }
+    // A filter expression switched on and left blank is refused by the serializer,
+    // and it refuses the WHOLE query rather than dropping the row, which strands
+    // every downstream reference to this step.
+    for (const f of inputs.filters ?? []) {
+        const blank = f.value instanceof Expr ? f.value.js.trim() === '' : String(f.value ?? '').trim() === '';
+        if (blank) {
+            diags.push({
+                level: 'error', code: 'DATAFABRIC_FILTER_BLANK_VALUE', step,
+                message: `"${step}" has a filter on ${JSON.stringify(f.field)} with a blank value. The serializer refuses the `
+                    + 'ENTIRE query rather than dropping the row, so the step emits nothing and every downstream $vars read of '
+                    + 'it breaks.',
+            });
+        }
+    }
+}
 function collectActionExprs(s, out, errorSource) {
     const push = (val) => {
         if (val instanceof Expr && !val.literal)
@@ -4691,6 +4854,30 @@ function collectActionExprs(s, out, errorSource) {
             push(val);
         return;
     }
+    if (s.spec.kind === 'dataFabricRead' || s.spec.kind === 'dataFabricCreate'
+        || s.spec.kind === 'dataFabricUpdate' || s.spec.kind === 'dataFabricDelete') {
+        // Every value a Data Fabric step carries is authored against flow scope: a
+        // filter's comparison value, the record id, the columns written. The family
+        // was missing here entirely, so a `$vars.` typo in any of them travelled to
+        // the platform unchecked — and the delete verb's no-output rule below has
+        // nothing to fire on until these are collected.
+        if (s.spec.kind === 'dataFabricRead') {
+            for (const f of s.spec.inputs.filters ?? [])
+                push(f.value);
+            return;
+        }
+        if (s.spec.kind === 'dataFabricCreate') {
+            for (const val of Object.values(s.spec.inputs.values ?? {}))
+                push(val);
+            return;
+        }
+        push(s.spec.inputs.record?.byId);
+        if (s.spec.kind === 'dataFabricUpdate') {
+            for (const val of Object.values(s.spec.inputs.set ?? {}))
+                push(val);
+        }
+        return;
+    }
     if (s.spec.kind === 'connector') {
         // Same gap on the connector surface: `messageToSend: tmpl`…${v('typo')}``
         // reached the runtime unchecked.

package/dist/core/actions.d.ts

@@ -2016,46 +2016,215 @@ export interface QueueItemInputs {
      */
     returns?: Record<string, ReturnFieldType>;
 }
-/** One filter row on a Data Fabric read — rows AND together unless `or` is set. */
+/**
+ * The comparison operators the Data Fabric query serializer can emit, spelled
+ * exactly as the file carries them.
+ *
+ * @remarks
+ * There is deliberately no `not in`, `not contains`, or null check — the
+ * serializer cannot emit them, and a filter it cannot emit takes the WHOLE
+ * query down rather than dropping one row. `is any of` is the legacy spelling
+ * of `in` and is still read, but author `in`.
+ */
+export type DataFabricOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'contains' | 'starts with' | 'ends with' | 'in';
+/** One filter row on a Data Fabric query — rows AND together unless `or` is set. */
 export interface DataFabricFilter {
-    /** The entity column to filter on. */
+    /**
+     * The entity column to filter on. A dotted related path (`customer.Name`) is
+     * capped at 3 segments and needs the canvas's `_entityFields` snapshot, which
+     * the SDK does not author — keep from-scratch filters on the entity's own
+     * columns.
+     */
     field: string;
-    /** Comparison operator the designer offers — `=` (the default), `!=`, `>`, `>=`, `<`, `<=`, `contains`, … */
-    operator?: string;
-    /** The comparison value. An `Expr` re-evaluates at activation time. */
+    /** Comparison operator; `=` when omitted. */
+    operator?: DataFabricOperator;
+    /**
+     * The comparison value. An `Expr` re-evaluates at activation time.
+     *
+     * A choice-set column compares against the choice's numeric `numberId`, never
+     * its label — a label matches nothing.
+     */
     value: string | Expr;
-    /** Join this row to the PREVIOUS one with OR instead of AND. */
+    /**
+     * Start a new OR alternative at this row.
+     *
+     * @remarks
+     * The query model is disjunctive — `alt1 OR alt2 OR …`, each alternative an
+     * AND of its own rows — so `or` SPLITS the list rather than joining one row
+     * to the one before it. `[A, B(or), C]` is therefore `A OR (B AND C)`, not
+     * `(A OR B) AND C`; to get the latter, write it out as
+     * `(A AND C) OR (B AND C)`.
+     *
+     * Ignored on the first row, which has no earlier alternative to split from.
+     */
     or?: boolean;
 }
+/** How a multi-record query orders its rows before the limit is applied. */
+export interface DataFabricSort {
+    /** The column to order by — a real one; a sort on a missing column is not caught by `validate`. */
+    field: string;
+    /** `'asc'` when omitted. */
+    direction?: 'asc' | 'desc';
+}
+/**
+ * Which record a Data Fabric write targets — exactly ONE of the two forms.
+ *
+ * @remarks
+ * `{ byId }` names a record id, literal or expression. `{ fromRead }` names an
+ * earlier {@link dataFabricRead} STEP and reuses the record that step found, so
+ * the id never has to be carried by hand; `check` rejects a name no read step
+ * has. Shared by {@link dataFabricUpdate} and {@link dataFabricDelete} — the
+ * platform gives them the same `recordSource` shape.
+ */
+export type DataFabricRecordRef = {
+    byId: string | Expr;
+    fromRead?: never;
+} | {
+    fromRead: string;
+    byId?: never;
+};
 export interface DataFabricReadInputs {
     /** The Data Fabric entity's name, e.g. `'Invoices'`. */
     entity: string;
-    /** Filter rows selecting the record to read. Omit to read the first record. */
+    /** Filter rows selecting the record(s) to query. Omit to take everything the entity holds. */
     filters?: DataFabricFilter[];
-    /** Folder key (GUID) for folder-scoped entities. */
+    /**
+     * `'single'` publishes ONE record as the step's `output`; `'multiple'`
+     * publishes the matching records under `output.results`.
+     *
+     * Setting either selects the node's **1.4** definition, which is where
+     * `resultMode` exists at all — the SDK's pinned default is 1.0, the
+     * read-one-record node this family started as. Omit it and nothing changes:
+     * the step stays on 1.0 and reads one record, as it always did.
+     *
+     * A `'single'` read faults only on an OVER-match; zero matches completes
+     * normally and leaves the step's output unresolved, so treat "not found" as a
+     * branch rather than an error.
+     */
+    resultMode?: 'single' | 'multiple';
+    /**
+     * Row cap for a `'multiple'` query. The emitted query ALWAYS carries a limit:
+     * omitting this resolves to 100, and 1000 is a hard ceiling — a larger value
+     * truncates silently, so page with `skip` instead.
+     */
+    limit?: number;
+    /** Rows to skip before the limit — the paging half of `limit`. */
+    skip?: number;
+    /** Order rows before the limit applies. Without it a limited slice is arbitrary. */
+    sort?: DataFabricSort;
+    /** Only these columns. Omit for every column the entity has. */
+    fields?: string[];
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
     folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
 }
-export interface DataFabricUpdateInputs {
+export interface DataFabricCreateInputs {
     /** The Data Fabric entity's name, e.g. `'Invoices'`. */
     entity: string;
     /**
-     * Which record to update: `{ byId: <record id> }`, or `{ fromRead: '<step>' }`
-     * naming an earlier `dataFabricRead` step whose record this write targets.
+     * The columns the new record starts with, by field name. At least one is
+     * required — the node's schema rejects an empty field list rather than
+     * inserting a blank row.
      */
-    record: {
-        byId: string | Expr;
-        fromRead?: never;
-    } | {
-        fromRead: string;
-        byId?: never;
-    };
+    values: Record<string, string | Expr>;
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+export interface DataFabricUpdateInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /** Which record to update — see {@link DataFabricRecordRef}. */
+    record: DataFabricRecordRef;
     /**
      * The columns to write, by field name. An empty string is a real write — it
      * clears the column.
      */
     set: Record<string, string | Expr>;
-    /** Folder key (GUID) for folder-scoped entities. */
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
+    folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
+}
+export interface DataFabricDeleteInputs {
+    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
+    entity: string;
+    /** Which record to delete — see {@link DataFabricRecordRef}. */
+    record: DataFabricRecordRef;
+    /**
+     * Folder key (GUID) for a folder-scoped entity — its `folderId` from
+     * `uip df entities list --include-folders`.
+     *
+     * Requires `resourceKey`: `folderKey` alone serializes the folder as a
+     * source-org LITERAL, which looks portable and breaks on cross-org deploy, so
+     * `check` refuses the pair being half-authored.
+     */
     folderKey?: string;
+    /**
+     * The key the entity's reference is registered under in the solution, from
+     * `uip solution resources list --kind Entity`.
+     *
+     * @remarks
+     * Only meaningful with `folderKey`. Supplying both emits the two
+     * `resource: 'Entity'` binding rows (`propertyAttribute` `name` and
+     * `folderKey`) that let the flow deploy to another org. Nothing mints this
+     * key for a hand-authored flow — if you cannot resolve one, keep the entity
+     * tenant-scoped and omit both.
+     */
+    resourceKey?: string;
 }
 export interface DocumentClassifyInputs {
     /** The document to classify — a file reference (`input('file')`, `out('fetch', 'fileRef')`, …). */
@@ -2191,9 +2360,15 @@ export type ActionSpec = {
 } | {
     kind: 'dataFabricRead';
     inputs: DataFabricReadInputs;
+} | {
+    kind: 'dataFabricCreate';
+    inputs: DataFabricCreateInputs;
 } | {
     kind: 'dataFabricUpdate';
     inputs: DataFabricUpdateInputs;
+} | {
+    kind: 'dataFabricDelete';
+    inputs: DataFabricDeleteInputs;
 } | {
     kind: 'waitEvent';
     subscription: EventSubscription;
@@ -2929,63 +3104,97 @@ export declare function documentClassify(inputs: DocumentClassifyInputs): Action
  */
 export declare function dynamicExtract(inputs: DynamicExtractInputs): ActionSpec;
 /**
- * Read ONE entity record from Data Fabric (`core.datafabric.read`). The record
+ * Query entity records from Data Fabric (`core.datafabric.read`). The result
  * publishes to the step's `output`; downstream references re-fetch fresh data
  * at activation time (the engine re-runs the query rather than caching).
  *
  * @remarks
- * **Prefer the connector for Data Fabric work during the transition.**
- * `core.datafabric.*` has exactly two verbs — this one and
- * {@link dataFabricUpdate} — and neither declares an output schema. Create,
- * delete, get-by-id, a multi-record query with a row limit, file record fields
- * and entity events are NOT in this family: they are operations on the SAME
- * product reached through its Integration Service connector,
+ * This node is **read-one AND query-many**, on its 1.4 definition: `resultMode:
+ * 'multiple'` publishes the matching records under `output.results`, and the
+ * platform renames the node "Query entity records" to say so. The SDK still
+ * pins 1.0 — read-one — as the no-`{ version }` default, so passing
+ * `resultMode` is what selects 1.4; see {@link DataFabricReadInputs.resultMode}.
+ *
+ * The native family covers all four CRUD verbs: this one,
+ * {@link dataFabricCreate}, {@link dataFabricUpdate} and
+ * {@link dataFabricDelete}. What it does NOT cover is get-by-id, a query row
+ * limit, file record fields, and entity events — those are operations on the
+ * SAME product reached through its Integration Service connector,
  * `uipath-uipath-dataservice` (the tenant displays it as **UiPath Data
- * Fabric**), which covers every verb including the two here.
- *
- * Taking this node for the one verb that has a native form leaves the rest of
- * the same entity on the connector — two connection bindings and two payload
- * shapes in one flow. So route entity work through the connector unless the
- * scenario names these nodes; native forms for the remaining verbs are the
- * direction of travel, and this guidance changes when they land. `check` does
- * not reject a native node — this is a routing default, not a rule:
+ * Fabric**). So a flow that needs one of those still straddles two surfaces,
+ * and the connector remains the one surface that covers everything:
  *
  * ```ts
- * .step('create', connector('uipath-uipath-dataservice', 'create-entity-record',
- *   { entityName: 'Contracts', contractTitle: 'Q3 renewal' }, { connection: 'df' }))
+ * .step('byId', connector('uipath-uipath-dataservice', 'get-entity-record-by-id',
+ *   { entityName: 'Contracts', recordId: input('id') }, { connection: 'df' }))
  * ```
  *
- * That operation's body fields come from the entity, so the library cannot
- * carry them: run `npx flow-sdk registry prepare uipath-uipath-dataservice
- * create-entity-record -f entityName=<Entity>` first (`uip maestro registry
- * prepare …` is the same command when you are driving through the UiPath CLI). The routing table is in
- * the `data-fabric.md` reference and the parent-field loop in
- * `connector-params.md` — cited by name rather than linked, because this
+ * A connector operation's body fields come from the entity, so the library
+ * cannot carry them: run `npx flow-sdk registry prepare uipath-uipath-dataservice
+ * get-entity-record-by-id -f entityName=<Entity>` first (`uip maestro registry
+ * prepare …` is the same command when you are driving through the UiPath CLI).
+ * The routing table is in the `data-fabric.md` reference and the parent-field
+ * loop in `connector-params.md` — cited by name rather than linked, because this
  * comment renders both into the flat corpus, where those files sit alongside
  * it, and onto the site, where each symbol is its own page and a relative
  * `./data-fabric` resolves to nothing.
  *
- * @param inputs - The entity, optional filter rows, and folder scope.
+ * @param inputs - The entity, optional filter rows, result mode, and folder scope.
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function dataFabricRead(inputs: DataFabricReadInputs): ActionSpec;
+/**
+ * Create an entity record in Data Fabric (`core.datafabric.create`). The new
+ * record publishes to the step's `output`, so a following
+ * {@link dataFabricUpdate} or {@link dataFabricDelete} can read its id.
+ *
+ * @remarks
+ * `values` must name at least one column — the node's schema rejects an empty
+ * field list rather than inserting a blank row, and `check` says so before the
+ * platform does. Field names are the ENTITY's, so copy them from the scenario
+ * or the tenant; nothing offline can tell a real column from a typo.
+ *
+ * See {@link dataFabricRead} for what the native family still does not cover
+ * and which connector operation covers it.
+ *
+ * @param inputs - The entity, the columns the record starts with, and folder scope.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function dataFabricCreate(inputs: DataFabricCreateInputs): ActionSpec;
 /**
  * Update an entity record in Data Fabric (`core.datafabric.update`). Target the
  * record by id or through an earlier {@link dataFabricRead} step; downstream
  * reads of this step observe the record AFTER the write.
  *
  * @remarks
- * The second and last verb of the native family — see {@link dataFabricRead}
- * for what the family does NOT cover, which connector operation covers it
- * instead, and why entity work routes through the connector during the
- * transition. For an update whose flow also creates, gets or deletes on the
- * same entity, use `connector(…, 'update-entity-record', …)` so the flow keeps
- * one surface.
+ * `set` must write at least one column: an empty `set` is a no-op the platform
+ * reports as success, so `check` rejects it.
+ *
+ * See {@link dataFabricRead} for what the native family still does not cover
+ * and which connector operation covers it.
  *
  * @param inputs - The entity, the record selector, and the columns to write.
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function dataFabricUpdate(inputs: DataFabricUpdateInputs): ActionSpec;
+/**
+ * Delete an entity record from Data Fabric (`core.datafabric.delete`). Target
+ * the record by id or through an earlier {@link dataFabricRead} step, exactly
+ * as {@link dataFabricUpdate} does.
+ *
+ * @remarks
+ * A delete **publishes nothing** — its definition declares no output — so
+ * `$vars.<step>.output` is undefined at run time and `check` rejects a read of
+ * it. Take what you need off the read step that found the record, before the
+ * delete.
+ *
+ * See {@link dataFabricRead} for what the native family still does not cover
+ * and which connector operation covers it.
+ *
+ * @param inputs - The entity, the record selector, and folder scope.
+ * @returns An action spec to pass to `.step(name, …)`.
+ */
+export declare function dataFabricDelete(inputs: DataFabricDeleteInputs): ActionSpec;
 /**
  * Declare an Orchestrator QUEUE ITEM step.
  *