@uipath/maestro-builder-sdk 6.18.10 → 6.19.0

package/dist/flow-node-type.d.ts

@@ -0,0 +1,192 @@
+/**
+ * The Flow specialization of the node-type contract (`core/nodes/`), and the
+ * contexts Flow lends a node type for each job. docs/NODE_TYPE_ARCHITECTURE_DESIGN.md
+ * §4.1–§4.3.
+ *
+ * A Flow node type serializes to a {@link FlowNodeContribution} — the same contract
+ * a custom `FlowAction.contribute()` returns, plus the two things built-in node
+ * types need and custom ones never had (`model`, `port`). The serializer still
+ * owns the node's id, label, `typeVersion`, layout, edges and definition dedupe;
+ * each context below is the whole of what a node type can see.
+ */
+import type { ArtifactContexts, NodeType } from './core/nodes/node-type.js';
+import type { VersionedNodeType } from './core/nodes/versioned.js';
+import type { NodeFamily, Placement } from './core/nodes/family.js';
+import type { DefinitionReference, NodeContribution } from './core/node-classes.js';
+import type { CheckOpts } from './check.js';
+/**
+ * What a Flow node type's `serialize` returns: the node's type-owned fields.
+ *
+ * The `inputs`, `outputs` and `bindings` are a {@link NodeContribution}'s; only
+ * `definition` differs (optional here), and `model` and `port` are Flow's own.
+ *
+ * A node type owns its bindings: together with what it hoists through
+ * `ctx.bind`, they must close every `<bindings.NAME>` its definition references.
+ * `serialize` enforces that (#942); `check` does not verify it, because the
+ * bindings exist only once the type serializes and no author input can open the
+ * gap, so the type's own tests are what pin it.
+ */
+export interface FlowNodeContribution extends Omit<NodeContribution, 'definition'> {
+    /**
+     * The definition to compile against. A `bundled` type must omit it: the
+     * serializer resolves `<typeName>@<version>` from the bundle, and refuses one
+     * returned. A `per-tenant` type must supply the definition it built (a
+     * `snapshot` reference).
+     */
+    definition?: DefinitionReference;
+    /**
+     * Whether the node carries the definition's `model` (`'definition'`, the default)
+     * or none (`'omit'`) — Data Fabric nodes never carry one (see `makeNode`).
+     */
+    model?: 'definition' | 'omit';
+    /** The forward port the next step's edge leaves from. Default: the definition's default source handle. */
+    port?: string;
+}
+/** What `serialize` may ask of the serializer, for one placement. */
+export interface FlowSerializeContext {
+    /** The step name the author gave this node. */
+    readonly step: string;
+    /**
+     * The version being emitted, always set: the author's `{ version }` when the step
+     * names one, else what `select()` or the default chose. It does not say whether
+     * the author pinned it.
+     */
+    readonly version: string;
+    /** Render one value (an `Expr`, or a literal) as the file stores it, with this scope's rename map. */
+    render(value: unknown): unknown;
+    /**
+     * Apply this scope's rename map to raw JavaScript that is not an `Expr` — a
+     * script body reads `$vars.<step>` like any expression, so a reused child's
+     * body must follow its copy's node ids too.
+     */
+    renameRefs(js: string): string;
+    /** The node id another step of this scope was emitted under — rename-aware, for subflow copies. */
+    stepNodeId(step: string): string;
+    /** A deterministic id for `seed`, unique to this flow and node. */
+    mint(seed: string): string;
+    /**
+     * Hoist a binding entry into the flow's `bindings`, deduplicated by `id`. With
+     * the contribution's own `bindings`, these must close every `<bindings.NAME>`
+     * the node's definition references: serialize refuses a name left open
+     * (`CONTRIBUTION_BINDING_UNRESOLVED`), and `check` does not see bindings.
+     */
+    bind(entry: {
+        readonly id: string;
+    } & Readonly<Record<string, unknown>>): void;
+    /** The bundled definition `<typeName>@<version>`, or undefined when the SDK does not ship it. */
+    definition(typeName: string, version: string): unknown;
+}
+/** What `deserialize` may ask of the decompiler, for one serialized node. */
+export interface FlowDeserializeContext {
+    /** The serialized node's id. */
+    readonly nodeId: string;
+    /** A serialized value back as the spec holds it: `=js:` text becomes an `Expr`; a literal stays itself. */
+    expr(raw: unknown): unknown;
+    /**
+     * A serialized value's TEXT, unwrapped from an expression envelope: a string
+     * as is, a `{ type: 'jsExpression', expression }` envelope as `=js:<expression>`,
+     * any other envelope as its expression; undefined for anything else.
+     */
+    sourceText(raw: unknown): string | undefined;
+    /** A plain value, unwrapped from a `{ type: 'literal', expression: '<json>' }` envelope when it is one. */
+    plainValue(raw: unknown): unknown;
+    /** The step name a node id was emitted for. */
+    stepName(nodeId: string): string;
+    /** The file's own `definitions[]` entry for this node, if it carries one. */
+    definition(): unknown;
+    /** Report something the lift could not keep. Decompile prints it once. */
+    warn(message: string): void;
+}
+/** What `print` may ask of the decompiler. Every method returns source text. */
+export interface FlowPrintContext {
+    /**
+     * Any spec value as source: an `Expr` as the helper an author writes (`input('x')`, `js\`…\``), an array or
+     * plain object recursively (`[a, b]`, `{ k: v }`), anything else as a literal.
+     */
+    value(value: unknown): string;
+    /** A string literal. */
+    string(text: string): string;
+    /** Any JSON value as a literal, verbatim (`{"a":1}`), where the source writes the value as data. */
+    json(value: unknown): string;
+    /** An object key: a bare identifier when legal, otherwise a quoted string. */
+    key(name: string): string;
+    /** An authoring helper (`lit`, `input`, …) by name: imported into the printed source, and its identifier. */
+    helper(name: string): string;
+}
+/** What a node-local `check` may ask of the checker. */
+export interface FlowCheckContext {
+    /** The step being checked. */
+    readonly step: string;
+    /** The version the node will be emitted at. */
+    readonly version: string;
+    /** Report a diagnostic on this step. Its severity is the family catalog's for `code`. */
+    report(code: string, message: string, suggestion?: string): void;
+    /**
+     * The flow input or variable a bare reference (`$vars.x`, or an input's
+     * `$vars.<trigger>.output.x`) names, with its declared type when it has one;
+     * undefined for anything else — a step output's type is not known offline.
+     */
+    declaredRef(js: string): {
+        name: string;
+        type: string | undefined;
+    } | undefined;
+    /** The options `check` was called with (the connector-library views among them). */
+    readonly options: CheckOpts;
+}
+/** What a family-level `check` may ask of the checker. */
+export interface FlowFamilyCheckContext {
+    /** Report a diagnostic on `step`. Its severity is the family catalog's for `code`. */
+    report(step: string, code: string, message: string, suggestion?: string): void;
+    /** Whether the flow has a step of that name, in any scope the family's placements can see. */
+    hasStep(step: string): boolean;
+    /** Where a step of that name is placed, when it is one of this registry's node types. */
+    placementOf(step: string): Placement | undefined;
+    /**
+     * Whether that step is one of this registry's node types whose `{ version }` did
+     * not resolve. It has no placement, and `NODE_VERSION_UNREGISTERED` already
+     * reports it, so a rule about it should stay silent rather than say it is missing.
+     */
+    versionUnresolved(step: string): boolean;
+}
+export interface FlowContexts extends ArtifactContexts {
+    serialize: FlowSerializeContext;
+    deserialize: FlowDeserializeContext;
+    print: FlowPrintContext;
+    check: FlowCheckContext;
+    familyCheck: FlowFamilyCheckContext;
+}
+/**
+ * What `rawNode` reports for a raw node of a registered type: the typed spelling
+ * to prefer (RAW_NODE_TYPED_FAMILY), and the inputs the product never reads
+ * (RAW_NODE_UNKNOWN_INPUT). Both apply to every version, registered or not —
+ * a raw node is often how an author reaches a version the SDK does not bundle.
+ */
+export interface FlowRawNodeAdvice {
+    /** The typed spelling the warning names, e.g. `dataFabricRead({ entity, … })`. */
+    readonly factory: string;
+    /** Appended to the warning: what the factory writes, and what still needs a raw node. */
+    readonly hint?: string;
+    /**
+     * A raw node's inputs carry a key the product never reads: an `error` at a version
+     * the SDK bundles (`bundled`), where the key set is known, else a `warning`.
+     */
+    inputProblem?(inputs: unknown, version: string, bundled: boolean): {
+        severity: 'error' | 'warning';
+        message: string;
+    } | undefined;
+}
+/** One Flow node type at one version. */
+export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution, FlowContexts> {
+    /**
+     * The node-level `model` every node of this type carries, whichever path emits
+     * it — this type's `serialize`, or a `rawNode` of its definition. `'omit'`: none
+     * (Data Fabric). Default `'definition'`; a contribution's own `model` wins.
+     */
+    readonly nodeModel?: 'definition' | 'omit';
+    /** What `rawNode` reports for a raw node of this type. */
+    readonly rawNode?: FlowRawNodeAdvice;
+}
+/** A Flow node type with several versions. */
+export type FlowVersionedNodeType<Spec> = VersionedNodeType<Spec, FlowNodeContribution, FlowContexts, FlowNodeType<Spec>>;
+/** A Flow node family. */
+export type FlowNodeFamily = NodeFamily<FlowContexts>;

package/dist/flow-node-type.js

@@ -0,0 +1 @@
+export {};

package/dist/flow-sdk.d.ts

@@ -18,11 +18,18 @@
  */
 export * from './core/expr.js';
 export * from './core/actions.js';
+export * from './nodes/data-fabric/flow/index.js';
+export * from './nodes/delay/flow/index.js';
+export * from './nodes/document/flow/index.js';
+export * from './nodes/mock/flow/index.js';
+export * from './nodes/script/flow/index.js';
+export * from './nodes/transform/flow/index.js';
 export { resolveFlowRefs, resolveRefPath, hasFileRefs } from './ref-resolve.js';
 export type { RefReader, ResolveRefsOptions } from './ref-resolve.js';
 export * from './core/connectors.js';
 export * from './core/lookups.js';
 export * from './core/node-classes.js';
+export * from './raw-node.js';
 import { Expr } from './core/expr.js';
 import type { ErrorEnvelopeField, TypeDesc } from './core/expr.js';
 import type { ActionSpec, EventSubscription, TriggerOptions } from './core/actions.js';

package/dist/flow-sdk.js

@@ -21,12 +21,20 @@
 // single import an author needs.
 export * from './core/expr.js';
 export * from './core/actions.js';
+// Node families' public surfaces (docs/NODE_TYPE_ARCHITECTURE_DESIGN.md §8).
+export * from './nodes/data-fabric/flow/index.js';
+export * from './nodes/delay/flow/index.js';
+export * from './nodes/document/flow/index.js';
+export * from './nodes/mock/flow/index.js';
+export * from './nodes/script/flow/index.js';
+export * from './nodes/transform/flow/index.js';
 // `$ref`-split ingestion (design §5): decompile resolves local-file refs into
 // one object model. Exported so a host doing its own file reading can too.
 export { resolveFlowRefs, resolveRefPath, hasFileRefs } from './ref-resolve.js';
 export * from './core/connectors.js';
 export * from './core/lookups.js';
 export * from './core/node-classes.js';
+export * from './raw-node.js';
 import { err as errRef, toExpr, types } from './core/expr.js';
 import { builtinActionSpec, builtinTriggerSpec, subscriptionFrom } from './core/actions.js';
 import { checkFlowExpressions, FlowBuildError } from './flow-expr-check.js';

package/dist/nodes/data-fabric/flow/check.d.ts

@@ -0,0 +1,13 @@
+import type { DataFabricCreateInputs, DataFabricDeleteInputs, DataFabricReadInputs, DataFabricUpdateInputs } from './spec.js';
+import type { DiagnosticCatalog, Placement } from '../../../core/nodes/family.js';
+import type { FlowCheckContext, FlowFamilyCheckContext } from '../../../flow-node-type.js';
+export declare const DATA_FABRIC_DIAGNOSTICS: DiagnosticCatalog;
+export declare function checkRead(inputs: DataFabricReadInputs, ctx: FlowCheckContext): void;
+export declare function checkCreate(inputs: DataFabricCreateInputs, ctx: FlowCheckContext): void;
+export declare function checkUpdate(inputs: DataFabricUpdateInputs, ctx: FlowCheckContext): void;
+export declare function checkWrite(inputs: DataFabricDeleteInputs, ctx: FlowCheckContext): void;
+/**
+ * Update and delete target a record `{ fromRead: '<step>' }` with the same
+ * selector, so they share the check: the step must be a read, and not a list.
+ */
+export declare function checkFromRead(placements: readonly Placement[], ctx: FlowFamilyCheckContext): void;

package/dist/nodes/data-fabric/flow/check.js

@@ -0,0 +1,164 @@
+/**
+ * The Flow Data Fabric family's rules: the per-step checks each verb runs, and
+ * the family-level `{ fromRead }` rules that need every placement at once. Moved
+ * verbatim from check.ts (Phase 2 of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md);
+ * codes, messages and order are unchanged.
+ */
+import { Expr } from '../../../core/expr.js';
+export const DATA_FABRIC_DIAGNOSTICS = {
+    DATAFABRIC_NO_ENTITY: { severity: 'error', summary: 'a verb names no entity' },
+    DATAFABRIC_EMPTY_VALUES: { severity: 'error', summary: 'a create writes no non-blank column' },
+    DATAFABRIC_EMPTY_SET: { severity: 'error', summary: 'an update writes no column' },
+    DATAFABRIC_SYSTEM_COLUMN: { severity: 'error', summary: 'a write targets a system column' },
+    DATAFABRIC_FOLDER_NO_RESOURCE_KEY: { severity: 'error', summary: 'folderKey without resourceKey' },
+    DATAFABRIC_RESOURCE_KEY_NO_FOLDER: { severity: 'error', summary: 'resourceKey without folderKey' },
+    DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE: { severity: 'error', summary: 'list-query options on a single read' },
+    DATAFABRIC_LIMIT_RANGE: { severity: 'error', summary: 'limit outside 1–1000' },
+    DATAFABRIC_IN_REQUIRES_MULTIPLE: { severity: 'error', summary: "an 'in' filter on a single read" },
+    DATAFABRIC_FILTER_BLANK_VALUE: { severity: 'error', summary: 'a filter with a blank value' },
+    DATAFABRIC_FROMREAD_UNKNOWN: { severity: 'error', summary: '{ fromRead } names no read step' },
+    DATAFABRIC_FROMREAD_MULTIPLE: { severity: 'error', summary: "{ fromRead } names a resultMode: 'multiple' query" },
+    DATAFABRIC_DELETE_HAS_NO_OUTPUT: { severity: 'error', summary: "a read of a delete's output" },
+};
+function checkEntity(inputs, ctx) {
+    if (!String(inputs.entity ?? '').trim()) {
+        ctx.report('DATAFABRIC_NO_ENTITY', `"${ctx.step}" names no Data Fabric entity. Set { entity: '<entity name>' }.`);
+    }
+}
+export function checkRead(inputs, ctx) {
+    checkEntity(inputs, ctx);
+    checkQuery(inputs, ctx);
+    checkScope(inputs, ctx);
+}
+export function checkCreate(inputs, ctx) {
+    checkEntity(inputs, ctx);
+    // 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(inputs.values ?? {})
+        .filter((v) => (v instanceof Expr ? true : String(v ?? '').trim() !== ''));
+    if (written.length === 0) {
+        ctx.report('DATAFABRIC_EMPTY_VALUES', `"${ctx.step}" 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.');
+    }
+    checkColumns(Object.keys(inputs.values ?? {}), 'values', ctx);
+    checkScope(inputs, ctx);
+}
+export function checkUpdate(inputs, ctx) {
+    checkEntity(inputs, ctx);
+    if (Object.keys(inputs.set ?? {}).length === 0) {
+        ctx.report('DATAFABRIC_EMPTY_SET', `"${ctx.step}" writes no columns — { set } is empty, so the update would no-op green.`);
+    }
+    checkColumns(Object.keys(inputs.set ?? {}), 'set', ctx);
+    checkScope(inputs, ctx);
+}
+export function checkWrite(inputs, ctx) {
+    checkEntity(inputs, ctx);
+    checkScope(inputs, ctx);
+}
+/**
+ * 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 SYSTEM_COLUMNS = new Set(['Id', 'CreateTime', 'CreatedBy', 'UpdateTime', 'UpdatedBy']);
+function checkColumns(columns, option, ctx) {
+    const system = columns.filter((c) => SYSTEM_COLUMNS.has(c));
+    if (system.length) {
+        ctx.report('DATAFABRIC_SYSTEM_COLUMN', `"${ctx.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 checkScope(inputs, ctx) {
+    if (inputs.folderKey !== undefined && inputs.resourceKey === undefined) {
+        ctx.report('DATAFABRIC_FOLDER_NO_RESOURCE_KEY', `"${ctx.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.', '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) {
+        ctx.report('DATAFABRIC_RESOURCE_KEY_NO_FOLDER', `"${ctx.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 checkQuery(inputs, ctx) {
+    const step = ctx.step;
+    const listOnly = ['limit', 'skip', 'sort', 'fields'].filter((k) => inputs[k] !== undefined);
+    if (listOnly.length && inputs.resultMode !== 'multiple') {
+        ctx.report('DATAFABRIC_QUERY_OPTS_WITHOUT_MULTIPLE', `"${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)'}.`, "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)) {
+        ctx.report('DATAFABRIC_LIMIT_RANGE', `"${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')) {
+        ctx.report('DATAFABRIC_IN_REQUIRES_MULTIPLE', `"${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) {
+            ctx.report('DATAFABRIC_FILTER_BLANK_VALUE', `"${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.');
+        }
+    }
+}
+/**
+ * Update and delete target a record `{ fromRead: '<step>' }` with the same
+ * selector, so they share the check: the step must be a read, and not a list.
+ */
+export function checkFromRead(placements, ctx) {
+    for (const p of placements) {
+        if (p.kind !== 'dataFabricUpdate' && p.kind !== 'dataFabricDelete')
+            continue;
+        const fromRead = p.spec.inputs?.record?.fromRead;
+        if (typeof fromRead !== 'string')
+            continue;
+        const factory = p.kind;
+        // A step whose version did not resolve is already an error; saying it does
+        // not exist would send the author to the selector instead of the pin.
+        if (ctx.versionUnresolved(fromRead))
+            continue;
+        const read = ctx.placementOf(fromRead);
+        if (read?.kind !== 'dataFabricRead') {
+            ctx.report(p.step, 'DATAFABRIC_FROMREAD_UNKNOWN', `"${p.step}" targets record: { fromRead: ${JSON.stringify(fromRead)} }, but no dataFabricRead step has that name.`, `${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 (read.spec.inputs?.resultMode === 'multiple') {
+            ctx.report(p.step, 'DATAFABRIC_FROMREAD_MULTIPLE', `"${p.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.', `loop the results and target each record with ${factory}({ …, record: { byId: … } })`);
+        }
+    }
+}

package/dist/nodes/data-fabric/flow/factories.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The Flow Data Fabric factories: `dataFabricRead()`, `dataFabricCreate()`,
+ * `dataFabricUpdate()` and `dataFabricDelete()`. Moved from core/actions.ts in
+ * Phase 2c of docs/NODE_TYPE_ARCHITECTURE_DESIGN.md; the package entry re-exports
+ * them, so authors import them exactly as before.
+ */
+import { type ActionSpec } from '../../../core/actions.js';
+import type { DataFabricCreateInputs, DataFabricDeleteInputs, DataFabricReadInputs, DataFabricUpdateInputs } from './spec.js';
+/**
+ * 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
+ * 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**). So a flow that needs one of those still straddles two surfaces,
+ * and the connector remains the one surface that covers everything:
+ *
+ * ```ts
+ * .step('byId', connector('uipath-uipath-dataservice', 'get-entity-record-by-id',
+ *   { entityName: 'Contracts', recordId: input('id') }, { connection: 'df' }))
+ * ```
+ *
+ * Get-by-id matters for long text. This node is a query even when it reads one
+ * record by an `Id` filter, and a Data Service query returns a PREVIEW of a
+ * long-text (`MULTILINE_MAX`) field: the first 10,000 characters plus
+ * `...[Truncated]`, with no flag in the output. A 15,551-character value comes
+ * back as 10,014 characters. When a field may exceed 10,000 characters, read
+ * it with `get-entity-record-by-id`, which returns the whole value
+ * (flow-builder-sdk#954).
+ *
+ * A connector operation's body fields come from the entity, so the library
+ * cannot carry them: run `uip maestro registry prepare uipath-uipath-dataservice
+ * get-entity-record-by-id -f entityName=<Entity>` first.
+ * 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, 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.
+ *
+ * The published `output` is the record as a query returns it, so a long-text
+ * (`MULTILINE_MAX`) field longer than 10,000 characters comes back cut, with
+ * `...[Truncated]` appended, even though the whole value was stored. Use the
+ * value you passed in, or re-read the record with the connector's
+ * `get-entity-record-by-id`, when the whole text is needed (flow-builder-sdk#954).
+ *
+ * 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
+ * `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;