@uipath/uipath-typescript 1.3.3 → 1.3.5

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
@@ -1122,6 +1130,8 @@ interface EntityServiceModel {
     /**
      * Deletes data from an entity by entity ID
      *
+     * Note: Records deleted using deleteRecordsById will not trigger Data Fabric trigger events. Use {@link deleteRecordById} if you need trigger events to fire for the deleted record.
+     *
      * @param id - UUID of the entity
      * @param recordIds - Array of record UUIDs to delete
      * @param options - Delete options
@@ -1136,6 +1146,25 @@ interface EntityServiceModel {
      * ```
      */
     deleteRecordsById(id: string, recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Deletes a single record from an entity by entity ID and record ID
+     *
+     * Note: Data Fabric supports trigger events only on individual deletes, not on deleting multiple records.
+     * Use this method if you need trigger events to fire for the deleted record.
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record to delete
+     * @returns Promise resolving to void on success
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * await entities.deleteRecordById("<entityId>", "<recordId>");
+     * ```
+     */
+    deleteRecordById(entityId: string, recordId: string): Promise<void>;
     /**
      * Queries entity records with filters, sorting, and SDK-managed pagination
      *
@@ -1321,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
      */
@@ -1368,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
      */
@@ -1426,11 +1473,23 @@ interface EntityMethods {
     /**
      * Delete data from this entity
      *
+     * Note: Records deleted using deleteRecords will not trigger Data Fabric trigger events. Use {@link deleteRecord} if you need trigger events to fire for the deleted record.
+     *
      * @param recordIds - Array of record UUIDs to delete
      * @param options - Delete options
      * @returns Promise resolving to delete response
      */
     deleteRecords(recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Delete a single record from this entity
+     *
+     * Note: Data Fabric supports trigger events only on individual deletes, not on deleting multiple records.
+     * Use this method if you need trigger events to fire for the deleted record.
+     *
+     * @param recordId - UUID of the record to delete
+     * @returns Promise resolving to void on success
+     */
+    deleteRecord(recordId: string): Promise<void>;
     /**
      * Get all records from this entity
      *
@@ -1545,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
      */
@@ -1764,6 +1831,8 @@ declare class EntityService extends BaseService implements EntityServiceModel {
     /**
      * Deletes data from an entity by entity ID
      *
+     * Note: Records deleted using deleteRecordsById will not trigger Data Fabric trigger events. Use {@link deleteRecordById} if you need trigger events to fire for the deleted record.
+     *
      * @param entityId - UUID of the entity
      * @param recordIds - Array of record UUIDs to delete
      * @param options - Delete options
@@ -1782,6 +1851,25 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      * ```
      */
     deleteRecordsById(id: string, recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Deletes a single record from an entity by entity ID and record ID
+     *
+     * Note: Data Fabric supports trigger events only on individual deletes, not on deleting multiple records.
+     * Use this method if you need trigger events to fire for the deleted record.
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record to delete
+     * @returns Promise resolving to void on success
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * await entities.deleteRecordById("<entityId>", "<recordId>");
+     * ```
+     */
+    deleteRecordById(entityId: string, recordId: string): Promise<void>;
     /**
      * Gets all entities in the system
      *
@@ -1980,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
      */
@@ -2031,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
      */
@@ -2057,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
      */
@@ -2070,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

@@ -504,6 +504,8 @@ class ErrorFactory {
 }
 
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+const TRACEPARENT = 'traceparent';
+const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
 /**
  * Content type constants for HTTP requests/responses
  */
@@ -557,8 +559,13 @@ class ApiClient {
         if (isFormData) {
             delete defaultHeaders['Content-Type'];
         }
+        const traceId = crypto.randomUUID().replace(/-/g, '');
+        const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+        const traceparentValue = `00-${traceId}-${spanId}-01`;
         const headers = {
             ...defaultHeaders,
+            [TRACEPARENT]: traceparentValue,
+            [UIPATH_TRACEPARENT_ID]: traceparentValue,
             ...options.headers
         };
         // Convert params to URLSearchParams
@@ -1667,6 +1674,13 @@ function createEntityMethods(entityData, service) {
                 throw new Error('Entity ID is undefined');
             return service.deleteRecordsById(entityData.id, recordIds, options);
         },
+        async deleteRecord(recordId) {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            if (!recordId)
+                throw new Error('Record ID is undefined');
+            return service.deleteRecordById(entityData.id, recordId);
+        },
         async getAllRecords(options) {
             if (!entityData.id)
                 throw new Error('Entity ID is undefined');
@@ -1861,6 +1875,7 @@ const DATA_FABRIC_ENDPOINTS = {
         BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert-batch`,
         UPDATE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update/${recordId}`,
         UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update-batch`,
+        DELETE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete/${recordId}`,
         DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
         UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
         DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
@@ -1912,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)
  */
@@ -1974,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
  */
@@ -1998,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.3";
+const SDK_VERSION = "1.3.5";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -2536,6 +2629,8 @@ class EntityService extends BaseService {
     /**
      * Deletes data from an entity by entity ID
      *
+     * Note: Records deleted using deleteRecordsById will not trigger Data Fabric trigger events. Use {@link deleteRecordById} if you need trigger events to fire for the deleted record.
+     *
      * @param entityId - UUID of the entity
      * @param recordIds - Array of record UUIDs to delete
      * @param options - Delete options
@@ -2563,6 +2658,27 @@ class EntityService extends BaseService {
         });
         return response.data;
     }
+    /**
+     * Deletes a single record from an entity by entity ID and record ID
+     *
+     * Note: Data Fabric supports trigger events only on individual deletes, not on deleting multiple records.
+     * Use this method if you need trigger events to fire for the deleted record.
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record to delete
+     * @returns Promise resolving to void on success
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * await entities.deleteRecordById("<entityId>", "<recordId>");
+     * ```
+     */
+    async deleteRecordById(entityId, recordId) {
+        await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_RECORD_BY_ID(entityId, recordId));
+    }
     /**
      * Gets all entities in the system
      *
@@ -2824,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
      */
@@ -2897,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
      */
@@ -2940,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 }),
@@ -2949,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 } }),
                 };
             });
         }
@@ -2998,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
      */
@@ -3056,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,
@@ -3073,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_]+/, '');
@@ -3115,6 +3374,9 @@ __decorate([
 __decorate([
     track('Entities.DeleteRecordsById')
 ], EntityService.prototype, "deleteRecordsById", null);
+__decorate([
+    track('Entities.DeleteRecordById')
+], EntityService.prototype, "deleteRecordById", null);
 __decorate([
     track('Entities.GetAll')
 ], EntityService.prototype, "getAll", null);

package/dist/feedback/index.cjs

@@ -506,6 +506,8 @@ class ErrorFactory {
 }
 
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+const TRACEPARENT = 'traceparent';
+const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
 /**
  * Content type constants for HTTP requests/responses
  */
@@ -559,8 +561,13 @@ class ApiClient {
         if (isFormData) {
             delete defaultHeaders['Content-Type'];
         }
+        const traceId = crypto.randomUUID().replace(/-/g, '');
+        const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+        const traceparentValue = `00-${traceId}-${spanId}-01`;
         const headers = {
             ...defaultHeaders,
+            [TRACEPARENT]: traceparentValue,
+            [UIPATH_TRACEPARENT_ID]: traceparentValue,
             ...options.headers
         };
         // Convert params to URLSearchParams
@@ -1558,7 +1565,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.3";
+const SDK_VERSION = "1.3.5";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";