@uipath/uipath-typescript 1.3.4 → 1.3.6

package/dist/entities/index.d.ts

@@ -515,6 +515,14 @@ interface EntityFieldBase {
     isEncrypted?: boolean;
     /** Default value for the field */
     defaultValue?: string;
+    /** Maximum character length for STRING fields (default: 200, range: 1–4000) and MULTILINE_TEXT fields (default: 200, range: 1–10000). */
+    lengthLimit?: number;
+    /** Maximum allowed value for numeric fields (INTEGER, BIG_INTEGER, FLOAT, DOUBLE, DECIMAL — default: 1,000,000,000,000; range: ±9,007,199,254,740,991) */
+    maxValue?: number;
+    /** Minimum allowed value for numeric fields (INTEGER, BIG_INTEGER, FLOAT, DOUBLE, DECIMAL — default: -1,000,000,000,000; range: ±9,007,199,254,740,991) */
+    minValue?: number;
+    /** Number of decimal places for DECIMAL, FLOAT, and DOUBLE fields (default: 2, range: 0–10) */
+    decimalPrecision?: number;
 }
 /**
  * User-facing field definition for creating or updating entity schemas
@@ -1342,6 +1350,13 @@ interface EntityServiceModel {
      *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true },
      *   { fieldName: "price", type: EntityFieldDataType.INTEGER, defaultValue: "0" },
      * ], { displayName: "Product Catalog", description: "Our product catalog", isRbacEnabled: true });
+     *
+     * // With advanced sqlType constraints (lengthLimit, decimalPrecision, maxValue, minValue) and defaultValue
+     * const ordersId = await entities.create("orders", [
+     *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true, lengthLimit: 500 },
+     *   { fieldName: "price", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   { fieldName: "quantity", type: EntityFieldDataType.INTEGER, maxValue: 10000, minValue: 1, defaultValue: "0" },
+     * ]);
      * ```
      * @internal
      */
@@ -1389,6 +1404,17 @@ interface EntityServiceModel {
      *   updateFields: [{ id: <fieldId>, displayName: "Unit Price", isRequired: true }],
      *   displayName: "Price Catalog",
      * });
+     *
+     * // Add a STRING/DECIMAL field with explicit advanced sqlType constraints and defaultValue
+     * await entities.updateById(<id>, {
+     *   addFields: [
+     *     { fieldName: "summary", type: EntityFieldDataType.STRING, lengthLimit: 500, defaultValue: "summary" },
+     *     { fieldName: "amount", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   ],
+     *   updateFields: [
+     *     { id: <fieldId>, lengthLimit: 1000 },
+     *   ],
+     * });
      * ```
      * @internal
      */
@@ -1578,6 +1604,14 @@ interface EntityMethods {
      *   displayName: "Updated Name",
      *   addFields: [{ fieldName: "notes", type: EntityFieldDataType.MULTILINE_TEXT }],
      * });
+     *
+     * // Add a STRING/DECIMAL field with explicit advanced sqlType constraints
+     * await entity.update({
+     *   addFields: [
+     *     { fieldName: "summary", type: EntityFieldDataType.STRING, lengthLimit: 500, defaultValue: "string" },
+     *     { fieldName: "amount", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   ],
+     * });
      * ```
      * @internal
      */
@@ -2034,6 +2068,13 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true },
      *   { fieldName: "price", type: EntityFieldDataType.INTEGER, defaultValue: "0" },
      * ], { displayName: "Product Catalog", description: "Our product catalog", isRbacEnabled: true });
+     *
+     * // With advanced sqlType constraints (lengthLimit, decimalPrecision, maxValue, minValue) and defaultValue
+     * const ordersId = await entities.create("orders", [
+     *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true, lengthLimit: 500 },
+     *   { fieldName: "price", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   { fieldName: "quantity", type: EntityFieldDataType.INTEGER, maxValue: 10000, minValue: 1, defaultValue: "0" },
+     * ]);
      * ```
      * @internal
      */
@@ -2085,6 +2126,17 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      *   updateFields: [{ id: "<fieldId>", displayName: "Unit Price", isRequired: true }],
      *   displayName: "Price Catalog",
      * });
+     *
+     * // Add a STRING/DECIMAL field with explicit advanced sqlType constraints and defaultValue
+     * await entities.updateById("<entityId>", {
+     *   addFields: [
+     *     { fieldName: "summary", type: EntityFieldDataType.STRING, lengthLimit: 500, defaultValue: "summary" },
+     *     { fieldName: "amount", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   ],
+     *   updateFields: [
+     *     { id: "<fieldId>", lengthLimit: 1000 },
+     *   ],
+     * });
      * ```
      * @internal
      */
@@ -2111,6 +2163,13 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      * @private
      */
     private mapFieldTypes;
+    /**
+     * Resolves an {@link EntityFieldDataType} from a field's `fieldDisplayType` and
+     * raw SQL type name. Prefers `fieldDisplayType` to disambiguate types that
+     * share a SQL type (FILE, CHOICE_SET_*, AUTO_NUMBER, RELATIONSHIP); falls back
+     * to the SQL-type-name mapping. Returns `undefined` if neither resolves.
+     */
+    private tryResolveFieldDataType;
     /**
      * Transforms nested reference objects in field metadata
      */
@@ -2124,6 +2183,28 @@ declare class EntityService extends BaseService implements EntityServiceModel {
     private mapExternalFields;
     /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
     private buildSchemaFieldPayload;
+    /**
+     * Derives the user-facing {@link EntityFieldDataType} for a field on the raw
+     * API response. Throws if the field's `fieldDisplayType` and `sqlType.name`
+     * are both unmappable.
+     */
+    private resolveFieldDataType;
+    /**
+     * Validates that the user-supplied constraint properties on a field are
+     * supported by the field's data type. Throws a `ValidationError` listing
+     * any unsupported properties.
+     */
+    private validateFieldConstraints;
+    /**
+     * Returns the sqlType constraint fields for a given field type.
+     *
+     * The API requires specific constraint properties to be set per SQL type;
+     * without them the field is stored in an incomplete state, causing
+     * "Field type cannot be changed" errors when the UI later tries to edit
+     * advanced options. User-supplied values from `EntityCreateFieldOptions`
+     * override the defaults where the type accepts overrides.
+     */
+    private buildSqlTypeConstraints;
     private static readonly RESERVED_FIELD_NAMES;
     private validateName;
 }

package/dist/entities/index.mjs

@@ -1927,6 +1927,20 @@ function createParams(paramsObj = {}) {
     return params;
 }
 
+/**
+ * Names of the per-field SQL constraint properties (i.e. the contents of `sqlType`
+ * excluding its `name`). Used internally to validate user-supplied constraints
+ * against the set of constraints that each `EntityFieldDataType` accepts.
+ *
+ * Enum values match the corresponding property names on `EntityCreateFieldOptions`.
+ */
+var EntityFieldConstraint;
+(function (EntityFieldConstraint) {
+    EntityFieldConstraint["LengthLimit"] = "lengthLimit";
+    EntityFieldConstraint["MaxValue"] = "maxValue";
+    EntityFieldConstraint["MinValue"] = "minValue";
+    EntityFieldConstraint["DecimalPrecision"] = "decimalPrecision";
+})(EntityFieldConstraint || (EntityFieldConstraint = {}));
 /**
  * Entity field data types (SQL types from API)
  */
@@ -1989,6 +2003,70 @@ const FieldDisplayTypeToDataType = {
     [FieldDisplayType.AutoNumber]: EntityFieldDataType.AUTO_NUMBER,
     [FieldDisplayType.Relationship]: EntityFieldDataType.RELATIONSHIP,
 };
+/**
+ * Default and fixed sqlType constraint values applied when the user does not provide them.
+ * The API requires these to be present on field creation — without them the field
+ * is stored in an incomplete state, causing "Field type cannot be changed" errors
+ * when the UI later tries to edit advanced options.
+ */
+const ENTITY_FIELD_CONSTRAINT_DEFAULTS = {
+    STRING_LENGTH_LIMIT: 200,
+    MULTILINE_TEXT_LENGTH_LIMIT: 200,
+    /** Fixed (non-overridable) length limit on DECIMAL payloads*/
+    DECIMAL_LENGTH_LIMIT: 1000,
+    DECIMAL_PRECISION: 2,
+    /** Fixed (non-overridable) length limit for BIT (BOOLEAN) fields */
+    BOOLEAN_LENGTH_LIMIT: 100,
+    /** Fixed (non-overridable) length limit for DATE / DATETIMEOFFSET fields */
+    DATE_LENGTH_LIMIT: 1000,
+    /** Fixed (non-overridable) length limit for UNIQUEIDENTIFIER-backed FILE and RELATIONSHIP fields */
+    UNIQUEIDENTIFIER_LENGTH_LIMIT: 300,
+    /** Fixed (non-overridable) length limit for CHOICE_SET_MULTIPLE fields */
+    CHOICE_SET_MULTIPLE_LENGTH_LIMIT: 4000,
+    NUMERIC_MAX_VALUE: 1000000000000,
+    NUMERIC_MIN_VALUE: -1e12,
+};
+/**
+ * Per-field-type spec describing which {@link EntityFieldConstraint}s the user
+ * may supply on create / update, and the inclusive value range for each.
+ *
+ * Source of truth: the platform's `Constants.cs` constraint table. Keys absent
+ * from a type's spec are not user-configurable for that type; passing one
+ * throws a `ValidationError`. Field types absent from this map (BOOLEAN, DATE,
+ * DATETIME, DATETIME_WITH_TZ, FILE, RELATIONSHIP, UUID, CHOICE_SET_SINGLE,
+ * CHOICE_SET_MULTIPLE, AUTO_NUMBER) accept no user-supplied constraints.
+ */
+const ENTITY_FIELD_CONSTRAINT_SPEC = {
+    [EntityFieldDataType.STRING]: {
+        [EntityFieldConstraint.LengthLimit]: { min: 1, max: 4000 },
+    },
+    [EntityFieldDataType.MULTILINE_TEXT]: {
+        [EntityFieldConstraint.LengthLimit]: { min: 1, max: 10000 },
+    },
+    [EntityFieldDataType.INTEGER]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+    },
+    [EntityFieldDataType.BIG_INTEGER]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+    },
+    [EntityFieldDataType.DECIMAL]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+    [EntityFieldDataType.FLOAT]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+    [EntityFieldDataType.DOUBLE]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+};
 /**
  * Maps SQL field types to friendly display names
  */
@@ -2013,7 +2091,7 @@ const EntityFieldTypeMap = {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.3.4";
+const SDK_VERSION = "1.3.6";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -2862,6 +2940,13 @@ class EntityService extends BaseService {
      *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true },
      *   { fieldName: "price", type: EntityFieldDataType.INTEGER, defaultValue: "0" },
      * ], { displayName: "Product Catalog", description: "Our product catalog", isRbacEnabled: true });
+     *
+     * // With advanced sqlType constraints (lengthLimit, decimalPrecision, maxValue, minValue) and defaultValue
+     * const ordersId = await entities.create("orders", [
+     *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true, lengthLimit: 500 },
+     *   { fieldName: "price", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   { fieldName: "quantity", type: EntityFieldDataType.INTEGER, maxValue: 10000, minValue: 1, defaultValue: "0" },
+     * ]);
      * ```
      * @internal
      */
@@ -2935,6 +3020,17 @@ class EntityService extends BaseService {
      *   updateFields: [{ id: "<fieldId>", displayName: "Unit Price", isRequired: true }],
      *   displayName: "Price Catalog",
      * });
+     *
+     * // Add a STRING/DECIMAL field with explicit advanced sqlType constraints and defaultValue
+     * await entities.updateById("<entityId>", {
+     *   addFields: [
+     *     { fieldName: "summary", type: EntityFieldDataType.STRING, lengthLimit: 500, defaultValue: "summary" },
+     *     { fieldName: "amount", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   ],
+     *   updateFields: [
+     *     { id: "<fieldId>", lengthLimit: 1000 },
+     *   ],
+     * });
      * ```
      * @internal
      */
@@ -2978,6 +3074,21 @@ class EntityService extends BaseService {
                 const update = updateMap.get(f.id ?? '');
                 if (!update)
                     return f;
+                const constraintUpdate = {
+                    ...(update.lengthLimit !== undefined && { lengthLimit: update.lengthLimit }),
+                    ...(update.maxValue !== undefined && { maxValue: update.maxValue }),
+                    ...(update.minValue !== undefined && { minValue: update.minValue }),
+                    ...(update.decimalPrecision !== undefined && { decimalPrecision: update.decimalPrecision }),
+                };
+                const hasConstraintUpdate = Object.keys(constraintUpdate).length > 0;
+                if (hasConstraintUpdate) {
+                    if (!f.sqlType) {
+                        throw new ValidationError({
+                            message: `Cannot update constraints on field '${f.name}' (id: ${f.id}) — the field is missing sqlType metadata in the entity definition.`,
+                        });
+                    }
+                    this.validateFieldConstraints(this.resolveFieldDataType(f), update, f.name);
+                }
                 return {
                     ...f,
                     ...(update.displayName !== undefined && { displayName: update.displayName }),
@@ -2987,6 +3098,7 @@ class EntityService extends BaseService {
                     ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
                     ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
                     ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
+                    ...(hasConstraintUpdate && f.sqlType && { sqlType: { ...f.sqlType, ...constraintUpdate } }),
                 };
             });
         }
@@ -3036,24 +3148,27 @@ class EntityService extends BaseService {
             let transformedField = transformData(field, EntityMap);
             // Map field type: prefer fieldDisplayType for types that share SQL types (File, ChoiceSet, AutoNumber)
             if (transformedField.fieldDataType?.name) {
-                const displayTypeMapped = transformedField.fieldDisplayType
-                    ? FieldDisplayTypeToDataType[transformedField.fieldDisplayType]
-                    : undefined;
-                if (displayTypeMapped) {
-                    transformedField.fieldDataType.name = displayTypeMapped;
-                }
-                else {
-                    const rawSqlTypeName = field.sqlType?.name;
-                    const mapped = rawSqlTypeName ? EntityFieldTypeMap[rawSqlTypeName] : undefined;
-                    if (mapped) {
-                        transformedField.fieldDataType.name = mapped;
-                    }
+                const mapped = this.tryResolveFieldDataType(transformedField.fieldDisplayType, field.sqlType?.name);
+                if (mapped) {
+                    transformedField.fieldDataType.name = mapped;
                 }
             }
             this.transformNestedReferences(transformedField);
             return transformedField;
         });
     }
+    /**
+     * Resolves an {@link EntityFieldDataType} from a field's `fieldDisplayType` and
+     * raw SQL type name. Prefers `fieldDisplayType` to disambiguate types that
+     * share a SQL type (FILE, CHOICE_SET_*, AUTO_NUMBER, RELATIONSHIP); falls back
+     * to the SQL-type-name mapping. Returns `undefined` if neither resolves.
+     */
+    tryResolveFieldDataType(fieldDisplayType, sqlTypeName) {
+        const displayMapped = fieldDisplayType ? FieldDisplayTypeToDataType[fieldDisplayType] : undefined;
+        if (displayMapped)
+            return displayMapped;
+        return sqlTypeName ? EntityFieldTypeMap[sqlTypeName] : undefined;
+    }
     /**
      * Transforms nested reference objects in field metadata
      */
@@ -3094,11 +3209,16 @@ class EntityService extends BaseService {
     /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
     buildSchemaFieldPayload(field) {
         this.validateName(field.fieldName, 'field');
-        const mapping = EntitySchemaFieldTypeMap[field.type ?? EntityFieldDataType.STRING];
+        const fieldType = field.type ?? EntityFieldDataType.STRING;
+        this.validateFieldConstraints(fieldType, field, field.fieldName);
+        const mapping = EntitySchemaFieldTypeMap[fieldType];
         return {
             name: field.fieldName,
             displayName: field.displayName ?? field.fieldName,
-            sqlType: { name: mapping.sqlTypeName },
+            sqlType: {
+                name: mapping.sqlTypeName,
+                ...this.buildSqlTypeConstraints(fieldType, field),
+            },
             fieldDisplayType: mapping.fieldDisplayType,
             description: field.description ?? '',
             isRequired: field.isRequired ?? false,
@@ -3111,6 +3231,107 @@ class EntityService extends BaseService {
             ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
         };
     }
+    /**
+     * Derives the user-facing {@link EntityFieldDataType} for a field on the raw
+     * API response. Throws if the field's `fieldDisplayType` and `sqlType.name`
+     * are both unmappable.
+     */
+    resolveFieldDataType(f) {
+        const mapped = this.tryResolveFieldDataType(f.fieldDisplayType, f.sqlType?.name);
+        if (!mapped) {
+            throw new ValidationError({
+                message: `Cannot determine field type for '${f.name}' (id: ${f.id}) — sqlType '${f.sqlType?.name ?? '(missing)'}' and fieldDisplayType '${f.fieldDisplayType ?? '(missing)'}' are both unrecognized.`,
+            });
+        }
+        return mapped;
+    }
+    /**
+     * Validates that the user-supplied constraint properties on a field are
+     * supported by the field's data type. Throws a `ValidationError` listing
+     * any unsupported properties.
+     */
+    validateFieldConstraints(type, field, fieldName) {
+        const spec = ENTITY_FIELD_CONSTRAINT_SPEC[type] ?? {};
+        const supported = Object.keys(spec);
+        const provided = Object.values(EntityFieldConstraint).filter(name => field[name] !== undefined);
+        const unsupported = provided.filter(p => !(p in spec));
+        if (unsupported.length > 0) {
+            const allowedDesc = supported.length > 0 ? supported.join(', ') : 'none';
+            throw new ValidationError({
+                message: `Field '${fieldName}' of type ${type} does not accept ${unsupported.join(', ')}. Allowed constraints for this type: ${allowedDesc}.`,
+            });
+        }
+        // Range check: each user-supplied constraint must be within its allowed bounds.
+        for (const name of provided) {
+            const range = spec[name];
+            const value = field[name];
+            if (range && value !== undefined && (value < range.min || value > range.max)) {
+                throw new ValidationError({
+                    message: `Field '${fieldName}' of type ${type} has ${name} ${value} out of range [${range.min}, ${range.max}].`,
+                });
+            }
+        }
+        // Cross-field check: when both bounds are user-supplied in the same call,
+        // minValue must be strictly less than maxValue.
+        if (field.minValue !== undefined && field.maxValue !== undefined && field.minValue >= field.maxValue) {
+            throw new ValidationError({
+                message: `Field '${fieldName}' of type ${type} has minValue ${field.minValue} >= maxValue ${field.maxValue}. minValue must be strictly less than maxValue.`,
+            });
+        }
+    }
+    /**
+     * Returns the sqlType constraint fields for a given field type.
+     *
+     * The API requires specific constraint properties to be set per SQL type;
+     * without them the field is stored in an incomplete state, causing
+     * "Field type cannot be changed" errors when the UI later tries to edit
+     * advanced options. User-supplied values from `EntityCreateFieldOptions`
+     * override the defaults where the type accepts overrides.
+     */
+    buildSqlTypeConstraints(type, field) {
+        const defaults = ENTITY_FIELD_CONSTRAINT_DEFAULTS;
+        switch (type) {
+            case EntityFieldDataType.STRING:
+                return { lengthLimit: field.lengthLimit ?? defaults.STRING_LENGTH_LIMIT };
+            case EntityFieldDataType.MULTILINE_TEXT:
+                return { lengthLimit: field.lengthLimit ?? defaults.MULTILINE_TEXT_LENGTH_LIMIT };
+            case EntityFieldDataType.DECIMAL:
+                return {
+                    lengthLimit: defaults.DECIMAL_LENGTH_LIMIT,
+                    decimalPrecision: field.decimalPrecision ?? defaults.DECIMAL_PRECISION,
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.BOOLEAN:
+                return { lengthLimit: defaults.BOOLEAN_LENGTH_LIMIT };
+            case EntityFieldDataType.DATE:
+            case EntityFieldDataType.DATETIME_WITH_TZ:
+                return { lengthLimit: defaults.DATE_LENGTH_LIMIT };
+            case EntityFieldDataType.INTEGER:
+            case EntityFieldDataType.BIG_INTEGER:
+                return {
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.FLOAT:
+            case EntityFieldDataType.DOUBLE:
+                return {
+                    decimalPrecision: field.decimalPrecision ?? defaults.DECIMAL_PRECISION,
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.FILE:
+            case EntityFieldDataType.RELATIONSHIP:
+                // UNIQUEIDENTIFIER fixed lengthLimit (300)
+                return { lengthLimit: defaults.UNIQUEIDENTIFIER_LENGTH_LIMIT };
+            case EntityFieldDataType.CHOICE_SET_MULTIPLE:
+                // CHOICE_SET_MULTIPLE fixed lengthLimit (4000)
+                return { lengthLimit: defaults.CHOICE_SET_MULTIPLE_LENGTH_LIMIT };
+            default:
+                // UUID, CHOICE_SET_SINGLE, AUTO_NUMBER, DATETIME — (sqlType: { name })
+                return {};
+        }
+    }
     validateName(name, context) {
         if (name.length < 3 || name.length > 100 || !/^[a-zA-Z]\w*$/.test(name)) {
             const suggestion = name.replace(/\W/g, '').replace(/^[0-9_]+/, '');

package/dist/feedback/index.cjs

@@ -505,6 +505,7 @@ class ErrorFactory {
     }
 }
 
+const FOLDER_KEY = 'X-UIPATH-FolderKey';
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
 const TRACEPARENT = 'traceparent';
 const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
@@ -1557,6 +1558,7 @@ const LLMOPS_BASE = 'llmopstenant_';
  */
 const FEEDBACK_ENDPOINTS = {
     GET_ALL: `${LLMOPS_BASE}/api/Feedback`,
+    GET_BY_ID: (id) => `${LLMOPS_BASE}/api/Feedback/${id}`,
 };
 
 /**
@@ -1565,7 +1567,7 @@ const FEEDBACK_ENDPOINTS = {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.3.4";
+const SDK_VERSION = "1.3.6";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -1791,8 +1793,9 @@ function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, op
         // Track the event if enabled
         if (shouldTrack) {
             // Use the full name provided in the decorator (e.g., "Queue.GetAll")
-            const serviceMethod = nameOrOptions
-                ;
+            const serviceMethod = typeof nameOrOptions === 'string'
+                ? nameOrOptions
+                : fallbackName;
             // Use 'Sdk.Run' as the name and serviceMethod as the service
             telemetryClient.track(serviceMethod, SDK_RUN_EVENT, opts.attributes);
         }
@@ -1821,7 +1824,7 @@ function createTrackedFunction(originalFunction, nameOrOptions, fallbackName, op
  */
 function track(nameOrOptions, options) {
     return function decorator(_target, propertyKey, descriptor) {
-        const opts = {};
+        const opts = typeof nameOrOptions === 'object' ? nameOrOptions : {};
         if (descriptor && typeof descriptor.value === 'function') {
             // Method decorator
             descriptor.value = createTrackedFunction(descriptor.value, nameOrOptions, propertyKey || 'unknown_method', opts);
@@ -1890,10 +1893,41 @@ class FeedbackService extends BaseService {
             excludeFromPrefix: Object.keys(options || {}),
         }, options);
     }
+    /**
+     * Gets a single feedback entry by its feedback ID.
+     *
+     * @param id - Feedback ID (GUID) of the feedback entry
+     * @param options - Required options including folderKey for folder-level authorization {@link FeedbackOptions}
+     * @returns Promise resolving to {@link FeedbackGetResponse}
+     * @example
+     * ```typescript
+     * import { Feedback } from '@uipath/uipath-typescript/feedback';
+     *
+     * const feedback = new Feedback(sdk);
+     *
+     * // First, get feedback entries to obtain the ID and folder key
+     * const allFeedback = await feedback.getAll({ pageSize: 10 });
+     * const feedbackId = allFeedback.items[0].id;
+     * const folderKey = allFeedback.items[0].folderKey;
+     * const item = await feedback.getById(feedbackId, { folderKey });
+     * console.log(item.isPositive, item.comment, item.status);
+     * ```
+     */
+    async getById(id, options) {
+        if (!id)
+            throw new ValidationError({ message: 'Feedback ID is required for getById' });
+        if (!options?.folderKey)
+            throw new ValidationError({ message: 'folderKey is required for getById' });
+        const response = await this.get(FEEDBACK_ENDPOINTS.GET_BY_ID(id), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+        return transformData(response.data, FeedbackMap);
+    }
 }
 __decorate([
     track('Feedback.GetAll')
 ], FeedbackService.prototype, "getAll", null);
+__decorate([
+    track('Feedback.GetById')
+], FeedbackService.prototype, "getById", null);
 
 /**
  * Status of a feedback entry in the review workflow

package/dist/feedback/index.d.ts

@@ -342,6 +342,8 @@ interface FeedbackGetResponse {
     isPositive: boolean;
     /** Categories associated with this feedback entry */
     feedbackCategories: FeedbackCategory[];
+    /** Folder key (GUID) of the folder the feedback belongs to */
+    folderKey?: string;
     /** Email address of the user who submitted the feedback */
     userEmail?: string;
     /** Current status of the feedback in the review workflow */
@@ -351,6 +353,13 @@ interface FeedbackGetResponse {
     /** Timestamp when the feedback was last updated */
     updatedTime: string;
 }
+/**
+ * Options shared across feedback operations
+ */
+interface FeedbackOptions {
+    /** Folder key for authorization */
+    folderKey: string;
+}
 /**
  * Options for retrieving multiple feedback entries
  */
@@ -425,6 +434,27 @@ interface FeedbackServiceModel {
      * ```
      */
     getAll<T extends FeedbackGetAllOptions = FeedbackGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<FeedbackGetResponse> : NonPaginatedResponse<FeedbackGetResponse>>;
+    /**
+     * Gets a single feedback entry by its feedback ID.
+     *
+     * @param id - Feedback ID (GUID) of the feedback entry
+     * @param options - Required options including folderKey for folder-level authorization {@link FeedbackOptions}
+     * @returns Promise resolving to {@link FeedbackGetResponse}
+     * @example
+     * ```typescript
+     * import { Feedback } from '@uipath/uipath-typescript/feedback';
+     *
+     * const feedback = new Feedback(sdk);
+     *
+     * // First, get feedback entries to obtain the ID and folder key
+     * const allFeedback = await feedback.getAll({ pageSize: 10 });
+     * const feedbackId = allFeedback.items[0].id;
+     * const folderKey = allFeedback.items[0].folderKey;
+     * const item = await feedback.getById(feedbackId, { folderKey });
+     * console.log(item.isPositive, item.comment, item.status);
+     * ```
+     */
+    getById(id: string, options: FeedbackOptions): Promise<FeedbackGetResponse>;
 }
 
 /**
@@ -469,7 +499,28 @@ declare class FeedbackService extends BaseService implements FeedbackServiceMode
      * ```
      */
     getAll<T extends FeedbackGetAllOptions = FeedbackGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<FeedbackGetResponse> : NonPaginatedResponse<FeedbackGetResponse>>;
+    /**
+     * Gets a single feedback entry by its feedback ID.
+     *
+     * @param id - Feedback ID (GUID) of the feedback entry
+     * @param options - Required options including folderKey for folder-level authorization {@link FeedbackOptions}
+     * @returns Promise resolving to {@link FeedbackGetResponse}
+     * @example
+     * ```typescript
+     * import { Feedback } from '@uipath/uipath-typescript/feedback';
+     *
+     * const feedback = new Feedback(sdk);
+     *
+     * // First, get feedback entries to obtain the ID and folder key
+     * const allFeedback = await feedback.getAll({ pageSize: 10 });
+     * const feedbackId = allFeedback.items[0].id;
+     * const folderKey = allFeedback.items[0].folderKey;
+     * const item = await feedback.getById(feedbackId, { folderKey });
+     * console.log(item.isPositive, item.comment, item.status);
+     * ```
+     */
+    getById(id: string, options: FeedbackOptions): Promise<FeedbackGetResponse>;
 }
 
 export { FeedbackService as Feedback, FeedbackStatus };
-export type { FeedbackCategory, FeedbackGetAllOptions, FeedbackGetResponse, FeedbackServiceModel };
+export type { FeedbackCategory, FeedbackGetAllOptions, FeedbackGetResponse, FeedbackOptions, FeedbackServiceModel };