@uipath/uipath-typescript 1.3.0 → 1.3.2

package/dist/entities/index.cjs

@@ -45,31 +45,43 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Type guards for error response types
+ * Base error class for all UiPath SDK errors
+ * Extends Error for standard error handling compatibility
  */
-function isOrchestratorError(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'message' in error &&
-        'errorCode' in error &&
-        typeof error.message === 'string' &&
-        typeof error.errorCode === 'number';
-}
-function isEntityError(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'error' in error &&
-        typeof error.error === 'string';
-}
-function isPimsError(error) {
-    return typeof error === 'object' &&
-        error !== null &&
-        'type' in error &&
-        'title' in error &&
-        'status' in error &&
-        typeof error.type === 'string' &&
-        typeof error.title === 'string' &&
-        typeof error.status === 'number';
+class UiPathError extends Error {
+    constructor(type, params) {
+        super(params.message);
+        this.name = type;
+        this.type = type;
+        this.statusCode = params.statusCode;
+        this.requestId = params.requestId;
+        this.timestamp = new Date();
+        // Maintains proper stack trace for where our error was thrown
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Returns a clean JSON representation of the error
+     */
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            statusCode: this.statusCode,
+            requestId: this.requestId,
+            timestamp: this.timestamp
+        };
+    }
+    /**
+     * Returns detailed debug information including stack trace
+     */
+    getDebugInfo() {
+        return {
+            ...this.toJSON(),
+            stack: this.stack
+        };
+    }
 }
 
 /**
@@ -133,6 +145,161 @@ const ErrorMessages = {
 const ErrorNames = {
     ABORT_ERROR: 'AbortError'};
 
+/**
+ * Error thrown when authentication fails (401 errors)
+ * Common scenarios:
+ * - Invalid credentials
+ * - Expired token
+ * - Missing authentication
+ */
+class AuthenticationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHENTICATION, {
+            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+class AuthorizationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.AUTHORIZATION, {
+            message: params.message || ErrorMessages.ACCESS_DENIED,
+            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+class ValidationError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.VALIDATION, {
+            message: params.message || ErrorMessages.VALIDATION_FAILED,
+            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+class NotFoundError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NOT_FOUND, {
+            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
+            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+class RateLimitError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.RATE_LIMIT, {
+            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
+            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+class ServerError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.SERVER, {
+            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
+            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
+            requestId: params.requestId
+        });
+    }
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable() {
+        return this.statusCode === HttpStatus.BAD_GATEWAY ||
+            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
+            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
+    }
+}
+
+/**
+ * Error thrown when network/connection issues occur
+ * Common scenarios:
+ * - Connection timeout
+ * - DNS resolution failure
+ * - Network unreachable
+ * - Request aborted
+ */
+class NetworkError extends UiPathError {
+    constructor(params = {}) {
+        super(ErrorType.NETWORK, {
+            message: params.message || ErrorMessages.NETWORK_ERROR,
+            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
+            requestId: params.requestId
+        });
+    }
+}
+
+/**
+ * Type guards for error response types
+ */
+function isOrchestratorError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        'errorCode' in error &&
+        typeof error.message === 'string' &&
+        typeof error.errorCode === 'number';
+}
+function isEntityError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'error' in error &&
+        typeof error.error === 'string';
+}
+function isPimsError(error) {
+    return typeof error === 'object' &&
+        error !== null &&
+        'type' in error &&
+        'title' in error &&
+        'status' in error &&
+        typeof error.type === 'string' &&
+        typeof error.title === 'string' &&
+        typeof error.status === 'number';
+}
+
 /**
  * Parser for Orchestrator/Task error format
  */
@@ -283,173 +450,6 @@ class ErrorResponseParser {
 // Export singleton instance
 const errorResponseParser = new ErrorResponseParser();
 
-/**
- * Base error class for all UiPath SDK errors
- * Extends Error for standard error handling compatibility
- */
-class UiPathError extends Error {
-    constructor(type, params) {
-        super(params.message);
-        this.name = type;
-        this.type = type;
-        this.statusCode = params.statusCode;
-        this.requestId = params.requestId;
-        this.timestamp = new Date();
-        // Maintains proper stack trace for where our error was thrown
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-    /**
-     * Returns a clean JSON representation of the error
-     */
-    toJSON() {
-        return {
-            type: this.type,
-            message: this.message,
-            statusCode: this.statusCode,
-            requestId: this.requestId,
-            timestamp: this.timestamp
-        };
-    }
-    /**
-     * Returns detailed debug information including stack trace
-     */
-    getDebugInfo() {
-        return {
-            ...this.toJSON(),
-            stack: this.stack
-        };
-    }
-}
-
-/**
- * Error thrown when authentication fails (401 errors)
- * Common scenarios:
- * - Invalid credentials
- * - Expired token
- * - Missing authentication
- */
-class AuthenticationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.AUTHENTICATION, {
-            message: params.message || ErrorMessages.AUTHENTICATION_FAILED,
-            statusCode: params.statusCode ?? HttpStatus.UNAUTHORIZED,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when authorization fails (403 errors)
- * Common scenarios:
- * - Insufficient permissions
- * - Access denied to resource
- * - Invalid scope
- */
-class AuthorizationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.AUTHORIZATION, {
-            message: params.message || ErrorMessages.ACCESS_DENIED,
-            statusCode: params.statusCode ?? HttpStatus.FORBIDDEN,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when validation fails (400 errors or client-side validation)
- * Common scenarios:
- * - Invalid input parameters
- * - Missing required fields
- * - Invalid data format
- */
-class ValidationError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.VALIDATION, {
-            message: params.message || ErrorMessages.VALIDATION_FAILED,
-            statusCode: params.statusCode ?? HttpStatus.BAD_REQUEST,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when a resource is not found (404 errors)
- * Common scenarios:
- * - Resource doesn't exist
- * - Invalid ID provided
- * - Resource deleted
- */
-class NotFoundError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.NOT_FOUND, {
-            message: params.message || ErrorMessages.RESOURCE_NOT_FOUND,
-            statusCode: params.statusCode ?? HttpStatus.NOT_FOUND,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when rate limit is exceeded (429 errors)
- * Common scenarios:
- * - Too many requests in a time window
- * - API throttling
- */
-class RateLimitError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.RATE_LIMIT, {
-            message: params.message || ErrorMessages.RATE_LIMIT_EXCEEDED,
-            statusCode: params.statusCode ?? HttpStatus.TOO_MANY_REQUESTS,
-            requestId: params.requestId
-        });
-    }
-}
-
-/**
- * Error thrown when server encounters an error (5xx errors)
- * Common scenarios:
- * - Internal server error
- * - Service unavailable
- * - Gateway timeout
- */
-class ServerError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.SERVER, {
-            message: params.message || ErrorMessages.INTERNAL_SERVER_ERROR,
-            statusCode: params.statusCode ?? HttpStatus.INTERNAL_SERVER_ERROR,
-            requestId: params.requestId
-        });
-    }
-    /**
-     * Checks if this is a temporary error that might succeed on retry
-     */
-    get isRetryable() {
-        return this.statusCode === HttpStatus.BAD_GATEWAY ||
-            this.statusCode === HttpStatus.SERVICE_UNAVAILABLE ||
-            this.statusCode === HttpStatus.GATEWAY_TIMEOUT;
-    }
-}
-
-/**
- * Error thrown when network/connection issues occur
- * Common scenarios:
- * - Connection timeout
- * - DNS resolution failure
- * - Network unreachable
- * - Request aborted
- */
-class NetworkError extends UiPathError {
-    constructor(params = {}) {
-        super(ErrorType.NETWORK, {
-            message: params.message || ErrorMessages.NETWORK_ERROR,
-            statusCode: params.statusCode, // Network errors typically don't have HTTP status codes
-            requestId: params.requestId
-        });
-    }
-}
-
 /**
  * Factory for creating typed errors based on HTTP status codes
  * Follows the Factory pattern for clean error instantiation
@@ -526,15 +526,11 @@ const RESPONSE_TYPES = {
 
 class ApiClient {
     constructor(config, executionContext, tokenManager, clientConfig = {}) {
-        this.defaultHeaders = {};
         this.config = config;
         this.executionContext = executionContext;
         this.clientConfig = clientConfig;
         this.tokenManager = tokenManager;
     }
-    setDefaultHeaders(headers) {
-        this.defaultHeaders = { ...this.defaultHeaders, ...headers };
-    }
     /**
      * Gets a valid authentication token, refreshing if necessary.
      * Used internally for API requests and exposed for services that need manual auth headers.
@@ -550,7 +546,6 @@ class ApiClient {
         return {
             'Authorization': `Bearer ${token}`,
             'Content-Type': CONTENT_TYPES.JSON,
-            ...this.defaultHeaders,
             ...this.clientConfig.headers
         };
     }
@@ -1411,6 +1406,8 @@ class BaseService {
      *
      * @param instance - UiPath SDK instance providing authentication and configuration.
      *                    Services receive this via dependency injection in the modular pattern.
+     * @param headers - Optional default headers to include in every request (e.g. `x-uipath-external-user-id` for
+     *                  CAS external-app auth)
      *
      * @example
      * ```typescript
@@ -1430,11 +1427,11 @@ class BaseService {
      * const entities = new Entities(sdk);
      * ```
      */
-    constructor(instance) {
+    constructor(instance, headers) {
         // Private field - not visible via Object.keys() or any reflection
         _BaseService_apiClient.set(this, void 0);
         const { config, context, tokenManager } = SDKInternalsRegistry.get(instance);
-        __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager), "f");
+        __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager, headers ? { headers } : {}), "f");
     }
     /**
      * Gets a valid authentication token, refreshing if necessary.
@@ -1693,27 +1690,41 @@ function createEntityMethods(entityData, service) {
                 throw new Error('Entity ID is undefined');
             return service.deleteAttachment(entityData.id, recordId, fieldName);
         },
+        async queryRecords(options) {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            return service.queryRecordsById(entityData.id, options);
+        },
+        async importRecords(file) {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            return service.importRecordsById(entityData.id, file);
+        },
         async insert(data, options) {
             return this.insertRecord(data, options);
         },
         async batchInsert(data, options) {
             return this.insertRecords(data, options);
         },
-        async update(data, options) {
-            return this.updateRecords(data, options);
+        async getRecords(options) {
+            return this.getAllRecords(options);
+        },
+        async delete() {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            return service.deleteById(entityData.id);
         },
-        async delete(recordIds, options) {
-            return this.deleteRecords(recordIds, options);
+        async update(options) {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            return service.updateById(entityData.id, options);
         },
-        async getRecords(options) {
-            return this.getAllRecords(options);
-        }
     };
 }
 /**
- * Creates an actionable entity metadata by combining entity with operational methods
+ * Creates an actionable entity by combining entity metadata with data and management methods
  *
- * @param entityData - Entity metadata
+ * @param entityMetadata - Entity metadata
  * @param service - The entity service instance
  * @returns Entity metadata with added methods
  */
@@ -1722,6 +1733,103 @@ function createEntityWithMethods(entityData, service) {
     return Object.assign({}, entityData, methods);
 }
 
+/**
+ * Entity field data type names (SQL-level types returned by the API)
+ */
+exports.EntityFieldDataType = void 0;
+(function (EntityFieldDataType) {
+    EntityFieldDataType["UUID"] = "UUID";
+    EntityFieldDataType["STRING"] = "STRING";
+    EntityFieldDataType["INTEGER"] = "INTEGER";
+    EntityFieldDataType["DATETIME"] = "DATETIME";
+    EntityFieldDataType["DATETIME_WITH_TZ"] = "DATETIME_WITH_TZ";
+    EntityFieldDataType["DECIMAL"] = "DECIMAL";
+    EntityFieldDataType["FLOAT"] = "FLOAT";
+    EntityFieldDataType["DOUBLE"] = "DOUBLE";
+    EntityFieldDataType["DATE"] = "DATE";
+    EntityFieldDataType["BOOLEAN"] = "BOOLEAN";
+    EntityFieldDataType["BIG_INTEGER"] = "BIG_INTEGER";
+    EntityFieldDataType["MULTILINE_TEXT"] = "MULTILINE_TEXT";
+    EntityFieldDataType["FILE"] = "FILE";
+    EntityFieldDataType["CHOICE_SET_SINGLE"] = "CHOICE_SET_SINGLE";
+    EntityFieldDataType["CHOICE_SET_MULTIPLE"] = "CHOICE_SET_MULTIPLE";
+    EntityFieldDataType["AUTO_NUMBER"] = "AUTO_NUMBER";
+    EntityFieldDataType["RELATIONSHIP"] = "RELATIONSHIP";
+})(exports.EntityFieldDataType || (exports.EntityFieldDataType = {}));
+/**
+ * Logical operator for combining query filter groups
+ */
+exports.LogicalOperator = void 0;
+(function (LogicalOperator) {
+    /** Combine conditions with AND — all conditions must match */
+    LogicalOperator[LogicalOperator["And"] = 0] = "And";
+    /** Combine conditions with OR — any condition must match */
+    LogicalOperator[LogicalOperator["Or"] = 1] = "Or";
+})(exports.LogicalOperator || (exports.LogicalOperator = {}));
+/**
+ * Comparison operators for entity query filters.
+ * Not all operators are valid for all field types.
+ */
+exports.QueryFilterOperator = void 0;
+(function (QueryFilterOperator) {
+    QueryFilterOperator["Equals"] = "=";
+    QueryFilterOperator["NotEquals"] = "!=";
+    QueryFilterOperator["GreaterThan"] = ">";
+    QueryFilterOperator["LessThan"] = "<";
+    QueryFilterOperator["GreaterThanOrEqual"] = ">=";
+    QueryFilterOperator["LessThanOrEqual"] = "<=";
+    QueryFilterOperator["Contains"] = "contains";
+    QueryFilterOperator["NotContains"] = "not contains";
+    QueryFilterOperator["StartsWith"] = "startswith";
+    QueryFilterOperator["EndsWith"] = "endswith";
+    QueryFilterOperator["In"] = "in";
+    QueryFilterOperator["NotIn"] = "not in";
+})(exports.QueryFilterOperator || (exports.QueryFilterOperator = {}));
+/**
+ * Entity type enum
+ */
+exports.EntityType = void 0;
+(function (EntityType) {
+    EntityType["Entity"] = "Entity";
+    EntityType["ChoiceSet"] = "ChoiceSet";
+    EntityType["InternalEntity"] = "InternalEntity";
+    EntityType["SystemEntity"] = "SystemEntity";
+})(exports.EntityType || (exports.EntityType = {}));
+/**
+ * Reference types for fields
+ */
+exports.ReferenceType = void 0;
+(function (ReferenceType) {
+    ReferenceType["ManyToOne"] = "ManyToOne";
+})(exports.ReferenceType || (exports.ReferenceType = {}));
+/**
+ * Field display types
+ */
+exports.FieldDisplayType = void 0;
+(function (FieldDisplayType) {
+    FieldDisplayType["Basic"] = "Basic";
+    FieldDisplayType["Relationship"] = "Relationship";
+    FieldDisplayType["File"] = "File";
+    FieldDisplayType["ChoiceSetSingle"] = "ChoiceSetSingle";
+    FieldDisplayType["ChoiceSetMultiple"] = "ChoiceSetMultiple";
+    FieldDisplayType["AutoNumber"] = "AutoNumber";
+})(exports.FieldDisplayType || (exports.FieldDisplayType = {}));
+/**
+ * Data direction type for external fields
+ */
+exports.DataDirectionType = void 0;
+(function (DataDirectionType) {
+    DataDirectionType["ReadOnly"] = "ReadOnly";
+    DataDirectionType["ReadAndWrite"] = "ReadAndWrite";
+})(exports.DataDirectionType || (exports.DataDirectionType = {}));
+/**
+ * Join type for source join criteria
+ */
+exports.JoinType = void 0;
+(function (JoinType) {
+    JoinType["LeftJoin"] = "LeftJoin";
+})(exports.JoinType || (exports.JoinType = {}));
+
 /**
  * Base path constants for different services
  */
@@ -1730,6 +1838,12 @@ const DATAFABRIC_BASE = 'datafabric_';
 /**
  * Data Fabric Service Endpoints
  */
+/**
+ * Default folder key used for tenant-level Data Fabric entities.
+ * Tenant-level entities are not scoped to a folder; this is the
+ * conventional placeholder value the API expects.
+ */
+const DATA_FABRIC_TENANT_FOLDER_ID = '00000000-0000-0000-0000-000000000000';
 /**
  * Data Fabric Entity Service Endpoints
  */
@@ -1744,6 +1858,11 @@ const DATA_FABRIC_ENDPOINTS = {
         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_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
+        UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
+        DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
+        UPDATE_METADATA: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}/metadata`,
+        QUERY_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/query`,
+        BULK_UPLOAD_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/bulk-upload`,
         DOWNLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
         UPLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
         DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
@@ -1789,69 +1908,6 @@ function createParams(paramsObj = {}) {
     return params;
 }
 
-/**
- * Entity field type names
- */
-exports.EntityFieldDataType = void 0;
-(function (EntityFieldDataType) {
-    EntityFieldDataType["UUID"] = "UUID";
-    EntityFieldDataType["STRING"] = "STRING";
-    EntityFieldDataType["INTEGER"] = "INTEGER";
-    EntityFieldDataType["DATETIME"] = "DATETIME";
-    EntityFieldDataType["DATETIME_WITH_TZ"] = "DATETIME_WITH_TZ";
-    EntityFieldDataType["DECIMAL"] = "DECIMAL";
-    EntityFieldDataType["FLOAT"] = "FLOAT";
-    EntityFieldDataType["DOUBLE"] = "DOUBLE";
-    EntityFieldDataType["DATE"] = "DATE";
-    EntityFieldDataType["BOOLEAN"] = "BOOLEAN";
-    EntityFieldDataType["BIG_INTEGER"] = "BIG_INTEGER";
-    EntityFieldDataType["MULTILINE_TEXT"] = "MULTILINE_TEXT";
-})(exports.EntityFieldDataType || (exports.EntityFieldDataType = {}));
-/**
- * Entity type enum
- */
-exports.EntityType = void 0;
-(function (EntityType) {
-    EntityType["Entity"] = "Entity";
-    EntityType["ChoiceSet"] = "ChoiceSet";
-    EntityType["InternalEntity"] = "InternalEntity";
-    EntityType["SystemEntity"] = "SystemEntity";
-})(exports.EntityType || (exports.EntityType = {}));
-/**
- * Reference types for fields
- */
-exports.ReferenceType = void 0;
-(function (ReferenceType) {
-    ReferenceType["ManyToOne"] = "ManyToOne";
-})(exports.ReferenceType || (exports.ReferenceType = {}));
-/**
- * Field display types
- */
-exports.FieldDisplayType = void 0;
-(function (FieldDisplayType) {
-    FieldDisplayType["Basic"] = "Basic";
-    FieldDisplayType["Relationship"] = "Relationship";
-    FieldDisplayType["File"] = "File";
-    FieldDisplayType["ChoiceSetSingle"] = "ChoiceSetSingle";
-    FieldDisplayType["ChoiceSetMultiple"] = "ChoiceSetMultiple";
-    FieldDisplayType["AutoNumber"] = "AutoNumber";
-})(exports.FieldDisplayType || (exports.FieldDisplayType = {}));
-/**
- * Data direction type for external fields
- */
-exports.DataDirectionType = void 0;
-(function (DataDirectionType) {
-    DataDirectionType["ReadOnly"] = "ReadOnly";
-    DataDirectionType["ReadAndWrite"] = "ReadAndWrite";
-})(exports.DataDirectionType || (exports.DataDirectionType = {}));
-/**
- * Join type for source join criteria
- */
-exports.JoinType = void 0;
-(function (JoinType) {
-    JoinType["LeftJoin"] = "LeftJoin";
-})(exports.JoinType || (exports.JoinType = {}));
-
 /**
  * Entity field data types (SQL types from API)
  */
@@ -1870,6 +1926,7 @@ var SqlFieldType;
     SqlFieldType["DECIMAL"] = "DECIMAL";
     SqlFieldType["MULTILINE"] = "MULTILINE";
 })(SqlFieldType || (SqlFieldType = {}));
+
 /**
  * Maps fields for Entities
  */
@@ -1879,6 +1936,40 @@ const EntityMap = {
     sqlType: 'fieldDataType',
     fieldDefinition: 'fieldMetaData'
 };
+/**
+ * Maps EntityFieldDataType values to the API field payload components for create/update operations
+ */
+const EntitySchemaFieldTypeMap = {
+    [exports.EntityFieldDataType.UUID]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.STRING]: { sqlTypeName: SqlFieldType.NVARCHAR, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.INTEGER]: { sqlTypeName: SqlFieldType.INT, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.DATETIME]: { sqlTypeName: SqlFieldType.DATETIME2, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.DATETIME_WITH_TZ]: { sqlTypeName: SqlFieldType.DATETIMEOFFSET, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.DECIMAL]: { sqlTypeName: SqlFieldType.DECIMAL, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.FLOAT]: { sqlTypeName: SqlFieldType.FLOAT, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.DOUBLE]: { sqlTypeName: SqlFieldType.REAL, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.DATE]: { sqlTypeName: SqlFieldType.DATE, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.BOOLEAN]: { sqlTypeName: SqlFieldType.BIT, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.BIG_INTEGER]: { sqlTypeName: SqlFieldType.BIGINT, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.MULTILINE_TEXT]: { sqlTypeName: SqlFieldType.MULTILINE, fieldDisplayType: exports.FieldDisplayType.Basic },
+    [exports.EntityFieldDataType.FILE]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.File },
+    [exports.EntityFieldDataType.CHOICE_SET_SINGLE]: { sqlTypeName: SqlFieldType.INT, fieldDisplayType: exports.FieldDisplayType.ChoiceSetSingle },
+    [exports.EntityFieldDataType.CHOICE_SET_MULTIPLE]: { sqlTypeName: SqlFieldType.NVARCHAR, fieldDisplayType: exports.FieldDisplayType.ChoiceSetMultiple },
+    [exports.EntityFieldDataType.AUTO_NUMBER]: { sqlTypeName: SqlFieldType.DECIMAL, fieldDisplayType: exports.FieldDisplayType.AutoNumber },
+    [exports.EntityFieldDataType.RELATIONSHIP]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.Relationship },
+};
+/**
+ * Maps FieldDisplayType values to EntityFieldDataType for types that share SQL types
+ * with other field types (File, ChoiceSetSingle, ChoiceSetMultiple, AutoNumber).
+ * Used during read-side transformation to produce the correct EntityFieldDataType.
+ */
+const FieldDisplayTypeToDataType = {
+    [exports.FieldDisplayType.File]: exports.EntityFieldDataType.FILE,
+    [exports.FieldDisplayType.ChoiceSetSingle]: exports.EntityFieldDataType.CHOICE_SET_SINGLE,
+    [exports.FieldDisplayType.ChoiceSetMultiple]: exports.EntityFieldDataType.CHOICE_SET_MULTIPLE,
+    [exports.FieldDisplayType.AutoNumber]: exports.EntityFieldDataType.AUTO_NUMBER,
+    [exports.FieldDisplayType.Relationship]: exports.EntityFieldDataType.RELATIONSHIP,
+};
 /**
  * Maps SQL field types to friendly display names
  */
@@ -1894,7 +1985,7 @@ const EntityFieldTypeMap = {
     [SqlFieldType.DATE]: exports.EntityFieldDataType.DATE,
     [SqlFieldType.BIT]: exports.EntityFieldDataType.BOOLEAN,
     [SqlFieldType.DECIMAL]: exports.EntityFieldDataType.DECIMAL,
-    [SqlFieldType.MULTILINE]: exports.EntityFieldDataType.MULTILINE_TEXT
+    [SqlFieldType.MULTILINE]: exports.EntityFieldDataType.MULTILINE_TEXT,
 };
 
 /**
@@ -1903,7 +1994,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.0";
+const SDK_VERSION = "1.3.2";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -2498,6 +2589,99 @@ class EntityService extends BaseService {
         });
         return entities;
     }
+    /**
+     * Queries entity records with filters, sorting, and pagination
+     *
+     * @param id - UUID of the entity
+     * @param options - Query options including filterGroup, selectedFields, sortOptions, and pagination
+     * @returns Promise resolving to {@link NonPaginatedResponse} without pagination options,
+     *   or {@link PaginatedResponse} when `pageSize`, `cursor`, or `jumpToPage` are provided
+     *
+     * @example
+     * ```typescript
+     * import { Entities, LogicalOperator, QueryFilterOperator } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Non-paginated query with a filter
+     * const result = await entities.queryRecordsById("<entityId>", {
+     *   filterGroup: {
+     *     logicalOperator: LogicalOperator.And,
+     *     queryFilters: [
+     *       { fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }
+     *     ]
+     *   },
+     *   sortOptions: [{ fieldName: "created_at", isDescending: true }],
+     * });
+     * console.log(`Found ${result.totalCount} records`);
+     *
+     * // With pagination
+     * const page1 = await entities.queryRecordsById("<entityId>", {
+     *   filterGroup: { queryFilters: [{ fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }] },
+     *   pageSize: 25,
+     * });
+     * if (page1.hasNextPage) {
+     *   const page2 = await entities.queryRecordsById("<entityId>", { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    async queryRecordsById(id, options) {
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(id),
+            method: HTTP_METHODS.POST,
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
+                totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
+                }
+            },
+            excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions']
+        }, options);
+    }
+    /**
+     * Imports records from a CSV file into an entity
+     *
+     * @param id - UUID of the entity
+     * @param file - CSV file to import (Blob, File, or Uint8Array)
+     * @returns Promise resolving to import result with record counts
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Browser: upload from file input
+     * const fileInput = document.getElementById('csv-input') as HTMLInputElement;
+     * const result = await entities.importRecordsById("<entityId>", fileInput.files[0]);
+     *
+     * // Node.js: read from disk
+     * const fileBuffer = fs.readFileSync('records.csv');
+     * const result = await entities.importRecordsById("<entityId>", new Blob([fileBuffer], { type: 'text/csv' }));
+     *
+     * console.log(`Inserted ${result.insertedRecords} of ${result.totalRecords} records`);
+     * if (result.errorFileLink) {
+     *   console.log(`Error file link: ${result.errorFileLink}`);
+     * }
+     * ```
+     * @internal
+     */
+    async importRecordsById(id, file) {
+        const formData = new FormData();
+        if (file instanceof Uint8Array) {
+            formData.append('file', new Blob([file.buffer]));
+        }
+        else {
+            formData.append('file', file);
+        }
+        const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.BULK_UPLOAD_BY_ID(id), formData);
+        return response.data;
+    }
     /**
      * Downloads an attachment from an entity record field
      *
@@ -2622,18 +2806,169 @@ class EntityService extends BaseService {
         return this.insertRecordsById(id, data, options);
     }
     /**
-     * @hidden
-     * @deprecated Use {@link updateRecordsById} instead.
+     * Creates a new Data Fabric entity with the given schema
+     *
+     * @param name - Entity name — must start with a letter and contain
+     *   only letters, numbers, and underscores (e.g., `"productCatalog"`).
+     * @param fields - Array of field definitions
+     * @param options - Optional entity-level settings ({@link EntityCreateOptions})
+     * @returns Promise resolving to the ID of the created entity
+     *
+     * @example
+     * ```typescript
+     * const entityId = await entities.create("product_catalog", [
+     *   { 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 });
+     * ```
+     * @internal
      */
-    async updateById(id, data, options = {}) {
-        return this.updateRecordsById(id, data, options);
+    async create(name, fields, options) {
+        this.validateName(name, 'entity');
+        for (const field of fields) {
+            this.validateName(field.fieldName, 'field');
+        }
+        const opts = options ?? {};
+        const payload = {
+            ...(opts.description !== undefined && { description: opts.description }),
+            displayName: opts.displayName ?? name,
+            entityDefinition: {
+                name,
+                fields: fields.map(f => this.buildSchemaFieldPayload(f)),
+                folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                isRbacEnabled: opts.isRbacEnabled ?? false,
+                isInsightsEnabled: opts.isAnalyticsEnabled ?? false,
+                externalFields: opts.externalFields ?? [],
+            },
+        };
+        const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, payload);
+        return response.data;
     }
     /**
-     * @hidden
-     * @deprecated Use {@link deleteRecordsById} instead.
+     * Deletes a Data Fabric entity and all its records
+     *
+     * @param id - UUID of the entity to delete
+     * @returns Promise resolving when the entity is deleted
+     *
+     * @example
+     * ```typescript
+     * await entities.deleteById("<entityId>");
+     * ```
+     * @internal
+     */
+    async deleteById(id) {
+        await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE(id));
+    }
+    /**
+     * Updates an existing Data Fabric entity — schema and/or metadata.
+     *
+     * Provide any combination of schema fields (`addFields`, `removeFields`, `updateFields`) and
+     * metadata fields (`displayName`, `description`, `isRbacEnabled`). Each group is applied
+     * only when the corresponding fields are present.
+     *
+     * **Warning:** Schema changes (`addFields`, `removeFields`, `updateFields`) use a
+     * read-modify-write pattern — concurrent calls on the same entity may silently
+     * overwrite each other's changes.
+     *
+     * @param id - UUID of the entity to update
+     * @param options - Changes to apply ({@link EntityUpdateByIdOptions})
+     * @returns Promise resolving when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // Schema-only
+     * await entities.updateById("<entityId>", {
+     *   addFields: [{ fieldName: "notes", type: EntityFieldDataType.MULTILINE_TEXT }],
+     *   removeFields: [{ fieldName: "old_field" }],
+     * });
+     *
+     * // Metadata-only
+     * await entities.updateById("<entityId>", {
+     *   displayName: "My Updated Entity",
+     *   description: "Updated description",
+     * });
+     *
+     * // Combined
+     * await entities.updateById("<entityId>", {
+     *   updateFields: [{ id: "<fieldId>", displayName: "Unit Price", isRequired: true }],
+     *   displayName: "Price Catalog",
+     * });
+     * ```
+     * @internal
+     */
+    async updateById(id, options) {
+        const opts = options ?? {};
+        const hasSchemaChanges = !!(opts.addFields?.length || opts.removeFields?.length || opts.updateFields?.length);
+        const hasMetadataChanges = opts.displayName !== undefined || opts.description !== undefined || opts.isRbacEnabled !== undefined;
+        if (hasSchemaChanges) {
+            await this.applySchemaUpdate(id, opts);
+        }
+        if (hasMetadataChanges) {
+            await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_METADATA(id), {
+                ...(opts.displayName !== undefined && { displayName: opts.displayName }),
+                ...(opts.description !== undefined && { description: opts.description }),
+                ...(opts.isRbacEnabled !== undefined && { isRbacEnabled: opts.isRbacEnabled }),
+            });
+        }
+    }
+    /**
+     * Fetches the current entity schema, applies the field delta, then posts the full updated schema.
+     *
+     * @param entityId - UUID of the entity to update
+     * @param options - Field changes to apply
+     * @private
      */
-    async deleteById(id, recordIds, options = {}) {
-        return this.deleteRecordsById(id, recordIds, options);
+    async applySchemaUpdate(entityId, options) {
+        const entityResponse = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(entityId));
+        const raw = entityResponse.data;
+        // Carry forward existing non-system fields from GET response (skip system/primary-key fields)
+        let fields = (raw.fields ?? [])
+            .filter(f => !f.isSystemField && !f.isPrimaryKey);
+        // Filter out removed fields
+        if (options.removeFields?.length) {
+            const removeSet = new Set(options.removeFields.map(r => r.fieldName));
+            fields = fields.filter(f => !removeSet.has(f.name));
+        }
+        // Apply per-field metadata updates (matched by field ID)
+        if (options.updateFields?.length) {
+            const updateMap = new Map(options.updateFields.map(u => [u.id, u]));
+            fields = fields.map(f => {
+                const update = updateMap.get(f.id ?? '');
+                if (!update)
+                    return f;
+                return {
+                    ...f,
+                    ...(update.displayName !== undefined && { displayName: update.displayName }),
+                    ...(update.description !== undefined && { description: update.description }),
+                    ...(update.isRequired !== undefined && { isRequired: update.isRequired }),
+                    ...(update.isUnique !== undefined && { isUnique: update.isUnique }),
+                    ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
+                    ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
+                    ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
+                };
+            });
+        }
+        // Build and append new fields
+        const newFields = [];
+        if (options.addFields?.length) {
+            for (const field of options.addFields) {
+                this.validateName(field.fieldName, 'field');
+            }
+            newFields.push(...options.addFields.map(f => this.buildSchemaFieldPayload(f)));
+        }
+        await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, {
+            displayName: raw.displayName,
+            description: raw.description,
+            entityDefinition: {
+                id: entityId,
+                name: raw.name,
+                fields: [...fields, ...newFields],
+                folderId: raw.folderId ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                isRbacEnabled: raw.isRbacEnabled ?? false,
+                isInsightsEnabled: raw.isInsightsEnabled ?? false,
+                externalFields: raw.externalFields ?? [],
+            },
+        });
     }
     /**
      * Orchestrates all field mapping transformations
@@ -2657,11 +2992,20 @@ class EntityService extends BaseService {
         metadata.fields = metadata.fields.map(field => {
             // Rename sqlType to fieldDataType
             let transformedField = transformData(field, EntityMap);
-            // Map SQL field type to friendly name
+            // Map field type: prefer fieldDisplayType for types that share SQL types (File, ChoiceSet, AutoNumber)
             if (transformedField.fieldDataType?.name) {
-                const sqlTypeName = transformedField.fieldDataType.name;
-                if (EntityFieldTypeMap[sqlTypeName]) {
-                    transformedField.fieldDataType.name = EntityFieldTypeMap[sqlTypeName];
+                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;
+                    }
                 }
             }
             this.transformNestedReferences(transformedField);
@@ -2705,7 +3049,44 @@ class EntityService extends BaseService {
             return externalSource;
         });
     }
+    /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
+    buildSchemaFieldPayload(field) {
+        this.validateName(field.fieldName, 'field');
+        const mapping = EntitySchemaFieldTypeMap[field.type ?? exports.EntityFieldDataType.STRING];
+        return {
+            name: field.fieldName,
+            displayName: field.displayName ?? field.fieldName,
+            sqlType: { name: mapping.sqlTypeName },
+            fieldDisplayType: mapping.fieldDisplayType,
+            description: field.description ?? '',
+            isRequired: field.isRequired ?? false,
+            isUnique: field.isUnique ?? false,
+            isRbacEnabled: field.isRbacEnabled ?? false,
+            isEncrypted: field.isEncrypted ?? false,
+            ...(field.defaultValue !== undefined && { defaultValue: field.defaultValue }),
+            ...(field.choiceSetId !== undefined && { choiceSetId: field.choiceSetId }),
+            ...(field.referenceEntityName !== undefined && { referenceEntityName: field.referenceEntityName }),
+            ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
+        };
+    }
+    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_]+/, '');
+            const defaultName = `My${context.charAt(0).toUpperCase() + context.slice(1)}`;
+            throw new ValidationError({
+                message: `Invalid ${context} name '${name}'. Must start with a letter, contain only letters, numbers, and underscores, 3–100 characters (e.g., "${suggestion || defaultName}").`
+            });
+        }
+        if (context === 'field' && EntityService.RESERVED_FIELD_NAMES.has(name)) {
+            throw new ValidationError({
+                message: `Field name '${name}' is reserved. Reserved names: ${[...EntityService.RESERVED_FIELD_NAMES].join(', ')}.`
+            });
+        }
+    }
 }
+EntityService.RESERVED_FIELD_NAMES = new Set([
+    'Id', 'CreatedBy', 'CreateTime', 'UpdatedBy', 'UpdateTime'
+]);
 __decorate([
     track('Entities.GetById')
 ], EntityService.prototype, "getById", null);
@@ -2733,6 +3114,12 @@ __decorate([
 __decorate([
     track('Entities.GetAll')
 ], EntityService.prototype, "getAll", null);
+__decorate([
+    track('Entities.QueryRecordsById')
+], EntityService.prototype, "queryRecordsById", null);
+__decorate([
+    track('Entities.ImportRecordsById')
+], EntityService.prototype, "importRecordsById", null);
 __decorate([
     track('Entities.DownloadAttachment')
 ], EntityService.prototype, "downloadAttachment", null);
@@ -2742,6 +3129,15 @@ __decorate([
 __decorate([
     track('Entities.DeleteAttachment')
 ], EntityService.prototype, "deleteAttachment", null);
+__decorate([
+    track('Entities.Create')
+], EntityService.prototype, "create", null);
+__decorate([
+    track('Entities.DeleteById')
+], EntityService.prototype, "deleteById", null);
+__decorate([
+    track('Entities.UpdateById')
+], EntityService.prototype, "updateById", null);
 
 class ChoiceSetService extends BaseService {
     /**