@uipath/skills 1.204.0 → 1.204.1

package/skills/uipath-platform/references/integration-service/activities.md

@@ -66,7 +66,7 @@ The **Operation** field on trigger activities indicates the trigger type:
 
 Some IS activities — most notably **List All Records** and other list/query operations — accept a server-side filter expressed in **CEQL** (Connector Expression Query Language). As with trigger filters (which compile to JMESPath), CEQL filters are authored as a **structured filter tree** and the CLI compiles them to a CEQL string. Authoring as a tree keeps the CLI and Studio Web in lockstep so the activity round-trips cleanly when re-opened in SW.
 
-**Never hand-write the CEQL string** outside a builder-SDK Flow. The tree is the only authored form; the grammar below describes what the compiler emits, so you can read a compiled query and recognize a malformed one. **A builder-SDK (`.flow.ts`) Flow is the exception:** there you write the CEQL string and the SDK derives the tree — see [connector-params.md § Structured filters (CEQL)](../../../uipath-maestro-flow/references/connector-params.md#structured-filters-ceql).
+**Never hand-write the CEQL string.** The tree is the only authored form; the grammar below describes what the compiler emits, so you can read a compiled query and recognize a malformed one. For a connector node in a Maestro flow, follow the filter-tree step in [uipath-maestro-flow — connector/impl.md Step 6a](../../../uipath-maestro-flow/references/author/plugins/connector/impl.md), which discovers the FilterBuilder parameter name from the node registry.
 
 ### Contract — three signals from IS metadata
 
@@ -212,7 +212,7 @@ Logical operators between siblings:
 
 Connectors with extensible/custom fields (Jira project+issuetype → custom Jira fields, Mailchimp list_id → audience merge fields, Salesforce custom objects) expose `Api`-type entries under `objectActions[]`. Each entry's `apiConfiguration.url`/`body` carries `{token}` placeholders naming the parent fields. The runtime replays the ObjectAction with cached parent values to fetch the connector-specific custom-field schema.
 
-**For Maestro flows**, this lives on the activity node as `essentialConfiguration.customFieldsRequestDetails`. In a builder-SDK Flow, the `registry prepare` that `check` names creates it — see [connector-params.md § Schema-dynamic operations](../../../uipath-maestro-flow/references/connector-params.md#schema-dynamic-operations-the-parent-field-loop).
+**For Maestro flows**, this lives on the activity node as `essentialConfiguration.customFieldsRequestDetails`. Authoring contract → [uipath-maestro-flow connector/impl.md Step 6c](../../../uipath-maestro-flow/references/author/plugins/connector/impl.md).
 
 Shape:
 

package/skills/uipath-platform/references/integration-service/activity-generation.md

@@ -301,7 +301,14 @@ $WORK/<Name>.json           the compiled activity metadata
 
 ## Putting it in a flow
 
-The builder-SDK Flow skill (`uipath-maestro-flow`) has no node for a generated activity: `rawNode` refuses every `uipath.connector.*` type, and `connector()` only takes catalog operations. Report that gap to the user rather than hand-editing the compiled `.flow`, and offer managed HTTP in connector mode ([http.md](../../../uipath-maestro-flow/references/http.md)) as the fallback.
+The activity can be placed in a Maestro flow as a node of type
+`uipath.connector.custom.<connector-key>.<slug>`. Nothing is published: `uip maestro
+flow node add <file>.flow <type> --metadata $WORK/<Name>.json --scripts $WORK`
+builds the node definition from the metadata and embeds every script in the node,
+and `node configure` reads the metadata from the node. Keep `$WORK` until that
+has run. The flow-side steps are the `uipath-maestro-flow` skill's
+[connector/impl-inline.md](../../../uipath-maestro-flow/references/author/plugins/connector/impl-inline.md);
+hand off to it rather than authoring the node from here.
 
 ## Keep the scripts readable
 

package/skills/uipath-platform/references/integration-service/triggers.md

@@ -169,9 +169,7 @@ Trigger filters narrow which events fire the trigger (e.g. only emails from a sp
 These steps assume the consuming skill has already loaded the trigger's `filterFields.fields` array (the source command varies by surface — e.g. maestro-flow uses `flow registry get`).
 
 1. For each user-intent condition, pick a matching `name` from `filterFields.fields` — using an unknown field name will be rejected by the CLI at configure time.
-2. Choose an operator based on the user's intent and the field type (see the operator table in the consuming skill — e.g. [uipath-maestro-flow event-trigger.md § Filter operators](../../../uipath-maestro-flow/references/event-trigger.md#filter-operators)).
-   **Builder-SDK Flow (`.flow.ts`): stop after step 2.** Write `filters: [{ field: '<name>', <operator>: <value> }]` on `onEvent(...)` / `waitForEvent(...)` — see [event-trigger.md](../../../uipath-maestro-flow/references/event-trigger.md#filter-operators); `check` validates each field and operator. Steps 3–6 describe the classic structured tree.
-
+2. Choose an operator based on the user's intent and the field type (see the operator table in the consuming skill — e.g. [uipath-maestro-flow > connector-trigger](../../../uipath-maestro-flow/references/author/plugins/connector-trigger/impl.md#supported-operators)).
 3. Build one leaf per condition; place multiple conditions under the same `groupOperator` (`0` for AND, `1` for OR).
 4. If you need mixed AND/OR logic, use nested `groups` (same shape as the root tree).
 5. **Wrap string values in a `value` object** with `value`, `rawString` (verbatim user-entered text including quotes for strings), and `isLiteral` — passing a bare string fails validation. A filter-tree leaf operand may be dynamic (`isLiteral: false`, compiled to a `{var_…}` placeholder plus `filterVariables`), but `eventParameters` must be literals, because a trigger is evaluated before any flow run exists.

package/version-manifest.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 2,
-  "skillsVersion": "1.204.0",
+  "skillsVersion": "1.204.1",
   "targetCli": "^1.204.0"
 }

package/skills/uipath-maestro-flow/examples/AquariumSafetyStop.flow.ts

@@ -1,26 +0,0 @@
-/**
- * CAPABILITY: terminate the whole run from a guard branch.
- *
- * Unlike `return`, terminate publishes no flow output and leaves no outgoing
- * path. It is appropriate when continuing the run would be unsafe.
- *
- * Generic scenario: stop an aquarium maintenance round when oxygen is too low.
- */
-import { flow, script, input, out, js, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('aquarium-safety-stop')
-  .name('AquariumSafetyStop')
-  .version('1.0.0')
-  .input({ tank: types.string, oxygenMgL: types.number })
-  .output({ status: types.string })
-  .branch(
-    'oxygenSafe',
-    js`${input('oxygenMgL')} >= 6`,
-    (safe) => safe
-      .step('recordSafe', script({
-        code: 'return "safe:" + $vars.start.output.tank + ":" + $vars.start.output.oxygenMgL;',
-      }))
-      .return({ status: out('recordSafe') }),
-    (unsafe) => unsafe.terminate('stopRound', 'Oxygen below the safe maintenance threshold'),
-  )
-  .build();

package/skills/uipath-maestro-flow/examples/ArchiveCardExtract.flow.ts

@@ -1,38 +0,0 @@
-/**
- * CAPABILITY: extract structured fields with a published IxP project.
- *
- * The registry supplies the complete project node type. Extraction results use
- * the nested `ExtractionResult.ResultsDocument.Fields[]` schema.
- *
- * Generic scenario: read the catalog fields on a scanned archive card.
- */
-import { flow, ixpExtract, script, out, err, tmpl, types } from '@uipath/maestro-builder-sdk';
-
-const PROJECT =
-  'uipath.ixp.archive-cards.2f6e5c18-43ac-4d6a-91d5-c7b1240e8a36-74a4b14d-8ef5-4f24-a6aa-0d6f52a08c11';
-
-export default flow('archive-card-extract')
-  .name('ArchiveCardExtract')
-  .version('1.0.0')
-  .input({ cardFile: types.file })
-  .output({ result: types.string })
-  .step('extractCard', ixpExtract({
-    project: PROJECT,
-    modelName: 'Archive Cards',
-    name: 'Archive Cards',
-    folderName: 'Shared',
-    fileRef: out('start', 'cardFile'),
-  }))
-  .onError((handler) => handler.return({
-    result: tmpl`could not extract archive card: ${err('extractCard', 'detail')}`,
-  }))
-  .step('readCard', script({
-    code: `const doc = $vars.extractCard.output.ExtractionResult.ResultsDocument || {};
-const fields = Array.isArray(doc.Fields) ? doc.Fields : [];
-const first = fields.length ? fields[0] : {};
-return 'type:' + (doc.DocumentTypeName || '?')
-  + ' fields:' + fields.length
-  + ' first:' + (first.FieldName || '-') + '=' + ((first.Values || [])[0] ?? '-');`,
-  }))
-  .return({ result: out('readCard') })
-  .build();

package/skills/uipath-maestro-flow/examples/BakeOffEntryForm.flow.ts

@@ -1,27 +0,0 @@
-/**
- * CAPABILITY: start a flow from a submitted FORM (`core.trigger.form`).
- *
- * `formTrigger()` takes no arguments. The form's fields are derived from
- * `.input()` — one field per input, required unless the input has a default —
- * so the submitted values ARE the flow's inputs and are read from
- * `$vars.start.output.<name>` exactly like a manual trigger's.
- *
- * Generic scenario: accept an entry into a village bake-off.
- *
- * No local rung renders a form; supply the values with `--input` when running.
- */
-import { flow, formTrigger, script, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('bake-off-entry-form')
-  .name('BakeOffEntryForm')
-  .version('1.0.0')
-  .input({ bakerName: types.string, category: types.string, servings: types.number })
-  .output({ confirmation: types.string })
-  .trigger(formTrigger())
-  .step('confirmEntry', script({
-    code:
-      'return $vars.start.output.bakerName + " entered " + $vars.start.output.category'
-      + ' + " with " + String($vars.start.output.servings) + " servings";',
-  }))
-  .return({ confirmation: out('confirmEntry') })
-  .build();

package/skills/uipath-maestro-flow/examples/BeeHiveLedger.flow.ts

@@ -1,61 +0,0 @@
-/**
- * CAPABILITY: native Data Fabric CRUD — query, create, update, delete.
- *
- * `core.datafabric.*` covers all four verbs, so entity CRUD needs no connector
- * and no connection binding. "Data Service" is the SAME product under its
- * connector name (`uipath-uipath-dataservice`); route there only for what the
- * native family lacks — get-by-id, a query with a row limit, file record
- * fields, and Record Created / Updated events.
- *
- * `record` is exactly one of `{ byId }` or `{ fromRead: '<read step name>' }`.
- * Chaining a write off the read — as here — avoids carrying an id by hand.
- * Filters default to `operator: '='`; `or: true` joins a row with OR.
- *
- * `resultMode: 'multiple'` publishes the matches under `output.results` and
- * selects the read node's 1.4 definition; omit it and the step stays on 1.0 and
- * reads ONE record. A delete publishes NOTHING — take what you need off the
- * read step that found the record, before the delete.
- *
- * Nothing here is checked against the real entity: a column name that does not
- * exist is DROPPED rather than rejected, so the flow validates, runs green, and
- * writes nothing. Resolve columns with `uip df entities get` before trusting a
- * write, and never write a system column (`Id`, `CreateTime`, `CreatedBy`,
- * `UpdateTime`, `UpdatedBy`) — Data Fabric assigns those.
- *
- * Generic scenario: find a hive by its tag, record today's inspection, log it,
- * and clear the stale draft the inspection replaces.
- */
-import {
-  flow, dataFabricRead, dataFabricCreate, dataFabricUpdate, dataFabricDelete,
-  script, input, out, types,
-} from '@uipath/maestro-builder-sdk';
-
-export default flow('bee-hive-ledger')
-  .name('BeeHiveLedger')
-  .version('1.0.0')
-  .input({ hiveTag: types.string, inspectedOn: types.string, draftId: types.string })
-  .output({ ledgerNote: types.string })
-  .step('findHive', dataFabricRead({
-    entity: 'Hives',
-    filters: [{ field: 'HiveTag', value: input('hiveTag') }],
-  }))
-  .step('recordInspection', dataFabricUpdate({
-    entity: 'Hives',
-    record: { fromRead: 'findHive' },
-    set: { LastInspectedOn: input('inspectedOn'), Status: 'Inspected' },
-  }))
-  .step('logInspection', dataFabricCreate({
-    entity: 'HiveInspections',
-    values: { HiveTag: input('hiveTag'), InspectedOn: input('inspectedOn') },
-  }))
-  .step('dropDraft', dataFabricDelete({
-    entity: 'HiveInspectionDrafts',
-    record: { byId: input('draftId') },
-  }))
-  .step('noteLedger', script({
-    code:
-      'return "hive " + $vars.start.output.hiveTag'
-      + ' + " inspected on " + $vars.start.output.inspectedOn;',
-  }))
-  .return({ ledgerNote: out('noteLedger') })
-  .build();

package/skills/uipath-maestro-flow/examples/BeltProgression.flow.ts

@@ -1,53 +0,0 @@
-/**
- * CAPABILITY: an N-way `.switch` — the many-armed sibling of `.branch`.
- *
- * A case matches when `<discriminant> === <case value>`, compared STRICTLY, so
- * the value's type counts (the ranks below are strings, so the cases are
- * strings). The optional last function is the DEFAULT arm, taken when nothing
- * matched. Each arm ends in its own `.return()`.
- *
- * Generic scenario (a dojo belt rank → what its next grading needs) so it reads
- * as "here is the switch shape", not as any task's expected output.
- */
-import { flow, script, input, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('belt-progression')
-  .name('BeltProgression')
-  .version('1.0.0')
-  .input({ rank: types.string })
-  .output({ nextGrading: types.string })
-
-  .switch(
-    'byRank',
-    input('rank'),
-    [
-      {
-        value: 'white',
-        body: (b) =>
-          b
-            .step('whiteNext', script({ code: 'return "yellow: 8 basic forms";' }))
-            .return({ nextGrading: out('whiteNext') }),
-      },
-      {
-        value: 'yellow',
-        body: (b) =>
-          b
-            .step('yellowNext', script({ code: 'return "green: 12 forms plus one spar";' }))
-            .return({ nextGrading: out('yellowNext') }),
-      },
-      {
-        value: 'green',
-        body: (b) =>
-          b
-            .step('greenNext', script({ code: 'return "brown: 20 forms plus board break";' }))
-            .return({ nextGrading: out('greenNext') }),
-      },
-    ],
-    // Default arm — any rank not listed above.
-    (other) =>
-      other
-        .step('unknownRank', script({ code: 'return "see the head instructor";' }))
-        .return({ nextGrading: out('unknownRank') }),
-  )
-
-  .build();

package/skills/uipath-maestro-flow/examples/BirdCountLookup.flow.ts

@@ -1,24 +0,0 @@
-/**
- * CAPABILITY: run a deployed API workflow as one flow step.
- *
- * The workflow key selects the published node; name and folder locate the
- * deployment. Declared returns make its response readable and typed.
- *
- * Generic scenario: look up the latest bird count for a nature reserve.
- */
-import { flow, apiWorkflow, input, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('bird-count-lookup')
-  .name('BirdCountLookup')
-  .version('1.0.0')
-  .input({ reserve: types.string })
-  .output({ count: types.number })
-  .step('lookupCount', apiWorkflow({
-    key: '3a6f4d22-8388-41c7-9f6a-6e4ea9154c32',
-    name: 'Reserve Bird Count',
-    folderPath: 'Shared/nature-observations',
-    inputs: { reserve: input('reserve') },
-    returns: { ObservedBirds: 'integer' },
-  }))
-  .return({ count: out('lookupCount', 'ObservedBirds') })
-  .build();

package/skills/uipath-maestro-flow/examples/ClubDirectory.flow.ts

@@ -1,56 +0,0 @@
-/**
- * CAPABILITY: call a CONNECTOR and read its LIST output as a TYPED COLLECTION.
- *
- *   connector('<connector-key>', '<operation>', { …params }, { connection, folder })
- *
- * The operation is resolved from the curated library at compile — a typo'd
- * operation or field is caught there. A LIST output is a typed collection, so:
- *
- *     $vars.groups.output[0].displayName   // index an element, then a field
- *     $vars.groups.output.length           // a member of the collection
- *     $vars.each.currentItem.displayName   // the loop item, typed from the collection
- *
- * Reading a field off the collection WITHOUT indexing is refused — it is
- * undefined at run time. `connection` / `folder` are `bindings.json` ids (see
- * that file). Narrow a call with the operation's own `where` / `pageSize`
- * parameters — one call is one page.
- *
- * Generic scenario: build a community board of the org's interest groups.
- */
-import { flow, connector, out, script, js, types } from '@uipath/maestro-builder-sdk';
-
-const DIRECTORY = { connection: 'entra', folder: 'shared' } as const;
-
-export default flow('club-directory')
-  .name('ClubDirectory')
-  .output({ headline: types.string, firstContact: types.string })
-
-  // The list call — one page of groups.
-  .step('groups', connector(
-    'uipath-microsoft-azureactivedirectory', 'list-groups',
-    {},
-    DIRECTORY,
-  ))
-
-  // An ELEMENT's field and the collection's LENGTH, in one expression site.
-  .step('headline', script({
-    code: `
-      return { text: $vars.groups.output.length + ' clubs; first up: '
-                   + $vars.groups.output[0].displayName };
-    `,
-  }))
-
-  // Iterate the collection — `currentItem` is typed from what it holds, so the
-  // body's field reads are CHECKED. A loop runs for effect: its results are not
-  // readable after it, so what gates the read below is `check`.
-  .loop('eachClub', out('groups'), (body) =>
-    body.step('poster', script({
-      code: 'return { line: "This week: " + $vars.eachClub.currentItem.displayName };',
-    })),
-  )
-
-  .return({
-    headline: out('headline', 'text'),
-    firstContact: js`$vars.groups.output[0].mail`,
-  })
-  .build();

package/skills/uipath-maestro-flow/examples/ConcertSoundcheck.flow.ts

@@ -1,59 +0,0 @@
-/**
- * CAPABILITY: a `.parallel` fan-out and its join — the builder's only non-linear
- * shape.
- *
- *     .parallel('mergeName', [
- *       (a) => a.step(…).step(…),   // an arm can be a CHAIN
- *       (b) => b.step(…),
- *       (c) => c.step(…),
- *     ])
- *     .step('after', …)   // continues from the Merge, so it sees every arm
- *
- * The name passed to `.parallel` is the MERGE, not a fork — reading its own
- * output is an error (`PARALLEL_HAS_NO_OUTPUT`); read the arms' steps instead.
- * Locally the arms run sequentially, so a green run proves the fork/join graph
- * is right and every arm ran — not that they ran at the same instant. Use it for
- * genuinely independent work.
- *
- * Generic scenario: three independent pre-show checks at a concert. No `.input`:
- * the data is variable defaults so the example is self-contained.
- */
-import { flow, script, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('concert-soundcheck')
-  .name('ConcertSoundcheck')
-  .version('1.0.0')
-  .output({ verdict: types.string })
-
-  .var('mics', types.object, { live: 6, expected: 6 })
-  .var('monitors', types.object, { working: 4, total: 4 })
-  .var('lightingCues', types.number, 18)
-
-  // Three checks with nothing to say to each other → they fan out.
-  .parallel('checksDone', [
-    // An arm can be a CHAIN: count, then phrase it.
-    (a) => a
-      .step('micCount', script({
-        code: 'return $vars.mics.live === $vars.mics.expected ? "all mics live" : ($vars.mics.expected - $vars.mics.live) + " mic(s) dead";',
-      }))
-      .step('micLine', script({
-        code: 'return "mics: " + $vars.micCount.output;',
-      })),
-
-    (b) => b.step('monitorLine', script({
-      code: 'return "monitors: " + ($vars.monitors.working === $vars.monitors.total ? "all good" : $vars.monitors.working + "/" + $vars.monitors.total);',
-    })),
-
-    (c) => c.step('lightingLine', script({
-      code: 'return "lighting: " + ($vars.lightingCues > 0 ? $vars.lightingCues + " cues loaded" : "no cues");',
-    })),
-  ])
-
-  // Runs after the join, so all three arms' outputs are readable here.
-  .step('verdict', script({
-    code: 'return [$vars.micLine.output, $vars.monitorLine.output, $vars.lightingLine.output].join("; ");',
-  }))
-
-  .return({ verdict: out('verdict') })
-
-  .build();

package/skills/uipath-maestro-flow/examples/DoorbellLog.flow.ts

@@ -1,45 +0,0 @@
-/**
- * CAPABILITY: a flow that STARTS on a connector event (`onEvent` trigger).
- *
- *     .trigger(onEvent({
- *       connector: 'uipath-http-webhook',
- *       event: 'http-webhook',
- *       connection: 'bWebhook', folder: 'bWebhookFolder',   // bindings.json ids
- *     }))
- *
- * There is no manual start: the event IS the start, and its payload arrives on
- * `$vars.start.output`. For the HTTP Webhook connector the CONNECTION is the
- * subscription's scope (each connection has its own URL), so there are no event
- * parameters and no `where` — binding the connection is what points the flow at
- * a URL at all. A local run subscribes to nothing; a start trigger's payload is
- * supplied AS FLOW INPUT for the dry run.
- *
- * Generic scenario: a smart doorbell posts to a webhook; the flow logs who rang.
- */
-import { flow, script, onEvent, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('doorbell-log')
-  .name('DoorbellLog')
-  .version('1.0.0')
-  .output({ entry: types.string })
-
-  .trigger(onEvent({
-    connector: 'uipath-http-webhook',
-    event: 'http-webhook',
-    connection: 'bWebhook',
-    folder: 'bWebhookFolder',
-  }))
-
-  // `request_body` is TEXT — parse it, and handle a body that is not JSON, since
-  // a webhook's body is whatever the caller sent.
-  .step('readPing', script({
-    code: `
-      var raw = $vars.start.output.request_body;
-      var who = "unknown";
-      try { who = JSON.parse(raw).visitor || "unknown"; } catch (e) { who = "unparseable"; }
-      return { entry: "doorbell: " + who + " rang" };
-    `,
-  }))
-  .return({ entry: out('readPing', 'entry') })
-
-  .build();

package/skills/uipath-maestro-flow/examples/FestivalMapScaffold.flow.ts

@@ -1,22 +0,0 @@
-/**
- * CAPABILITY: keep an unfinished step in a deployable graph with `mock()`.
- *
- * A placeholder publishes no value. Downstream work must use author-supplied
- * data until the real implementation replaces the placeholder.
- *
- * Generic scenario: reserve a map-rendering step while a festival layout is
- * still being designed.
- */
-import { flow, mock, script, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('festival-map-scaffold')
-  .name('FestivalMapScaffold')
-  .version('1.0.0')
-  .input({ mapName: types.string })
-  .output({ note: types.string })
-  .step('drawLegend', mock())
-  .step('announceDraft', script({
-    code: 'return "festival map draft: " + $vars.start.output.mapName;',
-  }))
-  .return({ note: out('announceDraft') })
-  .build();

package/skills/uipath-maestro-flow/examples/FieldTripQuickForm.flow.ts

@@ -1,45 +0,0 @@
-/**
- * CAPABILITY: a `quick-form` human task with shown and answered fields, routed
- * per outcome.
- *
- * A shown field has `direction: 'input'` and a value from the flow. An answered
- * field has `direction: 'output'` and is read by its id after the reviewer picks
- * an outcome. The explicit variant emits the quick-form node family, which has
- * one exit per outcome (`outcome-approve`, `outcome-revise`): `.stepSwitch`
- * gives each one its own arm. A plain `.step()` after the task would instead
- * continue every outcome to that one next step.
- *
- * Generic scenario: a coordinator reviews a proposed field-trip destination.
- */
-import { flow, hitl, input, lit, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('field-trip-quick-form')
-  .name('FieldTripQuickForm')
-  .version('1.0.0')
-  .input({ destination: types.string })
-  .output({ outcome: types.string, note: types.string })
-  .stepSwitch('review', hitl({
-    variant: 'quick-form',
-    title: 'Review field trip',
-    priority: 'Medium',
-    fields: [
-      {
-        id: 'destination',
-        label: 'Destination',
-        type: 'text',
-        direction: 'input',
-        value: input('destination'),
-      },
-      {
-        id: 'note',
-        label: 'Coordinator note',
-        type: 'text',
-        direction: 'output',
-      },
-    ],
-    outcomes: ['Approve', 'Revise'],
-  }), [
-    { value: 'Approve', body: (b) => b.return({ outcome: lit('approved'), note: out('review', 'note') }) },
-    { value: 'Revise', body: (b) => b.return({ outcome: lit('sent back for revision'), note: out('review', 'note') }) },
-  ])
-  .build();

package/skills/uipath-maestro-flow/examples/FossilCatalogEnrich.flow.ts

@@ -1,26 +0,0 @@
-/**
- * CAPABILITY: append AI-generated columns to an uploaded CSV with batch transform.
- *
- * The service receives a file attachment and returns a new file handle. Each
- * output column declares both the CSV header and the instruction for its cells.
- *
- * Generic scenario: add era and material labels to a fossil catalog export.
- */
-import { flow, batchTransform, out, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('fossil-catalog-enrich')
-  .name('FossilCatalogEnrich')
-  .version('1.0.0')
-  .input({ catalogFile: types.file })
-  .output({ result: types.file })
-  .step('labelSpecimens', batchTransform({
-    attachment: out('start', 'catalogFile'),
-    prompt: 'Classify each specimen from the catalog description.',
-    outputColumns: [
-      { name: 'Era', description: 'The geological era most consistent with the row' },
-      { name: 'Material', description: 'The preserved material described by the row' },
-    ],
-    enableWebSearchGrounding: false,
-  }))
-  .return({ result: out('labelSpecimens') })
-  .build();

package/skills/uipath-maestro-flow/examples/GallerySubmission.flow.ts

@@ -1,67 +0,0 @@
-/**
- * CAPABILITY: a `hitl` human task, and routing on WHICH BUTTON was pressed.
- *
- * More than one outcome routes PER OUTCOME by default: the task leaves on an
- * `outcome-<slug>` exit, one per button, and `.stepSwitch` gives each of them an
- * arm. There is no tacit next step and no decision node in the middle — an arm
- * that does not `.return()` converges, which is why a flow VARIABLE plus one
- * `.return()` beats returning separately from every arm.
- *
- *   fields[]:  direction: 'input'  → shown to the reviewer (bind to a value)
- *              direction: 'output' → the reviewer fills it in (read by id)
- *   outcomes[]: the buttons; each one gets an arm
- *
- * Generic scenario (an art-gallery submission going to a curator) so it teaches
- * the human-task shape rather than a task answer.
- */
-import { flow, hitl, script, input, out, v, lit, types } from '@uipath/maestro-builder-sdk';
-
-export default flow('gallery-submission')
-  .name('GallerySubmission')
-  .version('1.0.0')
-  .input({ title: types.string, medium: types.string, widthCm: types.number, heightCm: types.number })
-  .output({ outcome: types.string, note: types.string })
-  // The arms' shared state. Its names are NOT the outputs' names: inputs, outputs
-  // and vars share one list in the .flow, so `.var('outcome')` beside the `outcome`
-  // output would be two globals with one id (`check`: VARIABLE_NAME_COLLISION).
-  .var('decision', types.string)
-  .var('curatorReply', types.string)
-
-  // A derived fact for the curator to judge by, rather than raw dimensions.
-  .step('wallSpace', script({
-    code: 'return Math.round(($vars.start.output.widthCm * $vars.start.output.heightCm) / 100) + " dm2 of wall";',
-  }))
-
-  // One arm per button. Each assigns the shared variables; the single return reads them.
-  .stepSwitch('curate', hitl({
-    title: 'Curate submission',
-    priority: 'Medium',
-    fields: [
-      { id: 'pieceTitle', label: 'Title', type: 'text', direction: 'input', value: input('title') },
-      { id: 'medium', label: 'Medium', type: 'text', direction: 'input', value: input('medium') },
-      { id: 'wall', label: 'Wall space', type: 'text', direction: 'input', value: out('wallSpace') },
-      { id: 'note', label: 'Curator note', type: 'text', direction: 'output' },
-    ],
-    outcomes: ['Accept', 'Decline'],
-  }), [
-    {
-      value: 'Accept',
-      body: (b) => b.step(
-        'hang',
-        script({ code: 'return "accepted for the spring wall: " + $vars.curate.output.note;' }),
-        { updates: { decision: lit('Accept'), curatorReply: out('hang') } },
-      ),
-    },
-    {
-      value: 'Decline',
-      body: (b) => b.step(
-        'returnPiece',
-        script({ code: 'return "returned to artist: " + $vars.curate.output.note;' }),
-        { updates: { decision: lit('Decline'), curatorReply: out('returnPiece') } },
-      ),
-    },
-  ])
-
-  .return({ outcome: v('decision'), note: v('curatorReply') })
-
-  .build();