@uipath/maestro-builder-sdk 6.52.0 → 6.52.2

package/dist/case/action-output-var.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The case variable a human task's form output writes when the author gives no
+ * `value`. Shared by the serializer, which writes the row, and the build-time
+ * expression check, which must count that variable as declared.
+ *
+ * @module
+ */
+/**
+ * The case variable an action output writes when the author gives no `value`:
+ * the Designer's camelCase of the field name (`Comment` → `comment`), or the
+ * name itself when that leaves nothing (a name of only punctuation).
+ */
+export declare function defaultActionOutputVar(name: string): string;
+/**
+ * The Designer's `camelizeDisplayName`: drop non-identifier characters, split on
+ * spaces/underscores, lower the first letter of the first word and upper the
+ * first letter of the rest (`APIOutput1` → `aPIOutput1`).
+ */
+export declare function camelizeName(name: string): string;

package/dist/case/action-output-var.js

@@ -0,0 +1,24 @@
+/**
+ * The case variable a human task's form output writes when the author gives no
+ * `value`. Shared by the serializer, which writes the row, and the build-time
+ * expression check, which must count that variable as declared.
+ *
+ * @module
+ */
+/**
+ * The case variable an action output writes when the author gives no `value`:
+ * the Designer's camelCase of the field name (`Comment` → `comment`), or the
+ * name itself when that leaves nothing (a name of only punctuation).
+ */
+export function defaultActionOutputVar(name) {
+    return camelizeName(name) || name;
+}
+/**
+ * The Designer's `camelizeDisplayName`: drop non-identifier characters, split on
+ * spaces/underscores, lower the first letter of the first word and upper the
+ * first letter of the rest (`APIOutput1` → `aPIOutput1`).
+ */
+export function camelizeName(name) {
+    const words = name.replace(/[^a-zA-Z0-9_ ]/g, '').split(/[\s_]+/).filter(Boolean);
+    return words.map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() : w.charAt(0).toUpperCase()) + w.slice(1)).join('');
+}

package/dist/case/case-expr-check.js

@@ -16,6 +16,7 @@
  * `case/check.ts`, not here.
  */
 import { checkExpression } from '../core/expr-check.js';
+import { defaultActionOutputVar } from './action-output-var.js';
 const NOUN = 'case variable';
 const NAMESPACE = 'vars';
 function checkExpr(expr, where, roots, out) {
@@ -44,12 +45,12 @@ export function checkCaseExpressions(built) {
                     roots.add(o.var);
                 // A human task's form outputs declare one too: the field's `value` is the
                 // variable the assignee's answer lands in (`.action({ outputs: [{ name:
-                // 'Action', value: 'decision' }] })` → `vars.decision`). The serializer
-                // registers exactly that companion (`emitActionField`), so a gate on it
-                // is a declared read, not a typo.
+                // 'Action', value: 'decision' }] })` → `vars.decision`). With no `value`
+                // the serializer writes the field's camelCased name (`approved` →
+                // `vars.approved`, builder-sdk#1422). Either way `emitActionField` writes
+                // that variable, so a gate on it is a declared read, not a typo.
                 for (const f of task.action?.outputs ?? [])
-                    if (f.value)
-                        roots.add(f.value);
+                    roots.add(f.value ?? defaultActionOutputVar(f.name));
             }
     // Event-trigger payload extractions declare readable case variables too.
     for (const t of built.triggers)

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

@@ -514,7 +514,14 @@ export interface ActionField {
     subType?: string;
     /** Human-facing label (defaults to `name` in the UI when omitted). */
     displayName?: string;
-    /** Input literal/expression, or the readable variable name for an output field. */
+    /**
+     * Input literal/expression, or the case variable an output field writes. An
+     * output without `value` writes the camelCased field name, made unique across
+     * the plan (`Comment` → `comment`, a second `Comment` → `comment2`), as the
+     * Case Designer does. Set `value` on any output another step reads: the
+     * default suffix depends on task order, so adding an earlier task with the
+     * same output name would move the unsuffixed variable to that task.
+     */
     value?: string;
     /** Require `value` to be non-empty at validation time. */
     required?: boolean;

package/dist/case/decompile.js

@@ -506,7 +506,11 @@ function connectorVersion(context) {
     const encoded = metadata?.activityPropertyConfiguration?.configuration;
     if (typeof encoded === 'string' && encoded.startsWith('=jsonString:')) {
         try {
-            return JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration?.packageVersion;
+            // The activity's version is `instanceParameters.version`. `packageVersion`
+            // is what the platform writes as "1.0.0" on every activity; an SDK plan
+            // once wrote the library version there, so it stays the fallback.
+            const essential = JSON.parse(encoded.slice('=jsonString:'.length))?.essentialConfiguration;
+            return essential?.instanceParameters?.version ?? essential?.packageVersion;
         }
         catch {
             throw new Error('connector task has malformed activity metadata configuration JSON.');

package/dist/case/serialize.js

@@ -11,7 +11,9 @@
 import { IdGen, offlineBindingSeed } from './ids.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { v31TaskSets } from './task-sets.js';
-import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
+import { camelizeName, defaultActionOutputVar } from './action-output-var.js';
+import { buildConnectorInputs, nestConnectorBody, replayInputsOf, transportHttpMethod } from '../core/connector-inputs.js';
+import { buildEssentialConfiguration } from '../core/connector-configuration.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
@@ -1166,10 +1168,17 @@ function stableUuid(seed) {
 // extracts a result field (`source`) into a case variable (`var`), registering a
 // root `inputOutputs` companion (`id === var`) so `=vars.<var>` resolves.
 /**
- * One action-task form field → a schema `InputOutput` row. Unlike reference-mode
- * io-binding, most form fields carry only a name + type plus optional Action
- * Center metadata. A designer output with `value` names its readable case
- * variable and therefore also carries the standard output identity fields.
+ * One action-task form field → a schema `InputOutput` row. Inputs carry only a
+ * name + type plus optional Action Center metadata. Every OUTPUT also carries
+ * the standard output identity fields (`id`, `var`, `source`, `target`,
+ * `elementId`): the Designer writes them on every output it saves, and
+ * `uip maestro case validate` refuses an output without an id
+ * (`CASE_MGMT_OUTPUT_ID_MISSING`).
+ *
+ * An output's `value` names the case variable it writes. With no `value`, the
+ * variable is the Designer's default: the camelCased field name, made unique
+ * across the plan (`Comment` → `comment`, a second `Comment` → `comment2`), as
+ * its own variable — never a reassignment of the first one.
  */
 function emitActionField(f, outputElementId, resolver) {
     const row = { name: f.name, type: f.type ?? 'string' };
@@ -1177,27 +1186,33 @@ function emitActionField(f, outputElementId, resolver) {
         row.subType = f.subType;
     if (f.displayName !== undefined)
         row.displayName = f.displayName;
-    if (f.value !== undefined)
-        row.value = f.value;
-    if (outputElementId !== undefined && f.value !== undefined) {
-        // `id == var` like the Designer; a second form output into the same case
-        // variable takes a suffixed id and becomes a reassigned row (`originalVar`).
-        const id = resolver ? claimOutputId(resolver, f.value) : f.value;
+    if (outputElementId === undefined) {
+        if (f.value !== undefined)
+            row.value = f.value;
+    }
+    else {
+        // An explicit `value` keeps its variable: `id == var` like the Designer, and
+        // a second form output into the same case variable takes a suffixed id and
+        // becomes a reassigned row (`originalVar`). A defaulted one claims its own.
+        const base = f.value ?? defaultActionOutputVar(f.name);
+        const id = resolver ? claimOutputId(resolver, base) : base;
+        const variable = f.value ?? id;
+        row.value = variable;
         row.id = id;
-        row.var = f.value;
-        if (id !== f.value)
+        row.var = variable;
+        if (id !== variable)
             row.originalVar = id;
         row.source = `=${f.name}`;
         row.target = `=${id}`;
         row.elementId = outputElementId;
-        // `id == value`: the row is the variable (the Designer writes no root entry
+        // `id == var`: the row is the variable (the Designer writes no root entry
         // for it). Only a suffixed, reassigned row needs the readable companion.
-        if (resolver && id === f.value)
-            addOwnNameRow(resolver, f.value, row);
-        else if (resolver && !resolver.varCompanions.has(f.value)) {
-            resolver.varCompanions.set(f.value, {
-                id: f.value,
-                name: f.value,
+        if (resolver && id === variable)
+            addOwnNameRow(resolver, variable, row);
+        else if (resolver && !resolver.varCompanions.has(variable)) {
+            resolver.varCompanions.set(variable, {
+                id: variable,
+                name: variable,
                 type: f.type ?? 'string',
                 elementId: 'root',
                 custom: true,
@@ -1444,7 +1459,7 @@ function connectorTaskData(spec, resolver, elementId, where, executionType) {
     // from the `body` slot. This used to drop the whole wire and push a filled
     // file part into the body, where the runtime does not look for it (#1420).
     const fileParts = (slots.multipartParameters ?? []).filter((part) => part.dataType.toLowerCase() === 'file');
-    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, executionType) }));
+    context.push(io('metadata', 'json', { body: connectorMetadata(rc, op, slots, elementId, executionType) }));
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),
@@ -1601,45 +1616,39 @@ function folderBindingRef(resolver, name, connection, site) {
     }
     return { id };
 }
-/** The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
+/**
+ * The connector `metadata` json blob: the FUNCTIONAL essentialConfiguration +
  * activityTypeId, and the multipart wire of a multipart operation. Designer
  * cosmetics (packageId/activityColor/…) are omitted — the caseplan
- * schema-validates without them (see design §C). */
-function connectorMetadata(rc, op, slots, executionType) {
+ * schema-validates without them (see design §C).
+ *
+ * The configuration is the one Flow writes, from the shared
+ * {@link buildEssentialConfiguration}. Case used to build its own, thinner copy:
+ * no `operation` verb, `customFieldsRequestDetails`, `connectorVersion` or
+ * `unifiedTypesCompatible`, a curated-only `instanceParameters` even for a
+ * Generic activity, and the library version where the platform writes
+ * `packageVersion: "1.0.0"` (#1420).
+ */
+function connectorMetadata(rc, op, slots, seed, executionType) {
     // The part DECLARATIONS only: a file part's value rides on its `file` input.
     const multipartParameters = (slots.multipartParameters ?? []).map(({ name, dataType }) => ({ name, dataType }));
-    const instanceParameters = {
-        connectorKey: rc.connectorKey,
-        objectName: op.objectName ?? rc.nodeType.split('.').pop(),
-        httpMethod: rc.httpMethod,
-        activityType: op.activityType ?? 'Curated',
-        version: rc.version,
-        supportsStreaming: op.supportsStreaming ?? false,
-        subType: op.subType ?? 'standard',
-    };
-    const configuration = {
-        essentialConfiguration: {
-            instanceParameters,
-            objectName: instanceParameters.objectName,
-            httpMethod: transportHttpMethod(rc.httpMethod),
-            path: rc.endpoint,
-            packageVersion: rc.version,
-            // An external task's object states how it runs; the Designer saves it here
-            // and beside the configuration. A plain connector activity has none.
-            ...(executionType ? { executionType } : {}),
-        },
-    };
+    // The configuration replays the authored values (a schema action's parent
+    // fields, a CEQL filter's tree), keyed by the library's own names, as Flow's.
+    const essential = buildEssentialConfiguration(rc.entry, rc.version, replayInputsOf(slots), seed, executionType ?? null);
+    const configuration = `=jsonString:${JSON.stringify({ essentialConfiguration: essential })}`;
+    const instanceParameters = essential.instanceParameters;
+    const objectName = String(op.objectName ?? rc.nodeType.split('.').pop());
     return {
         activityPropertyConfiguration: {
             ...(multipartParameters.length ? { multipartParameters } : {}),
-            configuration: `=jsonString:${JSON.stringify(configuration)}`,
+            configuration,
             uiPathActivityTypeId: rc.activityTypeId ?? '',
             errorState: { issues: [] },
             ...(executionType ? { executionType } : {}),
         },
         activityMetadata: {
             activity: {
-                displayName: rc.entry.display?.label ?? instanceParameters.objectName,
+                displayName: rc.entry.display?.label ?? objectName,
                 description: rc.entry.display?.description ?? '',
                 category: rc.connectorName,
                 configuration: JSON.stringify(instanceParameters),
@@ -1653,7 +1662,7 @@ function connectorMetadata(rc, op, slots, executionType) {
         telemetryData: {
             connectorKey: rc.connectorKey,
             connectorName: rc.connectorName,
-            objectName: instanceParameters.objectName,
+            objectName,
             objectDisplayName: op.objectDisplayName ?? rc.entry.display?.operationLabel ?? '',
         },
     };
@@ -1709,8 +1718,7 @@ function ownOutputVars(built) {
                     if (isOwnNameOutput(o))
                         vars.add(o.var);
                 for (const f of task.action?.outputs ?? [])
-                    if (f.value !== undefined)
-                        vars.add(f.value);
+                    vars.add(f.value ?? defaultActionOutputVar(f.name));
             }
     return vars;
 }
@@ -1731,15 +1739,6 @@ function keepsOwnName(name, field) {
         return false;
     return [field, camelizeName(field)].some((base) => name === base || (name.startsWith(base) && /^(?:[2-9]|[1-9]\d+)$/.test(name.slice(base.length))));
 }
-/**
- * The Designer's `camelizeDisplayName`: drop non-identifier characters, split on
- * spaces/underscores, lower the first letter of the first word and upper the
- * first letter of the rest (`APIOutput1` → `aPIOutput1`).
- */
-function camelizeName(name) {
-    const words = name.replace(/[^a-zA-Z0-9_ ]/g, '').split(/[\s_]+/).filter(Boolean);
-    return words.map((w, i) => (i === 0 ? w.charAt(0).toLowerCase() : w.charAt(0).toUpperCase()) + w.slice(1)).join('');
-}
 /** The `Error` output's schema: the designer's (and the CLI's) `ERROR_OUTPUT_SCHEMA`. */
 const ERROR_OUTPUT_SCHEMA = {
     type: 'object',

package/dist/core/connector-configuration.d.ts

@@ -63,6 +63,33 @@
  *
  * Neither is cosmetic for a generic node: v1's own `check_generic_dynamic_node.py`
  * identifies the activity semantically, by `activityType == 'generic'` **and
- * `operation == 'list'`**, read from these very keys.
+ * `operation == 'list'`**, read from these very keys. *
+ * ## `savedJitInputFieldId` is not written, because the library cannot say when
+ *
+ * The CLI writes `savedJitInputFieldId: "in_<objectName>"` for a create /
+ * update / replace whose IS metadata declares a `body` PARAMETER (a
+ * just-in-time body). The offline library does not carry that parameter: its
+ * `operation.parameters` hold only `query` · `path` · `multipart`. Its body
+ * FIELDS do not stand in for it. Measured over the Designer- and CLI-saved
+ * create/update/replace nodes in the eval corpus: Slack `create-channel` (2
+ * body fields) carries the key, while `join-channel` (1 body field, 0/2) and
+ * `create-group-direct-message` (1 body field, 0/89) do not, and Data Service
+ * `create-entity-record` (no body fields) does (336/405). Writing it on a
+ * guess would be wrong on hundreds of nodes, so it stays out until the library
+ * records the body parameter.
+ */
+export declare function buildConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string, executionType?: string | null): string;
+/**
+ * The `essentialConfiguration` object that {@link buildConfiguration} wraps in
+ * its `=jsonString:` envelope. For a caller that also needs a field of it (Case
+ * copies its `instanceParameters` into the activity metadata), so it does not
+ * parse the string back.
+ *
+ * @param entry - The connector library entry.
+ * @param version - The connector version.
+ * @param inputValues - The authored inputs to replay, keyed by the library's names.
+ * @param seed - Seed for the saved filter tree ids.
+ * @param executionType - An External Agent / Workflow object's run mode, or `null`.
+ * @returns The essential configuration, with only Studio Web's essential keys.
  */
-export declare function buildConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string): string;
+export declare function buildEssentialConfiguration(entry: any, version: string, inputValues?: Record<string, unknown>, seed?: string, executionType?: string | null): Record<string, unknown>;

package/dist/core/connector-configuration.js

@@ -20,6 +20,14 @@ const ESSENTIAL_DEFAULTS = {
     executionType: null,
     operation: 'create',
     packageVersion: '1.0.0',
+    // The CLI's offline builder writes these two on every activity
+    // (`buildActivityEssentialConfiguration`, uipath-cli
+    // `integrationservice-sdk/src/dap/essential-config.ts`), and so does every
+    // Designer save in the eval corpus. `connectorVersion` is a request header
+    // the library does not carry; Studio Web fills it from its type cache on
+    // open, so offline it is `null`, as the CLI and the Case fixture write it.
+    connectorVersion: null,
+    unifiedTypesCompatible: true,
 };
 /**
  * Which of an operation's parameters carries a CEQL filter.
@@ -161,9 +169,40 @@ function envelope(flat) {
  *
  * Neither is cosmetic for a generic node: v1's own `check_generic_dynamic_node.py`
  * identifies the activity semantically, by `activityType == 'generic'` **and
- * `operation == 'list'`**, read from these very keys.
+ * `operation == 'list'`**, read from these very keys. *
+ * ## `savedJitInputFieldId` is not written, because the library cannot say when
+ *
+ * The CLI writes `savedJitInputFieldId: "in_<objectName>"` for a create /
+ * update / replace whose IS metadata declares a `body` PARAMETER (a
+ * just-in-time body). The offline library does not carry that parameter: its
+ * `operation.parameters` hold only `query` · `path` · `multipart`. Its body
+ * FIELDS do not stand in for it. Measured over the Designer- and CLI-saved
+ * create/update/replace nodes in the eval corpus: Slack `create-channel` (2
+ * body fields) carries the key, while `join-channel` (1 body field, 0/2) and
+ * `create-group-direct-message` (1 body field, 0/89) do not, and Data Service
+ * `create-entity-record` (no body fields) does (336/405). Writing it on a
+ * guess would be wrong on hundreds of nodes, so it stays out until the library
+ * records the body parameter.
+ */
+export function buildConfiguration(entry, version, inputValues, seed = 'node', executionType = null) {
+    return '=jsonString:' + JSON.stringify({
+        essentialConfiguration: buildEssentialConfiguration(entry, version, inputValues, seed, executionType),
+    });
+}
+/**
+ * The `essentialConfiguration` object that {@link buildConfiguration} wraps in
+ * its `=jsonString:` envelope. For a caller that also needs a field of it (Case
+ * copies its `instanceParameters` into the activity metadata), so it does not
+ * parse the string back.
+ *
+ * @param entry - The connector library entry.
+ * @param version - The connector version.
+ * @param inputValues - The authored inputs to replay, keyed by the library's names.
+ * @param seed - Seed for the saved filter tree ids.
+ * @param executionType - An External Agent / Workflow object's run mode, or `null`.
+ * @returns The essential configuration, with only Studio Web's essential keys.
  */
-export function buildConfiguration(entry, version, inputValues, seed = 'node') {
+export function buildEssentialConfiguration(entry, version, inputValues, seed = 'node', executionType = null) {
     const op = entry.operation ?? {};
     const conn = entry.connector ?? {};
     const at = op.activityType;
@@ -177,6 +216,9 @@ export function buildConfiguration(entry, version, inputValues, seed = 'node') {
         : ESSENTIAL_DEFAULTS.operation;
     const composed = {
         ...ESSENTIAL_DEFAULTS,
+        // An External Agent / Workflow object states how it runs; a connector
+        // activity has none (`null`, the default).
+        executionType,
         operation: verb,
         customFieldsRequestDetails: schemaReplayDetails(op, inputValues),
         savedFilterTrees: savedFilterTrees(op, inputValues, seed),
@@ -202,5 +244,5 @@ export function buildConfiguration(entry, version, inputValues, seed = 'node') {
             },
         ...(op.pathTemplate || op.path ? { path: op.pathTemplate || op.path } : {}),
     };
-    return '=jsonString:' + JSON.stringify(envelope(composed));
+    return envelope(composed).essentialConfiguration;
 }

package/dist/core/connector-inputs.d.ts

@@ -58,6 +58,16 @@ export declare const CONNECTOR_INPUT_MISSING = "CONNECTOR_INPUT_MISSING";
  */
 export declare function connectorInputErrors(rc: ResolvedConnector, inputs: Record<string, unknown>, resolutions?: LookupResolutions, lookups?: Readonly<Record<string, LookupSpec>>, wire?: Pick<ConnectorInputOpts, 'dialect' | 'render'>): string | undefined;
 export declare function buildConnectorInputs(rc: any, inputs: Record<string, unknown>, opts: ConnectorInputOpts): ConnectorSlots;
+/**
+ * The authored values a connector's `configuration` replays (a schema action's
+ * parent fields, a CEQL filter's tree), keyed by the library's own names: the
+ * body, path and query slots, merged. Flow and Case both write the
+ * configuration from this, so the two cannot drift.
+ *
+ * @param slots - The slots {@link buildConnectorInputs} returned.
+ * @returns The merged body, path and query values.
+ */
+export declare function replayInputsOf(slots: ConnectorSlots): Record<string, unknown>;
 /**
  * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
  * runtime composes from `bodyParameters`. Measured on the designer's own nodes in

package/dist/core/connector-inputs.js

@@ -253,6 +253,22 @@ function swapLookupTokens(value, resolutions, unresolved) {
         return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
     return value;
 }
+/**
+ * The authored values a connector's `configuration` replays (a schema action's
+ * parent fields, a CEQL filter's tree), keyed by the library's own names: the
+ * body, path and query slots, merged. Flow and Case both write the
+ * configuration from this, so the two cannot drift.
+ *
+ * @param slots - The slots {@link buildConnectorInputs} returned.
+ * @returns The merged body, path and query values.
+ */
+export function replayInputsOf(slots) {
+    return {
+        ...(slots.bodyParameters ?? {}),
+        ...(slots.pathParameters ?? {}),
+        ...(slots.queryParameters ?? {}),
+    };
+}
 /**
  * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
  * runtime composes from `bodyParameters`. Measured on the designer's own nodes in

package/dist/nodes/connector/flow/node-type.js

@@ -1,7 +1,7 @@
 import { BindingRefusal, bindingMissingMessage, missingBindingLabels } from '../../../core/binding-messages.js';
 import { prepareCommand } from '../../../core/cli-spelling.js';
 import { buildConfiguration } from '../../../core/connector-configuration.js';
-import { CONNECTOR_INPUT_MISSING, FLOW_EXPR_DIALECT, buildConnectorInputs, transportHttpMethod } from '../../../core/connector-inputs.js';
+import { CONNECTOR_INPUT_MISSING, FLOW_EXPR_DIALECT, buildConnectorInputs, replayInputsOf, transportHttpMethod } from '../../../core/connector-inputs.js';
 import { ConnectorResolveError } from '../../../core/connector-resolve-error.js';
 import { definitionHasErrorPort } from '../../../core/error-port.js';
 import { Expr } from '../../../core/expr.js';
@@ -141,11 +141,7 @@ function serializeConnector(spec, ctx) {
             ? library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
             : {},
     });
-    const replayInputs = {
-        ...(connectorInputs.bodyParameters ?? {}),
-        ...(connectorInputs.pathParameters ?? {}),
-        ...(connectorInputs.queryParameters ?? {}),
-    };
+    const replayInputs = replayInputsOf(connectorInputs);
     const detail = {
         connector: rc.connectorKey,
         method: transportHttpMethod(rc.httpMethod),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.52.0",
+  "version": "6.52.2",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -96,5 +96,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "4338e0cd3aa57c2329696080bee010a1e80d2e87"
+  "gitref": "410164517bc2552666c867e9107b2cbb57acd083"
 }