@uipath/maestro-builder-sdk 6.67.1 → 6.68.1

package/dist/bpmn/bpmn-sdk.d.ts

@@ -25,8 +25,8 @@ import type { ConnectorDescriptor } from '../core/connectors.js';
 import type { RegistryTypeSpec, TypedContextRow, TypedInputRow, TypedOutputRow } from './typed-node.js';
 import { type HumanTaskForm } from './human-task-form.js';
 export type { HumanTaskForm, HumanTaskFormField, HumanTaskShownField, HumanTaskAskedField, HumanTaskInOutField, HumanTaskOutcome, } from './human-task-form.js';
-import { type DataServiceOperation } from './data-service.js';
-export type { DataServiceOperation } from './data-service.js';
+import { type DataServiceEntity, type DataServiceOperation } from './data-service.js';
+export type { DataServiceEntity, DataServiceFolderEntity, DataServiceOperation } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
 export type { BpmnLocatedDiagnostic } from './bpmn-expr-check.js';
 export { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
@@ -1121,8 +1121,15 @@ export interface BindingOpts {
 export interface DataServiceOpts extends ActivityOpts {
     /** Display name the designer shows. Defaults to one built from the operation, e.g. `Create ContractRegistry`. */
     name?: string;
-    /** The Data Service entity the operation addresses, e.g. `'ContractRegistry'`. */
-    entity: string;
+    /**
+     * The Data Service entity the operation addresses: a tenant-level entity by name, e.g.
+     * `'ContractRegistry'`, or a FOLDER-scoped one as `{ name, folderKey }` — what Studio
+     * Web's folder entity picker selects. A folder-scoped entity is written with the
+     * connector's `_V3` operations (`entityScope=folder`, `folderEntityName`,
+     * `folderEntityName_folderKey`); see {@link DataServiceFolderEntity}. Not to be confused
+     * with `folder`, which is where the CONNECTION lives.
+     */
+    entity: DataServiceEntity;
     /**
      * The Data Fabric connection: the id of a `.binding()` declared with
      * `propertyAttribute: 'ConnectionId'` (with or without the `=bindings.` prefix), or
@@ -2522,6 +2529,31 @@ declare abstract class ScopeBuilder {
      * The response lands in `outputVar` (default `<id>_response`) and the error payload in
      * `<id>_Error`, both declared for you.
      *
+     * **A folder-scoped entity** — one Studio Web's entity picker lists under an
+     * Orchestrator folder rather than at tenant level — is `entity: { name, folderKey }`.
+     * The record operations (create, update, get, query, delete) then write the connector's
+     * `_V3` operation, which selects the entity with `entityScope=folder`,
+     * `folderEntityName` and `folderEntityName_folderKey` query rows. The file operations
+     * refuse it. `folderKey` is the entity's folder; `folder` stays the connection's.
+     *
+     * @example
+     * **Create a record in a folder-scoped entity**
+     * ```ts
+     * bpmn('picker')
+     *   .startEvent('start')
+     *   .dataService('create', {
+     *     entity: { name: 'SkillPickerEvalEntity', folderKey: 'c4359cde-55f0-4f0e-9322-c6cdce74ab4c' },
+     *     connection: '0f6156da-7a1c-4cd8-910e-d7fd338baef7',
+     *     folder: 'c4359cde-55f0-4f0e-9322-c6cdce74ab4c',
+     *     op: 'create',
+     *     record: { title: 'PickerTest' },
+     *   })
+     *   .endEvent('done')
+     *   .sequenceFlow('start', 'create')
+     *   .sequenceFlow('create', 'done')
+     *   .build();
+     * ```
+     *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
      * @param opts - The entity, connection and folder, plus the operation and its parameters — see {@link DataServiceOpts} and {@link DataServiceOperation}.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.

package/dist/bpmn/bpmn-sdk.js

@@ -1123,6 +1123,31 @@ class ScopeBuilder {
      * The response lands in `outputVar` (default `<id>_response`) and the error payload in
      * `<id>_Error`, both declared for you.
      *
+     * **A folder-scoped entity** — one Studio Web's entity picker lists under an
+     * Orchestrator folder rather than at tenant level — is `entity: { name, folderKey }`.
+     * The record operations (create, update, get, query, delete) then write the connector's
+     * `_V3` operation, which selects the entity with `entityScope=folder`,
+     * `folderEntityName` and `folderEntityName_folderKey` query rows. The file operations
+     * refuse it. `folderKey` is the entity's folder; `folder` stays the connection's.
+     *
+     * @example
+     * **Create a record in a folder-scoped entity**
+     * ```ts
+     * bpmn('picker')
+     *   .startEvent('start')
+     *   .dataService('create', {
+     *     entity: { name: 'SkillPickerEvalEntity', folderKey: 'c4359cde-55f0-4f0e-9322-c6cdce74ab4c' },
+     *     connection: '0f6156da-7a1c-4cd8-910e-d7fd338baef7',
+     *     folder: 'c4359cde-55f0-4f0e-9322-c6cdce74ab4c',
+     *     op: 'create',
+     *     record: { title: 'PickerTest' },
+     *   })
+     *   .endEvent('done')
+     *   .sequenceFlow('start', 'create')
+     *   .sequenceFlow('create', 'done')
+     *   .build();
+     * ```
+     *
      * @param id - The element id, unique in the process and used by `sequenceFlow`.
      * @param opts - The entity, connection and folder, plus the operation and its parameters — see {@link DataServiceOpts} and {@link DataServiceOperation}.
      * @param body - Boundary events attached to this activity, declared on the {@link ActivityBuilder} it receives.

package/dist/bpmn/data-service.d.ts

@@ -30,6 +30,29 @@
  * `file`, and typed as the converter types it (`integer` for `start`, `limit`,
  * `expansionLevel`); only the record itself is a json `body` row. Nothing here needs
  * the connector library.
+ *
+ * A **folder-scoped** entity (`entity: { name, folderKey }`, #1392) has a third form: the
+ * connector's `_V3` operations (`CreateEntityRecord_V3`, …), which select the entity with
+ * query parameters instead of the path — `entityScope=folder`, the solution-resource
+ * picker `folderEntityName`, and its companion `folderEntityName_folderKey`, the
+ * Orchestrator folder the entity lives in. The parameter names, targets and paths are
+ * `uip is resources describe uipath-uipath-dataservice <Op>_V3`'s. The `_V3` file operations
+ * declare no field-name parameter (the file field is a dynamic field from the entity's
+ * schema), so where they take it is not known here, and they refuse a folder-scoped
+ * entity rather than guess.
+ *
+ * **No `Entity` binding rows, by design.** The Maestro designer (PO.Frontend
+ * `IntsvcActivityProperties.tsx`) has two paths. Its V1 path, which writes this per-row
+ * shape, renders the connector with `enableResourceFields: false`: there is no resource
+ * picker, so the entity and folder are literal rows. Only its V2 path — a solution, an
+ * `activityConfigurationVersion` of `v2`, the parameters as one `queryParameters` json
+ * input and Studio Web's serialized configuration in `metadata` — mints the
+ * `resource="entity"` `name` / `folderKey` binding pair (`createActivityBindingMinter`),
+ * records `savedResourceSelections`, and packages a `Scope: "Folder"` entry into
+ * `bindings_v2.json`. That configuration blob is the design-time client's output, which
+ * nothing in the SDK can build offline — the same gap as Flow's #849. Until a V2 connector
+ * emitter exists, a folder-scoped entity is fixed at compile time, not re-pointable per
+ * environment at deploy.
  */
 import type { TypedInputRow } from './typed-node.js';
 /** The connector key the tenant lists Data Fabric under. */
@@ -113,6 +136,23 @@ export type DataServiceOperation = {
     /** The file field's name. */
     field: string;
 };
+/**
+ * A Data Fabric entity in an Orchestrator folder — what Studio Web's folder-scoped entity
+ * picker selects, as opposed to a tenant-level entity named by a plain string.
+ */
+export interface DataServiceFolderEntity {
+    /** The entity's name, e.g. `'SkillPickerEvalEntity'`. */
+    name: string;
+    /**
+     * The key of the Orchestrator folder the entity lives in (a GUID: `uip or folders
+     * list --all --path <FolderPath> --output json` → `Key`; without `--all` the list holds
+     * only the caller's own folders), or a `=`-expression yielding it. Never the folder's
+     * PATH (`'Shared'`): that is refused, since it would compile, validate and fail at run time.
+     */
+    folderKey: string;
+}
+/** A tenant-level entity by name, or a folder-scoped one — see {@link DataServiceFolderEntity}. */
+export type DataServiceEntity = string | DataServiceFolderEntity;
 /** What the wire needs for one operation, before bindings and outputs are added. */
 export interface DataServiceWire {
     /** A display name when the author gave none, e.g. `Create ContractRegistry`. */
@@ -125,8 +165,12 @@ export interface DataServiceWire {
 /**
  * The context and payload rows for one operation on one entity.
  *
- * @param entity - The Data Service entity, e.g. `'ContractRegistry'`.
+ * @param entity - The Data Service entity: a name, e.g. `'ContractRegistry'`, or a
+ * folder-scoped `{ name, folderKey }`.
  * @param operation - Which operation, and its parameters.
  * @returns The wire shape, without the connection/folder wiring the builder adds.
+ * @throws CompileRefusal for a folder-scoped entity on a file operation (`BPMN_DATA_SERVICE_FOLDER_FILE_OP`), or one with no name
+ *   (`BPMN_DATA_SERVICE_ENTITY_NO_NAME`), no folder key (`BPMN_DATA_SERVICE_FOLDER_KEY_MISSING`) or a folder key that is not a
+ *   key (`BPMN_DATA_SERVICE_FOLDER_KEY_NOT_GUID`).
  */
-export declare function dataServiceWire(entity: string, operation: DataServiceOperation): DataServiceWire;
+export declare function dataServiceWire(entity: DataServiceEntity, operation: DataServiceOperation): DataServiceWire;

package/dist/bpmn/data-service.js

@@ -1,3 +1,5 @@
+import { CompileRefusal } from '../core/compile-refusal.js';
+import { ownEntry } from '../core/own-entry.js';
 /** The connector key the tenant lists Data Fabric under. */
 export const DATA_SERVICE_CONNECTOR_KEY = 'uipath-uipath-dataservice';
 /** The extension type every Integration Service activity dispatches through. */
@@ -5,11 +7,17 @@ export const DATA_SERVICE_ACTIVITY_TYPE = 'Intsvc.ActivityExecution';
 /**
  * The context and payload rows for one operation on one entity.
  *
- * @param entity - The Data Service entity, e.g. `'ContractRegistry'`.
+ * @param entity - The Data Service entity: a name, e.g. `'ContractRegistry'`, or a
+ * folder-scoped `{ name, folderKey }`.
  * @param operation - Which operation, and its parameters.
  * @returns The wire shape, without the connection/folder wiring the builder adds.
+ * @throws CompileRefusal for a folder-scoped entity on a file operation (`BPMN_DATA_SERVICE_FOLDER_FILE_OP`), or one with no name
+ *   (`BPMN_DATA_SERVICE_ENTITY_NO_NAME`), no folder key (`BPMN_DATA_SERVICE_FOLDER_KEY_MISSING`) or a folder key that is not a
+ *   key (`BPMN_DATA_SERVICE_FOLDER_KEY_NOT_GUID`).
  */
 export function dataServiceWire(entity, operation) {
+    if (typeof entity !== 'string')
+        return folderEntityWire(entity, operation);
     const attachment = '/Attachment/{entityName}/{recordId}/{fieldName}';
     switch (operation.op) {
         case 'create':
@@ -86,6 +94,87 @@ export function dataServiceWire(entity, operation) {
             };
     }
 }
+/** The `_V3` scope rows' wire names, as `describe` declares them and the canvas writes them. */
+const FOLDER_SCOPE = {
+    scopeParameter: 'entityScope',
+    scopeValue: 'folder',
+    nameParameter: 'folderEntityName',
+    folderKeyParameter: 'folderEntityName_folderKey',
+};
+/** The five `_V3` record operations, from `uip is resources describe uipath-uipath-dataservice <Op>_V3`. */
+const FOLDER_OPERATIONS = {
+    create: { operation: 'Create', objectName: 'CreateEntityRecord_V3', method: 'POST', path: '/v3/CreateEntityRecord/insert', label: (e) => `Create ${e}` },
+    update: { operation: 'Replace', objectName: 'UpdateEntityRecord_V3', method: 'PUT', path: '/v3/UpdateEntityRecord/update', label: (e) => `Update ${e}` },
+    get: { operation: 'List', objectName: 'GetEntityRecord_V3', method: 'GET', path: '/v3/GetEntityRecord/read', label: (e) => `Get ${e} record` },
+    query: { operation: 'Create', objectName: 'QueryEntityRecords_V3', method: 'POST', path: '/v3/QueryEntityRecords/query', label: (e) => `Query ${e}` },
+    delete: { operation: 'Create', objectName: 'DeleteEntityRecord_V3', method: 'POST', path: '/v3/DeleteEntityRecord/delete', label: (e) => `Delete ${e} record` },
+};
+/** A folder key: a GUID, as `uip or folders list` returns it. */
+const GUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Refuse a folder-scoped entity whose name or folder key cannot be right, at the
+ * call that wrote it. The folder key is the trap: the connector's `describe` labels
+ * the parameter "Orchestrator Folder Path", so a path (`'Shared'`) is the likely
+ * mistake, and it builds, checks and validates, then fails at run time.
+ */
+function validateFolderEntity(entity) {
+    if (typeof entity?.name !== 'string' || entity.name.trim() === '') {
+        throw new CompileRefusal('BPMN_DATA_SERVICE_ENTITY_NO_NAME', 'dataService: a folder-scoped entity needs its name: entity: { name, folderKey }.');
+    }
+    const key = entity.folderKey;
+    if (typeof key !== 'string' || key.trim() === '') {
+        throw new CompileRefusal('BPMN_DATA_SERVICE_FOLDER_KEY_MISSING', `dataService: the folder-scoped entity "${entity.name}" needs the key of the Orchestrator folder it lives in: entity: { name, folderKey }. ` +
+            'Find it with: uip or folders list --all --path <FolderPath> --output json (its Key).');
+    }
+    if (!key.startsWith('=') && !GUID.test(key)) {
+        throw new CompileRefusal('BPMN_DATA_SERVICE_FOLDER_KEY_NOT_GUID', `dataService: folderKey ${JSON.stringify(key)} for entity "${entity.name}" is not a folder key. It takes the folder's KEY (a GUID) or a =-expression, ` +
+            `not its path. Find it with: uip or folders list --all --path ${/\s/.test(key) ? `'${key}'` : key} --output json (its Key).`);
+    }
+}
+/**
+ * The `_V3` form for a folder-scoped entity. The three scope rows come first, then the
+ * operation's own parameters, which `_V3` takes as query rows where the tenant forms
+ * use the path (`recordId`, never `id`).
+ */
+function folderEntityWire(entity, operation) {
+    validateFolderEntity(entity);
+    if (operation.op === 'downloadFile' || operation.op === 'uploadFile' || operation.op === 'deleteFile') {
+        throw new CompileRefusal('BPMN_DATA_SERVICE_FOLDER_FILE_OP', `dataService: ${operation.op} does not support a folder-scoped entity yet. Its _V3 operation declares no field-name parameter, ` +
+            `so where it takes "${operation.field}" is unknown here. Use a tenant-level entity (entity: '${entity.name}'), or write the task with .activity().`);
+    }
+    const scope = [
+        scalarRow(FOLDER_SCOPE.scopeParameter, 'query', FOLDER_SCOPE.scopeValue),
+        scalarRow(FOLDER_SCOPE.nameParameter, 'query', entity.name),
+        scalarRow(FOLDER_SCOPE.folderKeyParameter, 'query', entity.folderKey),
+    ];
+    const op = ownEntry(FOLDER_OPERATIONS, operation.op);
+    const wire = (inputRows) => ({
+        label: op.label(entity.name),
+        context: { operation: op.operation, objectName: op.objectName, method: op.method, path: op.path },
+        inputRows: [...scope, ...inputRows],
+    });
+    switch (operation.op) {
+        case 'create':
+            return wire([bodyRow(operation.record)]);
+        case 'update':
+            return wire([scalarRow('recordId', 'query', operation.id), bodyRow(operation.record)]);
+        case 'get':
+            return wire([scalarRow('recordId', 'query', operation.recordId), ...optionalRow('expansionLevel', 'query', operation.expansionLevel)]);
+        case 'query':
+            return wire([
+                ...optionalRow('queryExpression', 'query', operation.where),
+                scalarRow('start', 'query', operation.start ?? 0),
+                scalarRow('limit', 'query', operation.limit ?? 100),
+                ...optionalRow('isAscending', 'query', operation.ascending),
+                ...optionalRow('expansionLevel', 'query', operation.expansionLevel),
+                // The sort field is a body field here too: `_sortFieldName` is the one
+                // `RequestFields` entry `QueryEntityRecords_V3` declares.
+                ...(operation.sortBy !== undefined ? [bodyRow({ _sortFieldName: operation.sortBy })] : []),
+            ]);
+        case 'delete':
+            return wire([scalarRow('recordId', 'query', operation.recordId)]);
+    }
+}
 function fileFieldRows(entity, recordId, field) {
     return [scalarRow('entityName', 'path', entity), scalarRow('recordId', 'path', recordId), scalarRow('fieldName', 'path', field)];
 }

package/dist/core/library.js

@@ -337,11 +337,13 @@ export class Library {
             // START form of none (448 `.event.` entries, 0 `.trigger.`; only the curated
             // overlay adds a handful of `.trigger.` pairs). The platform ships both for
             // one operation and the namespace is the only difference, so the start form
-            // is DERIVED from its wait sibling here — measured against the platform's
-            // own `registry get` answers for both forms (see `deriveTriggerForm`).
-            if (kind !== 'trigger')
+            // is DERIVED from its wait sibling — measured against the platform's own
+            // `registry get` answers for both forms (see `deriveTriggerForm`).
+            // `eventFallback` is the one place that says so; `identifyEvent` reads it too.
+            const fallback = eventFallback(kind);
+            if (!fallback)
                 throw error;
-            const siblingType = `uipath.connector.event.${key}.${event}`;
+            const siblingType = `uipath.connector.${fallback.ns}.${key}.${event}`;
             let sibling;
             try {
                 sibling = this.resolveType(siblingType, version, objectName);
@@ -355,7 +357,7 @@ export class Library {
                     throw siblingError;
                 throw error;
             }
-            rc = deriveTriggerForm(sibling, nodeType);
+            rc = fallback.derive(sibling, nodeType);
         }
         return normalizeEventOperation(rc);
     }
@@ -365,31 +367,40 @@ export class Library {
      * {@link identifyAction} for connector activities.
      */
     identifyEvent(kind, wire) {
-        const prefix = `uipath.connector.${kind}.${wire.connectorKey}.`;
-        for (const layer of this.layers) {
-            for (const indexed of layer.entries) {
-                if (indexed.connectorKey !== wire.connectorKey || !String(indexed.nodeType ?? '').startsWith(prefix))
-                    continue;
-                if (wire.version && indexed.version !== wire.version)
-                    continue;
-                const entryPath = libraryPath(layer.dir, indexed.path);
-                const entry = readJson(this.read, entryPath);
-                const operation = normalizeEventOperation({ entry, v1def: readV1def(this.read, entryPath) }).entry.operation ?? {};
-                // A GENERIC event's entry names no object — the wire's object is the
-                // author's choice, so it identifies nothing here and comes back as `object`.
-                const generic = operation.activityType === 'GenericTrigger';
-                if (!generic && wire.objectName && operation.objectName !== wire.objectName)
-                    continue;
-                if (wire.eventOperation && operation.eventOperation !== wire.eventOperation)
-                    continue;
-                if (wire.eventMode && operation.eventMode !== wire.eventMode)
-                    continue;
-                return {
-                    key: wire.connectorKey,
-                    event: String(indexed.nodeType).slice(prefix.length),
-                    version: String(indexed.version),
-                    ...(generic && wire.objectName ? { object: wire.objectName } : {}),
-                };
+        // The same sources, in the same order, that `resolveEvent` reads: a trigger
+        // the library carries only in its WAIT form is identified from that entry,
+        // passed through the same derivation compile used to write it (#1073).
+        const fallback = eventFallback(kind);
+        const sources = [{ ns: kind, derive: undefined }, ...(fallback ? [fallback] : [])];
+        for (const source of sources) {
+            const prefix = `uipath.connector.${source.ns}.${wire.connectorKey}.`;
+            for (const layer of this.layers) {
+                for (const indexed of layer.entries) {
+                    if (indexed.connectorKey !== wire.connectorKey || !String(indexed.nodeType ?? '').startsWith(prefix))
+                        continue;
+                    if (wire.version && indexed.version !== wire.version)
+                        continue;
+                    const event = String(indexed.nodeType).slice(prefix.length);
+                    const entryPath = libraryPath(layer.dir, indexed.path);
+                    const read = { entry: readJson(this.read, entryPath), v1def: readV1def(this.read, entryPath) };
+                    const asked = source.derive ? source.derive(read, `uipath.connector.${kind}.${wire.connectorKey}.${event}`) : read;
+                    const operation = normalizeEventOperation(asked).entry.operation ?? {};
+                    // A GENERIC event's entry names no object — the wire's object is the
+                    // author's choice, so it identifies nothing here and comes back as `object`.
+                    const generic = operation.activityType === 'GenericTrigger';
+                    if (!generic && wire.objectName && operation.objectName !== wire.objectName)
+                        continue;
+                    if (wire.eventOperation && operation.eventOperation !== wire.eventOperation)
+                        continue;
+                    if (wire.eventMode && operation.eventMode !== wire.eventMode)
+                        continue;
+                    return {
+                        key: wire.connectorKey,
+                        event,
+                        version: String(indexed.version),
+                        ...(generic && wire.objectName ? { object: wire.objectName } : {}),
+                    };
+                }
             }
         }
         throw new CompileRefusal('EVENT_UNKNOWN', `connector ${kind} event not found in library: ${wire.connectorKey} `
@@ -1146,6 +1157,23 @@ function normalizeEventOperation(rc) {
     };
     return { ...rc, entry: { ...rc.entry, operation: normalized } };
 }
+/**
+ * The fallback the library uses for a connector event of `kind` that its own
+ * namespace cannot resolve, or `undefined` when there is none.
+ *
+ * A start (`trigger`) falls back to its wait form, DERIVED by `deriveTriggerForm`,
+ * because the registry dump ships wait forms only. A wait (`event`) has no
+ * fallback.
+ *
+ * `resolveEvent` (TypeScript to wire) and `identifyEvent` (wire back to
+ * TypeScript) both read this, so the reverse lookup cannot miss an entry the
+ * forward one resolved (#1073: decompile threw "connector trigger event not
+ * found" for every trigger the library carried only as `.event.`).
+ */
+function eventFallback(kind) {
+    return kind === 'trigger' ? TRIGGER_FALLBACK : undefined;
+}
+const TRIGGER_FALLBACK = { ns: 'event', derive: (rc, nodeType) => deriveTriggerForm(rc, nodeType) };
 /**
  * Derive a connector event's START form (`uipath.connector.trigger.<key>.<event>`)
  * from its WAIT form (`uipath.connector.event.<key>.<event>`).

package/dist/core/refusals.d.ts

@@ -72,6 +72,10 @@ export declare const REFUSALS: {
     readonly BPMN_CHOOSE_ARM_NO_WHEN: "lowering";
     readonly BPMN_CHOOSE_MANY_OTHERWISE: "lowering";
     readonly BPMN_CONTEXT_FIELD_UNKNOWN: "lowering";
+    readonly BPMN_DATA_SERVICE_ENTITY_NO_NAME: "lowering";
+    readonly BPMN_DATA_SERVICE_FOLDER_FILE_OP: "lowering";
+    readonly BPMN_DATA_SERVICE_FOLDER_KEY_MISSING: "lowering";
+    readonly BPMN_DATA_SERVICE_FOLDER_KEY_NOT_GUID: "lowering";
     readonly BPMN_DUP_BOUNDARY_ID: "lowering";
     readonly BPMN_DUP_ERROR_CATCH: "lowering";
     readonly BPMN_ERROR_NAME_EMPTY: "lowering";

package/dist/core/refusals.js

@@ -120,6 +120,10 @@ export const REFUSALS = {
     BPMN_CHOOSE_ARM_NO_WHEN: 'lowering',
     BPMN_CHOOSE_MANY_OTHERWISE: 'lowering',
     BPMN_CONTEXT_FIELD_UNKNOWN: 'lowering',
+    BPMN_DATA_SERVICE_ENTITY_NO_NAME: 'lowering',
+    BPMN_DATA_SERVICE_FOLDER_FILE_OP: 'lowering',
+    BPMN_DATA_SERVICE_FOLDER_KEY_MISSING: 'lowering',
+    BPMN_DATA_SERVICE_FOLDER_KEY_NOT_GUID: 'lowering',
     BPMN_DUP_BOUNDARY_ID: 'lowering',
     BPMN_DUP_ERROR_CATCH: 'lowering',
     BPMN_ERROR_NAME_EMPTY: 'lowering',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.67.1",
+  "version": "6.68.1",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "65595ae4c46cbbf4515e357d3cb4b3fbe2f33715"
+  "gitref": "cc5d3156131d305c073258591e362deb7f4fbbde"
 }