@uipath/maestro-builder-sdk 6.31.7 → 6.31.8

package/dist/check.js

@@ -10,7 +10,7 @@ import { FlowNode } from './core/node-classes.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
 import { definitionHasErrorPort, errorPortRefusal } from './core/error-port.js';
 import { actionVersion, bundledActionNodeType, bundledContainerDefinition, bundledDefinition, perCallDefinition, resolveContributionDefinition } from './serialize.js';
-import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy } from './core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText } from './core/form-field-type.js';
 import { AGENTIC_PROCESS_FORMS } from './core/agentic-process-forms.js';
 import { checkEventResolution, checkEventSubscription, eventParamsFor, } from './core/event-checks.js';
 import { checkCookedEscapes } from './flow-expr-check.js';
@@ -3416,7 +3416,7 @@ function checkInlineAgent(step, inputs, diags, opts = {}) {
                 if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
                     at('INLINE_AGENT_ESCALATION_FIELD_TYPE_UNKNOWN', `Inline agent step "${step}"'s quick-form escalation gives the field "${String(f?.id ?? '?')}" the type `
                         + `${JSON.stringify(f?.type)}, ${formFieldTypeWhy(f?.type, `which the form does not recognize — it would `
-                            + `be published as a plain string`)}. Valid: ${FORM_FIELD_TYPES.join(', ')}.`, formFieldTypeHint(f?.type));
+                            + `be published as a plain string`)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
                 }
             }
             continue;

package/dist/core/actions.d.ts

@@ -55,11 +55,22 @@ export interface ConnectorOpts {
     object?: string;
 }
 /**
- * A form field's type. The platform does not recognize a type outside this set:
- * older runtimes read it as text (so a number field becomes a text box), newer
- * ones reject the form. That is why `check` rejects anything outside this set.
+ * The platform's 11 canonical quick-form field types (`@uipath/hitl-schema-types`
+ * `fieldType`), which the designer saves. Each has its own value shape:
+ * `integer` → a JSON integer, `date` → `'2026-10-15'`, `datetime` → an ISO
+ * date-time, `file` → a binary-format string, `object` / `array` → JSON.
  */
-export type FormFieldType = 'text' | 'number' | 'boolean' | 'date-time';
+export type CanonicalFormFieldType = 'string' | 'number' | 'integer' | 'float' | 'double' | 'boolean' | 'date' | 'datetime' | 'file' | 'object' | 'array';
+/**
+ * A form field's type: one of the platform's canonical types, or `'text'` /
+ * `'date-time'`, the SDK's older spellings of `'string'` / `'datetime'` (the
+ * platform resolves both). A quick form with any other type fails the
+ * platform's validation, which is why `check` rejects it.
+ *
+ * @example
+ * hitl({ fields: [{ id: 'dueOn', type: 'date', direction: 'output' }], outcomes: ['Done'] })
+ */
+export type FormFieldType = CanonicalFormFieldType | 'text' | 'date-time';
 /** A value the reviewer READS: shown on the form, filled in from the flow. */
 export interface ShownField {
     /** Field id — the key the answer object uses. Must be unique on the form. */

package/dist/core/form-field-type.d.ts

@@ -1,49 +1,94 @@
 /**
- * The product's spellings of the form-field types the SDK models.
+ * The quick-form field-type vocabulary: the product's own, transcribed.
  *
  * A quick form's field `type` is read by the product through
- * `@uipath/hitl-schema-types` `normalizeFieldType`. Its canonical stored values
- * are `string`, `number`, `boolean`, `datetime`, … and it accepts aliases for
- * each: `text` is an alias of `string`, `date-time` of `datetime`, and .NET
- * names such as `System.String` resolve too. The designer saves the canonical
- * value, so a canvas-built form says `"string"`; the SDK (like flow-v1's
- * serializer and `uip maestro flow hitl add`) writes `text`.
+ * `@uipath/hitl-schema-types` (`fieldType`, `resolveFieldType`,
+ * `FIELD_TYPE_TO_JSON_SCHEMA`). It has 11 canonical stored values — `string`,
+ * `number`, `integer`, `float`, `double`, `boolean`, `date`, `datetime`, `file`,
+ * `object`, `array` — and it resolves aliases onto them: `text` is a legacy
+ * alias of `string`, `date-time` of `datetime`, and .NET names such as
+ * `System.Int32` resolve too. A `quick` form whose type resolves to none of the
+ * 11 fails the product's validation.
  *
- * So `"string"` and `"text"` are the same field on the wire. This table maps
- * each product spelling of the four types {@link FormFieldType} models to the
- * SDK's spelling, so decompile hands the author source `check` accepts.
- * A type the SDK does not model (`integer`, `date`,
- * `file`, …) has no entry: it stays as written, and `check` reports it.
+ * That package is published only to GitHub Packages, so the SDK cannot depend
+ * on it at runtime. This module is a transcription, and
+ * `tests/hitl-field-type-contract.test.ts` runs the real package against it:
+ * the canonical set, each type's JSON Schema, and every alias below must agree
+ * with the pinned `@uipath/hitl-schema-types`. A canonical-set or JSON Schema
+ * change upstream fails there; a new alias does not. The test also pins how the
+ * package resolves the spellings this module leaves out, so a change in those
+ * shows up.
  *
- * Mirrors `resolveFieldType` in `@uipath/hitl-schema-types` 1.1.6, restricted
- * to the groups that resolve to `string`, `number`, `boolean` and `datetime`
- * (minus `singleSelect` / `enum` / `union` / …, which resolve to `string` but
- * are not a plain text box).
+ * Every SDK path reads field types from here: `check` (human tasks and inline
+ * agent quick-form escalations), decompile, and the serializers' output
+ * schemas.
  */
-import type { FormFieldType } from './actions.js';
+import type { CanonicalFormFieldType } from './actions.js';
+/** The product's 11 canonical quick-form field types, in its own order. */
+export declare const CANONICAL_FORM_FIELD_TYPES: CanonicalFormFieldType[];
+/** The SDK's legacy spellings (`text`, `date-time`), for diagnostics that list them. */
+export declare const LEGACY_FORM_FIELD_TYPES: string[];
+/** Every form-field type the SDK accepts in source: the 11 canonical ones and the SDK's legacy aliases. */
+export declare const FORM_FIELD_TYPES: string[];
+/**
+ * The tail of a "Valid: …" diagnostic: the canonical types, then the legacy
+ * spellings in parentheses.
+ *
+ * @example
+ * validFormFieldTypesText() // 'string, number, …, array (or the older text, date-time)'
+ */
+export declare function validFormFieldTypesText(): string;
+/** The product aliases, for the contract test. */
+export declare const FORM_FIELD_TYPE_ALIASES: Readonly<Record<string, CanonicalFormFieldType>>;
+/**
+ * The canonical type a wire or source spelling names, or `undefined` when it
+ * names none the SDK models.
+ *
+ * @example
+ * canonicalFormFieldType('integer')      // 'integer'
+ * canonicalFormFieldType('text')         // 'string'
+ * canonicalFormFieldType('System.Int32') // 'integer'
+ * canonicalFormFieldType('string[]')     // 'array'
+ * canonicalFormFieldType('string | null') // 'string'
+ * canonicalFormFieldType('singleSelect') // undefined
+ */
+export declare function canonicalFormFieldType(type: unknown): CanonicalFormFieldType | undefined;
 /**
- * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
- * does not model that type.
+ * The spelling decompile writes into source for a wire field type: a canonical
+ * type or an SDK alias stays as written, so a canvas form (`"integer"`,
+ * `"date"`) and a classic-CLI form (`"text"`) both compile back to the bytes
+ * they came from; a product alias the SDK does not accept in source
+ * (`"System.Int32"`, `"string[]"`) becomes its canonical type; anything else
+ * stays verbatim for `check` to report.
  *
  * @example
- * sdkFormFieldType('string')   // 'text'
- * sdkFormFieldType('datetime') // 'date-time'
- * sdkFormFieldType('integer')  // undefined
+ * sourceFormFieldType('date')          // 'date'
+ * sourceFormFieldType('text')          // 'text'
+ * sourceFormFieldType('System.String') // 'string'
+ * sourceFormFieldType('string[]')      // 'array'
+ * sourceFormFieldType('singleSelect')  // 'singleSelect'
  */
-export declare function sdkFormFieldType(wire: unknown): FormFieldType | undefined;
+export declare function sourceFormFieldType(wire: unknown): string;
 /**
- * Why a form-field type is refused: a product spelling of a type the SDK
- * models (`"string"` is the platform's own name for text), or a type
- * the SDK does not model at all. `unknownWhy` is the caller's reason for the
- * second case; the default is a human task's.
+ * Why a form-field type is refused: a product alias the SDK does not accept in
+ * source (`"System.Int32"` is the platform's .NET name for `integer`), a control
+ * spelling the platform accepts but the SDK does not model yet
+ * (`"singleSelect"`), or a type the product does not recognize at all.
+ * `unknownWhy` is the caller's reason for the last case; the default is a human
+ * task's.
  */
 export declare function formFieldTypeWhy(type: unknown, unknownWhy?: string): string;
-/** The form-field types the SDK models. */
-export declare const FORM_FIELD_TYPES: string[];
-/** The `suggestion` for an unknown form-field type: the nearest valid one, else `type: 'text'`. */
+/** The `suggestion` for an unknown form-field type: its canonical type, the nearest valid one, else `type: 'string'`. */
 export declare function formFieldTypeHint(type: unknown): string;
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-export declare const FORM_FIELD_JSON_TYPE: Record<FormFieldType, {
+/**
+ * The JSON Schema of a field's value, for the output (and escalation input)
+ * schemas the serializers write; `undefined` for a type the SDK does not model.
+ *
+ * @example
+ * formFieldJsonSchema('date') // { type: 'string', format: 'date' }
+ * formFieldJsonSchema('text') // { type: 'string' }
+ */
+export declare function formFieldJsonSchema(type: unknown): {
     type: string;
     format?: string;
-}>;
+} | undefined;

package/dist/core/form-field-type.js

@@ -1,63 +1,197 @@
 import { nearestName } from './edit-distance.js';
-const PRODUCT_SPELLINGS = {
-    text: 'text',
-    string: 'text',
-    String: 'text',
-    'System.String': 'text',
-    'System.Char': 'text',
-    Char: 'text',
-    number: 'number',
+import { ownEntry } from './own-entry.js';
+/**
+ * Each canonical type's JSON Schema, as `FIELD_TYPE_TO_JSON_SCHEMA` gives it.
+ * `Record<CanonicalFormFieldType, …>` makes tsc refuse a missing or extra one.
+ * `float` and `double` are both `number`: JSON Schema has no precision; `file`
+ * is `format: 'binary'` (the OpenAPI convention for an upload).
+ */
+const CANONICAL_JSON_SCHEMA = {
+    string: { type: 'string' },
+    number: { type: 'number' },
+    integer: { type: 'integer' },
+    float: { type: 'number' },
+    double: { type: 'number' },
+    boolean: { type: 'boolean' },
+    date: { type: 'string', format: 'date' },
+    datetime: { type: 'string', format: 'date-time' },
+    file: { type: 'string', format: 'binary' },
+    object: { type: 'object' },
+    array: { type: 'array' },
+};
+/** The product's 11 canonical quick-form field types, in its own order. */
+export const CANONICAL_FORM_FIELD_TYPES = Object.keys(CANONICAL_JSON_SCHEMA);
+/**
+ * The SDK's own legacy spellings, accepted in source: `text` (what the SDK,
+ * flow-v1's serializer and `uip maestro flow hitl add` have always written) and
+ * `date-time`. The product resolves both.
+ */
+const SDK_ALIASES = {
+    text: 'string',
+    'date-time': 'datetime',
+};
+/** The SDK's legacy spellings (`text`, `date-time`), for diagnostics that list them. */
+export const LEGACY_FORM_FIELD_TYPES = Object.keys(SDK_ALIASES);
+/** Every form-field type the SDK accepts in source: the 11 canonical ones and the SDK's legacy aliases. */
+export const FORM_FIELD_TYPES = [...CANONICAL_FORM_FIELD_TYPES, ...LEGACY_FORM_FIELD_TYPES];
+/**
+ * The tail of a "Valid: …" diagnostic: the canonical types, then the legacy
+ * spellings in parentheses.
+ *
+ * @example
+ * validFormFieldTypesText() // 'string, number, …, array (or the older text, date-time)'
+ */
+export function validFormFieldTypesText() {
+    return `${CANONICAL_FORM_FIELD_TYPES.join(', ')} (or the older ${LEGACY_FORM_FIELD_TYPES.join(', ')})`;
+}
+/**
+ * The product's other data-type spellings, each with the canonical type it
+ * resolves to (`resolveFieldType` in `@uipath/hitl-schema-types` 1.2.0). The
+ * .NET names come from forms built by RPA / agent tooling. The scope-walker
+ * shapes (`union`, `intersection`, `ref`, `any`) reach `field.type` when a
+ * canvas author binds a Flow variable; they carry no narrower shape, so they
+ * resolve to `string`. `T[]` and `a | b` are matched by pattern in
+ * `canonicalFormFieldType`.
+ *
+ * Deliberately left out: the CONTROL spellings `singleSelect`, `multiSelect`
+ * and `enum` (`CONTROL_FORM_FIELD_TYPES`). The product infers a `controlType`
+ * from those, so rewriting one to its data type would change how the form
+ * renders. Decompile keeps them as written, and `check` reports them.
+ */
+const PRODUCT_ALIASES = {
+    ...SDK_ALIASES,
+    String: 'string',
+    'System.String': 'string',
+    'System.Char': 'string',
+    Char: 'string',
     Number: 'number',
-    boolean: 'boolean',
+    Int32: 'integer',
+    Int64: 'integer',
+    'System.Int32': 'integer',
+    'System.Int64': 'integer',
+    'System.Byte': 'integer',
+    'System.Int16': 'integer',
+    Byte: 'integer',
+    Int16: 'integer',
+    UInt16: 'integer',
+    UInt32: 'integer',
+    UInt64: 'integer',
+    Float: 'float',
+    Single: 'float',
+    'System.Single': 'float',
+    Double: 'double',
+    Decimal: 'double',
+    'System.Double': 'double',
+    'System.Decimal': 'double',
     Boolean: 'boolean',
     'System.Boolean': 'boolean',
-    'date-time': 'date-time',
-    datetime: 'date-time',
-    dateTime: 'date-time',
-    DateTime: 'date-time',
-    'System.DateTime': 'date-time',
+    Date: 'date',
+    'System.DateOnly': 'date',
+    DateOnly: 'date',
+    dateTime: 'datetime',
+    DateTime: 'datetime',
+    'System.DateTime': 'datetime',
+    File: 'file',
+    Object: 'object',
+    DataTable: 'object',
+    QueueItem: 'object',
+    Array: 'array',
+    GenericValue: 'array',
+    list: 'array',
+    List: 'array',
+    union: 'string',
+    intersection: 'string',
+    ref: 'string',
+    any: 'string',
 };
 /**
- * The SDK's spelling of a wire form-field type, or `undefined` when the SDK
- * does not model that type.
+ * The product's control spellings: it accepts them as a field `type` and infers
+ * a picker control from them (`CONTROL_FOR_DECLARED_TYPE`). The SDK does not
+ * model them yet.
+ */
+const CONTROL_FORM_FIELD_TYPES = ['singleSelect', 'multiSelect', 'enum'];
+/** The product aliases, for the contract test. */
+export const FORM_FIELD_TYPE_ALIASES = PRODUCT_ALIASES;
+const isCanonical = (t) => typeof t === 'string' && Object.hasOwn(CANONICAL_JSON_SCHEMA, t);
+/**
+ * The canonical type a wire or source spelling names, or `undefined` when it
+ * names none the SDK models.
+ *
+ * @example
+ * canonicalFormFieldType('integer')      // 'integer'
+ * canonicalFormFieldType('text')         // 'string'
+ * canonicalFormFieldType('System.Int32') // 'integer'
+ * canonicalFormFieldType('string[]')     // 'array'
+ * canonicalFormFieldType('string | null') // 'string'
+ * canonicalFormFieldType('singleSelect') // undefined
+ */
+export function canonicalFormFieldType(type) {
+    if (isCanonical(type))
+        return type;
+    if (typeof type !== 'string')
+        return undefined;
+    // The package's own order: the two scope-walker patterns before the names.
+    if (type.endsWith('[]'))
+        return 'array';
+    if (type.includes(' | '))
+        return 'string';
+    return Object.hasOwn(PRODUCT_ALIASES, type) ? PRODUCT_ALIASES[type] : undefined;
+}
+/**
+ * The spelling decompile writes into source for a wire field type: a canonical
+ * type or an SDK alias stays as written, so a canvas form (`"integer"`,
+ * `"date"`) and a classic-CLI form (`"text"`) both compile back to the bytes
+ * they came from; a product alias the SDK does not accept in source
+ * (`"System.Int32"`, `"string[]"`) becomes its canonical type; anything else
+ * stays verbatim for `check` to report.
  *
  * @example
- * sdkFormFieldType('string')   // 'text'
- * sdkFormFieldType('datetime') // 'date-time'
- * sdkFormFieldType('integer')  // undefined
+ * sourceFormFieldType('date')          // 'date'
+ * sourceFormFieldType('text')          // 'text'
+ * sourceFormFieldType('System.String') // 'string'
+ * sourceFormFieldType('string[]')      // 'array'
+ * sourceFormFieldType('singleSelect')  // 'singleSelect'
  */
-export function sdkFormFieldType(wire) {
-    return typeof wire === 'string' && Object.hasOwn(PRODUCT_SPELLINGS, wire) ? PRODUCT_SPELLINGS[wire] : undefined;
+export function sourceFormFieldType(wire) {
+    if (typeof wire === 'string' && FORM_FIELD_TYPES.includes(wire))
+        return wire;
+    return canonicalFormFieldType(wire) ?? String(wire);
 }
 /**
- * Why a form-field type is refused: a product spelling of a type the SDK
- * models (`"string"` is the platform's own name for text), or a type
- * the SDK does not model at all. `unknownWhy` is the caller's reason for the
- * second case; the default is a human task's.
- */
-export function formFieldTypeWhy(type, unknownWhy = `which the platform does not recognize. Older runtimes read it as text, newer ones reject `
-    + `the form`) {
-    const alias = sdkFormFieldType(type);
-    return alias !== undefined
-        ? `which is the platform's spelling of the SDK's '${alias}' — the SDK writes '${alias}'`
-        : unknownWhy;
+ * Why a form-field type is refused: a product alias the SDK does not accept in
+ * source (`"System.Int32"` is the platform's .NET name for `integer`), a control
+ * spelling the platform accepts but the SDK does not model yet
+ * (`"singleSelect"`), or a type the product does not recognize at all.
+ * `unknownWhy` is the caller's reason for the last case; the default is a human
+ * task's.
+ */
+export function formFieldTypeWhy(type, unknownWhy = `which is not a quick-form field type: the platform rejects the form`) {
+    const canonical = canonicalFormFieldType(type);
+    if (canonical !== undefined)
+        return `which is the platform's alias of '${canonical}' — the SDK writes '${canonical}'`;
+    if (typeof type === 'string' && CONTROL_FORM_FIELD_TYPES.includes(type)) {
+        return `which the platform accepts as a picker control but the SDK does not model yet`;
+    }
+    return unknownWhy;
 }
-/** Every FormFieldType, once; `Record<FormFieldType, …>` makes tsc refuse a missing or extra one. */
-const FORM_FIELD_TYPE_SET = { text: true, number: true, boolean: true, 'date-time': true };
-/** The form-field types the SDK models. */
-export const FORM_FIELD_TYPES = Object.keys(FORM_FIELD_TYPE_SET);
-/** The `suggestion` for an unknown form-field type: the nearest valid one, else `type: 'text'`. */
+/** The `suggestion` for an unknown form-field type: its canonical type, the nearest valid one, else `type: 'string'`. */
 export function formFieldTypeHint(type) {
-    const alias = sdkFormFieldType(type);
-    if (alias !== undefined)
-        return `type: '${alias}'`;
+    const canonical = canonicalFormFieldType(type);
+    if (canonical !== undefined)
+        return `type: '${canonical}'`;
     const nearest = nearestName(String(type), FORM_FIELD_TYPES);
-    return nearest !== undefined ? `type: '${nearest}'` : `type: 'text'`;
+    return nearest !== undefined ? `type: '${nearest}'` : `type: 'string'`;
+}
+/**
+ * The JSON Schema of a field's value, for the output (and escalation input)
+ * schemas the serializers write; `undefined` for a type the SDK does not model.
+ *
+ * @example
+ * formFieldJsonSchema('date') // { type: 'string', format: 'date' }
+ * formFieldJsonSchema('text') // { type: 'string' }
+ */
+export function formFieldJsonSchema(type) {
+    const canonical = canonicalFormFieldType(type);
+    const schema = canonical === undefined ? undefined : ownEntry(CANONICAL_JSON_SCHEMA, canonical);
+    return schema === undefined ? undefined : { ...schema };
 }
-/** JSON-Schema type per form-field type, as flow-v1's form serializer maps them (quick-form escalations and human tasks). */
-export const FORM_FIELD_JSON_TYPE = {
-    text: { type: 'string' },
-    number: { type: 'number' },
-    boolean: { type: 'boolean' },
-    'date-time': { type: 'string', format: 'date-time' },
-};

package/dist/decompile.js

@@ -50,7 +50,7 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
-import { sdkFormFieldType } from './core/form-field-type.js';
+import { sourceFormFieldType } from './core/form-field-type.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -1304,7 +1304,7 @@ function emitAgentCluster(node, imp, inputNames, graph) {
             ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
             ['fields', rows.length ? `[${rows.map((f) => opts([
                     ['id', tsText(f.id)],
-                    ['type', tsLiteral(sdkFormFieldType(f.type ?? 'text') ?? String(f.type))],
+                    ['type', tsLiteral(sourceFormFieldType(f.type ?? 'string'))],
                     ['direction', tsLiteral(String(f.direction ?? 'output'))],
                 ])).join(', ')}]` : undefined],
             ['app', app === undefined ? undefined : opts([

package/dist/nodes/hitl/flow/check.js

@@ -1,6 +1,6 @@
 import { Expr } from '../../../core/expr.js';
 import { nearestName } from '../../../core/edit-distance.js';
-import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy } from '../../../core/form-field-type.js';
+import { FORM_FIELD_TYPES, formFieldTypeHint, formFieldTypeWhy, validFormFieldTypesText } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, outcomeIdOf } from '../../../core/hitl-routing.js';
 export const HITL_DIAGNOSTICS = {
@@ -213,7 +213,7 @@ export function checkHitl(inputs, ctx) {
         }
         if (!FORM_FIELD_TYPES.includes(String(f?.type))) {
             at('HITL_FIELD_TYPE_UNKNOWN', `Human task "${step}" gives the form field "${id}" the type ${JSON.stringify(f?.type)}, `
-                + `${formFieldTypeWhy(f?.type)}. Valid: ${FORM_FIELD_TYPES.join(', ')}.`, formFieldTypeHint(f?.type));
+                + `${formFieldTypeWhy(f?.type)}. Valid: ${validFormFieldTypesText()}.`, formFieldTypeHint(f?.type));
         }
         if (isAnswerField(f))
             answers++; // an `output`, or an `inOut` whose reviewed value comes back

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

@@ -13,11 +13,10 @@
  * every edge out of an outcome-handle node to.
  */
 import { Expr, toExpr } from '../../../core/expr.js';
-import { FORM_FIELD_JSON_TYPE, sdkFormFieldType } from '../../../core/form-field-type.js';
+import { formFieldJsonSchema, sourceFormFieldType } from '../../../core/form-field-type.js';
 import { isAnswerField } from '../../../core/hitl-answers.js';
 import { OUTCOME_HANDLE_NODE_TYPES, hitlExitModel, outcomeIdOf, outcomeSlug } from '../../../core/hitl-routing.js';
 import { jsonClone } from '../../../core/json-clone.js';
-import { ownEntry } from '../../../core/own-entry.js';
 import { schemaId } from '../../../core/stable-id.js';
 import { wireExprBody } from '../../../core/wire-expr.js';
 import { checkHitl, checkHitlRead } from './check.js';
@@ -99,7 +98,7 @@ function hitlInputs(inputs, nodeType, ctx) {
         // inOut fields land in the answers too — their reviewed value flows back.
         if (!isAnswerField(f))
             continue;
-        properties[f.id] = { ...ownEntry(FORM_FIELD_JSON_TYPE, String(f.type)) };
+        properties[f.id] = { ...formFieldJsonSchema(f.type) };
     }
     const names = outcomes.map((o) => o.name).filter((n) => typeof n === 'string');
     if (names.length > 0) {
@@ -331,8 +330,9 @@ function liftHitl(node, typeName, ctx) {
             id,
             // serialize defaults a row's label to its id.
             ...(typeof f.label === 'string' && f.label !== id ? { label: f.label } : {}),
-            // The product's own spelling (`"string"`, `"datetime"`, …) → the SDK's (#1143).
-            type: sdkFormFieldType(f.type ?? 'text') ?? String(f.type),
+            // A type the SDK accepts stays as written, so the form compiles back to
+            // the same bytes; a .NET alias becomes its canonical type (#1143, #1176).
+            type: sourceFormFieldType(f.type ?? 'string'),
             direction,
             ...(value !== undefined ? { value } : {}),
             ...(f.required === true ? { required: true } : {}),

package/dist/serialize.js

@@ -20,7 +20,7 @@ import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { stepExits } from './flow-step-exits.js';
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
-import { FORM_FIELD_JSON_TYPE } from './core/form-field-type.js';
+import { formFieldJsonSchema } from './core/form-field-type.js';
 import { ConnectorResolveError } from './core/connector-resolve-error.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
@@ -1362,7 +1362,7 @@ function escalationResourceJson(esc, spec) {
         const fields = esc.fields ?? [];
         const props = (dirs) => Object.fromEntries(fields
             .filter((f) => dirs.includes(f.direction))
-            .map((f) => [f.id, ownEntry(FORM_FIELD_JSON_TYPE, String(f.type)) ?? { type: 'string' }]));
+            .map((f) => [f.id, formFieldJsonSchema(f.type) ?? { type: 'string' }]));
         channel = {
             ...common,
             type: 'actionCenterQuickForm',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.31.7",
+  "version": "6.31.8",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "99f1861467ac06fba1c816f365bf027e1e2c8e05"
+  "gitref": "294a7da19cbb9eaad2ae8b97b35fdc07923d50ac"
 }