@uipath/vertical-solutions-tool 1.201.0-preview.115 → 1.201.0-preview.122

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   Command,
   metadata,
   registerCommands
-} from "./tool-zacw4j6n.js";
+} from "./tool-qyzy93kq.js";
 import"./tool-9qecd4wb.js";
 import"./tool-4pvh3k50.js";
 import"./tool-5arsyj36.js";

package/dist/{tool-zacw4j6n.js → tool-qyzy93kq.js}

@@ -6876,7 +6876,7 @@ var require_src6 = __commonJS((exports) => {
 var package_default = {
   name: "@uipath/vertical-solutions-tool",
   license: "MIT",
-  version: "1.201.0-preview.115",
+  version: "1.201.0-preview.122",
   description: "Scaffold and generate Vertical Solution projects.",
   private: false,
   repository: {
@@ -6921,7 +6921,7 @@ var package_default = {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/uipath-typescript": "^1.5.4",
+    "@uipath/uipath-typescript": "^1.6.1",
     "@inquirer/prompts": "^8.3.2",
     "@types/node": "^25.5.2",
     commander: "^14.0.3",
@@ -6983,6 +6983,7 @@ 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"]);
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -8160,6 +8161,7 @@ var CLI_ERROR_CODES = [
   "invalid_argument",
   "authentication_required",
   "permission_denied",
+  "local_permission_denied",
   "not_found",
   "rate_limited",
   "network_error",
@@ -8595,12 +8597,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 ?? parseHttpStatusFromMessage(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);
 }
@@ -9103,11 +9109,10 @@ 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/telemetry/ship-succeeded.ts
 var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
+// ../common/src/tool-provider.ts
+var factorySlot = singleton("PackagerFactoryProvider");
 // ../../node_modules/@inquirer/checkbox/node_modules/@inquirer/core/dist/lib/key.js
 var keybindings = ["emacs", "vim"];
 var keybindingLookup = new Set(keybindings);
@@ -30908,6 +30913,9 @@ var getAuthContext = async (options = {}) => {
     tenantName
   };
 };
+// ../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";
@@ -35082,7 +35090,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`,
@@ -35109,7 +35133,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`,
@@ -35117,7 +35145,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: {
@@ -35180,6 +35209,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}`,
@@ -35422,7 +35452,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";
@@ -35701,11 +35731,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(config3, executionContext) {
-    this.skipAcrValues = false;
     const isCallback = AuthService.isInOAuthCallback();
     const storedContext = isCallback ? AuthService.getStoredOAuthContext() : null;
     if (!isCallback) {
@@ -35768,9 +35796,6 @@ class AuthService {
   getTokenManager() {
     return this.tokenManager;
   }
-  setMultiLogin() {
-    this.skipAcrValues = true;
-  }
   async authenticate(config3) {
     if (!isBrowser2) {
       return false;
@@ -35886,9 +35911,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,
@@ -35898,8 +35920,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({
@@ -36063,7 +36084,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;
@@ -36076,7 +36096,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);
@@ -36118,10 +36137,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");
   }
@@ -36168,7 +36183,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(config3) {
+_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(config3) {
   validateConfig(config3);
   const hasSecretAuth = hasSecretConfig(config3);
   const hasOAuthAuth = hasOAuthConfig(config3);
@@ -36183,9 +36198,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,
@@ -36325,7 +36337,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 {
@@ -36410,22 +36422,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, path3, options = {}) {
     const normalizedPath = path3.startsWith("/") ? path3.substring(1) : path3;
     const url2 = 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`;
@@ -37342,6 +37352,7 @@ var DataDirectionType;
 var JoinType;
 (function(JoinType2) {
   JoinType2["LeftJoin"] = "LeftJoin";
+  JoinType2["InnerJoin"] = "InnerJoin";
 })(JoinType || (JoinType = {}));
 function createParams(paramsObj = {}) {
   const params = {};
@@ -37383,7 +37394,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 },
@@ -37474,6 +37486,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) {
@@ -37580,11 +37607,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 ValidationError3({
+        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 }),
@@ -37687,7 +37725,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) {
@@ -37743,6 +37781,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);
@@ -37825,20 +37867,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 ValidationError3({
-        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)
@@ -38657,6 +38699,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);
     }
   };
 }
@@ -38793,6 +38842,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 (error52) {
+    console.warn(`Failed to fetch BPMN metadata for instance ${instanceId} :`, error52);
+  }
+  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",
@@ -38913,85 +39056,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 (error52) {
-      console.warn(`Failed to fetch BPMN metadata for instance ${instanceId} :`, error52);
-    }
-    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((path3, opts) => this.get(path3, opts ?? {}), instanceId, folderKey, options);
   }
   async getIncidents(instanceId, folderKey) {
     const rawResponse = await this.get(MAESTRO_ENDPOINTS.INCIDENTS.GET_BY_INSTANCE(instanceId), {
@@ -39313,15 +39379,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 ValidationError3({
+        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 ValidationError3({
+      message: `${resourceType} name is required and cannot be empty.`
+    });
+  }
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new ValidationError3({
+      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, transform3, 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 transform3(items[0]);
+  }
+}
+function describeFolderForError(folderId, folderKey, folderPath) {
+  const path3 = folderPath?.trim();
+  if (path3)
+    return ` in folder '${path3}'`;
+  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) => {
@@ -39464,6 +39656,113 @@ class TaskService extends BaseService {
       data: options
     };
   }
+  async getDataById(id, options) {
+    if (!id) {
+      throw new ValidationError3({ 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 getDataByKey(key, options) {
+    if (!key) {
+      throw new ValidationError3({ 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);
+  }
+  async fetchTaskData(endpoint, params, headers) {
+    const response = await this.get(endpoint, { params, headers });
+    const { data: userPayload, ...systemFields2 } = response.data;
+    const transformed = transformData(systemFields2, TaskMap);
+    const withStatus = applyDataTransforms(transformed, { field: "status", valueMap: TaskStatusMap });
+    return { ...withStatus, data: userPayload ?? null };
+  }
+  async saveData(taskId, data, options) {
+    if (!taskId) {
+      throw new ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ message: "taskId is required for createComment" });
+    }
+    if (!text) {
+      throw new ValidationError3({ 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;
@@ -39511,6 +39810,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) {
@@ -39663,6 +39983,9 @@ class CaseInstancesService extends BaseService {
     }
     return transformedResponse;
   }
+  async getVariables(instanceId, folderKey, options) {
+    return fetchInstanceVariables((path3, opts) => this.get(path3, opts ?? {}), instanceId, folderKey, options);
+  }
   async getStages(caseInstanceId, folderKey) {
     const [executionHistoryResponse, caseJsonResponse] = await Promise.allSettled([
       this.getExecutionHistory(caseInstanceId, folderKey),
@@ -39815,6 +40138,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);
@@ -39827,101 +40153,6 @@ __decorate([
 __decorate([
   track("CaseInstances.GetStagesSlaSummary")
 ], CaseInstancesService.prototype, "getStagesSlaSummary", null);
-function validateName(resourceType, name) {
-  if (!name) {
-    throw new ValidationError3({
-      message: `${resourceType} name is required and cannot be empty.`
-    });
-  }
-  const trimmed = name.trim();
-  if (!trimmed) {
-    throw new ValidationError3({
-      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 ValidationError3({
-        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, transform3, 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 transform3(items[0]);
-  }
-}
-function describeFolderForError(folderId, folderKey, folderPath) {
-  const path3 = folderPath?.trim();
-  if (path3)
-    return ` in folder '${path3}'`;
-  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";
@@ -40368,6 +40599,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);
     }
   };
 }
@@ -40405,10 +40650,51 @@ class AttachmentService extends BaseService {
     camelCased.blobFileAccess = transformData(camelCased.blobFileAccess, BucketMap);
     return transformData(camelCased, AttachmentsMap);
   }
+  async create(name, content, options) {
+    if (!name) {
+      throw new ValidationError3({ message: "name is required for create" });
+    }
+    if (!content) {
+      throw new ValidationError3({ 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";
@@ -40653,6 +40939,38 @@ class JobService extends FolderScopedService {
     const rawJob = transformData(pascalToCamelCaseKeys(response.data), JobMap);
     return createJobWithMethods(rawJob, this);
   }
+  async getAttachments(jobKey, folderId) {
+    if (!jobKey) {
+      throw new ValidationError3({ message: "jobKey is required for getAttachments" });
+    }
+    if (!folderId) {
+      throw new ValidationError3({ 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 ValidationError3({ message: "attachmentId is required for linkAttachment" });
+    }
+    if (!jobKey) {
+      throw new ValidationError3({ message: "jobKey is required for linkAttachment" });
+    }
+    if (!folderId) {
+      throw new ValidationError3({ 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;
@@ -40728,6 +41046,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";
@@ -40901,6 +41225,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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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() {
@@ -40949,6 +41379,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"
@@ -41279,6 +41717,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";
@@ -41877,4 +42326,4 @@ var registerCommands = async (program2) => {
 
 export { Command, metadata, registerCommands };
 
-//# debugId=D868B67AAFBD26AF64756E2164756E21
+//# debugId=2B88BAE2C3B2D7B064756E2164756E21

package/dist/tool.js

@@ -1,7 +1,7 @@
 import {
   metadata,
   registerCommands
-} from "./tool-zacw4j6n.js";
+} from "./tool-qyzy93kq.js";
 import"./tool-9qecd4wb.js";
 import"./tool-4pvh3k50.js";
 import"./tool-5arsyj36.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/vertical-solutions-tool",
   "license": "MIT",
-  "version": "1.201.0-preview.115",
+  "version": "1.201.0-preview.122",
   "description": "Scaffold and generate Vertical Solution projects.",
   "private": false,
   "repository": {
@@ -34,5 +34,5 @@
   "files": [
     "dist"
   ],
-  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
+  "gitHead": "6c56f56100be96231fccbaa59e99d64d94808d58"
 }