@uipath/data-fabric-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/dist/{tool-cyfkvxhw.js → tool-4g47skgm.js}

@@ -6595,7 +6595,7 @@ var require_src6 = __commonJS((exports) => {
 var package_default = {
   name: "@uipath/data-fabric-tool",
   license: "MIT",
-  version: "1.201.0-preview.115",
+  version: "1.201.0-preview.121",
   description: "Manage Data Fabric entities and records.",
   type: "module",
   main: "./dist/tool.js",
@@ -6618,7 +6618,7 @@ var package_default = {
     "@uipath/common": "workspace:*",
     "@uipath/auth": "workspace:*",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/uipath-typescript": "^1.5.4",
+    "@uipath/uipath-typescript": "^1.6.1",
     "@types/node": "^25.5.2",
     typescript: "^7.0.2"
   }
@@ -6681,17 +6681,18 @@ var TLS_ERROR_CODES = new Set([
 ]);
 var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
 var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
+var LOCAL_PERMISSION_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
+var LOCAL_PERMISSION_MESSAGE_PATTERN = /\b(EACCES|EPERM|EROFS)\b/;
+function localPermissionInstructions(code, path) {
+  const target = path !== undefined ? `'${path}'` : "a local file or resource";
+  if (code === "EROFS") {
+    return `The filesystem containing ${target} is read-only (EROFS), so the ` + "CLI could not write to it. This is a local environment problem, " + "not a UiPath service error — retrying will not help. Use a " + "writable location, or give this environment write access to the " + "path.";
+  }
+  const remedy = process.platform === "win32" ? "Re-run from an elevated terminal, close any program holding " + "the file open, or grant your user access to the path." : "Grant this user (or the sandbox the command runs in) access " + "to the path, or run the command outside the sandbox.";
+  return `The operating system denied access to ${target} (${code}). This is ` + "a local permission problem, not a UiPath service error — retrying " + `without a permission change will not help. ${remedy}`;
+}
 function describeConnectivityError(error) {
-  const queue = [error];
-  const seen = new Set;
-  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
-    const current = queue.shift();
-    if (current === null || typeof current !== "object")
-      continue;
-    if (seen.has(current))
-      continue;
-    seen.add(current);
-    const cur = current;
+  for (const cur of walkErrorGraph(error)) {
     const code = typeof cur.code === "string" ? cur.code : undefined;
     const message = typeof cur.message === "string" ? cur.message : undefined;
     if (code && TLS_ERROR_CODES.has(code)) {
@@ -6710,6 +6711,49 @@ function describeConnectivityError(error) {
         instructions: NETWORK_INSTRUCTIONS
       };
     }
+  }
+  return;
+}
+function describePermissionError(error) {
+  for (const cur of walkErrorGraph(error)) {
+    const message = typeof cur.message === "string" ? cur.message : undefined;
+    const code = matchLocalPermissionCode(cur.code, message);
+    if (!code)
+      continue;
+    const path = localPermissionPath(cur.path, message);
+    return {
+      code,
+      message: message ?? code,
+      ...path !== undefined ? { path } : {},
+      instructions: localPermissionInstructions(code, path)
+    };
+  }
+  return;
+}
+function matchLocalPermissionCode(code, message) {
+  if (typeof code === "string" && LOCAL_PERMISSION_ERROR_CODES.has(code)) {
+    return code;
+  }
+  const match = message ? LOCAL_PERMISSION_MESSAGE_PATTERN.exec(message) : null;
+  return match ? match[1] : undefined;
+}
+function localPermissionPath(path, message) {
+  if (typeof path === "string")
+    return path;
+  return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
+}
+function* walkErrorGraph(error) {
+  const queue = [error];
+  const seen = new Set;
+  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
+    const current = queue.shift();
+    if (current === null || typeof current !== "object")
+      continue;
+    if (seen.has(current))
+      continue;
+    seen.add(current);
+    const cur = current;
+    yield cur;
     if (cur.cause !== undefined)
       queue.push(cur.cause);
     if (Array.isArray(cur.errors))
@@ -6770,6 +6814,12 @@ function classifyError(status, error) {
   if (status !== undefined && status >= 500 && status < 600) {
     return { errorCode: "server_error", retry: "RetryLater" };
   }
+  if (status === undefined && describePermissionError(error)) {
+    return {
+      errorCode: "local_permission_denied",
+      retry: "RetryWillNotFix"
+    };
+  }
   const connectivity = describeConnectivityError(error);
   if (connectivity) {
     return {
@@ -6872,6 +6922,16 @@ async function extractErrorDetails(error, options) {
       message = `${message}: ${connectivity.message}`;
     }
   }
+  const permission = status === undefined ? describePermissionError(error) : undefined;
+  if (permission) {
+    if (permission.message !== message && !message.includes(permission.message)) {
+      message = `${message}: ${permission.message}`;
+    }
+    if (!message.includes(permission.instructions)) {
+      const punctuated = message.endsWith(".") ? message : `${message}.`;
+      message = `${punctuated} ${permission.instructions}`;
+    }
+  }
   let details = rawMessage;
   if (rawBody) {
     if (parsedBody) {
@@ -6911,6 +6971,9 @@ async function extractErrorDetails(error, options) {
   if (parsedBody?.traceId && typeof parsedBody.traceId === "string") {
     context.traceId = parsedBody.traceId;
   }
+  if (permission?.path !== undefined) {
+    context.path = permission.path;
+  }
   if (status === 429) {
     const resp = response;
     const headersObj = resp?.headers;
@@ -8153,6 +8216,7 @@ var CLI_ERROR_CODES = [
   "invalid_argument",
   "authentication_required",
   "permission_denied",
+  "local_permission_denied",
   "not_found",
   "rate_limited",
   "network_error",
@@ -8588,12 +8652,16 @@ function defaultErrorCodeForHttpStatus(status) {
     return "server_error";
   return;
 }
+var LOCAL_PERMISSION_TEXT_PATTERN = /(?:\b|\()(?:EACCES|EPERM|EROFS)(?::\s|\))/;
 function defaultErrorCodeForFailure(data) {
   if (data.Result === RESULTS.Failure) {
     const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage2(data.Message);
     const errorCode = defaultErrorCodeForHttpStatus(status);
     if (errorCode)
       return errorCode;
+    if (status === undefined && (LOCAL_PERMISSION_TEXT_PATTERN.test(data.Message) || LOCAL_PERMISSION_TEXT_PATTERN.test(data.Instructions))) {
+      return "local_permission_denied";
+    }
   }
   return defaultErrorCodeForResult(data.Result);
 }
@@ -9112,9 +9180,6 @@ var ScreenLogger;
 })(ScreenLogger ||= {});
 // ../common/src/sdk-user-agent.ts
 var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
-// ../common/src/tool-provider.ts
-var factorySlot = singleton("PackagerFactoryProvider");
-var moduleSlot = singleton("ToolModuleProvider");
 // ../common/src/stdin.ts
 async function readStdin() {
   if (process.stdin.isTTY) {
@@ -9132,6 +9197,8 @@ async function readStdin() {
 }
 // ../common/src/telemetry/ship-succeeded.ts
 var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
+// ../common/src/tool-provider.ts
+var factorySlot = singleton("PackagerFactoryProvider");
 // src/utils/output.ts
 function fail(message, instructions) {
   OutputFormatter.error({
@@ -9141,6 +9208,16 @@ function fail(message, instructions) {
   });
   processContext.exit(1);
 }
+function failInvalidArgument(message, instructions) {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    Message: message,
+    Instructions: instructions,
+    ErrorCode: "invalid_argument",
+    Retry: "RetryWillNotFix"
+  });
+  processContext.exit(1);
+}
 function requireDestructiveConfirmation(options, operation, reasonInstruction) {
   if (options.confirm === true && options.yes !== true) {
     warnDeprecatedOptionAlias("--confirm", "--yes");
@@ -9150,7 +9227,7 @@ function requireDestructiveConfirmation(options, operation, reasonInstruction) {
   }
   const reason = options.reason?.trim();
   if (reason === undefined || reason === "") {
-    fail("Reason required for destructive operation", reasonInstruction);
+    failInvalidArgument("Reason required for destructive operation", reasonInstruction);
     return null;
   }
   return reason;
@@ -10396,6 +10473,9 @@ function normalizeTokenRefreshUnavailableFailure() {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+// ../auth/src/tenantSelection.ts
+var IDENTIFIER_STATUSES = new Set([400, 403, 404]);
+
 // ../auth/src/selectTenant.ts
 var TENANT_SELECTION_REQUIRED_CODE = "TENANT_SELECTION_REQUIRED";
 var INVALID_TENANT_CODE = "INVALID_TENANT";
@@ -14570,7 +14650,23 @@ var TASK_ENDPOINTS = {
   COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
   GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
   GET_GENERIC_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataById`,
-  GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`
+  GET_GENERIC_TASK_BY_KEY: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataByKey`,
+  GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`,
+  SAVE_TASK_TAGS: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/SaveTaskTags`,
+  SAVE_TASK_DATA: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/SaveTaskData`,
+  SAVE_FORM_TASK_DATA: `${ORCHESTRATOR_BASE}/forms/TaskForms/SaveTaskData`,
+  SAVE_APP_TASK_DATA: `${ORCHESTRATOR_BASE}/tasks/AppTasks/SaveAppTasksData`,
+  EDIT_TASK_METADATA: `${ORCHESTRATOR_BASE}/odata/Tasks/UiPath.Server.Configuration.OData.EditTaskMetadata`
+};
+var TASK_CATALOG_ENDPOINTS = {
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/TaskCatalogs`,
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/TaskCatalogs(${id})`,
+  CREATE: `${ORCHESTRATOR_BASE}/odata/TaskCatalogs/UiPath.Server.Configuration.OData.CreateTaskCatalog`,
+  UPDATE: (id) => `${ORCHESTRATOR_BASE}/odata/TaskCatalogs(${id})/UiPath.Server.Configuration.OData.UpdateTaskCatalog`
+};
+var TASK_NOTE_ENDPOINTS = {
+  GET_BY_TASK_ID: (taskId) => `${ORCHESTRATOR_BASE}/odata/TaskNotes/UiPath.Server.Configuration.OData.GetByTaskId(taskId=${taskId})`,
+  CREATE: `${ORCHESTRATOR_BASE}/odata/TaskNotes/UiPath.Server.Configuration.OData.CreateTaskNote`
 };
 var BUCKET_ENDPOINTS = {
   GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
@@ -14597,7 +14693,11 @@ var JOB_ENDPOINTS = {
   GET_BY_KEY: (identifier) => `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${identifier})`,
   STOP: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StopJobs`,
   RESUME: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.ResumeJob`,
-  RESTART: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.RestartJob`
+  RESTART: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.RestartJob`,
+  ATTACHMENTS: {
+    GET_BY_JOB_KEY: `${ORCHESTRATOR_BASE}/api/JobAttachments/GetByJobKey`,
+    LINK: `${ORCHESTRATOR_BASE}/api/JobAttachments/Post`
+  }
 };
 var ASSET_ENDPOINTS = {
   GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
@@ -14605,7 +14705,8 @@ var ASSET_ENDPOINTS = {
   GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`
 };
 var ORCHESTRATOR_ATTACHMENT_ENDPOINTS = {
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Attachments(${id})`
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Attachments(${id})`,
+  CREATE: `${ORCHESTRATOR_BASE}/odata/Attachments`
 };
 var MAESTRO_ENDPOINTS = {
   PROCESSES: {
@@ -14668,6 +14769,7 @@ var DATA_FABRIC_ENDPOINTS = {
     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`,
+    QUERY_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/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}`,
@@ -14910,7 +15012,7 @@ class EmbeddedTokenManager {
     this.cancelRefresh?.();
   }
 }
-var SDK_VERSION = "1.5.5";
+var SDK_VERSION = "1.6.1";
 var CLOUD_ROLE_NAME = "uipath-ts-sdk";
 var SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
 var SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
@@ -15189,11 +15291,9 @@ class TokenManager {
     return token;
   }
 }
-var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 class AuthService {
   constructor(config2, executionContext) {
-    this.skipAcrValues = false;
     const isCallback = AuthService.isInOAuthCallback();
     const storedContext = isCallback ? AuthService.getStoredOAuthContext() : null;
     if (!isCallback) {
@@ -15256,9 +15356,6 @@ class AuthService {
   getTokenManager() {
     return this.tokenManager;
   }
-  setMultiLogin() {
-    this.skipAcrValues = true;
-  }
   async authenticate(config2) {
     if (!isBrowser2) {
       return false;
@@ -15374,9 +15471,6 @@ class AuthService {
     }
   }
   getAuthorizationUrl(params) {
-    const orgName = this.config.orgName;
-    const isGuid = GUID_REGEX.test(orgName);
-    const acrValues = isGuid ? `tenant:${orgName}` : `tenantName:${orgName}`;
     const queryParams = new URLSearchParams({
       response_type: "code",
       client_id: params.clientId,
@@ -15386,8 +15480,7 @@ class AuthService {
       scope: params.scope + " offline_access",
       state: params.state || this.generateCodeVerifier().slice(0, 16)
     });
-    const authorizeUrl = `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
-    return this.skipAcrValues ? authorizeUrl : `${authorizeUrl}&acr_values=${acrValues}`;
+    return `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
   }
   async _getAccessToken(params) {
     const body = new URLSearchParams({
@@ -15551,7 +15644,6 @@ var _UiPath_config;
 var _UiPath_authService;
 var _UiPath_initialized;
 var _UiPath_partialConfig;
-var _UiPath_multiLogin;
 var _UiPath_metaFolderKey;
 var _UiPath_metaOrgId;
 var _UiPath_metaTenantId;
@@ -15564,7 +15656,6 @@ var UiPath$1 = class UiPath {
     _UiPath_authService.set(this, undefined);
     _UiPath_initialized.set(this, false);
     _UiPath_partialConfig.set(this, undefined);
-    _UiPath_multiLogin.set(this, false);
     _UiPath_metaFolderKey.set(this, undefined);
     _UiPath_metaOrgId.set(this, undefined);
     _UiPath_metaTenantId.set(this, undefined);
@@ -15606,10 +15697,6 @@ var UiPath$1 = class UiPath {
       throw new Error(`Failed to initialize UiPath SDK: ${errorMessage2}`);
     }
   }
-  setMultiLogin() {
-    __classPrivateFieldSet(this, _UiPath_multiLogin, true, "f");
-    __classPrivateFieldGet(this, _UiPath_authService, "f")?.setMultiLogin();
-  }
   isInitialized() {
     return __classPrivateFieldGet(this, _UiPath_initialized, "f");
   }
@@ -15656,7 +15743,7 @@ var UiPath$1 = class UiPath {
     __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
   }
 };
-_UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initialized = new WeakMap, _UiPath_partialConfig = new WeakMap, _UiPath_multiLogin = new WeakMap, _UiPath_metaFolderKey = new WeakMap, _UiPath_metaOrgId = new WeakMap, _UiPath_metaTenantId = new WeakMap, _UiPath_instances = new WeakSet, _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig2(config2) {
+_UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initialized = new WeakMap, _UiPath_partialConfig = new WeakMap, _UiPath_metaFolderKey = new WeakMap, _UiPath_metaOrgId = new WeakMap, _UiPath_metaTenantId = new WeakMap, _UiPath_instances = new WeakSet, _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig2(config2) {
   validateConfig(config2);
   const hasSecretAuth = hasSecretConfig(config2);
   const hasOAuthAuth = hasOAuthConfig(config2);
@@ -15671,9 +15758,6 @@ _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initial
   });
   const executionContext = new ExecutionContext;
   __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
-  if (__classPrivateFieldGet(this, _UiPath_multiLogin, "f")) {
-    __classPrivateFieldGet(this, _UiPath_authService, "f").setMultiLogin();
-  }
   __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
   SDKInternalsRegistry.set(this, {
     config: internalConfig,
@@ -15813,7 +15897,7 @@ class ErrorResponseParser {
   }
   async parse(response) {
     try {
-      const errorBody = await response.json();
+      const errorBody = await response.clone().json();
       const strategy = this.strategies.find((s) => s.canParse(errorBody));
       return strategy.parse(errorBody, response);
     } catch {
@@ -15898,22 +15982,20 @@ class ApiClient {
   async getValidToken() {
     return this.tokenManager.getValidToken();
   }
-  async getDefaultHeaders() {
+  async getDefaultHeaders(includeDefaultContentType) {
     const token = await this.getValidToken();
-    return {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": CONTENT_TYPES.JSON,
-      ...this.clientConfig.headers
-    };
+    const base = { Authorization: `Bearer ${token}` };
+    if (includeDefaultContentType) {
+      base["Content-Type"] = CONTENT_TYPES.JSON;
+    }
+    return { ...base, ...this.clientConfig.headers };
   }
   async request(method, path, options = {}) {
     const normalizedPath = path.startsWith("/") ? path.substring(1) : path;
     const url = new URL(`${this.config.orgName}/${this.config.tenantName}/${normalizedPath}`, this.config.baseUrl).toString();
     const isFormData = options.body instanceof FormData;
-    const defaultHeaders = await this.getDefaultHeaders();
-    if (isFormData) {
-      delete defaultHeaders["Content-Type"];
-    }
+    const isBodyless = isFormData || method === "GET" || method === "HEAD";
+    const defaultHeaders = await this.getDefaultHeaders(!isBodyless);
     const traceId = crypto.randomUUID().replace(/-/g, "");
     const spanId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
     const traceparentValue = `00-${traceId}-${spanId}-01`;
@@ -16830,6 +16912,7 @@ var DataDirectionType;
 var JoinType;
 (function(JoinType2) {
   JoinType2["LeftJoin"] = "LeftJoin";
+  JoinType2["InnerJoin"] = "InnerJoin";
 })(JoinType || (JoinType = {}));
 function createParams(paramsObj = {}) {
   const params = {};
@@ -16871,7 +16954,8 @@ var EntityMap = {
   createTime: "createdTime",
   updateTime: "updatedTime",
   sqlType: "fieldDataType",
-  fieldDefinition: "fieldMetaData"
+  fieldDefinition: "fieldMetaData",
+  isInsightsEnabled: "isAnalyticsEnabled"
 };
 var EntitySchemaFieldTypeMap = {
   [EntityFieldDataType.UUID]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: FieldDisplayType.Basic },
@@ -16962,6 +17046,21 @@ var EntityFieldTypeMap = {
   [SqlFieldType.MULTILINE]: EntityFieldDataType.MULTILINE_TEXT,
   [SqlFieldType.MULTILINE_MAX]: EntityFieldDataType.MULTILINE_MAX
 };
+var JOIN_TYPE_WIRE = {
+  [JoinType.LeftJoin]: "LEFT",
+  [JoinType.InnerJoin]: "INNER"
+};
+var qualifyJoinField = (entityName, field) => field.includes(".") ? field : `${entityName}.${field}`;
+function toWireJoin(join, baseEntityName) {
+  return {
+    type: JOIN_TYPE_WIRE[join.joinType ?? JoinType.LeftJoin],
+    entity: join.relatedEntityName,
+    on: {
+      left: qualifyJoinField(join.entityName ?? baseEntityName, join.joinFieldName),
+      right: qualifyJoinField(join.relatedEntityName, join.relatedFieldName)
+    }
+  };
+}
 
 class EntityService extends BaseService {
   async getById(id, options) {
@@ -17068,11 +17167,22 @@ class EntityService extends BaseService {
         message: `A maximum of ${MAX_QUERY_JOINS} joins is supported per query (received ${options.joins.length})`
       });
     }
+    if (options?.joins && options.joins.length > 0 && !options.selectedFields?.length && !options.aggregates?.length) {
+      throw new ValidationError({
+        message: 'Join queries require selectedFields or aggregates — reference fields as "<EntityName>.<FieldName>" (e.g. "Customer.name")'
+      });
+    }
     const { folderKey, expansionLevel, ...rest } = options ?? {};
+    let getEndpoint = () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(id);
+    if (options?.joins && options.joins.length > 0) {
+      const baseEntityName = await this.resolveEntityName(id, folderKey);
+      rest.joins = options.joins.map((join) => toWireJoin(join, baseEntityName));
+      getEndpoint = () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_NAME(baseEntityName);
+    }
     const downstreamOptions = options === undefined ? undefined : rest;
     return PaginationHelpers.getAll({
       serviceAccess: this.createPaginationServiceAccess(),
-      getEndpoint: () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(id),
+      getEndpoint,
       method: HTTP_METHODS.POST,
       headers: createHeaders({ [FOLDER_KEY]: folderKey }),
       queryParams: createParams({ expansionLevel }),
@@ -17175,7 +17285,7 @@ class EntityService extends BaseService {
     const raw = entityResponse.data;
     let fields = (raw.fields ?? []).filter((f) => !f.isSystemField && !f.isPrimaryKey);
     if (options.removeFields?.length) {
-      const removeSet = new Set(options.removeFields.map((r) => r.fieldName));
+      const removeSet = new Set(options.removeFields.map((r) => r.name));
       fields = fields.filter((f) => !removeSet.has(f.name));
     }
     if (options.updateFields?.length) {
@@ -17231,6 +17341,10 @@ class EntityService extends BaseService {
       }
     }, { headers: folderHeaders });
   }
+  async resolveEntityName(id, folderKey) {
+    const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(id), { headers: createHeaders({ [FOLDER_KEY]: folderKey }) });
+    return transformData(response.data, EntityMap).name;
+  }
   applyFieldMappings(metadata) {
     this.mapFieldTypes(metadata);
     this.mapExternalFields(metadata);
@@ -17313,20 +17427,20 @@ class EntityService extends BaseService {
   }
   buildSchemaFieldPayload(field, refMeta) {
     const fieldType = field.type ?? EntityFieldDataType.STRING;
-    this.validateFieldConstraints(fieldType, field, field.fieldName);
+    this.validateFieldConstraints(fieldType, field, field.name);
     const isRelationship = fieldType === EntityFieldDataType.RELATIONSHIP;
     const isFile = fieldType === EntityFieldDataType.FILE;
     if (isRelationship && (!field.referenceEntityId || !field.referenceFieldId)) {
       throw new ValidationError({
-        message: `Field '${field.fieldName}' of type ${fieldType} requires both referenceEntityId and referenceFieldId (UUIDs of the target entity and field).`
+        message: `Field '${field.name}' of type ${fieldType} requires both referenceEntityId and referenceFieldId (UUIDs of the target entity and field).`
       });
     }
     const mapping = EntitySchemaFieldTypeMap[fieldType];
     const referenceEntityBody = refMeta?.referenceEntity ?? (field.referenceEntityId === undefined ? undefined : { id: field.referenceEntityId });
     const referenceChoiceSetBody = refMeta?.referenceChoiceSet;
     return {
-      name: field.fieldName,
-      displayName: field.displayName ?? field.fieldName,
+      name: field.name,
+      displayName: field.displayName ?? field.name,
       sqlType: {
         name: mapping.sqlTypeName,
         ...this.buildSqlTypeConstraints(fieldType, field)
@@ -18145,6 +18259,13 @@ function createCaseInstanceMethods(instanceData, service) {
       if (!instanceData.instanceId)
         throw new Error("Case instance ID is undefined");
       return service.getStagesSlaSummary({ caseInstanceId: instanceData.instanceId });
+    },
+    async getVariables(options) {
+      if (!instanceData.instanceId)
+        throw new Error("Case instance ID is undefined");
+      if (!instanceData.folderKey)
+        throw new Error("Case instance folder key is undefined");
+      return service.getVariables(instanceData.instanceId, instanceData.folderKey, options);
     }
   };
 }
@@ -18281,6 +18402,100 @@ class BpmnHelpers {
     };
   }
 }
+var INPUT_OUTPUT_REGEX = /<uipath:inputOutput\s+([^/]+?)(?:\/(?:>)?|>[\s\S]*?<\/uipath:inputOutput>)/g;
+var BPMN_ELEMENT_REGEX = /<bpmn:\w+\s+([^>]+)/g;
+function getVariableSource(bpmnXml) {
+  const elementNameMap = new Map;
+  const elementMatches = bpmnXml.matchAll(BPMN_ELEMENT_REGEX);
+  for (const match of elementMatches) {
+    const attributes = match[1];
+    const idMatch = attributes.match(/id="([^"]+)"/);
+    const nameMatch = attributes.match(/name="([^"]+)"/);
+    if (idMatch && nameMatch) {
+      elementNameMap.set(idMatch[1], nameMatch[1]);
+    }
+  }
+  return elementNameMap;
+}
+function parseBpmnVariables(bpmnXml) {
+  const variableMap = new Map;
+  const variableSourceMap = getVariableSource(bpmnXml);
+  const inputOutputMatches = bpmnXml.matchAll(INPUT_OUTPUT_REGEX);
+  for (const match of inputOutputMatches) {
+    const attributes = match[1];
+    const idMatch = attributes.match(/id="([^"]+)"/);
+    const nameMatch = attributes.match(/name="([^"]+)"/);
+    const typeMatch = attributes.match(/type="([^"]+)"/);
+    const elementIdMatch = attributes.match(/elementId="([^"]+)"/);
+    if (idMatch && nameMatch && typeMatch && elementIdMatch) {
+      const elementId = elementIdMatch[1];
+      const sourceName = variableSourceMap.get(elementId) || elementId;
+      const metadata = {
+        id: idMatch[1],
+        name: nameMatch[1],
+        type: typeMatch[1],
+        elementId,
+        source: sourceName
+      };
+      variableMap.set(metadata.id, metadata);
+    }
+  }
+  return variableMap;
+}
+function transformGlobalVariables(globals, variableMetadata) {
+  const enrichedGlobalVariables = [];
+  if (globals && typeof globals === "object") {
+    for (const [variableId, value] of Object.entries(globals)) {
+      const metadata = variableMetadata.get(variableId);
+      if (metadata) {
+        enrichedGlobalVariables.push({
+          id: metadata.id,
+          name: metadata.name,
+          type: metadata.type,
+          elementId: metadata.elementId,
+          source: metadata.source,
+          value
+        });
+      }
+    }
+  }
+  return enrichedGlobalVariables;
+}
+async function fetchInstanceVariables(httpGet, instanceId, folderKey, options) {
+  const queryParams = options?.parentElementId ? { parentElementId: options.parentElementId } : undefined;
+  const [bpmnResult, variablesResult] = await Promise.allSettled([
+    httpGet(MAESTRO_ENDPOINTS.INSTANCES.GET_BPMN(instanceId), {
+      headers: createHeaders({
+        [FOLDER_KEY]: folderKey,
+        Accept: CONTENT_TYPES.XML
+      })
+    }),
+    httpGet(MAESTRO_ENDPOINTS.INSTANCES.GET_VARIABLES(instanceId), {
+      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
+      params: queryParams
+    })
+  ]);
+  if (variablesResult.status === "rejected") {
+    throw variablesResult.reason;
+  }
+  const response = variablesResult.value;
+  let variableMetadata = new Map;
+  try {
+    if (bpmnResult.status === "rejected") {
+      throw bpmnResult.reason;
+    }
+    variableMetadata = parseBpmnVariables(bpmnResult.value.data);
+  } catch (error) {
+    console.warn(`Failed to fetch BPMN metadata for instance ${instanceId} :`, error);
+  }
+  const enrichedGlobalVariables = transformGlobalVariables(response.data.globals, variableMetadata);
+  return {
+    elements: response.data.elements,
+    globalVariables: enrichedGlobalVariables,
+    instanceId: response.data.instanceId,
+    parentElementId: response.data.parentElementId
+  };
+}
 var ProcessInstanceMap = {
   startedTimeUtc: "startedTime",
   completedTimeUtc: "completedTime",
@@ -18401,85 +18616,8 @@ class ProcessInstancesService extends BaseService {
       data: response.data
     };
   }
-  parseBpmnVariables(bpmnXml) {
-    const variableMap = new Map;
-    const variableSourceMap = this.getVariableSource(bpmnXml);
-    const inputOutputRegex = /<uipath:inputOutput\s+([^/]+?)(?:\/(?:>)?|>[\s\S]*?<\/uipath:inputOutput>)/g;
-    const inputOutputMatches = bpmnXml.matchAll(inputOutputRegex);
-    for (const match of inputOutputMatches) {
-      const attributes = match[1];
-      const idMatch = attributes.match(/id="([^"]+)"/);
-      const nameMatch = attributes.match(/name="([^"]+)"/);
-      const typeMatch = attributes.match(/type="([^"]+)"/);
-      const elementIdMatch = attributes.match(/elementId="([^"]+)"/);
-      if (idMatch && nameMatch && typeMatch && elementIdMatch) {
-        const elementId = elementIdMatch[1];
-        const sourceName = variableSourceMap.get(elementId) || elementId;
-        const metadata = {
-          id: idMatch[1],
-          name: nameMatch[1],
-          type: typeMatch[1],
-          elementId,
-          source: sourceName
-        };
-        variableMap.set(metadata.id, metadata);
-      }
-    }
-    return variableMap;
-  }
-  getVariableSource(bpmnXml) {
-    const elementNameMap = new Map;
-    const elementRegex = /<bpmn:\w+\s+([^>]*id="([^"]+)"[^>]*name="([^"]+)"[^>]*)/g;
-    const elementMatches = bpmnXml.matchAll(elementRegex);
-    for (const match of elementMatches) {
-      const elementId = match[2];
-      const elementName = match[3];
-      if (elementId && elementName) {
-        elementNameMap.set(elementId, elementName);
-      }
-    }
-    return elementNameMap;
-  }
-  transformGlobalVariables(globals, variableMetadata) {
-    const enrichedGlobalVariables = [];
-    if (globals && typeof globals === "object") {
-      for (const [variableId, value] of Object.entries(globals)) {
-        const metadata = variableMetadata.get(variableId);
-        if (metadata) {
-          enrichedGlobalVariables.push({
-            id: metadata.id,
-            name: metadata.name,
-            type: metadata.type,
-            elementId: metadata.elementId,
-            source: metadata.source,
-            value
-          });
-        }
-      }
-    }
-    return enrichedGlobalVariables;
-  }
   async getVariables(instanceId, folderKey, options) {
-    let variableMetadata = new Map;
-    try {
-      const bpmnXml = await this.getBpmn(instanceId, folderKey);
-      variableMetadata = this.parseBpmnVariables(bpmnXml);
-    } catch (error) {
-      console.warn(`Failed to fetch BPMN metadata for instance ${instanceId} :`, error);
-    }
-    const queryParams = options?.parentElementId ? { parentElementId: options.parentElementId } : undefined;
-    const response = await this.get(MAESTRO_ENDPOINTS.INSTANCES.GET_VARIABLES(instanceId), {
-      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
-      params: queryParams
-    });
-    const enrichedGlobalVariables = this.transformGlobalVariables(response.data.globals, variableMetadata);
-    const variablesResponse = {
-      elements: response.data.elements,
-      globalVariables: enrichedGlobalVariables,
-      instanceId: response.data.instanceId,
-      parentElementId: response.data.parentElementId
-    };
-    return variablesResponse;
+    return fetchInstanceVariables((path, opts) => this.get(path, opts ?? {}), instanceId, folderKey, options);
   }
   async getIncidents(instanceId, folderKey) {
     const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_BY_INSTANCE(instanceId), {
@@ -18801,15 +18939,141 @@ function createTaskMethods(taskData, service) {
         data: options.data,
         action: options.action
       }, folderId);
+    },
+    async saveData(data, options) {
+      if (!taskData.id)
+        throw new Error("Task ID is undefined");
+      return service.saveData(taskData.id, data, resolveTaskFolder({ ...options, type: taskData.type }, taskData.folderId));
+    },
+    async saveTags(tags, options) {
+      if (!taskData.id)
+        throw new Error("Task ID is undefined");
+      return service.saveTags(taskData.id, tags, resolveTaskFolder(options, taskData.folderId));
+    },
+    async editMetadata(options) {
+      if (!taskData.id)
+        throw new Error("Task ID is undefined");
+      return service.editMetadata(taskData.id, resolveTaskFolder(options, taskData.folderId));
+    },
+    getComments(options) {
+      if (!taskData.id)
+        throw new Error("Task ID is undefined");
+      return service.getComments(taskData.id, resolveTaskFolder(options, taskData.folderId));
+    },
+    async createComment(text, options) {
+      if (!taskData.id)
+        throw new Error("Task ID is undefined");
+      return service.createComment(taskData.id, text, resolveTaskFolder(options, taskData.folderId));
     }
   };
 }
+function resolveTaskFolder(options, folderId) {
+  if (options && (options.folderId !== undefined || options.folderKey !== undefined || options.folderPath !== undefined)) {
+    return options;
+  }
+  return { ...options, folderId };
+}
 function createTaskWithMethods(taskData, service) {
   const methods = createTaskMethods(taskData, service);
   return Object.assign({}, taskData, methods);
 }
+function resolveFolderHeaders(input) {
+  const { folderId, folderKey, folderPath, resourceType, fallbackFolderKey } = input;
+  const trimmedKey = folderKey?.trim();
+  const trimmedPath = folderPath?.trim();
+  const headers = {};
+  if (folderId !== undefined) {
+    headers[FOLDER_ID] = folderId;
+  }
+  if (trimmedKey) {
+    headers[FOLDER_KEY] = trimmedKey;
+  }
+  if (trimmedPath) {
+    headers[FOLDER_PATH_ENCODED] = encodeFolderPathHeader(trimmedPath);
+  }
+  if (Object.keys(headers).length === 0) {
+    if (!fallbackFolderKey) {
+      throw new ValidationError({
+        message: `${resourceType} requires folder context: pass \`folderId\`, \`folderKey\`, or \`folderPath\`, or initialize the SDK with a folder context.`
+      });
+    }
+    headers[FOLDER_KEY] = fallbackFolderKey;
+  }
+  return createHeaders(headers);
+}
+function validateName(resourceType, name) {
+  if (!name) {
+    throw new ValidationError({
+      message: `${resourceType} name is required and cannot be empty.`
+    });
+  }
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new ValidationError({
+      message: `${resourceType} name is required and cannot be empty.`
+    });
+  }
+  return trimmed;
+}
+var SINGLE_QUOTE_RE = /'/g;
+
+class FolderScopedService extends BaseService {
+  async _getByFolder(endpoint, folderId, options = {}, transformFn) {
+    const headers = createHeaders({ [FOLDER_ID]: folderId });
+    const keysToPrefix = Object.keys(options);
+    const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+    const response = await this.get(endpoint, {
+      params: apiOptions,
+      headers
+    });
+    if (transformFn) {
+      return response.data?.value.map(transformFn);
+    }
+    return response.data?.value;
+  }
+  async getByNameLookup(resourceType, endpoint, name, options, transform2, responseFieldMap) {
+    const validatedName = validateName(resourceType, name);
+    const { folderId, folderKey, folderPath, ...queryOptions } = options;
+    const headers = resolveFolderHeaders({
+      folderId,
+      folderKey,
+      folderPath,
+      resourceType: `${resourceType}.getByName`,
+      fallbackFolderKey: this.config.folderKey
+    });
+    const apiFieldOptions = responseFieldMap ? transformOptions(queryOptions, responseFieldMap) : queryOptions;
+    const apiOptions = {
+      ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
+      $filter: `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
+      $top: "1"
+    };
+    const response = await this.get(endpoint, {
+      headers,
+      params: apiOptions
+    });
+    const items = response.data?.value;
+    if (!items?.length) {
+      const folderHint = describeFolderForError(folderId, folderKey, folderPath);
+      throw new NotFoundError({
+        message: `${resourceType} '${validatedName}' not found${folderHint}.`
+      });
+    }
+    return transform2(items[0]);
+  }
+}
+function describeFolderForError(folderId, folderKey, folderPath) {
+  const path = folderPath?.trim();
+  if (path)
+    return ` in folder '${path}'`;
+  const key = folderKey?.trim();
+  if (key)
+    return ` in folder (key: ${key})`;
+  if (typeof folderId === "number")
+    return ` in folder (id: ${folderId})`;
+  return "";
+}
 
-class TaskService extends BaseService {
+class TaskService extends FolderScopedService {
   constructor() {
     super(...arguments);
     this.processTaskParameters = (options, folderId) => {
@@ -18952,32 +19216,139 @@ class TaskService extends BaseService {
       data: options
     };
   }
-  getByTaskType(id, folderId, taskType, options = {}) {
-    const endpoint = TASK_TYPE_ENDPOINTS[taskType];
-    const extraParams = taskType === TaskType.Form ? { expandOnFormLayout: true, ...options } : options;
-    return this.getTaskByTypeEndpoint(id, folderId, endpoint, extraParams);
+  async getDataById(id, options) {
+    if (!id) {
+      throw new ValidationError({ message: "id is required for getDataById" });
+    }
+    const headers = this.resolveFolder(options, "Tasks.getDataById");
+    return this.fetchTaskData(TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID, { taskId: id }, headers);
   }
-  async getTaskByTypeEndpoint(id, folderId, endpoint, extraParams = {}) {
-    const headers = createHeaders({ [FOLDER_ID]: folderId });
-    const response = await this.get(endpoint, {
-      params: {
-        taskId: id,
-        ...extraParams
-      },
-      headers
-    });
-    const transformedTask = transformData(response.data, TaskMap);
-    return createTaskWithMethods(applyDataTransforms(transformedTask, { field: "status", valueMap: TaskStatusMap }), this);
+  async getDataByKey(key, options) {
+    if (!key) {
+      throw new ValidationError({ message: "key is required for getDataByKey" });
+    }
+    const headers = this.resolveFolder(options, "Tasks.getDataByKey");
+    return this.fetchTaskData(TASK_ENDPOINTS.GET_GENERIC_TASK_BY_KEY, { taskKey: key }, headers);
   }
-  addDefaultExpand(options) {
-    const processedOptions = { ...options };
-    processedOptions.expand = processedOptions.expand ? `${DEFAULT_TASK_EXPAND},${processedOptions.expand}` : DEFAULT_TASK_EXPAND;
-    return processedOptions;
+  async fetchTaskData(endpoint, params, headers) {
+    const response = await this.get(endpoint, { params, headers });
+    const { data: userPayload, ...systemFields } = response.data;
+    const transformed = transformData(systemFields, TaskMap);
+    const withStatus = applyDataTransforms(transformed, { field: "status", valueMap: TaskStatusMap });
+    return { ...withStatus, data: userPayload ?? null };
   }
-}
-__decorate([
-  track("Tasks.Create")
-], TaskService.prototype, "create", null);
+  async saveData(taskId, data, options) {
+    if (!taskId) {
+      throw new ValidationError({ message: "taskId is required for saveData" });
+    }
+    const headers = this.resolveFolder(options, "Tasks.saveData");
+    let type = options?.type;
+    if (!type) {
+      const task = await this.fetchTaskData(TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID, { taskId }, headers);
+      type = task.type;
+    }
+    let endpoint;
+    switch (type) {
+      case TaskType.Form:
+        endpoint = TASK_ENDPOINTS.SAVE_FORM_TASK_DATA;
+        break;
+      case TaskType.App:
+        endpoint = TASK_ENDPOINTS.SAVE_APP_TASK_DATA;
+        break;
+      default:
+        endpoint = TASK_ENDPOINTS.SAVE_TASK_DATA;
+        break;
+    }
+    await this.put(endpoint, { TaskId: taskId, Data: data }, { headers });
+  }
+  async saveTags(taskId, tags, options) {
+    if (!taskId) {
+      throw new ValidationError({ message: "taskId is required for saveTags" });
+    }
+    const headers = this.resolveFolder(options, "Tasks.saveTags");
+    const body = { TaskId: taskId, Tags: tags.map((tag) => camelToPascalCaseKeys(tag)) };
+    await this.put(TASK_ENDPOINTS.SAVE_TASK_TAGS, body, { headers });
+  }
+  async editMetadata(taskId, options) {
+    if (!taskId) {
+      throw new ValidationError({ message: "taskId is required for editMetadata" });
+    }
+    const { folderId, folderKey, folderPath, expand: _expand, select: _select, unlinkTaskCatalog, ...metadata } = options ?? {};
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "Tasks.editMetadata", fallbackFolderKey: this.config.folderKey });
+    const body = { taskId, ...metadata, ...unlinkTaskCatalog !== undefined ? { unsetTaskCatalog: unlinkTaskCatalog } : {} };
+    await this.post(TASK_ENDPOINTS.EDIT_TASK_METADATA, camelToPascalCaseKeys(body), { headers });
+  }
+  async getComments(taskId, options) {
+    if (!taskId) {
+      throw new ValidationError({ message: "taskId is required for getComments" });
+    }
+    const { folderId, folderKey, folderPath, ...queryOptions } = options ?? {};
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "Tasks.getComments", fallbackFolderKey: this.config.folderKey });
+    const transformComment = (comment) => transformData(pascalToCamelCaseKeys(comment), TaskMap);
+    const apiOptions = transformOptions(queryOptions, TaskMap);
+    return PaginationHelpers.getAll({
+      serviceAccess: this.createPaginationServiceAccess(),
+      getEndpoint: () => TASK_NOTE_ENDPOINTS.GET_BY_TASK_ID(taskId),
+      headers,
+      transformFn: transformComment,
+      pagination: {
+        paginationType: PaginationType.OFFSET,
+        itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+        totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+        paginationParams: {
+          pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+          offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+          countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+        }
+      }
+    }, apiOptions);
+  }
+  async createComment(taskId, text, options) {
+    if (!taskId) {
+      throw new ValidationError({ message: "taskId is required for createComment" });
+    }
+    if (!text) {
+      throw new ValidationError({ message: "text is required for createComment" });
+    }
+    const headers = this.resolveFolder(options, "Tasks.createComment");
+    const response = await this.post(TASK_NOTE_ENDPOINTS.CREATE, camelToPascalCaseKeys({ taskId, text }), { headers });
+    return transformData(pascalToCamelCaseKeys(response.data), TaskMap);
+  }
+  resolveFolder(options, resourceType) {
+    return resolveFolderHeaders({
+      folderId: options?.folderId,
+      folderKey: options?.folderKey,
+      folderPath: options?.folderPath,
+      resourceType,
+      fallbackFolderKey: this.config.folderKey
+    });
+  }
+  getByTaskType(id, folderId, taskType, options = {}) {
+    const endpoint = TASK_TYPE_ENDPOINTS[taskType];
+    const extraParams = taskType === TaskType.Form ? { expandOnFormLayout: true, ...options } : options;
+    return this.getTaskByTypeEndpoint(id, folderId, endpoint, extraParams);
+  }
+  async getTaskByTypeEndpoint(id, folderId, endpoint, extraParams = {}) {
+    const headers = createHeaders({ [FOLDER_ID]: folderId });
+    const response = await this.get(endpoint, {
+      params: {
+        taskId: id,
+        ...extraParams
+      },
+      headers
+    });
+    const transformedTask = transformData(response.data, TaskMap);
+    return createTaskWithMethods(applyDataTransforms(transformedTask, { field: "status", valueMap: TaskStatusMap }), this);
+  }
+  addDefaultExpand(options) {
+    const processedOptions = { ...options };
+    processedOptions.expand = processedOptions.expand ? `${DEFAULT_TASK_EXPAND},${processedOptions.expand}` : DEFAULT_TASK_EXPAND;
+    return processedOptions;
+  }
+}
+__decorate([
+  track("Tasks.Create")
+], TaskService.prototype, "create", null);
 __decorate([
   track("Tasks.GetUsers")
 ], TaskService.prototype, "getUsers", null);
@@ -18999,6 +19370,27 @@ __decorate([
 __decorate([
   track("Tasks.Complete")
 ], TaskService.prototype, "complete", null);
+__decorate([
+  track("Tasks.GetDataById")
+], TaskService.prototype, "getDataById", null);
+__decorate([
+  track("Tasks.GetDataByKey")
+], TaskService.prototype, "getDataByKey", null);
+__decorate([
+  track("Tasks.SaveData")
+], TaskService.prototype, "saveData", null);
+__decorate([
+  track("Tasks.SaveTags")
+], TaskService.prototype, "saveTags", null);
+__decorate([
+  track("Tasks.EditMetadata")
+], TaskService.prototype, "editMetadata", null);
+__decorate([
+  track("Tasks.GetComments")
+], TaskService.prototype, "getComments", null);
+__decorate([
+  track("Tasks.CreateComment")
+], TaskService.prototype, "createComment", null);
 
 class CaseInstancesService extends BaseService {
   constructor(instance) {
@@ -19151,6 +19543,9 @@ class CaseInstancesService extends BaseService {
     }
     return transformedResponse;
   }
+  async getVariables(instanceId, folderKey, options) {
+    return fetchInstanceVariables((path, opts) => this.get(path, opts ?? {}), instanceId, folderKey, options);
+  }
   async getStages(caseInstanceId, folderKey) {
     const [executionHistoryResponse, caseJsonResponse] = await Promise.allSettled([
       this.getExecutionHistory(caseInstanceId, folderKey),
@@ -19303,6 +19698,9 @@ __decorate([
 __decorate([
   track("CaseInstances.GetExecutionHistory")
 ], CaseInstancesService.prototype, "getExecutionHistory", null);
+__decorate([
+  track("CaseInstances.GetVariables")
+], CaseInstancesService.prototype, "getVariables", null);
 __decorate([
   track("CaseInstances.GetStages")
 ], CaseInstancesService.prototype, "getStages", null);
@@ -19315,101 +19713,6 @@ __decorate([
 __decorate([
   track("CaseInstances.GetStagesSlaSummary")
 ], CaseInstancesService.prototype, "getStagesSlaSummary", null);
-function validateName(resourceType, name) {
-  if (!name) {
-    throw new ValidationError({
-      message: `${resourceType} name is required and cannot be empty.`
-    });
-  }
-  const trimmed = name.trim();
-  if (!trimmed) {
-    throw new ValidationError({
-      message: `${resourceType} name is required and cannot be empty.`
-    });
-  }
-  return trimmed;
-}
-function resolveFolderHeaders(input) {
-  const { folderId, folderKey, folderPath, resourceType, fallbackFolderKey } = input;
-  const trimmedKey = folderKey?.trim();
-  const trimmedPath = folderPath?.trim();
-  const headers = {};
-  if (folderId !== undefined) {
-    headers[FOLDER_ID] = folderId;
-  }
-  if (trimmedKey) {
-    headers[FOLDER_KEY] = trimmedKey;
-  }
-  if (trimmedPath) {
-    headers[FOLDER_PATH_ENCODED] = encodeFolderPathHeader(trimmedPath);
-  }
-  if (Object.keys(headers).length === 0) {
-    if (!fallbackFolderKey) {
-      throw new ValidationError({
-        message: `${resourceType} requires folder context: pass \`folderId\`, \`folderKey\`, or \`folderPath\`, or initialize the SDK with a folder context.`
-      });
-    }
-    headers[FOLDER_KEY] = fallbackFolderKey;
-  }
-  return createHeaders(headers);
-}
-var SINGLE_QUOTE_RE = /'/g;
-
-class FolderScopedService extends BaseService {
-  async _getByFolder(endpoint, folderId, options = {}, transformFn) {
-    const headers = createHeaders({ [FOLDER_ID]: folderId });
-    const keysToPrefix = Object.keys(options);
-    const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-    const response = await this.get(endpoint, {
-      params: apiOptions,
-      headers
-    });
-    if (transformFn) {
-      return response.data?.value.map(transformFn);
-    }
-    return response.data?.value;
-  }
-  async getByNameLookup(resourceType, endpoint, name, options, transform2, responseFieldMap) {
-    const validatedName = validateName(resourceType, name);
-    const { folderId, folderKey, folderPath, ...queryOptions } = options;
-    const headers = resolveFolderHeaders({
-      folderId,
-      folderKey,
-      folderPath,
-      resourceType: `${resourceType}.getByName`,
-      fallbackFolderKey: this.config.folderKey
-    });
-    const apiFieldOptions = responseFieldMap ? transformOptions(queryOptions, responseFieldMap) : queryOptions;
-    const apiOptions = {
-      ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
-      $filter: `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
-      $top: "1"
-    };
-    const response = await this.get(endpoint, {
-      headers,
-      params: apiOptions
-    });
-    const items = response.data?.value;
-    if (!items?.length) {
-      const folderHint = describeFolderForError(folderId, folderKey, folderPath);
-      throw new NotFoundError({
-        message: `${resourceType} '${validatedName}' not found${folderHint}.`
-      });
-    }
-    return transform2(items[0]);
-  }
-}
-function describeFolderForError(folderId, folderKey, folderPath) {
-  const path = folderPath?.trim();
-  if (path)
-    return ` in folder '${path}'`;
-  const key = folderKey?.trim();
-  if (key)
-    return ` in folder (key: ${key})`;
-  if (typeof folderId === "number")
-    return ` in folder (id: ${folderId})`;
-  return "";
-}
 var AssetValueScope;
 (function(AssetValueScope2) {
   AssetValueScope2["Global"] = "Global";
@@ -19856,6 +20159,20 @@ function createJobMethods(jobData, service) {
       if (!jobData.folderId)
         throw new Error("Job folderId is undefined");
       return service.restart(jobData.key, jobData.folderId);
+    },
+    async getAttachments() {
+      if (!jobData.key)
+        throw new Error("Job key is undefined");
+      if (!jobData.folderId)
+        throw new Error("Job folderId is undefined");
+      return service.getAttachments(jobData.key, jobData.folderId);
+    },
+    async linkAttachment(attachmentId, options) {
+      if (!jobData.key)
+        throw new Error("Job key is undefined");
+      if (!jobData.folderId)
+        throw new Error("Job folderId is undefined");
+      return service.linkAttachment(attachmentId, jobData.key, jobData.folderId, options);
     }
   };
 }
@@ -19893,10 +20210,51 @@ class AttachmentService extends BaseService {
     camelCased.blobFileAccess = transformData(camelCased.blobFileAccess, BucketMap);
     return transformData(camelCased, AttachmentsMap);
   }
+  async create(name, content, options) {
+    if (!name) {
+      throw new ValidationError({ message: "name is required for create" });
+    }
+    if (!content) {
+      throw new ValidationError({ message: "content is required for create" });
+    }
+    const response = await this.post(ORCHESTRATOR_ATTACHMENT_ENDPOINTS.CREATE, camelToPascalCaseKeys({
+      name,
+      jobKey: options?.jobKey,
+      attachmentCategory: options?.category
+    }), { headers: createHeaders({ [FOLDER_ID]: options?.folderId }) });
+    const camelCased = pascalToCamelCaseKeys(response.data);
+    camelCased.blobFileAccess = transformData(camelCased.blobFileAccess, BucketMap);
+    const attachment = transformData(camelCased, AttachmentsMap);
+    await this.uploadContent(attachment.blobFileAccess, content);
+    const { blobFileAccess: _blobFileAccess, "@odata.context": _odataContext, ...created } = attachment;
+    return created;
+  }
+  async uploadContent(blobFileAccess, content) {
+    if (!blobFileAccess?.uri) {
+      throw new ServerError({ message: "Attachment upload URI missing from the create response" });
+    }
+    const rawHeaders = blobFileAccess.headers;
+    const requestHeaders = rawHeaders && "keys" in rawHeaders && "values" in rawHeaders ? arrayDictionaryToRecord(rawHeaders) : { ...rawHeaders };
+    if (blobFileAccess.requiresAuth) {
+      requestHeaders["Authorization"] = `Bearer ${await this.getValidAuthToken()}`;
+    }
+    const response = await fetch(blobFileAccess.uri, {
+      method: "PUT",
+      body: content,
+      headers: createHeaders(requestHeaders)
+    });
+    if (!response.ok) {
+      const errorInfo = await errorResponseParser.parse(response);
+      throw ErrorFactory.createFromHttpStatus(response.status, errorInfo);
+    }
+  }
 }
 __decorate([
   track("Attachments.GetById")
 ], AttachmentService.prototype, "getById", null);
+__decorate([
+  track("Attachments.Create")
+], AttachmentService.prototype, "create", null);
 var PackageType;
 (function(PackageType2) {
   PackageType2["Undefined"] = "Undefined";
@@ -20141,6 +20499,38 @@ class JobService extends FolderScopedService {
     const rawJob = transformData(pascalToCamelCaseKeys(response.data), JobMap);
     return createJobWithMethods(rawJob, this);
   }
+  async getAttachments(jobKey, folderId) {
+    if (!jobKey) {
+      throw new ValidationError({ message: "jobKey is required for getAttachments" });
+    }
+    if (!folderId) {
+      throw new ValidationError({ message: "folderId is required for getAttachments" });
+    }
+    const response = await this.get(JOB_ENDPOINTS.ATTACHMENTS.GET_BY_JOB_KEY, {
+      params: { jobKey },
+      headers: createHeaders({ [FOLDER_ID]: folderId })
+    });
+    return transformData(response.data, JobMap);
+  }
+  async linkAttachment(attachmentId, jobKey, folderId, options) {
+    if (!attachmentId) {
+      throw new ValidationError({ message: "attachmentId is required for linkAttachment" });
+    }
+    if (!jobKey) {
+      throw new ValidationError({ message: "jobKey is required for linkAttachment" });
+    }
+    if (!folderId) {
+      throw new ValidationError({ message: "folderId is required for linkAttachment" });
+    }
+    const response = await this.post(JOB_ENDPOINTS.ATTACHMENTS.LINK, {
+      attachmentId,
+      jobKey,
+      category: options?.category
+    }, {
+      headers: createHeaders({ [FOLDER_ID]: folderId })
+    });
+    return transformData(response.data, JobMap);
+  }
   async downloadOutputFile(outputFileKey) {
     const attachment = await this.attachmentService.getById(outputFileKey);
     const blobAccess = attachment.blobFileAccess;
@@ -20216,6 +20606,12 @@ __decorate([
 __decorate([
   track("Jobs.Restart")
 ], JobService.prototype, "restart", null);
+__decorate([
+  track("Jobs.GetAttachments")
+], JobService.prototype, "getAttachments", null);
+__decorate([
+  track("Jobs.LinkAttachment")
+], JobService.prototype, "linkAttachment", null);
 var JobSubState;
 (function(JobSubState2) {
   JobSubState2["WithFaults"] = "WITH_FAULTS";
@@ -20389,6 +20785,112 @@ __decorate([
 __decorate([
   track("Queues.GetById")
 ], QueueService.prototype, "getById", null);
+var TaskCatalogMap = {
+  creationTime: "createdTime",
+  lastModificationTime: "lastModifiedTime"
+};
+var TaskCatalogRetentionAction;
+(function(TaskCatalogRetentionAction2) {
+  TaskCatalogRetentionAction2["Delete"] = "Delete";
+  TaskCatalogRetentionAction2["Archive"] = "Archive";
+  TaskCatalogRetentionAction2["None"] = "None";
+})(TaskCatalogRetentionAction || (TaskCatalogRetentionAction = {}));
+
+class TaskCatalogService extends FolderScopedService {
+  async getAll(options) {
+    const { folderId, folderKey, folderPath, ...queryOptions } = options ?? {};
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "TaskCatalogs.getAll", fallbackFolderKey: this.config.folderKey });
+    const transformCatalog = (catalog) => transformData(pascalToCamelCaseKeys(catalog), TaskCatalogMap);
+    const apiOptions = transformOptions(queryOptions, TaskCatalogMap);
+    return PaginationHelpers.getAll({
+      serviceAccess: this.createPaginationServiceAccess(),
+      getEndpoint: () => TASK_CATALOG_ENDPOINTS.GET_ALL,
+      headers,
+      transformFn: transformCatalog,
+      pagination: {
+        paginationType: PaginationType.OFFSET,
+        itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+        totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+        paginationParams: {
+          pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+          offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+          countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+        }
+      }
+    }, apiOptions);
+  }
+  async getById(id, options = {}) {
+    return this.fetchById(id, options);
+  }
+  async fetchById(id, options = {}) {
+    const { folderId, folderKey, folderPath, ...queryOptions } = options;
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "TaskCatalogs.getById", fallbackFolderKey: this.config.folderKey });
+    const apiFieldOptions = transformOptions(queryOptions, TaskCatalogMap);
+    const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
+    const response = await this.get(TASK_CATALOG_ENDPOINTS.GET_BY_ID(id), { headers, params: apiOptions });
+    return transformData(pascalToCamelCaseKeys(response.data), TaskCatalogMap);
+  }
+  async getByName(name, options = {}) {
+    return this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
+  }
+  async create(name, options = {}) {
+    if (!name) {
+      throw new ValidationError({ message: "name is required for create" });
+    }
+    const { folderId, folderKey, folderPath, expand: _expand, select: _select, ...fields } = options;
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "TaskCatalogs.create", fallbackFolderKey: this.config.folderKey });
+    const response = await this.post(TASK_CATALOG_ENDPOINTS.CREATE, camelToPascalCaseKeys({ name, ...fields }), { headers });
+    return transformData(pascalToCamelCaseKeys(response.data), TaskCatalogMap);
+  }
+  async updateById(id, options = {}) {
+    if (!id) {
+      throw new ValidationError({ message: "id is required for updateById" });
+    }
+    const { folderId, folderKey, folderPath } = options;
+    const current = await this.fetchById(id, { folderId, folderKey, folderPath });
+    return this.update(current, options);
+  }
+  async updateByName(name, options = {}) {
+    if (!name) {
+      throw new ValidationError({ message: "name is required for updateByName" });
+    }
+    const { folderId, folderKey, folderPath } = options;
+    const current = await this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, { folderId, folderKey, folderPath }, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
+    return this.update(current, options);
+  }
+  async update(current, options) {
+    const { folderId, folderKey, folderPath } = options;
+    const headers = resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "TaskCatalogs.update", fallbackFolderKey: this.config.folderKey });
+    const body = camelToPascalCaseKeys({
+      name: options.name ?? current.name,
+      description: options.description ?? current.description,
+      encrypted: current.encrypted,
+      retentionAction: options.retentionAction ?? (current.retentionAction === TaskCatalogRetentionAction.None ? null : current.retentionAction),
+      retentionPeriod: options.retentionPeriod ?? current.retentionPeriod,
+      retentionBucketId: options.retentionBucketId ?? current.retentionBucketId,
+      ...options.tags !== undefined ? { tags: options.tags } : {}
+    });
+    await this.post(TASK_CATALOG_ENDPOINTS.UPDATE(current.id), body, { headers });
+  }
+}
+__decorate([
+  track("TaskCatalogs.GetAll")
+], TaskCatalogService.prototype, "getAll", null);
+__decorate([
+  track("TaskCatalogs.GetById")
+], TaskCatalogService.prototype, "getById", null);
+__decorate([
+  track("TaskCatalogs.GetByName")
+], TaskCatalogService.prototype, "getByName", null);
+__decorate([
+  track("TaskCatalogs.Create")
+], TaskCatalogService.prototype, "create", null);
+__decorate([
+  track("TaskCatalogs.UpdateById")
+], TaskCatalogService.prototype, "updateById", null);
+__decorate([
+  track("TaskCatalogs.UpdateByName")
+], TaskCatalogService.prototype, "updateByName", null);
 
 class UiPath2 extends UiPath$1 {
   constructor() {
@@ -20437,6 +20939,14 @@ class UiPath2 extends UiPath$1 {
     return this.getService(AssetService);
   }
 }
+var FunctionHttpMethod;
+(function(FunctionHttpMethod2) {
+  FunctionHttpMethod2["Get"] = "Get";
+  FunctionHttpMethod2["Post"] = "Post";
+  FunctionHttpMethod2["Put"] = "Put";
+  FunctionHttpMethod2["Patch"] = "Patch";
+  FunctionHttpMethod2["Delete"] = "Delete";
+})(FunctionHttpMethod || (FunctionHttpMethod = {}));
 var CommonFieldMap = {
   createdAt: "createdTime",
   updatedAt: "updatedTime"
@@ -20767,6 +21277,17 @@ var PolicyEvaluationResult;
   PolicyEvaluationResult2["SimulatedAllow"] = "SimulatedAllow";
   PolicyEvaluationResult2["SimulatedDeny"] = "SimulatedDeny";
 })(PolicyEvaluationResult || (PolicyEvaluationResult = {}));
+var PlatformSettingKey;
+(function(PlatformSettingKey2) {
+  PlatformSettingKey2["UserLanguage"] = "UserLanguage.Language";
+  PlatformSettingKey2["UserLanguageDate"] = "UserLanguage.Date";
+  PlatformSettingKey2["UserTheme"] = "UserTheme.Theme";
+  PlatformSettingKey2["UserAccessibility"] = "UserAccessibility.Accessibility";
+  PlatformSettingKey2["UserAlert"] = "UserAlert.AlertDuration";
+  PlatformSettingKey2["UserCaseAppOrder"] = "UserCase.AppOrderByTenant";
+  PlatformSettingKey2["UserCasePinnedInstancesByTenant"] = "UserCase.PinnedInstancesByTenant";
+  PlatformSettingKey2["UserCaseInstancesTableFiltersByTenant"] = "UserCase.InstancesTableFiltersByTenant";
+})(PlatformSettingKey || (PlatformSettingKey = {}));
 var SpanStatus;
 (function(SpanStatus2) {
   SpanStatus2["Unset"] = "Unset";
@@ -21124,7 +21645,7 @@ function findInvalidFieldName(fields) {
   for (const f of fields) {
     if (typeof f !== "object" || f === null)
       continue;
-    const fieldName = f.fieldName;
+    const fieldName = f.name;
     if (typeof fieldName !== "string")
       continue;
     const err = validateName2(fieldName, "field");
@@ -21174,27 +21695,27 @@ function findInvalidFieldMetadata(fields, entityName) {
     if (typeof f !== "object" || f === null)
       continue;
     const rec = f;
-    const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+    const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
     const metadataErr = validateMetadataLengths(rec, `Field '${fieldName}'`);
     if (metadataErr)
       return metadataErr;
-    if (typeof rec.fieldName !== "string")
+    if (typeof rec.name !== "string")
       continue;
-    const normalizedName = rec.fieldName.toLowerCase();
+    const normalizedName = rec.name.toLowerCase();
     if (names.has(normalizedName)) {
       return {
-        message: `Duplicate field name '${rec.fieldName}' (case-insensitive)`,
+        message: `Duplicate field name '${rec.name}' (case-insensitive)`,
         instructions: "Every field in one create/addFields batch must have a unique name, ignoring case."
       };
     }
     names.add(normalizedName);
     if (entityName !== undefined && normalizedName === entityName.toLowerCase()) {
       return {
-        message: `Field name '${rec.fieldName}' cannot match entity name '${entityName}'`,
+        message: `Field name '${rec.name}' cannot match entity name '${entityName}'`,
         instructions: "Entity and field names are compared case-insensitively. Pick a different field name."
       };
     }
-    const effectiveDisplayName = typeof rec.displayName === "string" && rec.displayName.length > 0 ? rec.displayName : rec.fieldName;
+    const effectiveDisplayName = typeof rec.displayName === "string" && rec.displayName.length > 0 ? rec.displayName : rec.name;
     const normalizedDisplayName = effectiveDisplayName.toLowerCase();
     if (displayNames.has(normalizedDisplayName)) {
       return {
@@ -21224,7 +21745,7 @@ function findUiBrokenFieldType(fields) {
     if (typeof type !== "string")
       continue;
     if (UI_BROKEN_FIELD_TYPES.has(type)) {
-      const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+      const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
       const substitute = UI_BROKEN_SUBSTITUTIONS[type];
       return {
         message: `Field '${fieldName}' uses type '${type}' which the Data Fabric UI cannot render`,
@@ -21241,7 +21762,7 @@ function findReferenceFolderKeyOnChoiceSet(fields) {
     const rec = f;
     const type = rec.type;
     if ((type === "CHOICE_SET_SINGLE" || type === "CHOICE_SET_MULTIPLE") && rec.referenceFolderKey !== undefined) {
-      const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+      const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
       return {
         message: `CHOICE_SET_* field '${fieldName}' must not pass 'referenceFolderKey'`,
         instructions: "The server resolves a choice set's folder from 'choiceSetId' alone. Passing 'referenceFolderKey' here is rejected by the platform with a misleading cross-scope error. Drop 'referenceFolderKey' from CHOICE_SET_SINGLE / CHOICE_SET_MULTIPLE field definitions."
@@ -21266,7 +21787,7 @@ function findReferenceFieldsOnFile(fields) {
     const invalidKeys = FILE_REFERENCE_KEYS.filter((key) => rec[key] !== undefined);
     if (invalidKeys.length === 0)
       continue;
-    const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+    const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
     return {
       message: `FILE field '${fieldName}' must not pass reference fields`,
       instructions: `FILE fields are auto-wired by the platform. Drop ${invalidKeys.map((key) => `'${key}'`).join(", ")} from the field definition.`
@@ -21282,7 +21803,7 @@ function findMissingComplexFieldExtras(fields) {
     const type = rec.type;
     if (typeof type !== "string")
       continue;
-    const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+    const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
     if (type === "CHOICE_SET_SINGLE" || type === "CHOICE_SET_MULTIPLE") {
       if (typeof rec.choiceSetId !== "string" || rec.choiceSetId.trim() === "") {
         return {
@@ -21323,7 +21844,7 @@ function findInvalidFieldConstraints(fields) {
     const type = rec.type;
     if (typeof type !== "string")
       continue;
-    const fieldName = typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+    const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
     if (rec.lengthLimit !== undefined) {
       if (!isNumber(rec.lengthLimit) || !Number.isInteger(rec.lengthLimit)) {
         return {
@@ -22173,7 +22694,7 @@ var registerChoiceSetValuesCommand = (program2) => {
 };
 
 // src/commands/directory.ts
-var PRINCIPAL_TYPES = ["User", "Group", "Application"];
+var PRINCIPAL_TYPES = Object.values(DataFabricDirectoryEntityTypeName);
 var DIRECTORY_LIST_EXAMPLES = [
   {
     Description: "List Data Fabric directory principals and their assigned roles.",
@@ -22230,7 +22751,7 @@ var DIRECTORY_REVOKE_ROLES_EXAMPLES = [
 ];
 var parsePrincipalType = (value) => {
   const match = PRINCIPAL_TYPES.find((t) => t.toLowerCase() === value.toLowerCase());
-  return match !== undefined ? match : null;
+  return match ?? null;
 };
 var parseRoleIds = (value) => value.split(",").map((id) => id.trim()).filter((id) => id !== "");
 var parseIntegerOption = (value) => {
@@ -22255,7 +22776,8 @@ var registerDirectoryCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [listError, result] = await catchError2(sdk.entities.directory.list({ skip, top }));
+    const listOptions = { skip, top };
+    const [listError, result] = await catchError2(sdk.entities.directory.list(listOptions));
     if (listError) {
       return fail("Error listing directory principals", await extractErrorMessage(listError));
     }
@@ -22277,14 +22799,15 @@ var registerDirectoryCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [assignError, result] = await catchError2(sdk.entities.directory.assignRoles(principalIds, principalType, roleIds, {
+    const assignOptions = {
       ...options.replace === true && {
         preserveExisting: false
       },
       ...options.uiAccess === false && {
         uiEnabled: false
       }
-    }));
+    };
+    const [assignError, result] = await catchError2(sdk.entities.directory.assignRoles(principalIds, principalType, roleIds, assignOptions));
     if (assignError) {
       return fail("Error assigning roles", await extractErrorMessage(assignError));
     }
@@ -22395,30 +22918,29 @@ var ENTITIES_GET_EXAMPLES = [
     Output: {
       Code: "EntitySchema",
       Data: {
-        id: "a1b2c3d4-0000-0000-0000-000000000001",
-        name: "Invoice",
-        displayName: "Invoice",
-        entityType: "Standard",
-        description: "Invoice records",
-        isRbacEnabled: false,
-        fields: [
+        Id: "a1b2c3d4-0000-0000-0000-000000000001",
+        Name: "Invoice",
+        DisplayName: "Invoice",
+        EntityType: "Standard",
+        Description: "Invoice records",
+        IsRbacEnabled: false,
+        Fields: [
           {
-            id: "f1000000-0000-0000-0000-000000000002",
-            name: "amount",
-            displayName: "Amount",
-            fieldDataType: { name: "DECIMAL" },
-            sqlType: {
-              name: "DECIMAL",
-              decimalPrecision: 2,
-              minValue: 0,
-              maxValue: 999999
+            Id: "f1000000-0000-0000-0000-000000000002",
+            Name: "amount",
+            DisplayName: "Amount",
+            FieldDataType: {
+              Name: "DECIMAL",
+              DecimalPrecision: 2,
+              MinValue: 0,
+              MaxValue: 999999
             },
-            isRequired: true,
-            isUnique: false,
-            isEncrypted: false,
-            isRbacEnabled: false,
-            isPrimaryKey: false,
-            isSystemField: false
+            IsRequired: true,
+            IsUnique: false,
+            IsEncrypted: false,
+            IsRbacEnabled: false,
+            IsPrimaryKey: false,
+            IsSystemField: false
           }
         ]
       }
@@ -22432,7 +22954,7 @@ var ENTITIES_DELETE_EXAMPLES = [
     Output: {
       Code: "EntityDeleted",
       Data: {
-        ID: "a1b2c3d4-0000-0000-0000-000000000001",
+        Id: "a1b2c3d4-0000-0000-0000-000000000001",
         Reason: "test entity cleanup"
       }
     }
@@ -22440,19 +22962,49 @@ var ENTITIES_DELETE_EXAMPLES = [
 ];
 var ENTITIES_CREATE_EXAMPLES = [
   {
-    Description: "Create an entity with choice-set, relationship, file, and large-text fields. " + "CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE require 'choiceSetId' (from 'df choice-sets list'). " + "RELATIONSHIP requires 'referenceEntityId' (UUID of the target entity, from 'df entities list') and 'referenceFieldId' (UUID of the field on the target entity, from 'df entities get <target-id>'). " + "Note: a RELATIONSHIP column on a record always stores the target record's UUID 'Id' (regardless of which 'referenceFieldId' configured the join) — see 'df records insert' for how to write the value. " + "FILE fields take only 'fieldName' and 'type' — the server auto-wires the internal attachment reference; populate them later with 'uip df files upload <entity-id> <record-id> <field-name> --file <path>'. " + "MULTILINE_MAX holds very large text ('lengthLimit' = UTF-16 byte budget, 1-131072; default max ~65,536 chars). Not filterable/sortable; 'records list'/'query' return a size marker — full content via 'records get'. Tenant-gated by the 'MultilineMax' feature flag.",
-    Command: `uip df entities create Expense --body '{"displayName":"Expense","fields":[{"fieldName":"category","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000001","isRequired":true},{"fieldName":"tags","type":"CHOICE_SET_MULTIPLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000002"},{"fieldName":"submitter","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","isRequired":true},{"fieldName":"receipt","type":"FILE"},{"fieldName":"notes","type":"MULTILINE_MAX"}]}'`,
+    Description: "Create an entity with choice-set, relationship, file, and large-text fields. " + "CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE require 'choiceSetId' (from 'df choice-sets list'). " + "RELATIONSHIP requires 'referenceEntityId' (UUID of the target entity, from 'df entities list') and 'referenceFieldId' (UUID of the field on the target entity, from 'df entities get <target-id>'). " + "Note: a RELATIONSHIP column on a record always stores the target record's UUID 'Id' (regardless of which 'referenceFieldId' configured the join) — see 'df records insert' for how to write the value. " + "FILE fields take only 'name' and 'type' — the server auto-wires the internal attachment reference; populate them later with 'uip df files upload <entity-id> <record-id> <field-name> --file <path>'. " + "MULTILINE_MAX holds very large text ('lengthLimit' = UTF-16 byte budget, 1-131072; default max ~65,536 chars). Not filterable/sortable; 'records list'/'query' return a size marker — full content via 'records get'. Tenant-gated by the 'MultilineMax' feature flag.",
+    Command: `uip df entities create Expense --body '{"displayName":"Expense","fields":[{"name":"category","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000001","isRequired":true},{"name":"tags","type":"CHOICE_SET_MULTIPLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000002"},{"name":"submitter","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","isRequired":true},{"name":"receipt","type":"FILE"},{"name":"notes","type":"MULTILINE_MAX"}]}'`,
     Output: {
       Code: "EntityCreated",
-      Data: { ID: "a1b2c3d4-0000-0000-0000-000000000004" }
+      Data: { Id: "a1b2c3d4-0000-0000-0000-000000000004" }
     }
   },
   {
     Description: "Create a folder-scoped entity with cross-folder references. " + "Pass '--folder-key' to place the new entity in a folder. " + "Per-field 'referenceFolderKey' points a RELATIONSHIP field at a target that lives in a different folder (or at the tenant level when omitted). " + "CHOICE_SET_* fields resolve scope from 'choiceSetId' and must not pass 'referenceFolderKey'. " + "Get target entity/field IDs from 'df entities list --folder-key <key>' and 'df entities get <id> --folder-key <key>'; get choice-set IDs from 'df choice-sets list --folder-key <key>' (omit '--folder-key' for tenant-level choice sets).",
-    Command: `uip df entities create OrderLine --folder-key f1000000-0000-0000-0000-000000000050 --body '{"displayName":"Order Line","fields":[{"fieldName":"purchaseOrder","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","referenceFolderKey":"f1000000-0000-0000-0000-000000000060","isRequired":true},{"fieldName":"userType","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000077"}]}'`,
+    Command: `uip df entities create OrderLine --folder-key f1000000-0000-0000-0000-000000000050 --body '{"displayName":"Order Line","fields":[{"name":"purchaseOrder","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","referenceFolderKey":"f1000000-0000-0000-0000-000000000060","isRequired":true},{"name":"userType","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000077"}]}'`,
     Output: {
       Code: "EntityCreated",
-      Data: { ID: "a1b2c3d4-0000-0000-0000-000000000005" }
+      Data: { Id: "a1b2c3d4-0000-0000-0000-000000000005" }
+    }
+  }
+];
+var ENTITIES_UPDATE_EXAMPLES = [
+  {
+    Description: "Add a field. addFields uses the flat write shape: name + type, plus optional lengthLimit, minValue, maxValue, decimalPrecision, displayName, description, isRequired, isUnique, choiceSetId, referenceEntityId, referenceFieldId, and referenceFolderKey. A field object copied from 'df entities get' is accepted in addFields and normalized, but do not replay a full 'entities get' entity object as the update body.",
+    Command: `uip df entities update a1b2c3d4-0000-0000-0000-000000000001 --body '{"addFields":[{"name":"note","type":"STRING","lengthLimit":200}]}'`,
+    Output: {
+      Code: "EntityUpdated",
+      Data: { Id: "a1b2c3d4-0000-0000-0000-000000000001" }
+    }
+  },
+  {
+    Description: "Update field metadata. updateFields uses field IDs from 'df entities get <entity-id>' and accepts metadata such as displayName, description, isRequired, isRbacEnabled, isEncrypted, isHiddenField, defaultValue, and constraints. Do not paste a full copied field object here; pass 'id' plus only the flat write-shape properties being changed. It cannot change a field's type or isUnique setting.",
+    Command: `uip df entities update a1b2c3d4-0000-0000-0000-000000000001 --body '{"updateFields":[{"id":"f1000000-0000-0000-0000-000000000002","displayName":"Amount (USD)","isRequired":true}]}'`,
+    Output: {
+      Code: "EntityUpdated",
+      Data: { Id: "a1b2c3d4-0000-0000-0000-000000000001" }
+    }
+  },
+  {
+    Description: "Remove fields. removeFields uses field names, not field IDs, and requires --yes with --reason because the field values are deleted.",
+    Command: `uip df entities update a1b2c3d4-0000-0000-0000-000000000001 --body '{"removeFields":[{"name":"oldColumn"}]}' --yes --reason "quarterly cleanup"`,
+    Output: {
+      Code: "EntityUpdated",
+      Data: {
+        Id: "a1b2c3d4-0000-0000-0000-000000000001",
+        RemovedFields: ["oldColumn"],
+        Reason: "quarterly cleanup"
+      }
     }
   }
 ];
@@ -22460,6 +23012,8 @@ var VALID_FIELD_TYPES = new Set(Object.values(EntityFieldDataType));
 var VALID_FIELD_TYPES_LIST = [...VALID_FIELD_TYPES].join(", ");
 function hasInvalidFieldType(fields) {
   return fields.some((f) => {
+    if (typeof f !== "object" || f === null)
+      return false;
     const field = f;
     return field.type !== undefined && !VALID_FIELD_TYPES.has(field.type);
   });
@@ -22470,7 +23024,8 @@ var KNOWN_UPDATE_KEYS = [
   "updateFields",
   "displayName",
   "description",
-  "isRbacEnabled"
+  "isRbacEnabled",
+  "isAnalyticsEnabled"
 ];
 function pickKnownUpdateKeys(input) {
   const out = {};
@@ -22480,6 +23035,109 @@ function pickKnownUpdateKeys(input) {
   }
   return out;
 }
+var ADD_FIELDS_ARRAY_INSTRUCTIONS = 'Example: {"addFields":[{"name":"title","type":"STRING"}]}';
+var UPDATE_FIELDS_ARRAY_INSTRUCTIONS = 'Example: {"updateFields":[{"id":"<fieldId>","displayName":"New Name"}]}';
+var REMOVE_FIELDS_ARRAY_INSTRUCTIONS = 'Example: {"removeFields":[{"name":"oldField"}]}';
+var ADD_FIELDS_FIELD_NAME_INSTRUCTIONS = 'Use the flat write shape, for example {"name":"title","type":"STRING"}. A field copied from "df entities get" is also accepted inside addFields and normalized.';
+var UPDATE_FIELDS_ID_INSTRUCTIONS = 'Use "df entities get <entityId>" to find field IDs. Example: {"id":"<fieldId>","displayName":"Total Amount","isRequired":true}';
+var REMOVE_FIELDS_FIELD_NAME_INSTRUCTIONS = 'Example: {"removeFields":[{"name":"oldField"}]}';
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readKey(record, camelKey, pascalKey) {
+  return record[camelKey] ?? record[pascalKey];
+}
+function readObjectKey(record, camelKey, pascalKey) {
+  const value = readKey(record, camelKey, pascalKey);
+  return isObjectRecord(value) ? value : undefined;
+}
+function setIfDefined(target, key, value) {
+  if (value !== undefined)
+    target[key] = value;
+}
+function readId(value) {
+  if (!isObjectRecord(value))
+    return;
+  return value.id ?? value.Id ?? value.ID;
+}
+function readFieldTypeMetadata(field) {
+  return readObjectKey(field, "fieldDataType", "FieldDataType");
+}
+function readConstraint(field, fieldTypeMetadata, camelKey, pascalKey) {
+  return readKey(field, camelKey, pascalKey) ?? (fieldTypeMetadata === undefined ? undefined : readKey(fieldTypeMetadata, camelKey, pascalKey));
+}
+function normalizeAddFieldShape(field) {
+  if (!isObjectRecord(field))
+    return field;
+  if (field.name !== undefined || field.type !== undefined)
+    return field;
+  const readName = readKey(field, "name", "Name");
+  const fieldTypeMetadata = readFieldTypeMetadata(field);
+  if (typeof readName !== "string" || fieldTypeMetadata === undefined) {
+    return field;
+  }
+  const normalized = { name: readName };
+  setIfDefined(normalized, "type", readKey(fieldTypeMetadata, "name", "Name"));
+  for (const [writeKey, pascalKey] of [
+    ["displayName", "DisplayName"],
+    ["description", "Description"],
+    ["isRequired", "IsRequired"],
+    ["isUnique", "IsUnique"],
+    ["isRbacEnabled", "IsRbacEnabled"],
+    ["isEncrypted", "IsEncrypted"],
+    ["isHiddenField", "IsHiddenField"],
+    ["defaultValue", "DefaultValue"]
+  ]) {
+    setIfDefined(normalized, writeKey, readKey(field, writeKey, pascalKey));
+  }
+  for (const [writeKey, pascalKey] of [
+    ["lengthLimit", "LengthLimit"],
+    ["maxValue", "MaxValue"],
+    ["minValue", "MinValue"],
+    ["decimalPrecision", "DecimalPrecision"]
+  ]) {
+    setIfDefined(normalized, writeKey, readConstraint(field, fieldTypeMetadata, writeKey, pascalKey));
+  }
+  setIfDefined(normalized, "choiceSetId", readKey(field, "choiceSetId", "ChoiceSetId") ?? readId(readKey(field, "referenceChoiceSet", "ReferenceChoiceSet")));
+  setIfDefined(normalized, "referenceEntityId", readKey(field, "referenceEntityId", "ReferenceEntityId") ?? readId(readKey(field, "referenceEntity", "ReferenceEntity")));
+  setIfDefined(normalized, "referenceFieldId", readKey(field, "referenceFieldId", "ReferenceFieldId") ?? readId(readKey(field, "referenceField", "ReferenceField")));
+  setIfDefined(normalized, "referenceFolderKey", readKey(field, "referenceFolderKey", "ReferenceFolderKey"));
+  return normalized;
+}
+function normalizeAddFields(addFields) {
+  return addFields.map((field) => normalizeAddFieldShape(field));
+}
+function hasMissingStringField(fields, key) {
+  return fields.some((field) => {
+    if (!isObjectRecord(field))
+      return true;
+    const value = field[key];
+    return typeof value !== "string" || value.trim() === "";
+  });
+}
+function getUpdateArray(input, key, instructions, issues) {
+  const value = input[key];
+  if (value === undefined)
+    return;
+  if (Array.isArray(value))
+    return value;
+  issues.push({
+    message: `'${key}' must be an array`,
+    instructions
+  });
+  return;
+}
+function combineValidationIssues(issues) {
+  if (issues.length === 0)
+    return null;
+  if (issues.length === 1)
+    return issues[0];
+  return {
+    message: `Update body validation failed: ${issues.map((issue2) => issue2.message).join("; ")}`,
+    instructions: issues.map((issue2, index) => `${index + 1}. ${issue2.instructions}`).join(`
+`)
+  };
+}
 function validateFieldsPayload(fields, entityName, isNewEntity = false) {
   return runChecks([
     () => findInvalidFieldName(fields),
@@ -22544,21 +23202,22 @@ var registerEntitiesCommand = (program2) => {
       Data: e
     });
   });
-  entities.command("create").description("Create a new Data Fabric entity").argument("<name>", "Entity name (must start with a letter; letters, numbers, and underscores only)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-f, --file <path>", "Path to JSON file with entity definition (fields array required; displayName, description, isRbacEnabled optional)").option("--body <json>", "Inline JSON entity definition").option("--folder-key <key>", "Folder key (GUID) of the target folder (for folder-scoped entities)").examples(ENTITIES_CREATE_EXAMPLES).trackedAction(processContext, async (name, options) => {
+  entities.command("create").description("Create a new Data Fabric entity").argument("<name>", "Entity name (must start with a letter; letters, numbers, and underscores only)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-f, --file <path>", "Path to JSON file with entity definition (fields array required; displayName, description, isRbacEnabled, isAnalyticsEnabled optional). A field object copied from 'df entities get' is also accepted and normalized to the write shape.").option("--body <json>", "Inline JSON entity definition. A field object copied from 'df entities get' is also accepted and normalized to the write shape.").option("--folder-key <key>", "Folder key (GUID) of the target folder (for folder-scoped entities)").examples(ENTITIES_CREATE_EXAMPLES).trackedAction(processContext, async (name, options) => {
     const [parseError, parsed] = await catchError2(readJsonInput(options.file, options.body, "Provide entity definition via --file or --body."));
     if (parseError) {
       return fail("Error parsing entity definition", parseError.message);
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return fail("Entity definition must be a JSON object", "Provide a JSON object with a 'fields' array and optional displayName, description, isRbacEnabled.");
+      return fail("Entity definition must be a JSON object", "Provide a JSON object with a 'fields' array and optional displayName, description, isRbacEnabled, isAnalyticsEnabled.");
     }
     const definition = parsed;
     if (!Array.isArray(definition.fields)) {
       return fail("Entity definition must include a 'fields' array", "Provide a JSON object with a 'fields' array containing field definitions.");
     }
-    const hasInvalidField = definition.fields.some((f) => typeof f !== "object" || f === null || typeof f.fieldName !== "string");
+    definition.fields = normalizeAddFields(definition.fields);
+    const hasInvalidField = definition.fields.some((f) => typeof f !== "object" || f === null || typeof f.name !== "string");
     if (hasInvalidField) {
-      return fail("Each field must include a 'fieldName' string", 'Example: {"fieldName":"title","type":"STRING"}');
+      return fail("Each field must include a 'name' string", 'Example: {"name":"title","type":"STRING"}');
     }
     if (hasInvalidFieldType(definition.fields)) {
       return fail("Invalid field type in fields", `Valid types: ${VALID_FIELD_TYPES_LIST}`);
@@ -22583,6 +23242,9 @@ var registerEntitiesCommand = (program2) => {
       ...definition.isRbacEnabled !== undefined && {
         isRbacEnabled: definition.isRbacEnabled
       },
+      ...definition.isAnalyticsEnabled !== undefined && {
+        isAnalyticsEnabled: definition.isAnalyticsEnabled
+      },
       ...options.folderKey !== undefined && {
         folderKey: options.folderKey
       }
@@ -22598,88 +23260,111 @@ var registerEntitiesCommand = (program2) => {
       Data: { ID: entityId }
     });
   });
-  entities.command("update").description("Update schema or metadata of a Data Fabric entity").argument("<id>", "Entity ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-f, --file <path>", "Path to JSON file with update options (addFields, updateFields, removeFields, displayName, description, isRbacEnabled)").option("--body <json>", "Inline JSON update options (use `-` to read from stdin)").option("-y, --yes", "Required when 'removeFields' is non-empty — acknowledges the field deletion is irreversible").addOption(new Option("--confirm", "Deprecated alias for --yes").hideHelp()).option("--reason <reason>", "Required when 'removeFields' is non-empty — echoed back in the response so the caller can log it").option("--folder-key <key>", "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)").trackedAction(processContext, async (id, options) => {
+  entities.command("update").description("Update schema or metadata of a Data Fabric entity").argument("<id>", "Entity ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("-f, --file <path>", "Path to JSON file with update options. Field shapes: addFields [{name,type,...}], updateFields [{id,...}], removeFields [{name}]. Do not paste a full copied field object into updateFields; pass id plus only changed flat properties. Also accepts the entity metadata keys displayName, description, isRbacEnabled and isAnalyticsEnabled.").option("--body <json>", "Inline JSON update options (use `-` to read from stdin). Field shapes: addFields [{name,type,...}], updateFields [{id,...}], removeFields [{name}]. Do not paste a full copied field object into updateFields; pass id plus only changed flat properties. Also accepts the entity metadata keys displayName, description, isRbacEnabled and isAnalyticsEnabled.").option("-y, --yes", "Required when 'removeFields' is non-empty — acknowledges the field deletion is irreversible").addOption(new Option("--confirm", "Deprecated alias for --yes").hideHelp()).option("--reason <reason>", "Required when 'removeFields' is non-empty — echoed back in the response so the caller can log it").option("--folder-key <key>", "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)").examples(ENTITIES_UPDATE_EXAMPLES).trackedAction(processContext, async (id, options) => {
     const [parseError, parsed] = await catchError2(readJsonInput(options.file, options.body, "Provide update options via --file or --body."));
     if (parseError) {
-      return fail("Error parsing update options", parseError.message);
+      return failInvalidArgument("Error parsing update options", parseError.message);
     }
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return fail("Update options must be a JSON object", "Provide a JSON object with addFields, updateFields, removeFields, displayName, description, or isRbacEnabled.");
+      return failInvalidArgument("Update options must be a JSON object", "Provide a JSON object with addFields, updateFields, removeFields, displayName, description, isRbacEnabled, or isAnalyticsEnabled.");
     }
     const input = parsed;
+    if (Array.isArray(input.addFields)) {
+      input.addFields = normalizeAddFields(input.addFields);
+    }
+    const validationIssues = [];
+    if (input.name !== undefined) {
+      validationIssues.push({
+        message: "Entity name cannot be changed after creation",
+        instructions: "Remove 'name' from the update body. The entity name is immutable — only 'displayName' and 'description' can be changed. To use a different name, create a new entity."
+      });
+    }
+    const hasMetadataUpdate = [
+      "description",
+      "isRbacEnabled",
+      "isAnalyticsEnabled"
+    ].some((key) => input[key] !== undefined);
+    if (hasMetadataUpdate && input.displayName === undefined) {
+      validationIssues.push({
+        message: "'displayName' is required when updating entity metadata",
+        instructions: `Include the current displayName in the body alongside description/isRbacEnabled/isAnalyticsEnabled — get it with 'df entities get <entityId>'. Example: {"displayName":"<current-display-name>","description":"<new-description>"}.`
+      });
+    }
     const metadataErr = validateSchemaMetadata(input, "Entity");
     if (metadataErr)
-      return fail(metadataErr.message, metadataErr.instructions);
-    if (input.addFields !== undefined && !Array.isArray(input.addFields)) {
-      return fail("'addFields' must be an array", 'Example: {"addFields":[{"fieldName":"title","type":"STRING"}]}');
+      validationIssues.push(metadataErr);
+    const addFields = getUpdateArray(input, "addFields", ADD_FIELDS_ARRAY_INSTRUCTIONS, validationIssues);
+    const updateFields = getUpdateArray(input, "updateFields", UPDATE_FIELDS_ARRAY_INSTRUCTIONS, validationIssues);
+    const removeFields = getUpdateArray(input, "removeFields", REMOVE_FIELDS_ARRAY_INSTRUCTIONS, validationIssues);
+    let addFieldNames = [];
+    if (addFields !== undefined) {
+      const hasInvalidAddFieldsShape = hasMissingStringField(addFields, "name");
+      if (hasInvalidAddFieldsShape) {
+        validationIssues.push({
+          message: "Each field in addFields must include a non-empty 'name' string",
+          instructions: ADD_FIELDS_FIELD_NAME_INSTRUCTIONS
+        });
+      } else {
+        addFieldNames = addFields.map((field) => field.name);
+        if (hasInvalidFieldType(addFields)) {
+          validationIssues.push({
+            message: "Invalid field type in addFields",
+            instructions: `Valid types: ${VALID_FIELD_TYPES_LIST}`
+          });
+        }
+        const addErr = validateFieldsPayload(addFields);
+        if (addErr)
+          validationIssues.push(addErr);
+      }
     }
-    if (input.updateFields !== undefined && !Array.isArray(input.updateFields)) {
-      return fail("'updateFields' must be an array", 'Example: {"updateFields":[{"id":"<fieldId>","displayName":"New Name"}]}');
+    let removedFieldNames = [];
+    if (removeFields !== undefined) {
+      if (hasMissingStringField(removeFields, "name")) {
+        validationIssues.push({
+          message: "Each field in removeFields must include a non-empty 'name' string",
+          instructions: REMOVE_FIELDS_FIELD_NAME_INSTRUCTIONS
+        });
+      } else {
+        removedFieldNames = removeFields.map((field) => field.name);
+      }
     }
-    if (input.removeFields !== undefined && !Array.isArray(input.removeFields)) {
-      return fail("'removeFields' must be an array", 'Example: {"removeFields":[{"fieldName":"oldField"}]}');
+    if (addFieldNames.length > 0 && removedFieldNames.length > 0) {
+      const removedNamesLower = new Set(removedFieldNames.map((name) => name.toLowerCase()));
+      const conflict = addFieldNames.find((name) => removedNamesLower.has(name.toLowerCase()));
+      if (conflict !== undefined) {
+        validationIssues.push({
+          message: `Field '${conflict}' appears in both addFields and removeFields`,
+          instructions: "A single update cannot add and remove the same field. Split into two calls if you need to recreate it."
+        });
+      }
+    }
+    if (updateFields !== undefined) {
+      const hasInvalidUpdateFieldsShape = hasMissingStringField(updateFields, "id");
+      if (hasInvalidUpdateFieldsShape) {
+        validationIssues.push({
+          message: "Each field in updateFields must include a non-empty 'id' string",
+          instructions: UPDATE_FIELDS_ID_INSTRUCTIONS
+        });
+      } else {
+        const updateErr = findIsUniqueInUpdateFields(updateFields);
+        if (updateErr)
+          validationIssues.push(updateErr);
+        const updateMetadataErr = findInvalidFieldMetadata(updateFields);
+        if (updateMetadataErr)
+          validationIssues.push(updateMetadataErr);
+      }
+    }
+    const validationErr = combineValidationIssues(validationIssues);
+    if (validationErr) {
+      return failInvalidArgument(validationErr.message, validationErr.instructions);
     }
     let trimmedReason;
-    let removedFieldNames = [];
-    const hasRemove = Array.isArray(input.removeFields) && input.removeFields.length > 0;
+    const hasRemove = removedFieldNames.length > 0;
     if (hasRemove) {
-      const removeFields = input.removeFields;
-      const hasInvalidRemove = removeFields.some((f) => {
-        if (typeof f !== "object" || f === null)
-          return true;
-        const fn = f.fieldName;
-        return typeof fn !== "string" || fn.trim() === "";
-      });
-      if (hasInvalidRemove) {
-        return fail("Each field in removeFields must include a non-empty 'fieldName' string", 'Example: {"removeFields":[{"fieldName":"oldField"}]}');
-      }
       const reason = requireDestructiveConfirmation(options, `remove fields from entity '${id}'`, 'Pass --reason "<text>" to record why fields are being removed.');
       if (reason === null)
         return;
       trimmedReason = reason;
-      removedFieldNames = removeFields.map((f) => f.fieldName);
-    }
-    if (Array.isArray(input.addFields)) {
-      const hasInvalidField = input.addFields.some((f) => {
-        if (typeof f !== "object" || f === null)
-          return true;
-        const fn = f.fieldName;
-        return typeof fn !== "string" || fn.trim() === "";
-      });
-      if (hasInvalidField) {
-        return fail("Each field in addFields must include a non-empty 'fieldName' string", 'Example: {"fieldName":"title","type":"STRING"}');
-      }
-      if (hasInvalidFieldType(input.addFields)) {
-        return fail("Invalid field type in addFields", `Valid types: ${VALID_FIELD_TYPES_LIST}`);
-      }
-      const addErr = validateFieldsPayload(input.addFields);
-      if (addErr)
-        return fail(addErr.message, addErr.instructions);
-      const addNames = input.addFields.map((f) => f.fieldName);
-      if (removedFieldNames.length > 0) {
-        const removedNamesLower = new Set(removedFieldNames.map((name) => name.toLowerCase()));
-        const conflict = addNames.find((name) => removedNamesLower.has(name.toLowerCase()));
-        if (conflict !== undefined) {
-          return fail(`Field '${conflict}' appears in both addFields and removeFields`, "A single update cannot add and remove the same field. Split into two calls if you need to recreate it.");
-        }
-      }
-    }
-    if (Array.isArray(input.updateFields)) {
-      const hasInvalidField = input.updateFields.some((f) => {
-        if (typeof f !== "object" || f === null)
-          return true;
-        const fid = f.id;
-        return typeof fid !== "string" || fid.trim() === "";
-      });
-      if (hasInvalidField) {
-        return fail("Each field in updateFields must include a non-empty 'id' string", `Use 'df entities get <entityId>' to find field IDs. Example: {"id":"<fieldId>","displayName":"Total Amount","isRequired":true}`);
-      }
-      const updateErr = findIsUniqueInUpdateFields(input.updateFields);
-      if (updateErr)
-        return fail(updateErr.message, updateErr.instructions);
-      const updateMetadataErr = findInvalidFieldMetadata(input.updateFields);
-      if (updateMetadataErr)
-        return fail(updateMetadataErr.message, updateMetadataErr.instructions);
     }
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
@@ -23311,12 +23996,13 @@ var registerRolesCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [listError, result] = await catchError2(sdk.entities.roles.getAll({
+    const getAllOptions = {
       stats: options.stats,
       ...options.folderKey !== undefined && {
         folderKey: options.folderKey
       }
-    }));
+    };
+    const [listError, result] = await catchError2(sdk.entities.roles.getAll(getAllOptions));
     if (listError) {
       return fail("Error listing roles", await extractErrorMessage(listError));
     }
@@ -23347,4 +24033,4 @@ var registerCommands = async (program2) => {
 
 export { Command, metadata, registerCommands };
 
-//# debugId=E0C8B7794AD61B2A64756E2164756E21
+//# debugId=7A4D0D3DD13A296A64756E2164756E21