@uipath/maestro-builder-sdk 6.40.1 → 6.41.0

package/dist/nodes/process/flow/spec.d.ts

@@ -0,0 +1,255 @@
+/**
+ * The process family's authoring types — an RPA process (`uipath.core.rpa-workflow.<key>`),
+ * an API workflow (`uipath.core.api-workflow.<key>`), a published function
+ * (`uipath.core.function.<key>`) and an agentic process (`uipath.core.agentic-process.<key>`,
+ * `uipath.core.flow.<key>`, `uipath.core.case-management.<key>`) — and their kinds'
+ * entries in `FlowActionSpecs`. Moved from core/actions.ts in Phase 4 of
+ * docs/NODE_TYPE_ARCHITECTURE_DESIGN.md. `ProcessLocation` stays in core: the
+ * agent shares it.
+ */
+import type { ProcessLocation, ReturnFieldType } from '../../../core/actions.js';
+export interface RpaWorkflowInputs {
+    /**
+     * The published process's release key (a GUID). It becomes part of the node's
+     * type, `uipath.core.rpa-workflow.<key>`. Find it with
+     * `uip or processes list --all-folders --process-type Process` (the row's `Key`)
+     * or `uip maestro flow registry search "uipath.core.rpa-workflow"`.
+     *
+     * For an in-solution sibling it is `resource.key` from
+     * `resources/solution_folder/process/process/<project>.json` — the suffix of the
+     * node type `uip maestro flow registry list --local` shows.
+     */
+    key: string;
+    /** The process's name in Orchestrator — e.g. `'RPA Workflow'`. */
+    name: string;
+    /**
+     * Where the process lives. `'published'` (the default) is a process deployed
+     * to `folderPath`. `'in-solution'` is a sibling RPA project of the same
+     * solution: it needs `projectId` and no `folderPath`.
+     */
+    location?: ProcessLocation;
+    /**
+     * The Orchestrator folder holding the process — e.g.
+     * `'Shared/uipath-maestro-flow/ProjectEuler RPA'`. Required for a published
+     * process; omit it for an in-solution sibling.
+     *
+     * @enforcedBy RPA_NO_FOLDER A published process needs its folder.
+     */
+    folderPath?: string;
+    /**
+     * The sibling RPA project's `resource.projectKey`, read from
+     * `resources/solution_folder/process/process/<project>.json`. Required only
+     * when `location` is `'in-solution'`.
+     *
+     * @enforcedBy RPA_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
+     */
+    projectId?: string;
+    /**
+     * The PROCESS's own input arguments, by its own argument names (e.g.
+     * `{ problemId: 123 }`). Not a fixed schema — every process declares its own,
+     * and only the deployed process knows them.
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * The process's OUTPUT arguments — the fields it returns, and their types
+     * (e.g. `{ title: 'string' }`). Required if anything reads the step's output.
+     *
+     * Why you have to say: the process's output schema lives on the tenant, and
+     * authoring happens offline. Without it `$vars.<step>.output.<field>` reads
+     * from an object with no declared fields, and nothing could tell a real field
+     * from a typo. Declaring
+     * the fields here is the same thing the platform's own definition does when it
+     * can reach the process, and it is what lets a misspelled read be caught at
+     * `uip maestro flow check` instead of at run time.
+     *
+     * @enforcedBy RPA_READ_UNKNOWN_FIELD A read of the output must name a field declared here.
+     * @enforcedBy RPA_READ_WITHOUT_RETURNS Reading a field off the result requires declaring it here.
+     */
+    returns?: Record<string, ReturnFieldType>;
+}
+export interface ApiWorkflowInputs {
+    /**
+     * The published API workflow's key (a GUID). It becomes part of the node's
+     * type, `uipath.core.api-workflow.<key>`. Find it with
+     * `uip or processes list --all-folders --process-type Api` (an API workflow's
+     * `ProcessKey` reads `<name>.api.<name>`; the GUID you want is the row's `Key`)
+     * or `uip maestro flow registry search`.
+     */
+    key: string;
+    /** The workflow's name in Orchestrator — e.g. `'NameToAgeFixed'`. */
+    name: string;
+    /** The Orchestrator folder holding it — e.g. `'Shared'`. */
+    folderPath: string;
+    /**
+     * The WORKFLOW's own input arguments, by its own argument names (e.g.
+     * `{ name: 'tomasz' }`). Not a fixed schema — every workflow declares its own.
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * The workflow's OUTPUT arguments — the fields it returns, and their types
+     * (e.g. `{ EstimatedAge: 'integer' }`). Required if anything reads the step's
+     * output, for the same reason as `rpaWorkflow`'s: the schema lives on the
+     * tenant and authoring happens offline, so an undeclared read is rejected.
+     *
+     * `'integer'` is what makes the replay fixture a number rather than a string;
+     * see {@link ReturnFieldType} for why the vocabulary carries it.
+     *
+     * @enforcedBy APIWF_READ_WITHOUT_RETURNS Reading a field off the result requires
+     * declaring it here.
+     */
+    returns?: Record<string, ReturnFieldType>;
+}
+/**
+ * A published Orchestrator **Function** — a small, single-purpose unit of code
+ * deployed as its own resource and invoked as one step
+ * (`Orchestrator.ExecuteFunctionAsync`). Same published-resource shape as
+ * {@link ApiWorkflowInputs}; what differs is the family and the folder.
+ */
+export interface PublishedFunctionInputs {
+    /**
+     * The function's key (a GUID) — it becomes part of the node's type,
+     * `uipath.core.function.<key>`. Find it with
+     * `uip maestro flow registry search "uipath.core.function"` (after
+     * `registry pull --force`) or the Orchestrator process listing.
+     */
+    key: string;
+    /** The function's name in Orchestrator, e.g. `'acme-echo'`. */
+    name: string;
+    /**
+     * The Orchestrator folder holding it. A function is usually deployed into a
+     * folder of its OWN name (e.g. `'Shared/acme-echo'`), and the binding's
+     * `resourceKey` is `<folderPath>.<name>` — copy the folder from the tenant
+     * rather than assuming `'Shared'`.
+     */
+    folderPath: string;
+    /** The function's own input arguments, by its own names. */
+    inputs?: Record<string, unknown>;
+    /**
+     * The function's OUTPUT arguments — the fields it returns, and their types.
+     * Required if anything reads the step's output: the schema lives on the
+     * tenant and authoring is offline, so an undeclared read is rejected.
+     *
+     * @enforcedBy FUNCTION_READ_WITHOUT_RETURNS Reading a field off the result
+     * requires declaring it here.
+     */
+    returns?: Record<string, ReturnFieldType>;
+}
+interface AgenticProcessInputsBase {
+    /**
+     * The published agentic process's key (a GUID). It becomes part of the node's
+     * type, `uipath.core.agentic-process.<key>`. Find it with
+     * `uip or processes list --all-folders --process-type ProcessOrchestration` (an
+     * agentic process's `ProcessKey` reads `<name>.agentic.<name>`; the GUID you want
+     * is the row's `Key`) or `uip maestro flow registry search agentic`.
+     *
+     * `--all-folders` PAGINATES at 50 rows and says so in `Pagination.HasMore` — pass
+     * `--limit`/`--offset`, or scope the call with `--folder-path`, or a process that
+     * exists will look as though it does not.
+     */
+    key: string;
+    /** The process's name in Orchestrator — e.g. `'ProcurementProcess'`. */
+    name: string;
+    /**
+     * Where the process lives. `'published'` (the default) is a process deployed
+     * to `folderPath`. `'in-solution'` is a sibling Flow of the same solution, so
+     * it needs `form: 'flow'`, `projectId` and no `folderPath`; `key` is the
+     * sibling's `resource.key` from `resources/solution_folder/process/flow/<project>.json`.
+     * Only the Flow form has been run in-solution; `'bpmn'` and `'case'` siblings
+     * are refused until they are.
+     *
+     * @enforcedBy AGENTIC_LOCAL_FORM_UNVERIFIED In-solution is supported for `form: 'flow'` only.
+     */
+    location?: ProcessLocation;
+    /**
+     * The Orchestrator folder holding it — e.g.
+     * `'Shared/uipath-agents/ProcurementProcess'`. Required for a published
+     * process; omit it for an in-solution sibling.
+     *
+     * @enforcedBy AGENTIC_NO_FOLDER A published process needs its folder.
+     */
+    folderPath?: string;
+    /**
+     * The sibling project's `resource.projectKey`, read from the same resource
+     * file as `key` (`resources/solution_folder/process/flow/<project>.json`).
+     * Required only when `location` is `'in-solution'`.
+     *
+     * @enforcedBy AGENTIC_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
+     */
+    projectId?: string;
+    /**
+     * The PROCESS's own input arguments, by its own argument names (e.g.
+     * `{ productId: 1 }`). Not a fixed schema — every agentic process declares its
+     * own, and only the deployed process knows them.
+     */
+    inputs?: Record<string, unknown>;
+    /**
+     * Which published form this Agentic Process is: the three forms
+     * share one public concept and differ only in wire identity. `'bpmn'` (the
+     * default, and what this factory always emitted) is a Maestro BPMN process
+     * orchestration; `'flow'` is a published Maestro Flow; `'case'` is a Case
+     * Management process.
+     */
+    form?: 'bpmn' | 'flow' | 'case';
+}
+/**
+ * Whether an Agentic Process step waits for the process's result.
+ * The discriminated union makes `returns` impossible to declare in the
+ * fire-and-forget form: an async dispatch publishes no output, so nothing
+ * downstream may read one.
+ */
+export type AgenticProcessCompletion = {
+    /** Wait for the process and publish its outputs (the default). */
+    completion?: 'wait';
+    /**
+     * The process's OUTPUT arguments — the fields it returns, and their types (e.g.
+     * `{ status: 'boolean' }`). Required if anything reads the step's output, for the
+     * same reason as `rpaWorkflow`'s and `apiWorkflow`'s: the schema lives on the
+     * tenant and authoring happens offline, so an undeclared read is rejected.
+     *
+     * `uip maestro flow registry get uipath.core.agentic-process.<process>` shows what
+     * the platform synthesizes, under `outputDefinition.output.schema.properties`.
+     *
+     * Worth knowing before you assert on a value: a process can DECLARE a field and
+     * still leave it empty. `Shared/uipath-agents/ProcurementProcess` declares
+     * `{status: boolean}` and every job returns `{"status": null}` (measured
+     * 2026-07-29, four jobs) — the field arrives, the value does not.
+     *
+     * @enforcedBy AGENTIC_READ_WITHOUT_RETURNS Reading a field off the result requires
+     * declaring it here.
+     */
+    returns?: Record<string, ReturnFieldType>;
+} | {
+    /**
+     * Dispatch the process and continue immediately — the platform's
+     * fire-and-forget switch. The node keeps only its `error` output (dispatch
+     * failures still route), and `check` rejects any read of the step's result.
+     * A local replay treats this as dispatch-only: it never fabricates the
+     * output a real run would not publish.
+     */
+    completion: 'fire-and-forget';
+    /** Impossible by design: an async dispatch publishes no output. */
+    returns?: never;
+};
+/** What `agenticProcess()` takes: the shared fields plus the completion policy. */
+export type AgenticProcessInputs = AgenticProcessInputsBase & AgenticProcessCompletion;
+declare module '../../../core/actions.js' {
+    interface FlowActionSpecs {
+        /** 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 agenticProcess} builds. */
+        agenticProcess: {
+            inputs: AgenticProcessInputs;
+        };
+    }
+}
+export {};

package/dist/nodes/process/flow/spec.js

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