@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/core/actions.d.ts

@@ -10,7 +10,6 @@
 import type { Expr } from './expr.js';
 import type { LookupToken } from './lookups.js';
 import { type ConnectorDescriptor, type TriggerDescriptor } from './connectors.js';
-import type { ScriptReturns } from './script-return.js';
 /** One conditional response branch on an HTTP node — a designer-visible side exit. */
 export interface HttpBranch {
     /**
@@ -146,44 +145,6 @@ export type HttpInputs = HttpInputsBase & ({
      */
     targetConnector?: string;
 });
-export interface ScriptInputs {
-    /** JavaScript body. Must `return` its result. Referenced via out('<step>'). */
-    code: string;
-    /**
-     * What the body RETURNS — the type of `out('<step>')`.
-     *
-     * The platform's definition can only say `output: {type: 'object'}` (a node
-     * type cannot know what a particular body returns), so the designer types
-     * every script read as `Record<string, any>` and reports mapping one into a
-     * `string` output as `Type 'Record<string, any>' is not assignable to type
-     * 'string'` — on a flow that is correct and runs.
-     *
-     * **Usually you do not need this.** The compiler reads the body and declares
-     * what it plainly returns, so `return "pending-approval"` is already a
-     * `string`. Reach for `returns` when the body does not say so syntactically —
-     * a value that comes back from a runtime read, or an object assembled
-     * dynamically:
-     *
-     * ```ts
-     * .step('policyLimit', script({
-     *   code: 'return $vars.fetchPolicy.output.body.limit;',
-     *   returns: 'number',
-     * }))
-     * ```
-     *
-     * For an object return, name the FIELDS instead — the spelling every other
-     * action's `returns` uses, and what licenses `out('<step>', '<field>')`:
-     *
-     * ```ts
-     * returns: { total: 'number', currency: 'string' }
-     * ```
-     *
-     * An explicit `returns` always wins over what the body looks like. Nothing is
-     * inferred when the body does not plainly agree with itself, and an unknown
-     * shape stays the definition's open object rather than being guessed at.
-     */
-    returns?: ScriptReturns;
-}
 export interface ConnectorOpts {
     /** Connector action version (defaults to the library's newest match). */
     version?: string;
@@ -228,111 +189,10 @@ export interface ConnectorOpts {
      */
     object?: string;
 }
-/** How a filter combines its rules: every rule must match, or any one. */
-export type FilterMatch = 'and' | 'or';
-/** Comparison a filter rule applies to a field. */
-export type FilterCondition = 'equals' | 'not_equals' | 'greater_than' | 'less_than' | 'greater_equal' | 'less_equal' | 'contains' | 'not_contains' | 'starts_with' | 'not_starts_with' | 'ends_with' | 'not_ends_with' | 'matches_regex' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'is_empty' | 'is_not_empty';
-export interface FilterRule {
-    /** Field on each item. Dot-paths reach nested fields (`'order.amount'`). */
-    field: string;
-    condition: FilterCondition;
-    /**
-     * What to compare against — a LITERAL only. The transform runtime reads this
-     * value as-is and evaluates nothing, so an expression here would compare every
-     * item against that text and match nothing. Hence `Expr` is not accepted: for
-     * a dynamic threshold, filter in a `script` step instead.
-     * Omit for the value-free conditions (`is_null`, `is_empty`, …).
-     */
-    value?: string | number | boolean | null;
-}
-/** What a map does to a field's value. Only `copy` is meaningful for non-text. */
-export type Transformation = 'copy' | 'uppercase' | 'lowercase' | 'trim';
-export interface FieldMapping {
-    /** Field to carry into the output. Must exist on the item, or it is skipped. */
-    field: string;
-    /** Defaults to `'copy'` (the value unchanged). */
-    transformation?: Transformation;
-    /** Output field name. Omit to keep `field`'s own name. */
-    renameTo?: string;
-}
-export type AggregationOperation = 'count' | 'sum' | 'average' | 'min' | 'max' | 'first' | 'last' | 'collect';
-export interface Aggregation {
-    operation: AggregationOperation;
-    /** Output field name for the aggregate. Required. */
-    alias: string;
-    /** Field to aggregate. Required for every operation except `count`. */
-    field?: string;
-}
-/**
- * One link in the chain. Operations run in the order given, and each one's
- * result is the next one's input — so a `map` that drops a field puts it out of
- * reach of a later `filter`.
- */
-export type TransformOperation = {
-    type: 'filter';
-    filters: FilterRule[];
-    operation?: FilterMatch;
-} | {
-    type: 'map';
-    mappings: FieldMapping[];
-    keepOriginalFields?: boolean;
-} | {
-    type: 'groupBy';
-    groupByField: string;
-    aggregations?: Aggregation[];
-};
-/**
- * Which Transform node type to emit.
- *
- * @remarks
- * The platform ships four: the generic `core.action.transform`, which chains N
- * operations, plus three single-purpose variants that each run exactly one.
- * They share ONE runtime — flow-v1 routes all four node types through the same
- * script generators and dispatches on the OPERATION's `type`, never the node's
- * (`bpmn-to-xml.ts`'s `DATA_TRANSFORM_NODE_TYPES` / `generateDataTransformScript`).
- * So a variant is the generic constrained to one operation, wearing a
- * self-describing node type and its own editor in the designer.
- *
- * Note the spelling: the node type is `core.action.transform.group-by`
- * (hyphen), while the operation it carries is `type: 'groupBy'` (camelCase) —
- * that mismatch is the platform's, not ours.
- */
-export type TransformVariant = 'map' | 'filter' | 'group-by';
-/**
- * The operation `type` each variant node must carry — one of, and only.
- *
- * @internal Serializer plumbing; an author states the variant, not the mapping.
- */
-export declare const VARIANT_OPERATION: Record<TransformVariant, TransformOperation['type']>;
-export interface TransformInputs {
-    /**
-     * The array to transform, as a REFERENCE: `v('catalog')` or
-     * `out('fetchOrders', 'body.items')`.
-     *
-     * This is a variable PATH, not a value field — the runtime turns the string
-     * into a lookup. An inline array or a computed `js` expression therefore
-     * resolves to nothing, which is why the type is `Expr` and `check` rejects
-     * anything that is not a bare `$vars.…` path. Keep static data in a
-     * `.var(name, types.array, [...])` default and point here.
-     */
-    collection: Expr;
-    /**
-     * Emit a single-purpose variant node instead of the generic Transform.
-     * Omit it for the generic (the default).
-     *
-     * With a variant, `operations` must hold exactly ONE operation of the
-     * matching type — `'filter'` → `type: 'filter'`, `'map'` → `type: 'map'`,
-     * `'group-by'` → `type: 'groupBy'`. `check` rejects anything else, naming
-     * both the variant and the operation it found.
-     */
-    variant?: TransformVariant;
-    /** At least one operation — an empty chain is a no-op node. */
-    operations: TransformOperation[];
-}
 /**
- * A form field's type. These are the platform's own strings — an unrecognized
- * one is NOT an error there, it silently normalizes to text (so a number field
- * becomes a text box), which is why `check` rejects anything outside this set.
+ * A form field's type. The platform does not recognize a type outside this set:
+ * older runtimes read it as text (so a number field becomes a text box), newer
+ * ones reject the form. That is why `check` rejects anything outside this set.
  */
 export type FormFieldType = 'text' | 'number' | 'boolean' | 'date-time';
 /** A value the reviewer READS: shown on the form, filled in from the flow. */
@@ -470,12 +330,20 @@ export interface DocValidationInputs {
  * rather than continuing (the platform's own two-value vocabulary — anything
  * that is not exactly `'End'` reads as continue).
  *
+ * `id` is the outcome's wire id — `schema.outcomes[].id`, and the `outcome-<id>`
+ * port its edge leaves from. Leave it out and the id is a slug of `name`
+ * (`'Needs info'` → `needs-info`). Set it only to keep an id a flow already
+ * has, as decompile does for a task the designer drew
+ * (`{ name: 'Reject', id: 'outcome-1778015958049' }`): merge keeps the
+ * original node, so its edges must use that node's ids.
+ *
  * @remarks
  * A bare string is shorthand for `{ name }`.
  */
 export type Outcome = string | {
     name: string;
     action?: 'Continue' | 'End';
+    id?: string;
 };
 /**
  * WHICH human-task node type to emit. The platform ships three spellings of the
@@ -951,36 +819,6 @@ export interface IxpExtractInputs {
      */
     description?: string;
 }
-/**
- * The twelve durations the designer's dropdown offers. Purely an ENCODING
- * detail: a duration in this list ships as `timerPreset: '<duration>'` and any
- * other ships as `timerPreset: 'custom'` + `timerValue: '<duration>'`. Both
- * deploy and both wait the same length of time — the author never picks.
- * `core-definitions.test.ts` pins this list against the definition's own form.
- */
-export declare const DELAY_PRESETS: readonly ["PT5S", "PT15S", "PT30S", "PT1M", "PT5M", "PT15M", "PT30M", "PT1H", "PT6H", "PT12H", "P1D", "P1W"];
-export type DelayInputs = {
-    /**
-     * How long to wait, as an ISO-8601 duration: `PT30S`, `PT15M`, `PT2H`,
-     * `P1D`, `P1W`. `PT` separates the time part, so `P1M` is a MONTH and
-     * `PT1M` is a minute.
-     * ISO-8601 duration format documentation is here:
-     * {@link https://docs.digi.com/resources/documentation/digidocs/90001488-13/reference/r_iso_8601_duration_format.htm}
-     */
-    duration: string;
-    /** Impossible together with `duration` — a delay waits one way or the other. */
-    until?: never;
-} | {
-    /**
-     * Wait until an ABSOLUTE date-time, ISO-8601: `2026-09-01T09:00:00Z` or
-     * `2026-09-01T09:00:00+02:00`. The platform's timeDate timer: the run
-     * parks until the wall clock reaches this moment (already-past dates
-     * fire immediately).
-     */
-    until: string;
-    /** Impossible together with `until` — a delay waits one way or the other. */
-    duration?: never;
-};
 /**
  * Where a process resource lives: deployed to an Orchestrator folder
  * (`'published'`, the default) or a sibling project of the SAME solution
@@ -1302,7 +1140,7 @@ export interface AgentInputs {
      *
      * **Display-only, and it is the only thing that differs.** `registry get` on a
      * coded and a low-code agent returns the same node type, the same
-     * `Orchestrator.StartAgentJob` service type, the same `sortOrder: 505` and the
+     * `Orchestrator.StartAgentJob` service type, the same `sortOrder` and the
      * same bindings shape; the single difference is `display.icon` —
      * `coded-agent` vs `autonomous-agent`. Which one a given resource is cannot be
      * known offline, so it is stated here rather than guessed. Check with
@@ -2155,361 +1993,131 @@ export interface QueueItemInputs {
     returns?: Record<string, ReturnFieldType>;
 }
 /**
- * The comparison operators the Data Fabric query serializer can emit, spelled
- * exactly as the file carries them.
+ * Every action kind, keyed by kind, to the body of its spec — the arm's fields
+ * other than `kind`. {@link ActionSpec} is built from it.
  *
  * @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. 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; `=` 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;
-    /**
-     * 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';
+ * An interface, not a closed union, so a node family can add its kinds where it
+ * is defined, by declaration merging, instead of editing this file
+ * (docs/NODE_TYPE_ARCHITECTURE_DESIGN.md §4.6). Most bodies are `{ inputs }`;
+ * `mock`, `connector` and `waitEvent` are not, which is why the value is the
+ * whole body rather than an inputs payload.
+ */
+export interface FlowActionSpecs {
+    /** The spec {@link http} builds. */
+    http: {
+        inputs: HttpInputs;
+    };
+    /** The spec {@link hitl} builds. */
+    hitl: {
+        inputs: HitlInputs;
+    };
+    /** The spec {@link rpaWorkflow} builds. */
+    rpaWorkflow: {
+        inputs: RpaWorkflowInputs;
+    };
+    /** The spec {@link apiWorkflow} builds. */
+    apiWorkflow: {
+        inputs: ApiWorkflowInputs;
+    };
+    /** The spec {@link publishedFunction} builds. */
+    publishedFunction: {
+        inputs: PublishedFunctionInputs;
+    };
+    /** The spec {@link sendMessage} builds. */
+    sendMessage: {
+        inputs: SendMessageInputs;
+    };
+    /** The spec {@link waitForMessage} builds. */
+    waitForMessage: {
+        inputs: WaitForMessageInputs;
+    };
+    /** The spec {@link conversationContext} builds. */
+    conversationContext: {
+        inputs: ConversationContextInputs;
+    };
+    /** The spec {@link createOutgoingCall} builds. */
+    createOutgoingCall: {
+        inputs: CreateOutgoingCallInputs;
+    };
+    /** The spec {@link endCall} builds. */
+    endCall: {
+        inputs: EndCallInputs;
+    };
+    /** The spec {@link voiceAgent} builds. */
+    voiceAgent: {
+        inputs: VoiceAgentInputs;
+    };
+    /** The spec {@link conversationalAgent} builds. */
+    conversationalAgent: {
+        inputs: ConversationalAgentInputs;
+    };
+    /** The spec {@link agenticProcess} builds. */
+    agenticProcess: {
+        inputs: AgenticProcessInputs;
+    };
+    /** The spec {@link agent} builds. */
+    agent: {
+        inputs: AgentInputs;
+    };
+    /** The spec {@link inlineAgent} builds. */
+    inlineAgent: {
+        inputs: InlineAgentInputs;
+    };
+    /** The spec {@link queueItem} builds. */
+    queueItem: {
+        inputs: QueueItemInputs;
+    };
+    /** The spec {@link summarize} builds. */
+    summarize: {
+        inputs: SummarizeInputs;
+    };
+    /** The spec {@link batchTransform} builds. */
+    batchTransform: {
+        inputs: BatchTransformInputs;
+    };
+    /** The spec {@link ixpExtract} builds. */
+    ixpExtract: {
+        inputs: IxpExtractInputs;
+    };
+    /** The spec {@link connector} builds. */
+    connector: {
+        /** The connector key, e.g. `'uipath-salesforce-slack'`. */
+        key: string;
+        /** The connector operation. */
+        action: string;
+        /** The exact connector version, when the author pins one. */
+        version?: string;
+        /** The connection's binding label. */
+        connection?: string;
+        /** The folder's binding label. */
+        folder?: string;
+        /** Which OBJECT a generic operation addresses — see {@link ConnectorOpts.object}. */
+        object?: string;
+        /** The operation's inputs, by field. */
+        inputs: Record<string, unknown>;
+    };
+    /** The spec {@link waitForEvent} builds. */
+    waitEvent: {
+        subscription: EventSubscription;
+    };
 }
 /**
- * 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.
+ * One action step's spec: `{ kind }` plus that kind's body from
+ * {@link FlowActionSpecs}, for every kind there.
  */
-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(s) to query. Omit to take everything the entity holds. */
-    filters?: DataFabricFilter[];
-    /**
-     * `'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 DataFabricCreateInputs {
-    /** The Data Fabric entity's name, e.g. `'Invoices'`. */
-    entity: string;
-    /**
-     * 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.
-     */
-    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 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')`, …). */
-    fileRef: string | Expr;
-    /** Page range to classify, e.g. `'1-3'`. Omit for the whole document. */
-    pageRange?: string;
-    /** Split multi-document files into per-type page ranges. */
-    splitPages?: boolean;
-    /** Model configuration overrides; omit for the platform defaults (gemini_2_5_flash). */
-    modelConfig?: Record<string, unknown>;
-}
-export interface DynamicExtractInputs {
-    /** The document to extract from — a file reference. */
-    fileRef: string | Expr;
-    /**
-     * The IXP model deployment the extraction runs against. Dynamic Extract
-     * authors its SCHEMA inline, but execution still needs a model: Studio Web's
-     * panel destructures `modelName` and `folderKey`, and the platform rejects an
-     * instance without them.
-     */
-    model: {
-        /** The deployment's model name, e.g. `'invoiceixp-cef0d447-ixp'`. */
-        modelName: string;
-        /** Folder key (GUID) the deployment lives in. */
-        folderKey: string;
-        /** The IXP project's id (GUID). */
-        projectId?: string;
-        /** The IXP project's display name. */
-        projectName?: string;
-        /** Folder display name. */
-        folderName?: string;
-        /** Deployment version tag; omit for the live version. */
-        versionTag?: string;
-    };
-    /**
-     * The extraction schema (the node's inline taxonomy): a JSON-schema-shaped
-     * document describing the fields to extract. This is the Dynamic Extract
-     * node's defining input — authored inline rather than referencing a deployed
-     * IXP project (use {@link ixpExtract} for those).
-     */
-    schema?: Record<string, unknown>;
-    /** Page range to extract, e.g. `'1-3'`. Omit for the whole document. */
-    pageRange?: string;
-    /** Model configuration overrides; omit for the platform defaults. */
-    modelConfig?: Record<string, unknown>;
-}
 export type ActionSpec = {
-    kind: 'http';
-    inputs: HttpInputs;
-} | {
-    kind: 'script';
-    inputs: ScriptInputs;
-} | {
-    kind: 'transform';
-    inputs: TransformInputs;
-} | {
-    kind: 'hitl';
-    inputs: HitlInputs;
-} | {
-    kind: 'delay';
-    inputs: DelayInputs;
-}
-/** A placeholder — no inputs, publishes nothing. See {@link mock}. */
- | {
-    kind: 'mock';
-} | {
-    kind: 'rpaWorkflow';
-    inputs: RpaWorkflowInputs;
-} | {
-    kind: 'apiWorkflow';
-    inputs: ApiWorkflowInputs;
-} | {
-    kind: 'publishedFunction';
-    inputs: PublishedFunctionInputs;
-} | {
-    kind: 'sendMessage';
-    inputs: SendMessageInputs;
-} | {
-    kind: 'waitForMessage';
-    inputs: WaitForMessageInputs;
-} | {
-    kind: 'conversationContext';
-    inputs: ConversationContextInputs;
-} | {
-    kind: 'createOutgoingCall';
-    inputs: CreateOutgoingCallInputs;
-} | {
-    kind: 'endCall';
-    inputs: EndCallInputs;
-} | {
-    kind: 'voiceAgent';
-    inputs: VoiceAgentInputs;
-} | {
-    kind: 'conversationalAgent';
-    inputs: ConversationalAgentInputs;
-} | {
-    kind: 'agenticProcess';
-    inputs: AgenticProcessInputs;
-} | {
-    kind: 'agent';
-    inputs: AgentInputs;
-} | {
-    kind: 'inlineAgent';
-    inputs: InlineAgentInputs;
-} | {
-    kind: 'queueItem';
-    inputs: QueueItemInputs;
-} | {
-    kind: 'summarize';
-    inputs: SummarizeInputs;
-} | {
-    kind: 'batchTransform';
-    inputs: BatchTransformInputs;
-} | {
-    kind: 'ixpExtract';
-    inputs: IxpExtractInputs;
-} | {
-    kind: 'connector';
-    key: string;
-    action: string;
-    version?: string;
-    connection?: string;
-    folder?: string;
-    /** Which OBJECT a generic operation addresses — see {@link ConnectorOpts.object}. */
-    object?: string;
-    inputs: Record<string, unknown>;
-} | {
-    kind: 'documentClassify';
-    inputs: DocumentClassifyInputs;
-} | {
-    kind: 'dynamicExtract';
-    inputs: DynamicExtractInputs;
-} | {
-    kind: 'dataFabricRead';
-    inputs: DataFabricReadInputs;
-} | {
-    kind: 'dataFabricCreate';
-    inputs: DataFabricCreateInputs;
-} | {
-    kind: 'dataFabricUpdate';
-    inputs: DataFabricUpdateInputs;
-} | {
-    kind: 'dataFabricDelete';
-    inputs: DataFabricDeleteInputs;
-} | {
-    kind: 'waitEvent';
-    subscription: EventSubscription;
+    [K in keyof FlowActionSpecs]: FlatSpec<{
+        kind: K;
+    } & FlowActionSpecs[K]>;
+}[keyof FlowActionSpecs];
+/**
+ * One object type in place of an intersection, keeping each property's optionality.
+ *
+ * @internal Type plumbing for {@link ActionSpec}; not an authoring type.
+ */
+type FlatSpec<T> = {
+    [P in keyof T]: T[P];
 };
 /**
  * Wrap a built-in action spec literal in its adapter class without changing
@@ -2539,60 +2147,6 @@ export declare function builtinTriggerSpec<S extends object>(spec: S): S;
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function http(inputs: HttpInputs): ActionSpec;
-/**
- * Declare an inline script action.
- *
- * @param inputs - The JavaScript body (`code`, which must `return`) and what it
- * returns (`returns`).
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function script(inputs: ScriptInputs): ActionSpec;
-/**
- * Declare a Transform action — a chain of declarative operations over a
- * collection. Read the result downstream with `out('<step>')`.
- *
- * @remarks
- * For a node that does ONE thing, name the variant — the emitted `.flow` then
- * carries `core.action.transform.filter` and reads as `Filter` in the designer
- * instead of a generic `Transform`:
- *
- * ```ts
- * .step('bigOrders', transform({
- *   variant: 'filter',
- *   collection: v('orders'),
- *   operations: [
- *     { type: 'filter', filters: [{ field: 'amount', condition: 'greater_equal', value: 100 }] },
- *   ],
- * }))
- * ```
- *
- * @example
- * **Filter a collection, then reshape what survives**
- * ```ts
- * .var('catalog', types.array, [
- *   { title: 'Deep Learning', author: 'Goodfellow', difficulty: 9, pages: 800 },
- *   { title: 'Information Theory', author: 'MacKay', difficulty: 7, pages: 540 },
- * ])
- * .step('curate', transform({
- *   collection: v('catalog'),
- *   operations: [
- *     { type: 'filter', operation: 'and', filters: [
- *       { field: 'difficulty', condition: 'greater_than', value: 5 },
- *       { field: 'pages', condition: 'less_than', value: 600 },
- *     ] },
- *     { type: 'map', keepOriginalFields: false, mappings: [
- *       { field: 'title', transformation: 'uppercase' },
- *       { field: 'author' },
- *     ] },
- *   ],
- * }))
- * ```
- *
- * @param inputs - The `collection` to transform and the chain of `operations` to
- * run over it.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function transform(inputs: TransformInputs): ActionSpec;
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.
@@ -2776,68 +2330,6 @@ export declare function batchTransform(inputs: BatchTransformInputs): ActionSpec
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function ixpExtract(inputs: IxpExtractInputs): ActionSpec;
-/**
- * Declare a delay — a step that pauses the flow for a fixed length of time and
- * then carries on.
- *
- * @remarks
- * A delay produces nothing: there is no `out('settle')` to read. It is a wait,
- * not a value.
- *
- * The node itself splits that one duration across two fields (`timerPreset`
- * holds it directly, or the literal `"custom"` with the real value in
- * `timerValue`); the serializer picks the encoding, so you state the wait once.
- *
- * @example
- * **Wait thirty seconds before carrying on**
- * ```ts
- * .step('settle', delay({ duration: 'PT30S' }))
- * ```
- *
- * @param inputs - How long to wait (`duration`), as an ISO-8601 duration.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function delay(inputs: DelayInputs): ActionSpec;
-/**
- * Declare a PLACEHOLDER step — "a real node goes here later".
- *
- * @remarks
- * A mock takes **no inputs and publishes nothing**. It is a marker on the canvas
- * that keeps the graph wired and the flow deployable while one step is still
- * missing — not a stub that returns test data. `out('extractInvoice')` is
- * refused at compile time (`MOCK_HAS_NO_OUTPUT`) because it would read `null` at
- * run time, always.
- *
- * Say what belongs there in the step's own name and in the label the canvas
- * shows; the corpus's placeholders read like
- * `"Extract Invoice Fields (mock — IxP model not yet published)"`.
- *
- * ### Why there are no arguments (convention #191 — the family contract)
- *
- * The platform's `core.logic.mock@1.0.0` declares **no `inputDefinition`** and one
- * output whose `source` is the literal `"null"`. Measured over the 4,033 distinct
- * archived `.flow` artifacts: **74 mock instances in 62 flows, and 0 carrying a
- * fixture anywhere in the node** — 71 of them with `inputs: {}` or no `inputs`
- * key. The 3 exceptions carry free-text `placeholder` / `_placeholder` keys the
- * definition never declares, invented by agents on runs that scored 0.9 and 0.4.
- *
- * **This is NOT a local runner's `kind: 'mock'` test construct**, which returns a
- * baked fixture. They are different things that share
- * a name, and a `mock({ fixture })` surface would emit a node whose local
- * behaviour and deployed behaviour disagree silently — see
- * [#125](https://github.com/UiPath/flow-builder-sdk/issues/125). Nothing this SDK
- * emits opens that channel: an SDK-authored mock publishes `null` locally,
- * exactly as the platform does.
- *
- * @example
- * **Hold a step's place until the real node exists**
- * ```ts
- * .step('extractInvoice', mock())      // ← swap for the IxP node once the project exists
- * ```
- *
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function mock(): ActionSpec;
 /**
  * Invoke a deployed RPA (robotic process automation) workflow — a classic
  * UI-automation process, published to Orchestrator, run by a robot.
@@ -3123,7 +2615,7 @@ export declare function agenticProcess(inputs: AgenticProcessInputs): ActionSpec
  * @remarks
  * **Coded and low-code agents are the same node.** This one factory authors both.
  * `registry get` on a coded agent and on a low-code one returns the same node type,
- * the same service type, the same `sortOrder: 505` and the same bindings shape; the
+ * the same service type, the same `sortOrder` and the same bindings shape; the
  * only difference is the icon, which is what `flavour` sets. Which kind a resource
  * is a property of what somebody published, not of the flow — so if a task asks for
  * "a coded agent", what it is asking you to get right is the RESOURCE you point at.
@@ -3221,131 +2713,6 @@ export declare function agent(inputs: AgentInputs): ActionSpec;
  * @returns An action spec to pass to `.step(name, …)`.
  */
 export declare function inlineAgent(inputs: InlineAgentInputs): ActionSpec;
-/**
- * Classify a document into a document type (`uipath.document.classify`). The
- * result publishes `ClassificationResult` — an array of typed classifications
- * with page ranges and confidences.
- *
- * @param inputs - The file reference and optional page range / split / model settings.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function documentClassify(inputs: DocumentClassifyInputs): ActionSpec;
-/**
- * Extract fields from a document with an INLINE schema — Dynamic Extract
- * (`uipath.ixp.extract-document-builder`), the newer of the two extraction
- * shapes. No deployed IXP project is referenced: the extraction schema rides
- * the node. The result publishes `ExtractionResult` (and `Taxonomy`).
- *
- * @param inputs - The file reference, the inline extraction schema, and
- * optional page range / model settings.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function dynamicExtract(inputs: DynamicExtractInputs): ActionSpec;
-/**
- * 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;
 /**
  * Declare an Orchestrator QUEUE ITEM step.
  *