@uipath/tasks-tool 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/{tool-jd94aet2.js → tool-2nzkz5r2.js}

@@ -9,7 +9,7 @@ import {
   extractErrorMessageSync,
   getLoginStatusAsync,
   processContext
-} from "./tool-x7dndnx8.js";
+} from "./tool-s6dm918n.js";
 import {
   require_src
 } from "./tool-bndhpxxj.js";
@@ -4503,7 +4503,7 @@ var package_default = {
   name: "@uipath/tasks-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0-preview.254",
+  version: "1.205.0-preview.256",
   description: "Manage Action Center tasks.",
   publishConfig: {
     registry: "https://npm.pkg.github.com/"
@@ -4532,7 +4532,7 @@ var package_default = {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
     "@uipath/orchestrator-sdk": "workspace:*",
-    "@uipath/uipath-typescript": "^1.7.1",
+    "@uipath/uipath-typescript": "^1.8.0",
     commander: "^14.0.3",
     typescript: "^7.0.2"
   }
@@ -8450,6 +8450,7 @@ object({
   baseUrl: string().url().default("https://cloud.uipath.com"),
   orgName: string().min(1),
   tenantName: string().min(1),
+  organizationId: string().optional(),
   secret: string().optional(),
   clientId: string().optional(),
   redirectUri: string().url().optional(),
@@ -8462,6 +8463,7 @@ class UiPathConfig {
     this.baseUrl = options.baseUrl;
     this.orgName = options.orgName;
     this.tenantName = options.tenantName;
+    this.organizationId = options.organizationId;
     this.secret = options.secret;
     this.clientId = options.clientId;
     this.redirectUri = options.redirectUri;
@@ -8506,6 +8508,11 @@ var AUTH_STORAGE_KEYS = {
   OAUTH_CONTEXT: "uipath_sdk_oauth_context",
   CODE_VERIFIER: "uipath_sdk_code_verifier"
 };
+var TOKEN_EXPIRY_BUFFER_MS = 60 * 1000;
+function getExpiryMs(expiresAt) {
+  const ms = expiresAt instanceof Date ? expiresAt.getTime() : new Date(expiresAt).getTime();
+  return Number.isNaN(ms) ? 0 : ms;
+}
 function hasOAuthConfig(config2) {
   return Boolean(config2.clientId && config2.redirectUri && config2.scope);
 }
@@ -8764,50 +8771,61 @@ 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`,
-  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
-  GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
-  GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
-  GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
-  DELETE_FILE: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.DeleteFile`,
-  GET_FILES: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetFiles`
-};
-var PROCESS_ENDPOINTS = {
-  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
-  START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`
-};
-var QUEUE_ENDPOINTS = {
-  GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
-  GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
-  GET_ITEMS: `${ORCHESTRATOR_BASE}/odata/QueueItems`,
-  ADD_ITEM: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.AddQueueItem`,
-  START_TRANSACTION: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.StartTransaction`,
-  SET_TRANSACTION_RESULT: (itemId) => `${ORCHESTRATOR_BASE}/odata/Queues(${itemId})/UiPathODataSvc.SetTransactionResult`
-};
-var JOB_ENDPOINTS = {
-  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Jobs`,
-  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`,
-  ATTACHMENTS: {
-    GET_BY_JOB_KEY: `${ORCHESTRATOR_BASE}/api/JobAttachments/GetByJobKey`,
-    LINK: `${ORCHESTRATOR_BASE}/api/JobAttachments/Post`
+var DATA_FABRIC_TENANT_FOLDER_ID = "00000000-0000-0000-0000-000000000000";
+var DATA_FABRIC_ENDPOINTS = {
+  ENTITY: {
+    GET_ALL: `${DATAFABRIC_BASE}/api/Entity`,
+    GET_ALL_V3: `${DATAFABRIC_BASE}/api/v3/entities`,
+    GET_ENTITY_RECORDS: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/read`,
+    GET_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityId}`,
+    GET_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/read/${recordId}`,
+    INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/insert`,
+    BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/insert-batch`,
+    UPDATE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/update/${recordId}`,
+    UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/update-batch`,
+    DELETE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/delete/${recordId}`,
+    DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/delete-batch`,
+    UPSERT: `${DATAFABRIC_BASE}/api/v3/entities`,
+    DELETE: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityId}`,
+    UPDATE_METADATA: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityId}/metadata`,
+    QUERY_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${entityId}/query`,
+    QUERY_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${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}`,
+    DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
+    GET_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/metadata`,
+    GET_ENTITY_RECORDS_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/read`,
+    GET_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/read/${recordId}`,
+    INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/insert`,
+    BATCH_INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/insert-batch`,
+    UPDATE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/update/${recordId}`,
+    UPDATE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/update-batch`,
+    DELETE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/delete/${recordId}`,
+    DELETE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/delete-batch`,
+    BULK_UPLOAD_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/bulk-upload`,
+    UPSERT_RECORD_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/v3/entities/${entityName}/upsert`,
+    ATTACHMENT_BY_NAME: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`
+  },
+  CHOICESETS: {
+    GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+    GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/v3/entities/entity/${choiceSetId}/query_expansion`,
+    CREATE: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
+    UPDATE: (choiceSetId) => `${DATAFABRIC_BASE}/api/v3/entities/${choiceSetId}/metadata`,
+    DELETE: (choiceSetId) => `${DATAFABRIC_BASE}/api/v3/entities/${choiceSetId}`,
+    INSERT_BY_NAME: (choiceSetName) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/insert`,
+    UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
+    DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`
+  },
+  ROLES: {
+    GET_ALL: `${DATAFABRIC_BASE}/api/v2/Role`
+  },
+  DIRECTORY: {
+    GET_ALL: `${DATAFABRIC_BASE}/api/Directory`,
+    ASSIGN_ROLES: `${DATAFABRIC_BASE}/api/Directory/Role`,
+    REVOKE_ROLES: `${DATAFABRIC_BASE}/api/Directory/RevokeRole`
   }
 };
-var ASSET_ENDPOINTS = {
-  GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered`,
-  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`
-};
-var ORCHESTRATOR_ATTACHMENT_ENDPOINTS = {
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Attachments(${id})`,
-  CREATE: `${ORCHESTRATOR_BASE}/odata/Attachments`
-};
 var MAESTRO_ENDPOINTS = {
   PROCESSES: {
     GET_ALL: `${PIMS_BASE}/api/v1/processes/summary`,
@@ -8855,60 +8873,50 @@ var MAESTRO_ENDPOINTS = {
     INCIDENTS_BY_TIME_WINDOW: `${INSIGHTS_RTM_BASE}/agenticInstanceStatus/IncidentsByTimeWindow`
   }
 };
-var DATA_FABRIC_TENANT_FOLDER_ID = "00000000-0000-0000-0000-000000000000";
-var DATA_FABRIC_ENDPOINTS = {
-  ENTITY: {
-    GET_ALL: `${DATAFABRIC_BASE}/api/Entity`,
-    GET_ALL_V2: `${DATAFABRIC_BASE}/api/v2/Entity`,
-    GET_ENTITY_RECORDS: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/read`,
-    GET_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
-    GET_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/v2/EntityService/entity/${entityId}/read/${recordId}`,
-    INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert`,
-    BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert-batch`,
-    UPDATE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update/${recordId}`,
-    UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update-batch`,
-    DELETE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete/${recordId}`,
-    DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
-    UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
-    DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
-    UPDATE: (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}`,
-    DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
-    GET_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/Entity/${entityName}/metadata`,
-    GET_ENTITY_RECORDS_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/read`,
-    GET_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/v2/EntityService/${entityName}/read/${recordId}`,
-    INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/insert`,
-    BATCH_INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/insert-batch`,
-    UPDATE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/update/${recordId}`,
-    UPDATE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/update-batch`,
-    DELETE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/delete/${recordId}`,
-    DELETE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/delete-batch`,
-    BULK_UPLOAD_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/bulk-upload`,
-    ATTACHMENT_BY_NAME: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`
-  },
-  CHOICESETS: {
-    GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
-    GET_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/query_expansion`,
-    CREATE: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
-    UPDATE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/metadata`,
-    DELETE: (choiceSetId) => `${DATAFABRIC_BASE}/api/Entity/${choiceSetId}/delete`,
-    INSERT_BY_NAME: (choiceSetName) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/insert`,
-    UPDATE_BY_NAME: (choiceSetName, valueId) => `${DATAFABRIC_BASE}/api/EntityService/${choiceSetName}/choiceset/${valueId}/update`,
-    DELETE_BY_ID: (choiceSetId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${choiceSetId}/choiceset/delete`
-  },
-  ROLES: {
-    GET_ALL: `${DATAFABRIC_BASE}/api/v2/Role`
-  },
-  DIRECTORY: {
-    GET_ALL: `${DATAFABRIC_BASE}/api/Directory`,
-    ASSIGN_ROLES: `${DATAFABRIC_BASE}/api/Directory/Role`,
-    REVOKE_ROLES: `${DATAFABRIC_BASE}/api/Directory/RevokeRole`
+var BUCKET_ENDPOINTS = {
+  GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/Buckets`,
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Buckets/UiPath.Server.Configuration.OData.GetBucketsAcrossFolders`,
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})`,
+  GET_FILE_META_DATA: (id) => `${ORCHESTRATOR_BASE}/api/Buckets/${id}/ListFiles`,
+  GET_READ_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetReadUri`,
+  GET_WRITE_URI: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetWriteUri`,
+  DELETE_FILE: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.DeleteFile`,
+  GET_FILES: (id) => `${ORCHESTRATOR_BASE}/odata/Buckets(${id})/UiPath.Server.Configuration.OData.GetFiles`
+};
+var PROCESS_ENDPOINTS = {
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Releases`,
+  START_PROCESS: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs`,
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Releases(${id})`
+};
+var QUEUE_ENDPOINTS = {
+  GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
+  GET_ITEMS: `${ORCHESTRATOR_BASE}/odata/QueueItems`,
+  ADD_ITEM: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.AddQueueItem`,
+  START_TRANSACTION: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.StartTransaction`,
+  SET_TRANSACTION_RESULT: (itemId) => `${ORCHESTRATOR_BASE}/odata/Queues(${itemId})/UiPathODataSvc.SetTransactionResult`
+};
+var JOB_ENDPOINTS = {
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Jobs`,
+  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`,
+  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`,
+  GET_ALL: `${ORCHESTRATOR_BASE}/odata/Assets/UiPath.Server.Configuration.OData.GetAssetsAcrossFolders`,
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Assets(${id})`
+};
+var ORCHESTRATOR_ATTACHMENT_ENDPOINTS = {
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/Attachments(${id})`,
+  CREATE: `${ORCHESTRATOR_BASE}/odata/Attachments`
+};
 var IDENTITY_ENDPOINTS = {
   TOKEN: `${IDENTITY_BASE}/connect/token`,
   AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
@@ -9106,7 +9114,7 @@ class EmbeddedTokenManager {
     this.cancelRefresh?.();
   }
 }
-var SDK_VERSION = "1.7.1";
+var SDK_VERSION = "1.8.0";
 var CLOUD_ROLE_NAME = "uipath-ts-sdk";
 var SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
 var SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
@@ -9204,11 +9212,11 @@ class TokenManager {
       this.isOAuth = false;
     }
   }
-  isTokenExpired(tokenInfo) {
+  isTokenExpired(tokenInfo, bufferMs = 0) {
     if (!tokenInfo?.expiresAt) {
       return false;
     }
-    return new Date >= tokenInfo.expiresAt;
+    return Date.now() >= getExpiryMs(tokenInfo.expiresAt) - bufferMs;
   }
   async getValidToken() {
     const tokenInfo = this.executionContext.get("tokenInfo");
@@ -9226,7 +9234,8 @@ class TokenManager {
     if (tokenInfo.type === "secret") {
       return tokenInfo.token;
     }
-    if (!this.isTokenExpired(tokenInfo)) {
+    const expiryBuffer = hasOAuthConfig(this.config) && tokenInfo.refreshToken ? TOKEN_EXPIRY_BUFFER_MS : 0;
+    if (!this.isTokenExpired(tokenInfo, expiryBuffer)) {
       return tokenInfo.token;
     }
     try {
@@ -9391,7 +9400,7 @@ class TokenManager {
     return token;
   }
 }
-var GUID_REGEX$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var GUID_REGEX$2 = /^[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) {
@@ -9596,7 +9605,7 @@ class AuthService {
       return authorizeUrl;
     }
     const orgName = this.config.orgName;
-    if (!GUID_REGEX$1.test(orgName)) {
+    if (!GUID_REGEX$2.test(orgName)) {
       console.warn(`[UiPath SDK] enforceSso was ignored: orgName "${orgName}" is not an organization id. ` + "Pass the organization id (GUID) as orgName to sign in through the org's identity provider.");
       return authorizeUrl;
     }
@@ -9685,6 +9694,58 @@ class AuthService {
     window.history.replaceState({}, "", url.toString());
   }
 }
+var UiPathMetaTags;
+(function(UiPathMetaTags2) {
+  UiPathMetaTags2["CLIENT_ID"] = "uipath:client-id";
+  UiPathMetaTags2["SCOPE"] = "uipath:scope";
+  UiPathMetaTags2["ORG_NAME"] = "uipath:org-name";
+  UiPathMetaTags2["ORG_ID"] = "uipath:org-id";
+  UiPathMetaTags2["TENANT_NAME"] = "uipath:tenant-name";
+  UiPathMetaTags2["BASE_URL"] = "uipath:base-url";
+  UiPathMetaTags2["REDIRECT_URI"] = "uipath:redirect-uri";
+  UiPathMetaTags2["CDN_BASE"] = "uipath:cdn-base";
+  UiPathMetaTags2["APP_BASE"] = "uipath:app-base";
+  UiPathMetaTags2["FOLDER_KEY"] = "uipath:folder-key";
+})(UiPathMetaTags || (UiPathMetaTags = {}));
+var UiPathElementIds;
+(function(UiPathElementIds2) {
+  UiPathElementIds2["RESOURCE_OVERRIDES"] = "uipath-overrides";
+})(UiPathElementIds || (UiPathElementIds = {}));
+function readEnv(name) {
+  const globals = globalThis;
+  try {
+    const fromNode = globals.process?.env?.[name];
+    if (fromNode)
+      return fromNode;
+  } catch {}
+  try {
+    const fromDeno = globals.Deno?.env?.get?.(name);
+    if (fromDeno)
+      return fromDeno;
+  } catch {}
+  return;
+}
+var UiPathEnvVars = {
+  BASE_URL: "UIPATH_BASE_URL",
+  ORG_NAME: "UIPATH_ORG_NAME",
+  TENANT_NAME: "UIPATH_TENANT_NAME",
+  ACCESS_TOKEN: "UIPATH_ACCESS_TOKEN"
+};
+function loadFromEnvironment() {
+  if (isBrowser)
+    return null;
+  const config2 = {
+    baseUrl: readEnv(UiPathEnvVars.BASE_URL),
+    orgName: readEnv(UiPathEnvVars.ORG_NAME),
+    tenantName: readEnv(UiPathEnvVars.TENANT_NAME),
+    secret: readEnv(UiPathEnvVars.ACCESS_TOKEN)
+  };
+  return Object.values(config2).some(Boolean) ? config2 : null;
+}
+var BASE_FIELDS = ["baseUrl", "orgName", "tenantName"];
+var OAUTH_FIELDS = ["clientId", "redirectUri", "scope"];
+var AUTH_FIELDS = ["secret", ...OAUTH_FIELDS];
+var HTTP_PROTOCOLS = new Set(["http:", "https:"]);
 function hasRequiredBaseFields(config2) {
   return Boolean(config2.baseUrl && config2.orgName && config2.tenantName);
 }
@@ -9693,18 +9754,28 @@ function hasValidAuthConfig(config2) {
   const hasOAuth = hasOAuthConfig(config2);
   return hasSecret !== hasOAuth;
 }
-function validateConfig(config2) {
-  if (!hasRequiredBaseFields(config2)) {
-    throw new Error("Missing required configuration: baseUrl, orgName, and tenantName are required");
-  }
-  const hasSecret = hasSecretConfig(config2);
-  const hasOAuth = hasOAuthConfig(config2);
-  if (hasSecret && hasOAuth) {
-    throw new Error("Invalid configuration: cannot provide both secret and OAuth credentials. Choose one authentication method.");
+function nonBlank(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function toHttpOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch (error) {
+    console.warn(`[UiPath SDK] baseUrl "${value}" is not a URL:`, error);
+    return null;
   }
-  if (!hasSecret && !hasOAuth) {
-    throw new Error("Invalid configuration: must provide either secret or OAuth credentials (clientId, redirectUri, and scope)");
+  if (!HTTP_PROTOCOLS.has(url.protocol)) {
+    console.warn(`[UiPath SDK] baseUrl "${value}" is not an http(s) URL; ignored.`);
+    return null;
   }
+  return url.origin;
+}
+function joinNames(names) {
+  if (names.length <= 1)
+    return names.join("");
+  return `${names.slice(0, -1).join(", ")} and ${names.slice(-1).join("")}`;
 }
 function isCompleteConfig(config2) {
   return hasRequiredBaseFields(config2) && hasValidAuthConfig(config2);
@@ -9715,56 +9786,449 @@ function compactConfig(config2) {
 function normalizeBaseUrl(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
-function missingConfigMessage() {
+function describeGaps(found) {
+  const gaps = [];
+  const missingBase = BASE_FIELDS.filter((field) => !found[field]);
+  if (missingBase.length > 0)
+    gaps.push(`missing ${missingBase.join(", ")}`);
+  const foundSecret = hasSecretConfig(found);
+  const foundOAuth = hasOAuthConfig(found);
+  if (!foundSecret && !foundOAuth) {
+    const named = OAUTH_FIELDS.filter((field) => found[field]);
+    gaps.push(named.length > 0 ? `the OAuth configuration is incomplete — ${named.join(", ")} set, ` + `${OAUTH_FIELDS.filter((field) => !found[field]).join(", ")} missing` : "no authentication method set (needs `secret`, or clientId, redirectUri and scope)");
+  }
+  return gaps.join("; ");
+}
+function missingConfigMessage(found, context) {
+  if (context) {
+    return missingContextMessage(found ?? {}, context);
+  }
   if (isBrowser) {
+    if (found && hasRequiredBaseFields(found) && !hasSecretConfig(found)) {
+      const missing = [];
+      if (!found.clientId)
+        missing.push("clientId");
+      if (!found.redirectUri)
+        missing.push("redirectUri");
+      if (missing.length > 0 && (found.clientId || found.redirectUri || found.scope)) {
+        const fields = missing.join(" and ");
+        const verb = missing.length > 1 ? "are" : "is";
+        const clientHint = missing.includes("clientId") ? " clientId must be a non-confidential OAuth client, or pass one with --client-id at deploy." : "";
+        return `UiPath SDK configuration is incomplete: ${fields} ${verb} empty. Set ${missing.length > 1 ? "them" : "it"} in uipath.json and redeploy.${clientHint}`;
+      }
+    }
     return "UiPath SDK configuration not found. " + "Ensure @uipath/coded-apps plugin is set up in your bundler to inject configuration during development and build.";
   }
-  return "UiPath SDK configuration not found. " + "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+  const guidance = "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+  if (!found)
+    return `UiPath SDK configuration not found. ${guidance}`;
+  return `UiPath SDK configuration is incomplete: ${describeGaps(found)}. ${guidance}`;
+}
+function missingContextMessage(config2, context) {
+  const missing = [];
+  if (!hasRequiredBaseFields(config2)) {
+    if (!context.platform) {
+      const variables = [];
+      if (!config2.baseUrl)
+        variables.push(UiPathEnvVars.BASE_URL);
+      if (!config2.orgName)
+        variables.push(UiPathEnvVars.ORG_NAME);
+      if (!config2.tenantName)
+        variables.push(UiPathEnvVars.TENANT_NAME);
+      missing.push(`ctx.platform is null (or set ${joinNames(variables)})`);
+    } else {
+      if (!config2.baseUrl) {
+        const baseUrl = nonBlank(context.platform.baseUrl);
+        const problem = baseUrl === undefined ? "is empty" : `"${baseUrl}" is not an http(s) URL`;
+        missing.push(`ctx.platform.baseUrl ${problem} (or set ${UiPathEnvVars.BASE_URL})`);
+      }
+      if (!config2.orgName)
+        missing.push(`ctx.platform.orgId is empty (or set ${UiPathEnvVars.ORG_NAME})`);
+      if (!config2.tenantName)
+        missing.push(`ctx.platform.tenantId is empty (or set ${UiPathEnvVars.TENANT_NAME})`);
+    }
+  }
+  if (!hasSecretConfig(config2) && !hasOAuthConfig(config2)) {
+    missing.push(`ctx.robot.accessToken is null (or set ${UiPathEnvVars.ACCESS_TOKEN})`);
+  }
+  if (missing.length === 0) {
+    return "UiPath SDK configuration is incomplete: " + "the handler context passed to new UiPath(ctx) does not form a complete configuration.";
+  }
+  return `UiPath SDK configuration is incomplete: ${missing.join("; ")}. ` + "A deployed Function receives these coordinates on the handler context; a local run sets the variables named.";
+}
+var AUTH_FIELD_SOURCES = {
+  secret: { envVar: UiPathEnvVars.ACCESS_TOKEN },
+  clientId: { metaTag: UiPathMetaTags.CLIENT_ID },
+  redirectUri: { metaTag: UiPathMetaTags.REDIRECT_URI },
+  scope: { metaTag: UiPathMetaTags.SCOPE }
+};
+function sourceOf(field, sources) {
+  if (sources.config?.[field])
+    return "the constructor argument";
+  const { metaTag, envVar } = AUTH_FIELD_SOURCES[field];
+  if (metaTag && sources.metaConfig?.[field])
+    return `<meta name="${metaTag}">`;
+  if (envVar && sources.environment?.[field])
+    return `the ${envVar} environment variable`;
+  return;
+}
+function conflictingAuthMessage(sources) {
+  const inventory = AUTH_FIELDS.map((field) => ({ field, source: sourceOf(field, sources) })).filter((entry) => Boolean(entry.source)).map(({ field, source }) => `  ${field}: ${source}`).join(`
+`);
+  const namedOAuth = AUTH_FIELDS.filter((field) => field !== "secret" && Boolean(sources.config?.[field]));
+  const remedy = namedOAuth.length > 0 ? `Remove ${namedOAuth.join(", ")} from the constructor argument to authenticate with secret, ` + "or remove secret to authenticate with OAuth." : "Pass exactly one authentication method.";
+  return "Invalid UiPath SDK configuration: it carries both authentication methods. " + `The SDK authenticates with secret, or with OAuth (clientId, redirectUri and scope), never both.
+` + `${inventory}
+` + "Every field the constructor argument leaves unset is inherited from the meta tags and the " + "environment, so naming one field of each method ends up carrying both. " + remedy;
+}
+var FOLDER_KEY = "X-UIPATH-FolderKey";
+var FOLDER_PATH_ENCODED = "X-UIPATH-FolderPath-Encoded";
+var FOLDER_ID = "X-UIPATH-OrganizationUnitId";
+var TRACEPARENT = "traceparent";
+var UIPATH_TRACEPARENT_ID = "x-uipath-traceparent-id";
+var CONTENT_TYPES = {
+  JSON: "application/json",
+  XML: "application/xml",
+  OCTET_STREAM: "application/octet-stream"
+};
+var RESPONSE_TYPES = {
+  JSON: "json",
+  TEXT: "text",
+  BLOB: "blob",
+  ARRAYBUFFER: "arraybuffer",
+  STREAM: "stream"
+};
+var DEFAULT_RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS"];
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 2,
+  initialDelayMs: 500,
+  backoffStrategy: "exponential",
+  backoffFactor: 2,
+  backoffMaxDelayMs: 30000,
+  retryableStatusCodes: DEFAULT_RETRYABLE_STATUS_CODES,
+  retryMethods: DEFAULT_RETRY_METHODS,
+  retryNetworkErrors: true,
+  respectRetryAfter: true,
+  maxRetryAfterMs: Infinity
+};
+var DEFAULT_API_CLIENT_RETRY = {
+  ...DEFAULT_RETRY_OPTIONS,
+  maxRetries: 0
+};
+function resolveRetryOptions(settings, defaults = DEFAULT_RETRY_OPTIONS) {
+  if (!settings)
+    return defaults;
+  const { retryDelay, useExponentialBackoff, ...live } = settings;
+  const resolved = { ...defaults };
+  for (const [key, value] of Object.entries(live)) {
+    if (value !== undefined) {
+      resolved[key] = value;
+    }
+  }
+  if (retryDelay !== undefined && live.initialDelayMs === undefined) {
+    resolved.initialDelayMs = retryDelay;
+  }
+  if (useExponentialBackoff !== undefined && live.backoffStrategy === undefined) {
+    resolved.backoffStrategy = useExponentialBackoff ? "exponential" : "constant";
+  }
+  return resolved;
+}
+function computeBackoffDelay(attempt, settings) {
+  const base = Math.max(0, settings.initialDelayMs);
+  let delay;
+  switch (settings.backoffStrategy) {
+    case "constant":
+      delay = base;
+      break;
+    case "linear":
+      delay = base * (attempt + 1);
+      break;
+    default:
+      delay = base * Math.pow(settings.backoffFactor, attempt);
+  }
+  return Math.min(delay, settings.backoffMaxDelayMs);
+}
+function parseRetryAfter(value, now = Date.now()) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date2 = Date.parse(trimmed);
+  if (Number.isNaN(date2))
+    return;
+  return Math.max(0, date2 - now);
+}
+function wait(durationMs) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, durationMs)));
+}
+var RETRY_AFTER = "retry-after";
+function createAttemptSignal(timeoutMs, external) {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+    return { signal: external, dispose: () => {} };
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
+  const onExternalAbort = () => controller.abort(external?.reason);
+  if (external) {
+    if (external.aborted) {
+      controller.abort(external.reason);
+    } else {
+      external.addEventListener("abort", onExternalAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", onExternalAbort);
+    }
+  };
+}
+function delayBeforeRetry(durationMs, signal) {
+  if (!signal)
+    return wait(durationMs);
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, durationMs));
+    signal.addEventListener("abort", onAbort);
+  });
+}
+async function fetchWithRetry(url, init, options) {
+  const settings = options.retry;
+  const method = (init.method ?? "GET").toUpperCase();
+  const retriesAllowed = settings.retryMethods.includes(method) ? Math.max(0, settings.maxRetries) : 0;
+  let attempt = 0;
+  for (;; ) {
+    const { signal, dispose } = createAttemptSignal(options.timeoutMs, options.signal);
+    let response;
+    let failure;
+    try {
+      response = await fetch(url, { ...init, signal });
+    } catch (error) {
+      failure = error;
+    } finally {
+      dispose();
+    }
+    if (options.signal?.aborted && failure !== undefined)
+      throw failure;
+    if (response && !settings.retryableStatusCodes.includes(response.status))
+      return response;
+    if (failure !== undefined && !settings.retryNetworkErrors)
+      throw failure;
+    if (attempt >= retriesAllowed) {
+      if (response)
+        return response;
+      throw failure;
+    }
+    const retryAfter = settings.respectRetryAfter && response ? parseRetryAfter(response.headers.get(RETRY_AFTER)) : undefined;
+    const delay = retryAfter !== undefined ? Math.min(retryAfter, settings.maxRetryAfterMs) : computeBackoffDelay(attempt, settings);
+    response?.body?.cancel().catch((error) => {
+      console.warn("[UiPath SDK] Could not release a discarded response body:", error);
+    });
+    await delayBeforeRetry(delay, options.signal);
+    attempt++;
+  }
 }
+var _OrganizationIdResolver_instances;
+var _OrganizationIdResolver_organizationId;
+var _OrganizationIdResolver_resolve;
+var GUID_REGEX$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DASH_REGEX = /-/g;
+var UNDERSCORE_REGEX = /_/g;
+var WHITESPACE_REGEX = /\s+/g;
+var ORGANIZATION_LOOKUP_CLIENT_ID = "1119a927-10ab-4543-bd1a-ad6bfbbc27f4";
+var ORGANIZATION_LOOKUP_REDIRECT_PATH = "portal_/api/tokenFactory/callback";
+var UNREGISTERED_ORGANIZATION_PATH = "/portal_/unregistered";
+var TENANT_ACR_PREFIX = "tenant:";
+var MAX_REDIRECT_HOPS = 3;
+var IDENTITY_ERROR_ID_PARAM = "errorId";
+var IDENTITY_ERROR_CODE_PARAM = "errorCode";
+var BODY_SNIPPET_LENGTH = 160;
+var CONFIG_HINT = "Set `organizationId` in the SDK configuration.";
+function isAuthorizeRequest(url) {
+  return url.pathname.endsWith(`/${IDENTITY_ENDPOINTS.AUTHORIZE}`);
+}
+function withoutQuery(url) {
+  const parsed = new URL(url);
+  return `${parsed.origin}${parsed.pathname}`;
+}
+function readIdentityError(url) {
+  const errorId = url.searchParams.get(IDENTITY_ERROR_ID_PARAM);
+  if (errorId) {
+    try {
+      const base642 = errorId.replace(DASH_REGEX, "+").replace(UNDERSCORE_REGEX, "/");
+      const json = decodeBase64(base642.padEnd(base642.length + (4 - base642.length % 4) % 4, "="));
+      const data = JSON.parse(json).Data;
+      const error = typeof data?.Error === "string" ? data.Error : undefined;
+      const description = typeof data?.ErrorDescription === "string" ? data.ErrorDescription : undefined;
+      if (error) {
+        return description ? `${error} (${description})` : error;
+      }
+    } catch {
+      return url.searchParams.get(IDENTITY_ERROR_CODE_PARAM) ?? undefined;
+    }
+  }
+  return url.searchParams.get(IDENTITY_ERROR_CODE_PARAM) ?? undefined;
+}
+async function describeResponse(response) {
+  const body = (await response.text().catch(() => "")).replace(WHITESPACE_REGEX, " ").trim();
+  return body ? `HTTP ${response.status}: ${body.slice(0, BODY_SNIPPET_LENGTH)}` : `HTTP ${response.status}`;
+}
+function randomUrlSafeToken() {
+  return `${crypto.randomUUID()}${crypto.randomUUID()}`.replace(DASH_REGEX, "");
+}
+function tracingHeaders() {
+  const traceId = crypto.randomUUID().replace(DASH_REGEX, "");
+  const spanId = crypto.randomUUID().replace(DASH_REGEX, "").slice(0, 16);
+  const traceparent = `00-${traceId}-${spanId}-01`;
+  return { [TRACEPARENT]: traceparent, [UIPATH_TRACEPARENT_ID]: traceparent };
+}
+function buildAuthorizeUrl(baseUrl, orgName) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: ORGANIZATION_LOOKUP_CLIENT_ID,
+    redirect_uri: `${baseUrl}/${ORGANIZATION_LOOKUP_REDIRECT_PATH}`,
+    scope: "openid",
+    code_challenge: randomUrlSafeToken(),
+    code_challenge_method: "S256",
+    state: randomUrlSafeToken(),
+    acr_values: `tenantName:${orgName}`
+  });
+  return `${baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${params.toString()}`;
+}
+function extractOrganizationId(location) {
+  const acrValues = [location.searchParams.get("acr_values")];
+  const returnUrl = location.searchParams.get("returnUrl");
+  if (returnUrl) {
+    acrValues.push(new URL(returnUrl, location.origin).searchParams.get("acr_values"));
+  }
+  for (const acr of acrValues) {
+    for (const token of acr?.split(" ") ?? []) {
+      if (token.startsWith(TENANT_ACR_PREFIX)) {
+        const candidate = token.slice(TENANT_ACR_PREFIX.length);
+        if (GUID_REGEX$1.test(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+  return;
+}
+async function lookupOrganizationIdForPat(baseUrl, orgName) {
+  let url = buildAuthorizeUrl(baseUrl, orgName);
+  for (let hop = 0;hop < MAX_REDIRECT_HOPS; hop++) {
+    const response = await fetchWithRetry(url, { redirect: "manual", headers: tracingHeaders() }, { retry: DEFAULT_RETRY_OPTIONS });
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new ValidationError({
+        message: `Could not resolve the organization id for '${orgName}': Identity answered ` + `${await describeResponse(response)} instead of redirecting. ${CONFIG_HINT}`
+      });
+    }
+    const target = new URL(location, url);
+    const organizationId = extractOrganizationId(target);
+    if (organizationId) {
+      return organizationId;
+    }
+    if (target.pathname.startsWith(UNREGISTERED_ORGANIZATION_PATH)) {
+      throw new ValidationError({ message: `Organization '${orgName}' was not found at ${baseUrl}.` });
+    }
+    const identityError = readIdentityError(target);
+    if (identityError) {
+      throw new ValidationError({
+        message: `Could not resolve the organization id for '${orgName}': Identity rejected the lookup ` + `with ${identityError}. ${CONFIG_HINT}`
+      });
+    }
+    url = isAuthorizeRequest(target) ? buildAuthorizeUrl(target.origin, orgName) : target.toString();
+  }
+  throw new ValidationError({
+    message: `Could not resolve the organization id for '${orgName}': gave up after ${MAX_REDIRECT_HOPS} ` + `redirects (last: ${withoutQuery(url)}). ${CONFIG_HINT}`
+  });
+}
+
+class OrganizationIdResolver {
+  constructor(config2, tokenManager) {
+    _OrganizationIdResolver_instances.add(this);
+    this.config = config2;
+    this.tokenManager = tokenManager;
+    _OrganizationIdResolver_organizationId.set(this, undefined);
+  }
+  resolve() {
+    if (!__classPrivateFieldGet(this, _OrganizationIdResolver_organizationId, "f")) {
+      __classPrivateFieldSet(this, _OrganizationIdResolver_organizationId, __classPrivateFieldGet(this, _OrganizationIdResolver_instances, "m", _OrganizationIdResolver_resolve).call(this).catch((error) => {
+        __classPrivateFieldSet(this, _OrganizationIdResolver_organizationId, undefined, "f");
+        throw error;
+      }), "f");
+    }
+    return __classPrivateFieldGet(this, _OrganizationIdResolver_organizationId, "f");
+  }
+}
+_OrganizationIdResolver_organizationId = new WeakMap, _OrganizationIdResolver_instances = new WeakSet, _OrganizationIdResolver_resolve = async function _OrganizationIdResolver_resolve2() {
+  const { organizationId, orgName, baseUrl } = this.config;
+  if (organizationId) {
+    return organizationId;
+  }
+  if (GUID_REGEX$1.test(orgName)) {
+    return orgName;
+  }
+  const claimed = decodeJwtClaims(this.tokenManager.getToken())?.prt_id;
+  if (typeof claimed === "string" && GUID_REGEX$1.test(claimed)) {
+    return claimed;
+  }
+  return lookupOrganizationIdForPat(baseUrl, orgName);
+};
 var REGISTRY_KEY2 = Symbol.for("@uipath/sdk-internals-registry");
+var UNCONFIGURED_KEY = Symbol.for("@uipath/sdk-unconfigured-reason");
+var globalStores = () => globalThis;
 var getGlobalStore = () => {
-  const globalObj = globalThis;
-  if (!globalObj[REGISTRY_KEY2]) {
-    globalObj[REGISTRY_KEY2] = new WeakMap;
-  }
-  return globalObj[REGISTRY_KEY2];
+  var _a;
+  return (_a = globalStores())[REGISTRY_KEY2] ?? (_a[REGISTRY_KEY2] = new WeakMap);
+};
+var getUnconfiguredStore = () => {
+  var _a;
+  return (_a = globalStores())[UNCONFIGURED_KEY] ?? (_a[UNCONFIGURED_KEY] = new WeakMap);
 };
 var looksLikeUiPath = (instance) => typeof instance.initialize === "function";
 
 class SDKInternalsRegistry {
-  static get store() {
-    return getGlobalStore();
-  }
   static set(instance, internals) {
     this.store.set(instance, internals);
   }
+  static setUnconfigured(instance, reason) {
+    this.unconfigured.set(instance, reason);
+  }
   static get(instance) {
     const internals = this.store.get(instance);
     if (!internals) {
-      if (looksLikeUiPath(instance)) {
-        throw new Error("Cannot create a service: the UiPath instance was never configured. " + missingConfigMessage());
+      const reason = this.unconfigured.get(instance);
+      if (reason !== undefined || looksLikeUiPath(instance)) {
+        throw new Error("Cannot create a service: the UiPath instance was never configured. " + (reason ?? missingConfigMessage()));
       }
       throw new Error("Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.");
     }
     return internals;
   }
+  static getOrganizationIdResolver(instance) {
+    const internals = this.get(instance);
+    internals.organizationIdResolver ?? (internals.organizationIdResolver = new OrganizationIdResolver(internals.config, internals.tokenManager));
+    return internals.organizationIdResolver;
+  }
+  static get store() {
+    return getGlobalStore();
+  }
+  static get unconfigured() {
+    return getUnconfiguredStore();
+  }
 }
-var UiPathMetaTags;
-(function(UiPathMetaTags2) {
-  UiPathMetaTags2["CLIENT_ID"] = "uipath:client-id";
-  UiPathMetaTags2["SCOPE"] = "uipath:scope";
-  UiPathMetaTags2["ORG_NAME"] = "uipath:org-name";
-  UiPathMetaTags2["TENANT_NAME"] = "uipath:tenant-name";
-  UiPathMetaTags2["BASE_URL"] = "uipath:base-url";
-  UiPathMetaTags2["REDIRECT_URI"] = "uipath:redirect-uri";
-  UiPathMetaTags2["CDN_BASE"] = "uipath:cdn-base";
-  UiPathMetaTags2["APP_BASE"] = "uipath:app-base";
-  UiPathMetaTags2["FOLDER_KEY"] = "uipath:folder-key";
-})(UiPathMetaTags || (UiPathMetaTags = {}));
-var UiPathElementIds;
-(function(UiPathElementIds2) {
-  UiPathElementIds2["RESOURCE_OVERRIDES"] = "uipath-overrides";
-})(UiPathElementIds || (UiPathElementIds = {}));
 function getMetaTagContent(name) {
   if (!isBrowser)
     return;
@@ -9777,6 +10241,7 @@ function loadFromMetaTags() {
     clientId: getMetaTagContent(UiPathMetaTags.CLIENT_ID),
     scope: getMetaTagContent(UiPathMetaTags.SCOPE),
     orgName: getMetaTagContent(UiPathMetaTags.ORG_NAME),
+    organizationId: getMetaTagContent(UiPathMetaTags.ORG_ID),
     tenantName: getMetaTagContent(UiPathMetaTags.TENANT_NAME),
     baseUrl: getMetaTagContent(UiPathMetaTags.BASE_URL),
     redirectUri: getMetaTagContent(UiPathMetaTags.REDIRECT_URI),
@@ -9785,52 +10250,23 @@ function loadFromMetaTags() {
   const hasAnyValue = Object.values(config2).some(Boolean);
   return hasAnyValue ? config2 : null;
 }
-function readEnv(name) {
-  const globals = globalThis;
-  try {
-    const fromNode = globals.process?.env?.[name];
-    if (fromNode)
-      return fromNode;
-  } catch {}
-  try {
-    const fromDeno = globals.Deno?.env?.get?.(name);
-    if (fromDeno)
-      return fromDeno;
-  } catch {}
-  return;
-}
-var UiPathEnvVars = {
-  BASE_URL: "UIPATH_BASE_URL",
-  ORG_NAME: "UIPATH_ORG_NAME",
-  TENANT_NAME: "UIPATH_TENANT_NAME",
-  ACCESS_TOKEN: "UIPATH_ACCESS_TOKEN"
-};
-function loadFromEnvironment() {
-  if (isBrowser)
-    return null;
-  const config2 = {
-    baseUrl: readEnv(UiPathEnvVars.BASE_URL),
-    orgName: readEnv(UiPathEnvVars.ORG_NAME),
-    tenantName: readEnv(UiPathEnvVars.TENANT_NAME),
-    secret: readEnv(UiPathEnvVars.ACCESS_TOKEN)
-  };
-  return Object.values(config2).some(Boolean) ? config2 : null;
-}
 function isFunctionContext(value) {
   return "platform" in value || "robot" in value;
 }
 function configFromFunctionContext(context) {
   const { platform, robot } = context;
-  if (!platform)
-    return null;
+  const baseUrl = nonBlank(platform?.baseUrl);
   const config2 = {
-    baseUrl: platform.baseUrl,
-    orgName: platform.orgId,
-    tenantName: platform.tenantId,
-    secret: robot?.accessToken ?? undefined
+    baseUrl: baseUrl === undefined ? undefined : toHttpOrigin(baseUrl) ?? undefined,
+    orgName: nonBlank(platform?.orgId),
+    tenantName: nonBlank(platform?.tenantId),
+    secret: nonBlank(robot?.accessToken)
   };
   return Object.values(config2).some(Boolean) ? config2 : null;
 }
+function folderKeyFromFunctionContext(context) {
+  return nonBlank(context.platform?.folderKey);
+}
 var _UiPath_instances;
 var _a;
 var _UiPath_config;
@@ -9838,6 +10274,8 @@ var _UiPath_authService;
 var _UiPath_initialized;
 var _UiPath_partialConfig;
 var _UiPath_metaFolderKey;
+var _UiPath_contextFolderKey;
+var _UiPath_functionContext;
 var _UiPath_metaOrgId;
 var _UiPath_metaTenantId;
 var _UiPath_initializeWithConfig;
@@ -9851,18 +10289,30 @@ var UiPath$1 = class UiPath {
     _UiPath_initialized.set(this, false);
     _UiPath_partialConfig.set(this, undefined);
     _UiPath_metaFolderKey.set(this, undefined);
+    _UiPath_contextFolderKey.set(this, undefined);
+    _UiPath_functionContext.set(this, undefined);
     _UiPath_metaOrgId.set(this, undefined);
     _UiPath_metaTenantId.set(this, undefined);
-    const resolved = config2 && isFunctionContext(config2) ? configFromFunctionContext(config2) ?? undefined : config2;
+    let resolved;
+    if (config2 && isFunctionContext(config2)) {
+      __classPrivateFieldSet(this, _UiPath_functionContext, config2, "f");
+      __classPrivateFieldSet(this, _UiPath_contextFolderKey, folderKeyFromFunctionContext(config2), "f");
+      resolved = configFromFunctionContext(config2) ?? undefined;
+    } else {
+      resolved = config2;
+    }
     const configFromMetaTags = loadFromMetaTags();
     __classPrivateFieldSet(this, _UiPath_metaFolderKey, configFromMetaTags?.folderKey, "f");
-    __classPrivateFieldSet(this, _UiPath_metaOrgId, configFromMetaTags?.orgName, "f");
+    __classPrivateFieldSet(this, _UiPath_metaOrgId, configFromMetaTags?.organizationId ?? configFromMetaTags?.orgName, "f");
     __classPrivateFieldSet(this, _UiPath_metaTenantId, configFromMetaTags?.tenantName, "f");
     const mergedConfig = __classPrivateFieldGet(_a, _a, "m", _UiPath_mergeConfigSources).call(_a, configFromMetaTags, resolved);
     if (mergedConfig && isCompleteConfig(mergedConfig)) {
       __classPrivateFieldGet(this, _UiPath_instances, "m", _UiPath_initializeWithConfig).call(this, mergedConfig);
-    } else if (resolved) {
-      __classPrivateFieldSet(this, _UiPath_partialConfig, resolved, "f");
+    } else {
+      if (resolved) {
+        __classPrivateFieldSet(this, _UiPath_partialConfig, resolved, "f");
+      }
+      SDKInternalsRegistry.setUnconfigured(this, missingConfigMessage(mergedConfig, __classPrivateFieldGet(this, _UiPath_functionContext, "f")));
     }
   }
   async initialize() {
@@ -9938,14 +10388,14 @@ var UiPath$1 = class UiPath {
     __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
   }
 };
-_a = UiPath$1, _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);
+_a = UiPath$1, _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initialized = new WeakMap, _UiPath_partialConfig = new WeakMap, _UiPath_metaFolderKey = new WeakMap, _UiPath_contextFolderKey = new WeakMap, _UiPath_functionContext = new WeakMap, _UiPath_metaOrgId = new WeakMap, _UiPath_metaTenantId = new WeakMap, _UiPath_instances = new WeakSet, _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig2(config2) {
   const hasSecretAuth = hasSecretConfig(config2);
   const hasOAuthAuth = hasOAuthConfig(config2);
   const internalConfig = new UiPathConfig({
     baseUrl: normalizeBaseUrl(config2.baseUrl),
     orgName: config2.orgName,
     tenantName: config2.tenantName,
+    organizationId: config2.organizationId,
     secret: hasSecretAuth ? config2.secret : undefined,
     clientId: hasOAuthAuth ? config2.clientId : undefined,
     redirectUri: hasOAuthAuth ? config2.redirectUri : undefined,
@@ -9959,7 +10409,8 @@ _a = UiPath$1, _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap,
     config: internalConfig,
     context: executionContext,
     tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager(),
-    folderKey: __classPrivateFieldGet(this, _UiPath_metaFolderKey, "f")
+    folderKey: __classPrivateFieldGet(this, _UiPath_contextFolderKey, "f") ?? __classPrivateFieldGet(this, _UiPath_metaFolderKey, "f"),
+    metaFolderKey: __classPrivateFieldGet(this, _UiPath_metaFolderKey, "f")
   });
   this.config = {
     baseUrl: internalConfig.baseUrl,
@@ -9981,7 +10432,8 @@ _a = UiPath$1, _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap,
     __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
   }
 }, _UiPath_mergeConfigSources = function _UiPath_mergeConfigSources2(metaConfig, config2) {
-  const layers = [loadFromEnvironment(), metaConfig, config2].filter((layer) => Boolean(layer)).map((layer) => compactConfig(layer));
+  const environment = loadFromEnvironment();
+  const layers = [environment, metaConfig, config2].filter((layer) => Boolean(layer)).map((layer) => compactConfig(layer));
   if (layers.length === 0)
     return;
   const merged = layers.reduce((acc, layer) => ({ ...acc, ...layer }), {});
@@ -9996,15 +10448,20 @@ _a = UiPath$1, _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap,
       delete merged.secret;
     }
   }
+  const mergedHasSecret = hasSecretConfig(merged);
+  const mergedHasOAuth = hasOAuthConfig(merged);
+  if (mergedHasSecret && mergedHasOAuth) {
+    throw new Error(conflictingAuthMessage({ config: config2, metaConfig, environment }));
+  }
   return merged;
 }, _UiPath_loadConfig = function _UiPath_loadConfig2() {
   const metaConfig = loadFromMetaTags();
   __classPrivateFieldSet(this, _UiPath_metaFolderKey, metaConfig?.folderKey, "f");
-  __classPrivateFieldSet(this, _UiPath_metaOrgId, metaConfig?.orgName, "f");
+  __classPrivateFieldSet(this, _UiPath_metaOrgId, metaConfig?.organizationId ?? metaConfig?.orgName, "f");
   __classPrivateFieldSet(this, _UiPath_metaTenantId, metaConfig?.tenantName, "f");
   const merged = __classPrivateFieldGet(_a, _a, "m", _UiPath_mergeConfigSources).call(_a, metaConfig, __classPrivateFieldGet(this, _UiPath_partialConfig, "f"));
   if (!merged || !isCompleteConfig(merged)) {
-    throw new Error(missingConfigMessage());
+    throw new Error(missingConfigMessage(merged, __classPrivateFieldGet(this, _UiPath_functionContext, "f")));
   }
   return merged;
 };
@@ -10154,37 +10611,20 @@ class ErrorFactory {
         });
     }
   }
-  static createNetworkError(error) {
-    let message = ErrorMessages.NETWORK_ERROR;
-    if (error instanceof Error) {
-      if (error.name === ErrorNames.ABORT_ERROR) {
-        message = ErrorMessages.REQUEST_ABORTED;
-      } else if (error.message.includes("timeout")) {
-        message = ErrorMessages.REQUEST_TIMEOUT;
-      } else {
-        message = error.message;
-      }
-    }
-    return new NetworkError({ message });
-  }
-}
-var FOLDER_KEY = "X-UIPATH-FolderKey";
-var FOLDER_PATH_ENCODED = "X-UIPATH-FolderPath-Encoded";
-var FOLDER_ID = "X-UIPATH-OrganizationUnitId";
-var TRACEPARENT = "traceparent";
-var UIPATH_TRACEPARENT_ID = "x-uipath-traceparent-id";
-var CONTENT_TYPES = {
-  JSON: "application/json",
-  XML: "application/xml",
-  OCTET_STREAM: "application/octet-stream"
-};
-var RESPONSE_TYPES = {
-  JSON: "json",
-  TEXT: "text",
-  BLOB: "blob",
-  ARRAYBUFFER: "arraybuffer",
-  STREAM: "stream"
-};
+  static createNetworkError(error) {
+    let message = ErrorMessages.NETWORK_ERROR;
+    if (error instanceof Error) {
+      if (error.name === ErrorNames.ABORT_ERROR) {
+        message = ErrorMessages.REQUEST_ABORTED;
+      } else if (error.message.includes("timeout")) {
+        message = ErrorMessages.REQUEST_TIMEOUT;
+      } else {
+        message = error.message;
+      }
+    }
+    return new NetworkError({ message });
+  }
+}
 function createParams(paramsObj = {}) {
   const params = {};
   for (const [key, value] of Object.entries(paramsObj)) {
@@ -10212,148 +10652,6 @@ function toSearchParams(params) {
   }
   return searchParams;
 }
-var DEFAULT_RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
-var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS"];
-var DEFAULT_RETRY_OPTIONS = {
-  maxRetries: 2,
-  initialDelayMs: 500,
-  backoffStrategy: "exponential",
-  backoffFactor: 2,
-  backoffMaxDelayMs: 30000,
-  retryableStatusCodes: DEFAULT_RETRYABLE_STATUS_CODES,
-  retryMethods: DEFAULT_RETRY_METHODS,
-  retryNetworkErrors: true,
-  respectRetryAfter: true,
-  maxRetryAfterMs: Infinity
-};
-var DEFAULT_API_CLIENT_RETRY = {
-  ...DEFAULT_RETRY_OPTIONS,
-  maxRetries: 0
-};
-function resolveRetryOptions(settings, defaults = DEFAULT_RETRY_OPTIONS) {
-  if (!settings)
-    return defaults;
-  const { retryDelay, useExponentialBackoff, ...live } = settings;
-  const resolved = { ...defaults };
-  for (const [key, value] of Object.entries(live)) {
-    if (value !== undefined) {
-      resolved[key] = value;
-    }
-  }
-  if (retryDelay !== undefined && live.initialDelayMs === undefined) {
-    resolved.initialDelayMs = retryDelay;
-  }
-  if (useExponentialBackoff !== undefined && live.backoffStrategy === undefined) {
-    resolved.backoffStrategy = useExponentialBackoff ? "exponential" : "constant";
-  }
-  return resolved;
-}
-function computeBackoffDelay(attempt, settings) {
-  const base = Math.max(0, settings.initialDelayMs);
-  let delay;
-  switch (settings.backoffStrategy) {
-    case "constant":
-      delay = base;
-      break;
-    case "linear":
-      delay = base * (attempt + 1);
-      break;
-    default:
-      delay = base * Math.pow(settings.backoffFactor, attempt);
-  }
-  return Math.min(delay, settings.backoffMaxDelayMs);
-}
-function parseRetryAfter(value, now = Date.now()) {
-  const trimmed = value?.trim();
-  if (!trimmed)
-    return;
-  const seconds = Number(trimmed);
-  if (Number.isFinite(seconds))
-    return Math.max(0, seconds * 1000);
-  const date2 = Date.parse(trimmed);
-  if (Number.isNaN(date2))
-    return;
-  return Math.max(0, date2 - now);
-}
-function wait(durationMs) {
-  return new Promise((resolve) => setTimeout(resolve, Math.max(0, durationMs)));
-}
-var RETRY_AFTER = "retry-after";
-function createAttemptSignal(timeoutMs, external) {
-  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
-    return { signal: external, dispose: () => {} };
-  const controller = new AbortController;
-  const timer = setTimeout(() => controller.abort(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
-  const onExternalAbort = () => controller.abort(external?.reason);
-  if (external) {
-    if (external.aborted) {
-      controller.abort(external.reason);
-    } else {
-      external.addEventListener("abort", onExternalAbort);
-    }
-  }
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      clearTimeout(timer);
-      external?.removeEventListener("abort", onExternalAbort);
-    }
-  };
-}
-function delayBeforeRetry(durationMs, signal) {
-  if (!signal)
-    return wait(durationMs);
-  if (signal.aborted)
-    return Promise.reject(signal.reason);
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, Math.max(0, durationMs));
-    signal.addEventListener("abort", onAbort);
-  });
-}
-async function fetchWithRetry(url, init, options) {
-  const settings = options.retry;
-  const method = (init.method ?? "GET").toUpperCase();
-  const retriesAllowed = settings.retryMethods.includes(method) ? Math.max(0, settings.maxRetries) : 0;
-  let attempt = 0;
-  for (;; ) {
-    const { signal, dispose } = createAttemptSignal(options.timeoutMs, options.signal);
-    let response;
-    let failure;
-    try {
-      response = await fetch(url, { ...init, signal });
-    } catch (error) {
-      failure = error;
-    } finally {
-      dispose();
-    }
-    if (options.signal?.aborted && failure !== undefined)
-      throw failure;
-    if (response && !settings.retryableStatusCodes.includes(response.status))
-      return response;
-    if (failure !== undefined && !settings.retryNetworkErrors)
-      throw failure;
-    if (attempt >= retriesAllowed) {
-      if (response)
-        return response;
-      throw failure;
-    }
-    const retryAfter = settings.respectRetryAfter && response ? parseRetryAfter(response.headers.get(RETRY_AFTER)) : undefined;
-    const delay = retryAfter !== undefined ? Math.min(retryAfter, settings.maxRetryAfterMs) : computeBackoffDelay(attempt, settings);
-    response?.body?.cancel().catch((error) => {
-      console.warn("[UiPath SDK] Could not release a discarded response body:", error);
-    });
-    await delayBeforeRetry(delay, options.signal);
-    attempt++;
-  }
-}
-
 class ApiClient {
   constructor(config2, executionContext, tokenManager, clientConfig = {}) {
     this.config = config2;
@@ -10945,9 +11243,9 @@ var _BaseService_apiClient;
 class BaseService {
   constructor(instance, headers) {
     _BaseService_apiClient.set(this, undefined);
-    const { config: config2, context, tokenManager, folderKey } = SDKInternalsRegistry.get(instance);
+    const { config: config2, context, tokenManager, folderKey, metaFolderKey } = SDKInternalsRegistry.get(instance);
     __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config2, context, tokenManager, headers ? { headers } : {}), "f");
-    this.config = { folderKey };
+    this.config = { folderKey, metaFolderKey };
   }
   async getValidAuthToken() {
     return __classPrivateFieldGet(this, _BaseService_apiClient, "f").getValidToken();
@@ -11036,7 +11334,7 @@ class BaseService {
         limitedPageSize = getLimitedPageSize(params.pageSize);
         const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM;
         const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS.OFFSET_PARAM;
-        const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS.COUNT_PARAM;
+        const countParam = paginationParams && "countParam" in paginationParams ? paginationParams.countParam : ODATA_OFFSET_PARAMS.COUNT_PARAM;
         const convertToSkip = paginationParams?.convertToSkip ?? true;
         const zeroBased = paginationParams?.zeroBased ?? false;
         requestParams[pageSizeParam] = limitedPageSize;
@@ -11048,7 +11346,7 @@ class BaseService {
           const sdkPageNumber = params.pageNumber || 1;
           requestParams[offsetParam] = zeroBased ? sdkPageNumber - 1 : sdkPageNumber;
         }
-        {
+        if (countParam) {
           requestParams[countParam] = true;
         }
         break;
@@ -11131,6 +11429,11 @@ function createEntityMethods(entityData, service) {
         throw new Error("Entity ID is undefined");
       return service.updateRecords({ id: entityData.id }, data, options);
     },
+    async upsert(data, options) {
+      if (!entityData.name)
+        throw new Error("Entity name is undefined");
+      return service.upsert({ name: entityData.name }, data, options);
+    },
     async deleteRecords(recordIds, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
@@ -11263,6 +11566,11 @@ var EntityHavingOperator;
   EntityHavingOperator2["LessThan"] = "<";
   EntityHavingOperator2["LessThanOrEqual"] = "<=";
 })(EntityHavingOperator || (EntityHavingOperator = {}));
+var EntityMultiEntityWriteOperation;
+(function(EntityMultiEntityWriteOperation2) {
+  EntityMultiEntityWriteOperation2["Insert"] = "Insert";
+  EntityMultiEntityWriteOperation2["Update"] = "Update";
+})(EntityMultiEntityWriteOperation || (EntityMultiEntityWriteOperation = {}));
 var EntityType;
 (function(EntityType2) {
   EntityType2["Entity"] = "Entity";
@@ -11270,6 +11578,12 @@ var EntityType;
   EntityType2["InternalEntity"] = "InternalEntity";
   EntityType2["SystemEntity"] = "SystemEntity";
 })(EntityType || (EntityType = {}));
+var EntityClass;
+(function(EntityClass2) {
+  EntityClass2["Native"] = "Native";
+  EntityClass2["Federated"] = "Federated";
+  EntityClass2["Case"] = "Case";
+})(EntityClass || (EntityClass = {}));
 var ReferenceType;
 (function(ReferenceType2) {
   ReferenceType2["ManyToOne"] = "ManyToOne";
@@ -11293,6 +11607,11 @@ var JoinType;
   JoinType2["LeftJoin"] = "LeftJoin";
   JoinType2["InnerJoin"] = "InnerJoin";
 })(JoinType || (JoinType = {}));
+var EntityClassId;
+(function(EntityClassId2) {
+  EntityClassId2[EntityClassId2["Native"] = 9] = "Native";
+  EntityClassId2[EntityClassId2["Federated"] = 10] = "Federated";
+})(EntityClassId || (EntityClassId = {}));
 var EntityFieldConstraint;
 (function(EntityFieldConstraint2) {
   EntityFieldConstraint2["LengthLimit"] = "lengthLimit";
@@ -11416,6 +11735,77 @@ var EntityFieldTypeMap = {
   [SqlFieldType.MULTILINE]: EntityFieldDataType.MULTILINE_TEXT,
   [SqlFieldType.MULTILINE_MAX]: EntityFieldDataType.MULTILINE_MAX
 };
+var EntityClassToIdMap = {
+  [EntityClass.Native]: EntityClassId.Native,
+  [EntityClass.Federated]: EntityClassId.Federated
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asResourceOverrides(value) {
+  if (!isPlainObject(value))
+    return;
+  const table = {};
+  for (const [key, properties] of Object.entries(value)) {
+    if (!isPlainObject(properties))
+      continue;
+    const bag = {};
+    for (const [property, propertyValue] of Object.entries(properties)) {
+      if (typeof propertyValue === "string")
+        bag[property] = propertyValue;
+    }
+    table[key] = bag;
+  }
+  return Object.keys(table).length > 0 ? table : undefined;
+}
+function readFromDocument() {
+  if (!isBrowser)
+    return;
+  const text = document.getElementById(UiPathElementIds.RESOURCE_OVERRIDES)?.textContent;
+  if (!text)
+    return;
+  try {
+    return asResourceOverrides(JSON.parse(text));
+  } catch (error) {
+    console.warn(`[UiPath SDK] Failed to parse <script id="${UiPathElementIds.RESOURCE_OVERRIDES}"> as JSON — proceeding without overrides:`, error);
+    return;
+  }
+}
+var table;
+var loaded = false;
+var pageOverrides = () => {
+  if (!loaded) {
+    loaded = true;
+    table = readFromDocument();
+  }
+  return table;
+};
+var RESOURCE_OVERWRITES_KEY = Symbol.for("uipath.resourceOverwrites.v1");
+function readOverrides() {
+  const slot = globalThis[RESOURCE_OVERWRITES_KEY];
+  const source = typeof slot === "function" ? slot : pageOverrides;
+  try {
+    return source();
+  } catch (error) {
+    console.warn("[UiPath SDK] Override source threw — proceeding without overrides:", error);
+    return;
+  }
+}
+function resolveOverride(resourceType, name, folderPath) {
+  const table2 = readOverrides();
+  if (!table2)
+    return;
+  const bindingType = resourceType.toLowerCase();
+  const scopedKey = folderPath ? `${bindingType}.${name}.${folderPath}` : undefined;
+  const unscopedKey = `${bindingType}.${name}`;
+  const entry = (scopedKey && table2[scopedKey]) ?? table2[unscopedKey];
+  if (!entry)
+    return;
+  return {
+    name: entry.name,
+    folderPath: entry.folderPath
+  };
+}
 var JOIN_TYPE_WIRE = {
   [JoinType.LeftJoin]: "LEFT",
   [JoinType.InnerJoin]: "INNER"
@@ -11431,6 +11821,39 @@ function toWireJoin(join, baseEntityName) {
     }
   };
 }
+function externalSourceObjectName(source) {
+  return source.externalObjectDetail?.externalObjectName;
+}
+function externalSourceFieldName(field) {
+  const def = field.fieldDefinition;
+  return def?.name ?? def?.Name;
+}
+function externalSourceMappedName(field) {
+  const m = field.externalFieldMappingDetail ?? field.ExternalFieldMappingDetail;
+  return m?.externalFieldName ?? m?.ExternalFieldName;
+}
+function sourceConnId(s) {
+  const ext = s.externalConnectionDetail;
+  const nat = s.nativeConnectionDetail;
+  return ext?.connectionId ?? nat?.entityId;
+}
+function carryForwardSource(source) {
+  const fields = (source.fields ?? []).map((f) => {
+    const fieldDefinition = { ...f.fieldDefinition };
+    if (fieldDefinition.fieldDisplayType === undefined && fieldDefinition.FieldDisplayType === undefined) {
+      fieldDefinition.fieldDisplayType = FieldDisplayType.Basic;
+    }
+    if (fieldDefinition.description === undefined && fieldDefinition.Description === undefined) {
+      fieldDefinition.description = "";
+    }
+    return { ...f, fieldDefinition };
+  });
+  return { ...source, fields };
+}
+function applyEntityNameOverride(entityName) {
+  const override = resolveOverride("Entity", entityName);
+  return override?.name ?? entityName;
+}
 function unwrapEntityRef(entityRef, callerLabel) {
   const { id, name } = entityRef ?? {};
   if (id && name) {
@@ -11442,7 +11865,7 @@ function unwrapEntityRef(entityRef, callerLabel) {
     return { byId: true, identifier: id };
   }
   if (name) {
-    return { byId: false, identifier: name };
+    return { byId: false, identifier: applyEntityNameOverride(name) };
   }
   throw new ValidationError({
     message: `${callerLabel}: entityRef must supply exactly one of 'id' or 'name'.`
@@ -11454,19 +11877,19 @@ class EntityService extends BaseService {
     return this.fetchEntityMetadata(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(id), options?.folderKey);
   }
   async getByName(entityName, options) {
-    return this.fetchEntityMetadata(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_NAME(entityName), options?.folderKey);
+    return this.fetchEntityMetadata(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_NAME(applyEntityNameOverride(entityName)), options?.folderKey);
   }
   async getAllRecords(entityId, options) {
     return this.getRecordsImpl(true, entityId, options);
   }
   async getRecordsByName(entityName, options) {
-    return this.getRecordsImpl(false, entityName, options);
+    return this.getRecordsImpl(false, applyEntityNameOverride(entityName), options);
   }
   async getRecordById(entityId, recordId, options = {}) {
     return this.getRecordImpl(true, entityId, recordId, options);
   }
   async getRecordByName(entityName, recordId, options = {}) {
-    return this.getRecordImpl(false, entityName, recordId, options);
+    return this.getRecordImpl(false, applyEntityNameOverride(entityName), recordId, options);
   }
   async insertRecord(entityRef, data, options = {}) {
     const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.insertRecord");
@@ -11496,6 +11919,11 @@ class EntityService extends BaseService {
   async updateRecordsById(id, data, options = {}) {
     return this.updateRecordsImpl(true, id, data, options);
   }
+  async upsert(entityRef, data, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.upsert");
+    const entityName = byId ? await this.resolveEntityName(identifier, options.folderKey) : identifier;
+    return this.upsertImpl(entityName, data, options);
+  }
   async deleteRecords(entityRef, recordIds, options = {}) {
     const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.deleteRecords");
     return this.deleteRecordsImpl(byId, identifier, recordIds, options);
@@ -11511,7 +11939,7 @@ class EntityService extends BaseService {
     return this.deleteRecordImpl(true, entityId, recordId, options);
   }
   async getAll(options) {
-    const endpoint = !options?.folderKey && options?.includeFolderEntities ? DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL_V2 : DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL;
+    const endpoint = options?.folderKey || options?.includeFolderEntities ? DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL_V3 : DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL;
     const response = await this.get(endpoint, { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
     const entities = response.data.map((entity) => {
       const metadata = transformData(entity, EntityMap);
@@ -11573,7 +12001,22 @@ class EntityService extends BaseService {
   }
   async create(name, fields, options) {
     const opts = options ?? {};
+    let entityClassId;
+    if (opts.entityClass !== undefined) {
+      entityClassId = EntityClassToIdMap[opts.entityClass];
+      if (entityClassId === undefined) {
+        throw new ValidationError({
+          message: `entityClass '${opts.entityClass}' is not creatable. Use EntityClass.Native or EntityClass.Federated.`
+        });
+      }
+    }
+    if (opts.entityClass === EntityClass.Federated && !opts.externalFields?.length) {
+      throw new ValidationError({
+        message: "Federated entities require at least one external source in `externalFields`."
+      });
+    }
     const fieldPayloads = await this.buildFieldsWithReferenceMeta(fields);
+    const externalFields = await this.buildExternalSourcesPayload(opts.externalFields);
     const payload = {
       ...opts.description !== undefined && { description: opts.description },
       displayName: opts.displayName ?? name,
@@ -11583,7 +12026,9 @@ class EntityService extends BaseService {
         folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
         isRbacEnabled: opts.isRbacEnabled ?? false,
         isInsightsEnabled: opts.isAnalyticsEnabled ?? false,
-        externalFields: opts.externalFields ?? []
+        externalFields,
+        ...entityClassId !== undefined && { entityClassId },
+        ...opts.sourceJoinConditionDetails !== undefined && { sourceJoinConditionDetails: opts.sourceJoinConditionDetails }
       }
     };
     const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, payload, { headers: createHeaders({ [FOLDER_KEY]: opts.folderKey }) });
@@ -11594,18 +12039,19 @@ class EntityService extends BaseService {
   }
   async updateById(id, options) {
     const opts = options ?? {};
-    const hasSchemaChanges = !!(opts.addFields?.length || opts.removeFields?.length || opts.updateFields?.length);
+    const hasFederatedChanges = !!(opts.addExternalSources?.length || opts.removeExternalSources?.length || opts.addExternalFields?.length || opts.removeExternalFields?.length || opts.addSourceJoins?.length || opts.updateSourceJoin?.length || opts.replaceSourceJoins !== undefined || opts.updateExternalConnection?.length);
+    const hasSchemaChanges = !!(opts.addFields?.length || opts.removeFields?.length || opts.updateFields?.length) || hasFederatedChanges;
     const hasMetadataChanges = opts.displayName !== undefined || opts.description !== undefined || opts.isRbacEnabled !== undefined;
     if (!hasSchemaChanges && !hasMetadataChanges) {
       throw new ValidationError({
-        message: "updateById requires at least one change — pass addFields, removeFields, updateFields, displayName, description, or isRbacEnabled."
+        message: "updateById requires at least one change — pass addFields, removeFields, updateFields, displayName, description, isRbacEnabled, or a federated source/join delta (addExternalSources, removeExternalSources, addExternalFields, removeExternalFields, addSourceJoins, updateSourceJoin, replaceSourceJoins, updateExternalConnection)."
       });
     }
     if (hasSchemaChanges) {
       await this.applySchemaUpdate(id, opts);
     }
     if (hasMetadataChanges) {
-      await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE(id), {
+      await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_METADATA(id), {
         ...opts.displayName !== undefined && { displayName: opts.displayName },
         ...opts.description !== undefined && { description: opts.description },
         ...opts.isRbacEnabled !== undefined && { isRbacEnabled: opts.isRbacEnabled }
@@ -11616,7 +12062,7 @@ class EntityService extends BaseService {
     const folderHeaders = createHeaders({ [FOLDER_KEY]: options.folderKey });
     const entityResponse = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(entityId), { headers: folderHeaders });
     const raw = entityResponse.data;
-    let fields = (raw.fields ?? []).filter((f) => !f.isSystemField && !f.isPrimaryKey);
+    let fields = (raw.fields ?? []).filter((f) => !f.isSystemField && !f.isPrimaryKey && !f.isExternalField);
     if (options.removeFields?.length) {
       const existingNames = new Set(fields.map((f) => f.name));
       const missing = options.removeFields.filter((r) => !existingNames.has(r.name)).map((r) => r.name);
@@ -11674,6 +12120,7 @@ class EntityService extends BaseService {
     if (options.addFields?.length) {
       newFields.push(...await this.buildFieldsWithReferenceMeta(options.addFields));
     }
+    const federated = await this.buildFederatedUpsertParts(raw, options);
     await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, {
       displayName: raw.displayName,
       description: raw.description,
@@ -11684,13 +12131,132 @@ class EntityService extends BaseService {
         folderId: raw.folderId ?? DATA_FABRIC_TENANT_FOLDER_ID,
         isRbacEnabled: raw.isRbacEnabled ?? false,
         isInsightsEnabled: raw.isInsightsEnabled ?? false,
-        externalFields: raw.externalFields ?? []
+        externalFields: federated.externalFields,
+        ...federated.entityClassId !== undefined && { entityClassId: federated.entityClassId },
+        ...federated.sourceJoinConditionDetails !== undefined && { sourceJoinConditionDetails: federated.sourceJoinConditionDetails }
       }
     }, { 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;
+  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;
+  }
+  async buildFederatedUpsertParts(raw, options) {
+    let externalFields = (raw.externalFields ?? []).map((s) => carryForwardSource({ ...s }));
+    let joins = this.translateSourceJoins(raw);
+    const entityClassId = raw.entityClass ? EntityClassToIdMap[raw.entityClass] : undefined;
+    const findSource = (ref) => externalFields.find((s) => externalSourceObjectName(s) === ref.sourceObjectName && sourceConnId(s) === ref.sourceConnectionId);
+    const notFound = (action, ref) => new ValidationError({ message: `Cannot ${action}: no source '${ref.sourceObjectName}' with connection '${ref.sourceConnectionId}' on the entity.` });
+    if (options.replaceSourceJoins !== undefined && (options.addSourceJoins?.length || options.updateSourceJoin?.length)) {
+      throw new ValidationError({ message: "replaceSourceJoins sets the entity's complete join set, so it cannot be combined with addSourceJoins or updateSourceJoin." });
+    }
+    if (options.addExternalSources?.length) {
+      externalFields.push(...await this.buildExternalSourcesPayload(options.addExternalSources));
+    }
+    if (options.removeExternalSources?.length) {
+      const removeKeys = new Set(options.removeExternalSources.map((r) => `${r.sourceObjectName} ${r.sourceConnectionId}`));
+      externalFields = externalFields.filter((s) => !removeKeys.has(`${externalSourceObjectName(s) ?? ""} ${sourceConnId(s) ?? ""}`));
+      joins = joins.filter((j) => !removeKeys.has(`${j.sourceObjectName} ${j.sourceObjectConnectionId}`) && !removeKeys.has(`${j.relatedSourceObjectName} ${j.relatedSourceObjectConnectionId}`));
+    }
+    if (options.addExternalFields?.length) {
+      for (const add of options.addExternalFields) {
+        const src = findSource(add);
+        if (!src)
+          throw notFound("add fields", add);
+        const builtFields = await this.buildExternalFieldsPayload(add.fields);
+        const existing = src.fields ?? [];
+        src.fields = [...existing, ...builtFields];
+      }
+    }
+    if (options.removeExternalFields?.length) {
+      for (const rem of options.removeExternalFields) {
+        const src = findSource(rem);
+        if (!src)
+          throw notFound("remove fields", rem);
+        const drop = new Set(rem.fieldNames);
+        const all = src.fields ?? [];
+        const dropExternal = new Set(all.filter((f) => drop.has(externalSourceFieldName(f) ?? "")).map((f) => externalSourceMappedName(f) ?? ""));
+        src.fields = all.filter((f) => !drop.has(externalSourceFieldName(f) ?? ""));
+        joins = joins.filter((j) => !(j.sourceObjectName === rem.sourceObjectName && j.sourceObjectConnectionId === rem.sourceConnectionId && dropExternal.has(j.sourceJoinField)) && !(j.relatedSourceObjectName === rem.sourceObjectName && j.relatedSourceObjectConnectionId === rem.sourceConnectionId && dropExternal.has(j.relatedSourceJoinField)));
+      }
+    }
+    if (options.addSourceJoins?.length) {
+      joins.push(...options.addSourceJoins.map((j) => ({ ...j })));
+    }
+    if (options.replaceSourceJoins !== undefined) {
+      joins = options.replaceSourceJoins.map((j) => ({ ...j }));
+    }
+    if (options.updateSourceJoin?.length) {
+      for (const up of options.updateSourceJoin) {
+        const join = joins.find((j) => j.sourceObjectName === up.sourceObjectName && j.sourceObjectConnectionId === up.sourceConnectionId && j.relatedSourceObjectName === up.relatedSourceObjectName && j.relatedSourceObjectConnectionId === up.relatedSourceConnectionId);
+        if (!join)
+          throw new ValidationError({ message: `Cannot update join: no join between '${up.sourceObjectName}' (${up.sourceConnectionId}) and '${up.relatedSourceObjectName}' (${up.relatedSourceConnectionId}).` });
+        if (up.sourceJoinField !== undefined)
+          join.sourceJoinField = up.sourceJoinField;
+        if (up.relatedSourceJoinField !== undefined)
+          join.relatedSourceJoinField = up.relatedSourceJoinField;
+      }
+    }
+    if (options.updateExternalConnection?.length) {
+      for (const swap of options.updateExternalConnection) {
+        const src = findSource(swap);
+        if (!src)
+          throw notFound("replace connection", swap);
+        if (src.nativeConnectionDetail !== undefined) {
+          throw new ValidationError({ message: `Cannot replace connection: source '${swap.sourceObjectName}' is a native (entity-backed) source, not a connector source.` });
+        }
+        const existingConn = src.externalConnectionDetail;
+        src.externalConnectionDetail = {
+          ...existingConn,
+          connectionId: swap.newConnectionId,
+          ...swap.newElementInstanceId !== undefined && { elementInstanceId: swap.newElementInstanceId },
+          ...swap.newFolderKey !== undefined && { folderKey: swap.newFolderKey },
+          ...swap.newConnectionName !== undefined && { connectionName: swap.newConnectionName }
+        };
+        const oldConnId = swap.sourceConnectionId;
+        const newConnId = swap.newConnectionId;
+        for (const j of joins) {
+          if (j.sourceObjectName === swap.sourceObjectName && j.sourceObjectConnectionId === oldConnId)
+            j.sourceObjectConnectionId = newConnId;
+          if (j.relatedSourceObjectName === swap.sourceObjectName && j.relatedSourceObjectConnectionId === oldConnId)
+            j.relatedSourceObjectConnectionId = newConnId;
+        }
+      }
+    }
+    externalFields = externalFields.map((s) => ({
+      ...s,
+      externalObjectDetail: { ...s.externalObjectDetail, isPrimarySource: false }
+    }));
+    return {
+      externalFields,
+      ...entityClassId !== undefined && { entityClassId },
+      ...joins.length > 0 && { sourceJoinConditionDetails: joins }
+    };
+  }
+  translateSourceJoins(raw) {
+    const byObjectId = new Map;
+    for (const source of raw.externalFields ?? []) {
+      const objectId = source.externalObjectDetail?.id;
+      if (!objectId)
+        continue;
+      byObjectId.set(objectId, {
+        name: source.externalObjectDetail?.externalObjectName,
+        connectionId: source.externalConnectionDetail?.connectionId ?? source.nativeConnectionDetail?.entityId
+      });
+    }
+    return (raw.sourceJoinCriterias ?? []).map((join) => {
+      const src = byObjectId.get(join.sourceObjectId ?? "");
+      const related = byObjectId.get(join.relatedSourceObjectId ?? "");
+      return {
+        sourceObjectName: src?.name,
+        sourceJoinField: join.joinFieldName,
+        sourceObjectConnectionId: src?.connectionId,
+        joinType: join.joinType,
+        relatedSourceObjectName: related?.name,
+        relatedSourceJoinField: join.relatedSourceFieldName,
+        relatedSourceObjectConnectionId: related?.connectionId
+      };
+    });
   }
   applyFieldMappings(metadata) {
     this.mapFieldTypes(metadata);
@@ -11749,6 +12315,24 @@ class EntityService extends BaseService {
     const metas = await Promise.all(fields.map((f) => this.buildReferenceMeta(f)));
     return fields.map((f, i) => this.buildSchemaFieldPayload(f, metas[i]));
   }
+  async buildExternalFieldsPayload(fields) {
+    const list = fields ?? [];
+    const fieldDefs = await this.buildFieldsWithReferenceMeta(list.map((f) => f.field));
+    return list.map((f, i) => ({
+      fieldDefinition: fieldDefs[i],
+      externalFieldMappingDetail: f.externalFieldMappingDetail
+    }));
+  }
+  async buildExternalSourcesPayload(sources) {
+    if (!sources?.length)
+      return [];
+    return Promise.all(sources.map(async (source) => ({
+      fields: await this.buildExternalFieldsPayload(source.fields),
+      externalObjectDetail: source.externalObjectDetail,
+      ...source.externalConnectionDetail !== undefined && { externalConnectionDetail: source.externalConnectionDetail },
+      ...source.nativeConnectionDetail !== undefined && { nativeConnectionDetail: source.nativeConnectionDetail }
+    })));
+  }
   async buildReferenceMeta(field) {
     if (field.referenceFolderKey === undefined)
       return;
@@ -11936,6 +12520,11 @@ class EntityService extends BaseService {
     const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_BY_NAME(identifier), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
     return response.data;
   }
+  async upsertImpl(entityName, data, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel });
+    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT_RECORD_BY_NAME(entityName), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
   async deleteRecordsImpl(byId, identifier, recordIds, options) {
     const params = createParams({ failOnFirst: options.failOnFirst });
     const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_BY_NAME(identifier), recordIds, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
@@ -12040,6 +12629,9 @@ __decorate([
 __decorate([
   track("Entities.UpdateRecordsById")
 ], EntityService.prototype, "updateRecordsById", null);
+__decorate([
+  track("Entities.Upsert")
+], EntityService.prototype, "upsert", null);
 __decorate([
   track("Entities.DeleteRecords")
 ], EntityService.prototype, "deleteRecords", null);
@@ -12147,7 +12739,7 @@ class ChoiceSetService extends BaseService {
     }, { headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
   }
   async deleteById(choiceSetId, options) {
-    await this.post(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE(choiceSetId), {}, { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+    await this.delete(DATA_FABRIC_ENDPOINTS.CHOICESETS.DELETE(choiceSetId), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
   }
   async insertValueById(choiceSetId, name, options) {
     const choiceSetName = await this.resolveChoiceSetName(choiceSetId, options?.folderKey);
@@ -13508,73 +14100,6 @@ function validateName(resourceType, name) {
   return trimmed;
 }
 var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asResourceOverrides(value) {
-  if (!isPlainObject(value))
-    return;
-  const table = {};
-  for (const [key, properties] of Object.entries(value)) {
-    if (!isPlainObject(properties))
-      continue;
-    const bag = {};
-    for (const [property, propertyValue] of Object.entries(properties)) {
-      if (typeof propertyValue === "string")
-        bag[property] = propertyValue;
-    }
-    table[key] = bag;
-  }
-  return Object.keys(table).length > 0 ? table : undefined;
-}
-function readFromDocument() {
-  if (!isBrowser)
-    return;
-  const text = document.getElementById(UiPathElementIds.RESOURCE_OVERRIDES)?.textContent;
-  if (!text)
-    return;
-  try {
-    return asResourceOverrides(JSON.parse(text));
-  } catch (error) {
-    console.warn(`[UiPath SDK] Failed to parse <script id="${UiPathElementIds.RESOURCE_OVERRIDES}"> as JSON — proceeding without overrides:`, error);
-    return;
-  }
-}
-var table;
-var loaded = false;
-var pageOverrides = () => {
-  if (!loaded) {
-    loaded = true;
-    table = readFromDocument();
-  }
-  return table;
-};
-var RESOURCE_OVERWRITES_KEY = Symbol.for("uipath.resourceOverwrites.v1");
-function readOverrides() {
-  const slot = globalThis[RESOURCE_OVERWRITES_KEY];
-  const source = typeof slot === "function" ? slot : pageOverrides;
-  try {
-    return source();
-  } catch (error) {
-    console.warn("[UiPath SDK] Override source threw — proceeding without overrides:", error);
-    return;
-  }
-}
-function resolveOverride(resourceType, name, folderPath) {
-  const table2 = readOverrides();
-  if (!table2)
-    return;
-  const bindingType = resourceType.toLowerCase();
-  const scopedKey = folderPath ? `${bindingType}.${name}.${folderPath}` : undefined;
-  const unscopedKey = `${bindingType}.${name}`;
-  const entry = (scopedKey && table2[scopedKey]) ?? table2[unscopedKey];
-  if (!entry)
-    return;
-  return {
-    name: entry.name,
-    folderPath: entry.folderPath
-  };
-}
 var SINGLE_QUOTE_RE = /'/g;
 
 class FolderScopedService extends BaseService {
@@ -13616,7 +14141,7 @@ class FolderScopedService extends BaseService {
     });
     const items = response.data?.value;
     if (!items?.length) {
-      const folderHint = describeFolderForError(folderId, folderKey, resolvedFolderPath);
+      const folderHint = describeFolderForError(folderId, headers[FOLDER_KEY], resolvedFolderPath);
       throw new NotFoundError({
         message: `${resourceType} '${resolvedName}' not found${folderHint}.`
       });
@@ -14564,10 +15089,7 @@ class BucketService extends FolderScopedService {
       }
     }, options);
   }
-  async getFileMetaData(bucketId, optionsOrFolderId, legacyOptions) {
-    if (!bucketId) {
-      throw new ValidationError({ message: "bucketId is required for getFileMetaData" });
-    }
+  async getFileMetaData(bucketIdOrRef, optionsOrFolderId, legacyOptions) {
     let folderId;
     let folderKey;
     let folderPath;
@@ -14579,10 +15101,14 @@ class BucketService extends FolderScopedService {
       const opts = optionsOrFolderId ?? {};
       ({ folderId, folderKey, folderPath, ...restOptions } = opts);
     }
+    const { id: bucketId, effectiveFolder } = await this.resolveBucketRef(bucketIdOrRef, { folderId, folderKey, folderPath }, "Buckets.getFileMetaData");
+    if (bucketId <= 0) {
+      throw new ValidationError({ message: "Buckets.getFileMetaData: bucketId must be a positive number." });
+    }
     const headers = resolveFolderHeaders({
-      folderId,
-      folderKey,
-      folderPath,
+      folderId: effectiveFolder.folderId ?? folderId,
+      folderKey: effectiveFolder.folderKey ?? folderKey,
+      folderPath: effectiveFolder.folderPath ?? folderPath,
       resourceType: "Buckets.getFileMetaData",
       fallbackFolderKey: this.config.folderKey
     });
@@ -14605,35 +15131,43 @@ class BucketService extends FolderScopedService {
       headers
     }, apiRestOptions);
   }
-  async uploadFile(bucketIdOrOptions, path, content, options) {
-    let bucketId;
+  async uploadFile(firstArg, path, content, options) {
+    let bucketIdOrRef;
     let resolvedPath;
     let resolvedContent;
     let folderId;
     let folderKey;
     let folderPath;
-    if (bucketIdOrOptions !== null && typeof bucketIdOrOptions === "object") {
-      ({ bucketId, path: resolvedPath, content: resolvedContent, folderId, folderKey, folderPath } = bucketIdOrOptions);
+    const isDeprecatedOptionsForm = firstArg !== null && typeof firstArg === "object" && "bucketId" in firstArg;
+    if (isDeprecatedOptionsForm) {
+      const opts = firstArg;
+      bucketIdOrRef = opts.bucketId;
+      resolvedPath = opts.path;
+      resolvedContent = opts.content;
+      folderId = opts.folderId;
+      folderKey = opts.folderKey;
+      folderPath = opts.folderPath;
     } else {
-      bucketId = bucketIdOrOptions;
+      bucketIdOrRef = firstArg;
       resolvedPath = path;
       resolvedContent = content;
       const opts = options ?? {};
       ({ folderId, folderKey, folderPath } = opts);
     }
-    if (!bucketId) {
-      throw new ValidationError({ message: "bucketId is required for uploadFile" });
-    }
     if (!resolvedPath) {
       throw new ValidationError({ message: "path is required for uploadFile" });
     }
     if (!resolvedContent) {
       throw new ValidationError({ message: "content is required for uploadFile" });
     }
+    const { id: bucketId, effectiveFolder } = await this.resolveBucketRef(bucketIdOrRef, { folderId, folderKey, folderPath }, "Buckets.uploadFile");
+    if (bucketId <= 0) {
+      throw new ValidationError({ message: "Buckets.uploadFile: bucketId must be a positive number." });
+    }
     const headers = resolveFolderHeaders({
-      folderId,
-      folderKey,
-      folderPath,
+      folderId: effectiveFolder.folderId ?? folderId,
+      folderKey: effectiveFolder.folderKey ?? folderKey,
+      folderPath: effectiveFolder.folderPath ?? folderPath,
       resourceType: "Buckets.uploadFile",
       fallbackFolderKey: this.config.folderKey
     });
@@ -14648,17 +15182,19 @@ class BucketService extends FolderScopedService {
       statusCode: response.status
     };
   }
-  async getReadUri(bucketIdOrOptions, path, options) {
-    let bucketId;
+  async getReadUri(firstArg, path, options) {
+    let bucketIdOrRef;
     let resolvedPath;
     let folderId;
     let folderKey;
     let folderPath;
     let expiryInMinutes;
     let restOptions;
-    if (bucketIdOrOptions !== null && typeof bucketIdOrOptions === "object") {
-      const { bucketId: bid, path: p, expiryInMinutes: e, folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = bucketIdOrOptions;
-      bucketId = bid;
+    const isDeprecatedOptionsForm = firstArg !== null && typeof firstArg === "object" && "bucketId" in firstArg;
+    if (isDeprecatedOptionsForm) {
+      const opts = firstArg;
+      const { bucketId: bid, path: p, expiryInMinutes: e, folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = opts;
+      bucketIdOrRef = bid;
       resolvedPath = p;
       expiryInMinutes = e;
       folderId = fid;
@@ -14666,15 +15202,22 @@ class BucketService extends FolderScopedService {
       folderPath = fpath;
       restOptions = rest;
     } else {
-      bucketId = bucketIdOrOptions;
+      bucketIdOrRef = firstArg;
       resolvedPath = path;
       const opts = options ?? {};
       ({ expiryInMinutes, folderId, folderKey, folderPath, ...restOptions } = opts);
     }
+    const { id: bucketId, effectiveFolder } = await this.resolveBucketRef(bucketIdOrRef, { folderId, folderKey, folderPath }, "Buckets.getReadUri");
+    if (bucketId <= 0) {
+      throw new ValidationError({ message: "Buckets.getReadUri: bucketId must be a positive number." });
+    }
+    if (!resolvedPath) {
+      throw new ValidationError({ message: "path is required for getReadUri" });
+    }
     const headers = resolveFolderHeaders({
-      folderId,
-      folderKey,
-      folderPath,
+      folderId: effectiveFolder.folderId ?? folderId,
+      folderKey: effectiveFolder.folderKey ?? folderKey,
+      folderPath: effectiveFolder.folderPath ?? folderPath,
       resourceType: "Buckets.getReadUri",
       fallbackFolderKey: this.config.folderKey
     });
@@ -14702,12 +15245,6 @@ class BucketService extends FolderScopedService {
     });
   }
   async _getUri(endpoint, bucketId, path, headers, queryOptions = {}) {
-    if (!bucketId) {
-      throw new ValidationError({ message: "bucketId is required for getUri" });
-    }
-    if (!path) {
-      throw new ValidationError({ message: "path is required for getUri" });
-    }
     const queryParams = filterUndefined({
       path,
       ...queryOptions
@@ -14722,15 +15259,16 @@ class BucketService extends FolderScopedService {
     }
     return transformedData;
   }
-  async getFiles(bucketId, options) {
-    if (!bucketId) {
-      throw new ValidationError({ message: "bucketId is required for getFiles" });
-    }
+  async getFiles(bucketIdOrRef, options) {
     const { folderId, folderKey, folderPath, ...restOptions } = options ?? {};
+    const { id: bucketId, effectiveFolder } = await this.resolveBucketRef(bucketIdOrRef, { folderId, folderKey, folderPath }, "Buckets.getFiles");
+    if (bucketId <= 0) {
+      throw new ValidationError({ message: "Buckets.getFiles: bucketId must be a positive number." });
+    }
     const headers = resolveFolderHeaders({
-      folderId,
-      folderKey,
-      folderPath,
+      folderId: effectiveFolder.folderId ?? folderId,
+      folderKey: effectiveFolder.folderKey ?? folderKey,
+      folderPath: effectiveFolder.folderPath ?? folderPath,
       resourceType: "Buckets.getFiles",
       fallbackFolderKey: this.config.folderKey
     });
@@ -14754,17 +15292,18 @@ class BucketService extends FolderScopedService {
       headers
     }, { ...apiRestOptions, directory: "/", recursive: true });
   }
-  async deleteFile(bucketId, path, options) {
-    if (!bucketId) {
-      throw new ValidationError({ message: "bucketId is required for deleteFile" });
-    }
+  async deleteFile(bucketIdOrRef, path, options) {
     if (!path) {
       throw new ValidationError({ message: "path is required for deleteFile" });
     }
+    const { id: bucketId, effectiveFolder } = await this.resolveBucketRef(bucketIdOrRef, { folderId: options?.folderId, folderKey: options?.folderKey, folderPath: options?.folderPath }, "Buckets.deleteFile");
+    if (bucketId <= 0) {
+      throw new ValidationError({ message: "Buckets.deleteFile: bucketId must be a positive number." });
+    }
     const headers = resolveFolderHeaders({
-      folderId: options?.folderId,
-      folderKey: options?.folderKey,
-      folderPath: options?.folderPath,
+      folderId: effectiveFolder.folderId ?? options?.folderId,
+      folderKey: effectiveFolder.folderKey ?? options?.folderKey,
+      folderPath: effectiveFolder.folderPath ?? options?.folderPath,
       resourceType: "Buckets.deleteFile",
       fallbackFolderKey: this.config.folderKey
     });
@@ -14782,6 +15321,17 @@ class BucketService extends FolderScopedService {
     };
     return this._getUri(BUCKET_ENDPOINTS.GET_WRITE_URI(bucketId), bucketId, path, headers, queryOptions);
   }
+  async resolveBucketRef(bucketIdOrRef, folderScope, callerLabel) {
+    if (bucketIdOrRef == null || typeof bucketIdOrRef === "number") {
+      return { id: bucketIdOrRef ?? 0, effectiveFolder: {} };
+    }
+    return resolveRefToId(bucketIdOrRef, {
+      byName: async (name) => {
+        const { result, effectiveFolder } = await this.getByNameLookup("Bucket", BUCKET_ENDPOINTS.GET_BY_FOLDER, name, folderScope, (raw) => pascalToCamelCaseKeys(raw), undefined, callerLabel);
+        return { id: result.id, ...effectiveFolder };
+      }
+    }, callerLabel);
+  }
 }
 __decorate([
   track("Buckets.GetById")
@@ -15328,6 +15878,13 @@ var JobState;
   JobState2["Cancelled"] = "Cancelled";
   JobState2["Unknown"] = "Unknown";
 })(JobState || (JobState = {}));
+var ConnectionState;
+(function(ConnectionState2) {
+  ConnectionState2["Enabled"] = "Enabled";
+  ConnectionState2["Disabled"] = "Disabled";
+  ConnectionState2["Expired"] = "Expired";
+  ConnectionState2["Failed"] = "Failed";
+})(ConnectionState || (ConnectionState = {}));
 var ProcessMap = {
   lastModificationTime: "lastModifiedTime",
   creationTime: "createdTime",
@@ -15363,14 +15920,34 @@ class ProcessService extends FolderScopedService {
       }
     }, apiOptions);
   }
-  async start(request, optionsOrFolderId, legacyOptions) {
+  async start(firstArg, optionsOrFolderId, legacyOptions) {
+    const looksLikeRef = isProcessRef(firstArg);
+    const looksLikeLegacy = isLegacyStartRequest(firstArg);
+    if (!looksLikeRef && !looksLikeLegacy) {
+      throw new ValidationError({
+        message: "Processes.start: first argument must be a ProcessRef (`{ name }` or `{ key }`) or a ProcessStartRequest (`{ processKey }` or `{ processName }`)."
+      });
+    }
     let folderId;
     let folderKey;
     let folderPath;
-    let queryOptions;
+    let queryOptions = {};
+    let startInfoExtras = {};
     if (typeof optionsOrFolderId === "number") {
       folderId = optionsOrFolderId;
       queryOptions = legacyOptions ?? {};
+    } else if (looksLikeRef) {
+      const { folderId: fid, folderKey: fkey, folderPath: fpath, expand, select, filter, orderby, ...restStartInfo } = optionsOrFolderId ?? {};
+      folderId = fid;
+      folderKey = fkey;
+      folderPath = fpath;
+      queryOptions = {
+        ...expand !== undefined && { expand },
+        ...select !== undefined && { select },
+        ...filter !== undefined && { filter },
+        ...orderby !== undefined && { orderby }
+      };
+      startInfoExtras = restStartInfo;
     } else {
       const { folderId: fid, folderKey: fkey, folderPath: fpath, ...rest } = optionsOrFolderId ?? {};
       folderId = fid;
@@ -15378,17 +15955,20 @@ class ProcessService extends FolderScopedService {
       folderPath = fpath;
       queryOptions = rest;
     }
+    const identity = looksLikeRef ? resolveProcessRefIdentity(firstArg, folderPath) : resolveLegacyIdentity(firstArg, folderPath);
     const headers = resolveFolderHeaders({
       folderId,
       folderKey,
-      folderPath,
-      resourceType: "processes.start",
+      folderPath: identity.folderPath ?? folderPath,
+      resourceType: "Processes.start",
       fallbackFolderKey: this.config.folderKey
     });
-    const apiRequest = transformRequest(request, ProcessMap);
-    const requestBody = {
-      startInfo: apiRequest
-    };
+    const startInfoSdk = looksLikeRef ? { ...startInfoExtras, ...identity.identity } : { ...firstArg, ...identity.identity };
+    if (!looksLikeRef && identity.dropProcessKey) {
+      delete startInfoSdk.processKey;
+    }
+    const apiRequest = transformRequest(startInfoSdk, ProcessMap);
+    const requestBody = { startInfo: apiRequest };
     const apiFieldOptions = transformOptions(queryOptions, ProcessMap);
     const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
     const response = await this.post(PROCESS_ENDPOINTS.START_PROCESS, requestBody, {
@@ -15406,8 +15986,7 @@ class ProcessService extends FolderScopedService {
       headers,
       params: apiOptions
     });
-    const transformedProcess = transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
-    return transformedProcess;
+    return transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
   }
   async getByName(name, options = {}) {
     const { result } = await this.getByNameLookup("Process", PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap), ProcessMap);
@@ -15426,6 +16005,64 @@ __decorate([
 __decorate([
   track("Processes.GetByName")
 ], ProcessService.prototype, "getByName", null);
+function isProcessRef(arg) {
+  if (arg == null || typeof arg !== "object")
+    return false;
+  const obj = arg;
+  if ("processKey" in obj || "processName" in obj)
+    return false;
+  return "name" in obj || "key" in obj;
+}
+function resolveProcessRefIdentity(processRef, folderPath) {
+  const name = "name" in processRef ? processRef.name : undefined;
+  const key = "key" in processRef ? processRef.key : undefined;
+  if (name) {
+    const override = resolveOverride("Process", name, folderPath);
+    return {
+      identity: { processName: override?.name ?? name },
+      folderPath: override?.folderPath
+    };
+  }
+  if (key) {
+    return { identity: { processKey: key } };
+  }
+  throw new ValidationError({
+    message: "Processes.start: processRef must supply a non-empty `name` or `key`."
+  });
+}
+function isLegacyStartRequest(arg) {
+  if (arg == null || typeof arg !== "object")
+    return false;
+  const obj = arg;
+  return "processKey" in obj || "processName" in obj;
+}
+function resolveLegacyIdentity(request, folderPath) {
+  if (request.processName) {
+    const name = request.processName;
+    const override = resolveOverride("Process", name, folderPath);
+    if (override?.name) {
+      return {
+        identity: { processName: override.name },
+        folderPath: override?.folderPath,
+        dropProcessKey: true
+      };
+    }
+    return { identity: {}, folderPath: override?.folderPath };
+  }
+  if (request.processKey) {
+    const key = request.processKey;
+    const override = resolveOverride("Process", key, folderPath);
+    if (override?.name) {
+      return {
+        identity: { processName: override.name },
+        folderPath: override?.folderPath,
+        dropProcessKey: true
+      };
+    }
+    return { identity: {}, folderPath: override?.folderPath };
+  }
+  return { identity: {} };
+}
 var QueuePriority;
 (function(QueuePriority2) {
   QueuePriority2["High"] = "High";
@@ -15903,6 +16540,32 @@ var FunctionHttpMethod;
   FunctionHttpMethod2["Patch"] = "Patch";
   FunctionHttpMethod2["Delete"] = "Delete";
 })(FunctionHttpMethod || (FunctionHttpMethod = {}));
+var FolderType;
+(function(FolderType2) {
+  FolderType2["Standard"] = "Standard";
+  FolderType2["Personal"] = "Personal";
+  FolderType2["Virtual"] = "Virtual";
+  FolderType2["Solution"] = "Solution";
+  FolderType2["DebugSolution"] = "DebugSolution";
+})(FolderType || (FolderType = {}));
+var FolderProvisionType;
+(function(FolderProvisionType2) {
+  FolderProvisionType2["Manual"] = "Manual";
+  FolderProvisionType2["Automatic"] = "Automatic";
+})(FolderProvisionType || (FolderProvisionType = {}));
+var FolderPermissionModel;
+(function(FolderPermissionModel2) {
+  FolderPermissionModel2["InheritFromTenant"] = "InheritFromTenant";
+  FolderPermissionModel2["FineGrained"] = "FineGrained";
+})(FolderPermissionModel || (FolderPermissionModel = {}));
+var FolderFeedType;
+(function(FolderFeedType2) {
+  FolderFeedType2["Undefined"] = "Undefined";
+  FolderFeedType2["Processes"] = "Processes";
+  FolderFeedType2["Libraries"] = "Libraries";
+  FolderFeedType2["PersonalWorkspace"] = "PersonalWorkspace";
+  FolderFeedType2["FolderHierarchy"] = "FolderHierarchy";
+})(FolderFeedType || (FolderFeedType = {}));
 var CommonFieldMap = {
   createdAt: "createdTime",
   updatedAt: "updatedTime"
@@ -15956,13 +16619,6 @@ var AgentMap = {
 var UserSettingsMap = {
   ...CommonFieldMap
 };
-var ConnectionState;
-(function(ConnectionState2) {
-  ConnectionState2["Enabled"] = "Enabled";
-  ConnectionState2["Disabled"] = "Disabled";
-  ConnectionState2["Expired"] = "Expired";
-  ConnectionState2["Failed"] = "Failed";
-})(ConnectionState || (ConnectionState = {}));
 var FeedbackStatus;
 (function(FeedbackStatus2) {
   FeedbackStatus2[FeedbackStatus2["Pending"] = 0] = "Pending";
@@ -16251,6 +16907,109 @@ var PlatformSettingKey;
   PlatformSettingKey2["UserCasePinnedInstancesByTenant"] = "UserCase.PinnedInstancesByTenant";
   PlatformSettingKey2["UserCaseInstancesTableFiltersByTenant"] = "UserCase.InstancesTableFiltersByTenant";
 })(PlatformSettingKey || (PlatformSettingKey = {}));
+var PlatformUserType;
+(function(PlatformUserType2) {
+  PlatformUserType2["User"] = "user";
+  PlatformUserType2["Robot"] = "robot";
+  PlatformUserType2["DirectoryUser"] = "directoryUser";
+  PlatformUserType2["DirectoryGroup"] = "directoryGroup";
+  PlatformUserType2["RobotAccount"] = "robotAccount";
+  PlatformUserType2["Application"] = "application";
+})(PlatformUserType || (PlatformUserType = {}));
+var PlatformUserCategory;
+(function(PlatformUserCategory2) {
+  PlatformUserCategory2["Local"] = "local";
+  PlatformUserCategory2["LinkedLocal"] = "linkedLocal";
+  PlatformUserCategory2["Directory"] = "directory";
+})(PlatformUserCategory || (PlatformUserCategory = {}));
+var PlatformUserSortField;
+(function(PlatformUserSortField2) {
+  PlatformUserSortField2["Id"] = "Id";
+  PlatformUserSortField2["UserName"] = "UserName";
+  PlatformUserSortField2["Email"] = "Email";
+  PlatformUserSortField2["EmailConfirmed"] = "EmailConfirmed";
+  PlatformUserSortField2["Name"] = "Name";
+  PlatformUserSortField2["Surname"] = "Surname";
+  PlatformUserSortField2["DisplayName"] = "DisplayName";
+  PlatformUserSortField2["CreatedTime"] = "CreationTime";
+  PlatformUserSortField2["LastModifiedTime"] = "LastModificationTime";
+  PlatformUserSortField2["LastLoginTime"] = "LastLoginTime";
+  PlatformUserSortField2["IsActive"] = "IsActive";
+  PlatformUserSortField2["Type"] = "Type";
+  PlatformUserSortField2["Category"] = "Category";
+  PlatformUserSortField2["InvitationAccepted"] = "InvitationAccepted";
+})(PlatformUserSortField || (PlatformUserSortField = {}));
+var PlatformUserSortOrder;
+(function(PlatformUserSortOrder2) {
+  PlatformUserSortOrder2["Ascending"] = "asc";
+  PlatformUserSortOrder2["Descending"] = "desc";
+})(PlatformUserSortOrder || (PlatformUserSortOrder = {}));
+var PlatformRoleType;
+(function(PlatformRoleType2) {
+  PlatformRoleType2["BuiltIn"] = "BUILTIN";
+  PlatformRoleType2["Platform"] = "PLATFORM";
+  PlatformRoleType2["Custom"] = "CUSTOM";
+})(PlatformRoleType || (PlatformRoleType = {}));
+var PlatformRoleScopeType;
+(function(PlatformRoleScopeType2) {
+  PlatformRoleScopeType2["Organization"] = "ORGANIZATION";
+  PlatformRoleScopeType2["Tenant"] = "TENANT";
+  PlatformRoleScopeType2["Project"] = "PROJECT";
+  PlatformRoleScopeType2["Process"] = "PROCESS";
+  PlatformRoleScopeType2["App"] = "APP";
+  PlatformRoleScopeType2["Mixed"] = "MIXED";
+})(PlatformRoleScopeType || (PlatformRoleScopeType = {}));
+var PlatformActionScopeType;
+(function(PlatformActionScopeType2) {
+  PlatformActionScopeType2["Any"] = "ANY";
+  PlatformActionScopeType2["None"] = "NONE";
+  PlatformActionScopeType2["Organization"] = "ORGANIZATION";
+  PlatformActionScopeType2["Tenant"] = "TENANT";
+  PlatformActionScopeType2["Folder"] = "FOLDER";
+  PlatformActionScopeType2["Project"] = "PROJECT";
+  PlatformActionScopeType2["Process"] = "PROCESS";
+})(PlatformActionScopeType || (PlatformActionScopeType = {}));
+var PlatformPrincipalType;
+(function(PlatformPrincipalType2) {
+  PlatformPrincipalType2["User"] = "User";
+  PlatformPrincipalType2["Group"] = "Group";
+  PlatformPrincipalType2["ExternalApplication"] = "ExternalApplication";
+  PlatformPrincipalType2["Robot"] = "Robot";
+})(PlatformPrincipalType || (PlatformPrincipalType = {}));
+var PlatformRoleSortField;
+(function(PlatformRoleSortField2) {
+  PlatformRoleSortField2["Id"] = "Id";
+  PlatformRoleSortField2["Name"] = "OriginalRoleName";
+  PlatformRoleSortField2["UniqueName"] = "UniqueName";
+  PlatformRoleSortField2["Description"] = "Description";
+  PlatformRoleSortField2["Type"] = "Type";
+  PlatformRoleSortField2["ScopeType"] = "ScopeType";
+  PlatformRoleSortField2["OrganizationId"] = "OrganizationId";
+  PlatformRoleSortField2["TenantId"] = "TenantId";
+  PlatformRoleSortField2["OwnerService"] = "OwnerService";
+  PlatformRoleSortField2["OwnerServiceId"] = "OwnerServiceId";
+  PlatformRoleSortField2["CreatedBy"] = "CreatedBy";
+  PlatformRoleSortField2["CreatedTime"] = "CreatedOn";
+  PlatformRoleSortField2["UpdatedBy"] = "UpdatedBy";
+  PlatformRoleSortField2["UpdatedTime"] = "UpdatedOn";
+})(PlatformRoleSortField || (PlatformRoleSortField = {}));
+var PlatformRoleSortOrder;
+(function(PlatformRoleSortOrder2) {
+  PlatformRoleSortOrder2["Ascending"] = "Asc";
+  PlatformRoleSortOrder2["Descending"] = "Desc";
+})(PlatformRoleSortOrder || (PlatformRoleSortOrder = {}));
+var PlatformGroupType;
+(function(PlatformGroupType2) {
+  PlatformGroupType2["BuiltIn"] = "builtIn";
+  PlatformGroupType2["Custom"] = "custom";
+})(PlatformGroupType || (PlatformGroupType = {}));
+var LifeCycleStage;
+(function(LifeCycleStage2) {
+  LifeCycleStage2["PREVIEW"] = "PREVIEW";
+  LifeCycleStage2["GA"] = "GA";
+  LifeCycleStage2["DEPRECATED"] = "DEPRECATED";
+  LifeCycleStage2["CUSTOM"] = "CUSTOM";
+})(LifeCycleStage || (LifeCycleStage = {}));
 var SpanStatus;
 (function(SpanStatus2) {
   SpanStatus2["Unset"] = "Unset";
@@ -16333,6 +17092,7 @@ var AgentGovernanceSection;
   AgentGovernanceSection2["Action"] = "action";
   AgentGovernanceSection2["Mode"] = "mode";
 })(AgentGovernanceSection || (AgentGovernanceSection = {}));
+var HOST_KEY = Symbol.for("uipath.host.v1");
 
 // ../../node_modules/@uipath/uipath-typescript/dist/tasks/index.mjs
 function __decorate2(decorators, target, key, desc) {
@@ -16591,6 +17351,7 @@ var TaskMap2 = {
 };
 var DEFAULT_TASK_EXPAND2 = "AssignedToUser,CreatorUser,LastModifierUser";
 var ORCHESTRATOR_BASE2 = "orchestrator_";
+var IDENTITY_BASE2 = "identity_";
 var TASK_ENDPOINTS2 = {
   CREATE_GENERIC_TASK: `${ORCHESTRATOR_BASE2}/tasks/GenericTasks/CreateTask`,
   GET_TASK_USERS: (folderId) => `${ORCHESTRATOR_BASE2}/odata/Tasks/UiPath.Server.Configuration.OData.GetTaskUsers(organizationUnitId=${folderId})`,
@@ -16623,6 +17384,9 @@ var TASK_NOTE_ENDPOINTS2 = {
   GET_BY_TASK_ID: (taskId) => `${ORCHESTRATOR_BASE2}/odata/TaskNotes/UiPath.Server.Configuration.OData.GetByTaskId(taskId=${taskId})`,
   CREATE: `${ORCHESTRATOR_BASE2}/odata/TaskNotes/UiPath.Server.Configuration.OData.CreateTaskNote`
 };
+var IDENTITY_ENDPOINTS2 = {
+  AUTHORIZE: `${IDENTITY_BASE2}/connect/authorize`
+};
 var TASK_TYPE_ENDPOINTS2 = {
   [TaskType2.Form]: TASK_ENDPOINTS2.GET_TASK_FORM_BY_ID,
   [TaskType2.App]: TASK_ENDPOINTS2.GET_APP_TASK_BY_ID,
@@ -17644,48 +18408,246 @@ class PaginationManager2 {
     return result;
   }
 }
-function missingConfigMessage2() {
+var UiPathMetaTags2;
+(function(UiPathMetaTags3) {
+  UiPathMetaTags3["CLIENT_ID"] = "uipath:client-id";
+  UiPathMetaTags3["SCOPE"] = "uipath:scope";
+  UiPathMetaTags3["ORG_NAME"] = "uipath:org-name";
+  UiPathMetaTags3["ORG_ID"] = "uipath:org-id";
+  UiPathMetaTags3["TENANT_NAME"] = "uipath:tenant-name";
+  UiPathMetaTags3["BASE_URL"] = "uipath:base-url";
+  UiPathMetaTags3["REDIRECT_URI"] = "uipath:redirect-uri";
+  UiPathMetaTags3["CDN_BASE"] = "uipath:cdn-base";
+  UiPathMetaTags3["APP_BASE"] = "uipath:app-base";
+  UiPathMetaTags3["FOLDER_KEY"] = "uipath:folder-key";
+})(UiPathMetaTags2 || (UiPathMetaTags2 = {}));
+var UiPathElementIds2;
+(function(UiPathElementIds3) {
+  UiPathElementIds3["RESOURCE_OVERRIDES"] = "uipath-overrides";
+})(UiPathElementIds2 || (UiPathElementIds2 = {}));
+function missingConfigMessage2(found, context) {
   if (isBrowser2) {
     return "UiPath SDK configuration not found. " + "Ensure @uipath/coded-apps plugin is set up in your bundler to inject configuration during development and build.";
   }
-  return "UiPath SDK configuration not found. " + "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+  const guidance = "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+  return `UiPath SDK configuration not found. ${guidance}`;
+}
+UiPathMetaTags2.CLIENT_ID, UiPathMetaTags2.REDIRECT_URI, UiPathMetaTags2.SCOPE;
+var BASE64URL_DASH_RE2 = /-/g;
+var BASE64URL_UNDERSCORE_RE2 = /_/g;
+function base64UrlToBase642(value) {
+  const base642 = value.replace(BASE64URL_DASH_RE2, "+").replace(BASE64URL_UNDERSCORE_RE2, "/");
+  return base642.padEnd(base642.length + (4 - base642.length % 4) % 4, "=");
+}
+function decodeJwtClaims2(token) {
+  try {
+    const payload = token?.split(".")[1];
+    if (!payload) {
+      return;
+    }
+    return JSON.parse(decodeBase642(base64UrlToBase642(payload)));
+  } catch {
+    return;
+  }
+}
+var _OrganizationIdResolver_instances2;
+var _OrganizationIdResolver_organizationId2;
+var _OrganizationIdResolver_resolve3;
+var GUID_REGEX$12 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DASH_REGEX2 = /-/g;
+var UNDERSCORE_REGEX2 = /_/g;
+var WHITESPACE_REGEX2 = /\s+/g;
+var ORGANIZATION_LOOKUP_CLIENT_ID2 = "1119a927-10ab-4543-bd1a-ad6bfbbc27f4";
+var ORGANIZATION_LOOKUP_REDIRECT_PATH2 = "portal_/api/tokenFactory/callback";
+var UNREGISTERED_ORGANIZATION_PATH2 = "/portal_/unregistered";
+var TENANT_ACR_PREFIX2 = "tenant:";
+var MAX_REDIRECT_HOPS2 = 3;
+var IDENTITY_ERROR_ID_PARAM2 = "errorId";
+var IDENTITY_ERROR_CODE_PARAM2 = "errorCode";
+var BODY_SNIPPET_LENGTH2 = 160;
+var CONFIG_HINT2 = "Set `organizationId` in the SDK configuration.";
+function isAuthorizeRequest2(url) {
+  return url.pathname.endsWith(`/${IDENTITY_ENDPOINTS2.AUTHORIZE}`);
+}
+function withoutQuery2(url) {
+  const parsed = new URL(url);
+  return `${parsed.origin}${parsed.pathname}`;
+}
+function readIdentityError2(url) {
+  const errorId = url.searchParams.get(IDENTITY_ERROR_ID_PARAM2);
+  if (errorId) {
+    try {
+      const base642 = errorId.replace(DASH_REGEX2, "+").replace(UNDERSCORE_REGEX2, "/");
+      const json = decodeBase642(base642.padEnd(base642.length + (4 - base642.length % 4) % 4, "="));
+      const data = JSON.parse(json).Data;
+      const error = typeof data?.Error === "string" ? data.Error : undefined;
+      const description = typeof data?.ErrorDescription === "string" ? data.ErrorDescription : undefined;
+      if (error) {
+        return description ? `${error} (${description})` : error;
+      }
+    } catch {
+      return url.searchParams.get(IDENTITY_ERROR_CODE_PARAM2) ?? undefined;
+    }
+  }
+  return url.searchParams.get(IDENTITY_ERROR_CODE_PARAM2) ?? undefined;
+}
+async function describeResponse2(response) {
+  const body = (await response.text().catch(() => "")).replace(WHITESPACE_REGEX2, " ").trim();
+  return body ? `HTTP ${response.status}: ${body.slice(0, BODY_SNIPPET_LENGTH2)}` : `HTTP ${response.status}`;
+}
+function randomUrlSafeToken2() {
+  return `${crypto.randomUUID()}${crypto.randomUUID()}`.replace(DASH_REGEX2, "");
+}
+function tracingHeaders2() {
+  const traceId = crypto.randomUUID().replace(DASH_REGEX2, "");
+  const spanId = crypto.randomUUID().replace(DASH_REGEX2, "").slice(0, 16);
+  const traceparent = `00-${traceId}-${spanId}-01`;
+  return { [TRACEPARENT2]: traceparent, [UIPATH_TRACEPARENT_ID2]: traceparent };
+}
+function buildAuthorizeUrl2(baseUrl, orgName) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: ORGANIZATION_LOOKUP_CLIENT_ID2,
+    redirect_uri: `${baseUrl}/${ORGANIZATION_LOOKUP_REDIRECT_PATH2}`,
+    scope: "openid",
+    code_challenge: randomUrlSafeToken2(),
+    code_challenge_method: "S256",
+    state: randomUrlSafeToken2(),
+    acr_values: `tenantName:${orgName}`
+  });
+  return `${baseUrl}/${IDENTITY_ENDPOINTS2.AUTHORIZE}?${params.toString()}`;
+}
+function extractOrganizationId2(location) {
+  const acrValues = [location.searchParams.get("acr_values")];
+  const returnUrl = location.searchParams.get("returnUrl");
+  if (returnUrl) {
+    acrValues.push(new URL(returnUrl, location.origin).searchParams.get("acr_values"));
+  }
+  for (const acr of acrValues) {
+    for (const token of acr?.split(" ") ?? []) {
+      if (token.startsWith(TENANT_ACR_PREFIX2)) {
+        const candidate = token.slice(TENANT_ACR_PREFIX2.length);
+        if (GUID_REGEX$12.test(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+  return;
+}
+async function lookupOrganizationIdForPat2(baseUrl, orgName) {
+  let url = buildAuthorizeUrl2(baseUrl, orgName);
+  for (let hop = 0;hop < MAX_REDIRECT_HOPS2; hop++) {
+    const response = await fetchWithRetry2(url, { redirect: "manual", headers: tracingHeaders2() }, { retry: DEFAULT_RETRY_OPTIONS2 });
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new ValidationError2({
+        message: `Could not resolve the organization id for '${orgName}': Identity answered ` + `${await describeResponse2(response)} instead of redirecting. ${CONFIG_HINT2}`
+      });
+    }
+    const target = new URL(location, url);
+    const organizationId = extractOrganizationId2(target);
+    if (organizationId) {
+      return organizationId;
+    }
+    if (target.pathname.startsWith(UNREGISTERED_ORGANIZATION_PATH2)) {
+      throw new ValidationError2({ message: `Organization '${orgName}' was not found at ${baseUrl}.` });
+    }
+    const identityError = readIdentityError2(target);
+    if (identityError) {
+      throw new ValidationError2({
+        message: `Could not resolve the organization id for '${orgName}': Identity rejected the lookup ` + `with ${identityError}. ${CONFIG_HINT2}`
+      });
+    }
+    url = isAuthorizeRequest2(target) ? buildAuthorizeUrl2(target.origin, orgName) : target.toString();
+  }
+  throw new ValidationError2({
+    message: `Could not resolve the organization id for '${orgName}': gave up after ${MAX_REDIRECT_HOPS2} ` + `redirects (last: ${withoutQuery2(url)}). ${CONFIG_HINT2}`
+  });
+}
+
+class OrganizationIdResolver2 {
+  constructor(config2, tokenManager) {
+    _OrganizationIdResolver_instances2.add(this);
+    this.config = config2;
+    this.tokenManager = tokenManager;
+    _OrganizationIdResolver_organizationId2.set(this, undefined);
+  }
+  resolve() {
+    if (!__classPrivateFieldGet2(this, _OrganizationIdResolver_organizationId2, "f")) {
+      __classPrivateFieldSet2(this, _OrganizationIdResolver_organizationId2, __classPrivateFieldGet2(this, _OrganizationIdResolver_instances2, "m", _OrganizationIdResolver_resolve3).call(this).catch((error) => {
+        __classPrivateFieldSet2(this, _OrganizationIdResolver_organizationId2, undefined, "f");
+        throw error;
+      }), "f");
+    }
+    return __classPrivateFieldGet2(this, _OrganizationIdResolver_organizationId2, "f");
+  }
 }
+_OrganizationIdResolver_organizationId2 = new WeakMap, _OrganizationIdResolver_instances2 = new WeakSet, _OrganizationIdResolver_resolve3 = async function _OrganizationIdResolver_resolve4() {
+  const { organizationId, orgName, baseUrl } = this.config;
+  if (organizationId) {
+    return organizationId;
+  }
+  if (GUID_REGEX$12.test(orgName)) {
+    return orgName;
+  }
+  const claimed = decodeJwtClaims2(this.tokenManager.getToken())?.prt_id;
+  if (typeof claimed === "string" && GUID_REGEX$12.test(claimed)) {
+    return claimed;
+  }
+  return lookupOrganizationIdForPat2(baseUrl, orgName);
+};
 var REGISTRY_KEY3 = Symbol.for("@uipath/sdk-internals-registry");
+var UNCONFIGURED_KEY2 = Symbol.for("@uipath/sdk-unconfigured-reason");
+var globalStores2 = () => globalThis;
 var getGlobalStore2 = () => {
-  const globalObj = globalThis;
-  if (!globalObj[REGISTRY_KEY3]) {
-    globalObj[REGISTRY_KEY3] = new WeakMap;
-  }
-  return globalObj[REGISTRY_KEY3];
+  var _a2;
+  return (_a2 = globalStores2())[REGISTRY_KEY3] ?? (_a2[REGISTRY_KEY3] = new WeakMap);
+};
+var getUnconfiguredStore2 = () => {
+  var _a2;
+  return (_a2 = globalStores2())[UNCONFIGURED_KEY2] ?? (_a2[UNCONFIGURED_KEY2] = new WeakMap);
 };
 var looksLikeUiPath2 = (instance) => typeof instance.initialize === "function";
 
 class SDKInternalsRegistry2 {
-  static get store() {
-    return getGlobalStore2();
-  }
   static set(instance, internals) {
     this.store.set(instance, internals);
   }
+  static setUnconfigured(instance, reason) {
+    this.unconfigured.set(instance, reason);
+  }
   static get(instance) {
     const internals = this.store.get(instance);
     if (!internals) {
-      if (looksLikeUiPath2(instance)) {
-        throw new Error("Cannot create a service: the UiPath instance was never configured. " + missingConfigMessage2());
+      const reason = this.unconfigured.get(instance);
+      if (reason !== undefined || looksLikeUiPath2(instance)) {
+        throw new Error("Cannot create a service: the UiPath instance was never configured. " + (reason ?? missingConfigMessage2()));
       }
       throw new Error("Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.");
     }
     return internals;
   }
+  static getOrganizationIdResolver(instance) {
+    const internals = this.get(instance);
+    internals.organizationIdResolver ?? (internals.organizationIdResolver = new OrganizationIdResolver2(internals.config, internals.tokenManager));
+    return internals.organizationIdResolver;
+  }
+  static get store() {
+    return getGlobalStore2();
+  }
+  static get unconfigured() {
+    return getUnconfiguredStore2();
+  }
 }
 var _BaseService_apiClient2;
 
 class BaseService2 {
   constructor(instance, headers) {
     _BaseService_apiClient2.set(this, undefined);
-    const { config: config2, context, tokenManager, folderKey } = SDKInternalsRegistry2.get(instance);
+    const { config: config2, context, tokenManager, folderKey, metaFolderKey } = SDKInternalsRegistry2.get(instance);
     __classPrivateFieldSet2(this, _BaseService_apiClient2, new ApiClient2(config2, context, tokenManager, headers ? { headers } : {}), "f");
-    this.config = { folderKey };
+    this.config = { folderKey, metaFolderKey };
   }
   async getValidAuthToken() {
     return __classPrivateFieldGet2(this, _BaseService_apiClient2, "f").getValidToken();
@@ -17774,7 +18736,7 @@ class BaseService2 {
         limitedPageSize = getLimitedPageSize2(params.pageSize);
         const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS2.PAGE_SIZE_PARAM;
         const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS2.OFFSET_PARAM;
-        const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS2.COUNT_PARAM;
+        const countParam = paginationParams && "countParam" in paginationParams ? paginationParams.countParam : ODATA_OFFSET_PARAMS2.COUNT_PARAM;
         const convertToSkip = paginationParams?.convertToSkip ?? true;
         const zeroBased = paginationParams?.zeroBased ?? false;
         requestParams[pageSizeParam] = limitedPageSize;
@@ -17786,7 +18748,7 @@ class BaseService2 {
           const sdkPageNumber = params.pageNumber || 1;
           requestParams[offsetParam] = zeroBased ? sdkPageNumber - 1 : sdkPageNumber;
         }
-        {
+        if (countParam) {
           requestParams[countParam] = true;
         }
         break;
@@ -17860,22 +18822,6 @@ function validateName2(resourceType, name) {
   return trimmed;
 }
 var GUID_REGEX2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var UiPathMetaTags2;
-(function(UiPathMetaTags3) {
-  UiPathMetaTags3["CLIENT_ID"] = "uipath:client-id";
-  UiPathMetaTags3["SCOPE"] = "uipath:scope";
-  UiPathMetaTags3["ORG_NAME"] = "uipath:org-name";
-  UiPathMetaTags3["TENANT_NAME"] = "uipath:tenant-name";
-  UiPathMetaTags3["BASE_URL"] = "uipath:base-url";
-  UiPathMetaTags3["REDIRECT_URI"] = "uipath:redirect-uri";
-  UiPathMetaTags3["CDN_BASE"] = "uipath:cdn-base";
-  UiPathMetaTags3["APP_BASE"] = "uipath:app-base";
-  UiPathMetaTags3["FOLDER_KEY"] = "uipath:folder-key";
-})(UiPathMetaTags2 || (UiPathMetaTags2 = {}));
-var UiPathElementIds2;
-(function(UiPathElementIds3) {
-  UiPathElementIds3["RESOURCE_OVERRIDES"] = "uipath-overrides";
-})(UiPathElementIds2 || (UiPathElementIds2 = {}));
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -17984,7 +18930,7 @@ class FolderScopedService2 extends BaseService2 {
     });
     const items = response.data?.value;
     if (!items?.length) {
-      const folderHint = describeFolderForError2(folderId, folderKey, resolvedFolderPath);
+      const folderHint = describeFolderForError2(folderId, headers[FOLDER_KEY2], resolvedFolderPath);
       throw new NotFoundError2({
         message: `${resourceType} '${resolvedName}' not found${folderHint}.`
       });
@@ -18597,11 +19543,11 @@ async function resolveFolderScope(options) {
     return parseIntArg(options.folderId, "--folder-id");
   }
   if (options.folderKey !== undefined) {
-    const { resolveFolderIdByKey } = await import("./folder-resolver-x3tk8v3w.js");
+    const { resolveFolderIdByKey } = await import("./folder-resolver-m2j9csxn.js");
     return resolveFolderIdByKey(options.folderKey, options.tenant);
   }
   if (options.folderPath !== undefined) {
-    const { resolveFolderIdByPath } = await import("./folder-resolver-x3tk8v3w.js");
+    const { resolveFolderIdByPath } = await import("./folder-resolver-m2j9csxn.js");
     return resolveFolderIdByPath(options.folderPath, options.tenant);
   }
   return;
@@ -18621,7 +19567,7 @@ async function resolveFolderId(options, missingFolderInstructions = DEFAULT_FOLD
     processContext.exit(1);
     return null;
   }
-  const { pickFolderInteractively } = await import("./folder-picker-interactive-sxhrahj5.js");
+  const { pickFolderInteractively } = await import("./folder-picker-interactive-2x6yr0wh.js");
   return pickFolderInteractively(options.tenant);
 }
 
@@ -19443,4 +20389,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=1E6B5B1756648EEB64756E2164756E21
+//# debugId=9BD45B63674E541364756E2164756E21