@uipath/solution-sdk 1.204.0 → 1.205.0-preview.258

package/dist/resources/index.js

@@ -7,26 +7,31 @@ import {
 import {
   FirstPartyServiceApi
 } from "../index-53w8skv5.js";
+import {
+  findSolutionFileUpward,
+  normalizeProjectType,
+  toPortableRelativePath
+} from "../index-zmneg45c.js";
+import {
+  getSolutionAuthContext
+} from "../index-cs3g624n.js";
 import {
   addSdkUserAgentHeader,
   catchError,
   extractErrorMessage,
-  findSolutionFileUpward,
   getSdkUserAgentToken,
   installSdkUserAgentHeader,
   isGuid,
-  logger,
-  normalizeProjectType,
-  toPortableRelativePath
-} from "../index-fb21bjwj.js";
+  logger
+} from "../index-enc2hqq5.js";
 import {
   getAuthContext,
   getLoginStatusAsync,
-  getSolutionAuthContext
-} from "../index-6gp5j7j5.js";
+  resolveSessionIdentity
+} from "../index-hkexw5er.js";
 import {
   getFileSystem
-} from "../index-g0hcxnae.js";
+} from "../index-y4vgqz1w.js";
 import {
   __commonJS,
   __require,
@@ -3334,6 +3339,19 @@ class NullSecretsProvider {
   }
 }
 
+// ../../node_modules/@uipath/resource-builder-sdk/dist/providers/feature-flag-provider.js
+class NullFeatureFlagProvider {
+  getBool(_featureFlagName, defaultValue) {
+    return defaultValue ?? false;
+  }
+  getInt(_featureFlagName, defaultValue) {
+    return defaultValue ?? 0;
+  }
+  getString(_featureFlagName, defaultValue) {
+    return defaultValue ?? "";
+  }
+}
+
 // ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/timeout-exception.js
 class TimeoutException extends Error {
   constructor(message, timeoutMs) {
@@ -3488,10 +3506,12 @@ function withFileOperationTimeout2(provider, timeoutMs) {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/solution-context-options.js
 var DEFAULT_SOLUTION_CONTEXT_OPTIONS = {
   lockTimeoutMs: 30000,
-  fileOperationTimeoutMs: 30000
+  fileOperationTimeoutMs: 30000,
+  maxDegreeOfParallelism: 1
 };
 var SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY = "SOL_RB_SOLUTION_CONTEXT_TIMEOUT_MS";
 var FILE_OPERATION_TIMEOUT_STORAGE_KEY = "SOL_RB_FILE_OPERATION_TIMEOUT_MS";
+var MAX_DEGREE_OF_PARALLELISM_STORAGE_KEY = "SOL_RB_MAX_DEGREE_OF_PARALLELISM";
 function resolveTimeoutMs(storageKey, configured, fallback) {
   const override = readTimeoutOverrideMs(storageKey);
   if (override !== undefined)
@@ -3504,10 +3524,33 @@ function resolveLockTimeoutMs(options) {
 function resolveFileOperationTimeoutMs(options) {
   return resolveTimeoutMs(FILE_OPERATION_TIMEOUT_STORAGE_KEY, options?.fileOperationTimeoutMs, DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs);
 }
+function isValidDegreeOfParallelism(value) {
+  return typeof value == "number" && Number.isInteger(value) && value > 0;
+}
+function resolveMaxDegreeOfParallelism(options) {
+  const override = readDegreeOfParallelismOverride(MAX_DEGREE_OF_PARALLELISM_STORAGE_KEY);
+  if (override !== undefined)
+    return override;
+  return isValidDegreeOfParallelism(options?.maxDegreeOfParallelism) ? options.maxDegreeOfParallelism : DEFAULT_SOLUTION_CONTEXT_OPTIONS.maxDegreeOfParallelism;
+}
+function readDegreeOfParallelismOverride(storageKey) {
+  try {
+    if ("u" < typeof localStorage)
+      return;
+    const raw = localStorage.getItem(storageKey);
+    if (raw === null || raw.trim() === "")
+      return;
+    const parsed = Number(raw);
+    return isValidDegreeOfParallelism(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
 function mergeSolutionContextOptions(options) {
   return {
     lockTimeoutMs: isValidTimeoutMs(options?.lockTimeoutMs) ? options.lockTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.lockTimeoutMs,
-    fileOperationTimeoutMs: isValidTimeoutMs(options?.fileOperationTimeoutMs) ? options.fileOperationTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs
+    fileOperationTimeoutMs: isValidTimeoutMs(options?.fileOperationTimeoutMs) ? options.fileOperationTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs,
+    maxDegreeOfParallelism: isValidDegreeOfParallelism(options?.maxDegreeOfParallelism) ? options.maxDegreeOfParallelism : DEFAULT_SOLUTION_CONTEXT_OPTIONS.maxDegreeOfParallelism
   };
 }
 
@@ -4298,6 +4341,16 @@ function getRootFolder(solution) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/multi-file-solution-definition-provider.js
+function nowMs() {
+  return globalThis.performance?.now?.() ?? Date.now();
+}
+function round1(ms) {
+  return Math.round(10 * ms) / 10;
+}
+function cancellationError(signal) {
+  return signal?.reason instanceof OperationCancelledException ? signal.reason : new OperationCancelledException;
+}
+
 class MultiFileSolutionDefinitionProvider {
   get caseInsensitiveSerializer() {
     if (!this._caseInsensitiveSerializer)
@@ -4315,137 +4368,344 @@ class MultiFileSolutionDefinitionProvider {
   }
   async readAsync(context, cancellationToken) {
     this.logger.info("Reading multi-file solution definition for solution %s", context.path);
-    const solutionKey = this.getSolutionKey(context);
-    const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
-    const resources = [];
-    const solutionFiles = [];
-    let hashes;
-    let paths;
-    const pathsByKind = this.getPathsByKind(context);
-    let tree;
-    pathsByKind.clear();
+    const loadStarted = nowMs();
+    let fileCount = 0;
+    let listMs = 0;
+    let readStarted = loadStarted;
+    let readWallMs = 0;
+    let readCompleted = false;
+    let ioMs = 0;
+    let maxFileIoMs = 0;
+    let parseMs = 0;
+    let hashMs = 0;
+    let chars = 0;
+    let loadedCount = 0;
     const parseErrors = [];
     const missingFiles = [];
     const invalidFiles = [];
-    context.items[SolutionContextKeys.PARSE_ERRORS_ITEM_KEY] = parseErrors;
-    if (!context.isReadOnly) {
-      hashes = this.getHashes(context);
-      paths = this.getPaths(context);
-      tree = this.getTree(context);
-      hashes.clear();
-      paths.clear();
-      tree.length = 0;
-    }
-    const resourceFiles = await fileStorageProvider.getFilesAsync(SolutionConstants.RESOURCE_FILES_FOLDER_NAME, "*.json", cancellationToken);
-    for (const resourceFile of resourceFiles)
-      try {
-        const stream = await fileStorageProvider.openFileAsync(resourceFile, cancellationToken);
-        const content = await this.streamToString(stream);
-        const wrapper = this.caseInsensitiveSerializer.deserialize(content);
-        if (wrapper?.resource) {
-          const rd = this.fromSerializable(wrapper.resource, solutionFiles);
-          const relPath = resourceFile.replace(/\\/g, "/");
-          const segments = relPath.split("/").filter((s) => s.length > 0);
-          const firstSegment = segments[0];
-          if (segments.length >= 3 && firstSegment && firstSegment.toLowerCase() === SolutionConstants.RESOURCE_FILES_FOLDER_NAME.toLowerCase()) {
-            const hasType = !!rd.type;
-            const folderSegmentCount = hasType ? segments.length - 3 : segments.length - 2;
-            if (folderSegmentCount < 1)
-              rd.folders = [
-                {
-                  fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
-                }
-              ];
-            else {
-              const segmentsToUse = segments.slice(1, folderSegmentCount);
-              const folderFqn = segmentsToUse.join("/");
-              rd.folders = [
-                {
-                  fullyQualifiedName: folderFqn
-                }
-              ];
+    let metricsLogged = false;
+    const logReadMetrics = (outcome) => {
+      metricsLogged = true;
+      const totalMs = nowMs() - loadStarted;
+      const mergeMs = readCompleted ? nowMs() - readStarted - readWallMs : 0;
+      const metrics = {
+        outcome,
+        path: context.path,
+        fileCount,
+        totalMs: round1(totalMs),
+        listMs: round1(listMs),
+        readWallMs: round1(readWallMs),
+        ioMs: round1(ioMs),
+        maxFileIoMs: round1(maxFileIoMs),
+        parseMs: round1(parseMs),
+        hashMs: round1(hashMs),
+        mergeMs: round1(mergeMs),
+        chars,
+        degreeOfParallelism: resolveMaxDegreeOfParallelism(this.options),
+        isReadOnly: context.isReadOnly,
+        loaded: loadedCount,
+        missing: missingFiles.length,
+        invalid: invalidFiles.length,
+        parseErrors: parseErrors.length
+      };
+      const message = `Solution read ${outcome} for solution ${context.path}: ${metrics.fileCount} files in ${metrics.totalMs} ms (list ${metrics.listMs} ms, read ${metrics.readWallMs} ms wall, io ${metrics.ioMs} ms summed, max file io ${metrics.maxFileIoMs} ms, parse ${metrics.parseMs} ms, hash ${metrics.hashMs} ms, merge ${metrics.mergeMs} ms); ${metrics.chars} chars; parallelism ${metrics.degreeOfParallelism}; readOnly ${metrics.isReadOnly}; loaded ${metrics.loaded}, missing ${metrics.missing}, invalid ${metrics.invalid}, parseErrors ${metrics.parseErrors}`;
+      if (outcome === "Success")
+        this.logger.info(message, metrics);
+      else
+        this.logger.warn(message, metrics);
+    };
+    const readCore = async () => {
+      const solutionKey = this.getSolutionKey(context);
+      const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
+      const resources = [];
+      const solutionFiles = [];
+      let hashes;
+      let paths;
+      const pathsByKind = this.getPathsByKind(context);
+      let tree;
+      pathsByKind.clear();
+      context.items[SolutionContextKeys.PARSE_ERRORS_ITEM_KEY] = parseErrors;
+      if (!context.isReadOnly) {
+        hashes = this.getHashes(context);
+        paths = this.getPaths(context);
+        tree = this.getTree(context);
+        hashes.clear();
+        paths.clear();
+        tree.length = 0;
+      }
+      const listStarted = nowMs();
+      const resourceFiles = await fileStorageProvider.getFilesAsync(SolutionConstants.RESOURCE_FILES_FOLDER_NAME, "*.json", cancellationToken);
+      listMs = nowMs() - listStarted;
+      fileCount = resourceFiles.length;
+      readStarted = nowMs();
+      const readResults = await this.readResourceFilesAsync(context, fileStorageProvider, resourceFiles, cancellationToken);
+      readWallMs = nowMs() - readStarted;
+      readCompleted = true;
+      let fatal;
+      let hasFatal = false;
+      for (const result of readResults)
+        if (result !== undefined) {
+          if (result.timings) {
+            ioMs += result.timings.ioMs;
+            maxFileIoMs = Math.max(maxFileIoMs, result.timings.ioMs);
+            parseMs += result.timings.parseMs;
+            hashMs += result.timings.hashMs;
+            chars += result.timings.chars;
+          }
+          if (result.fatal !== undefined) {
+            if (!hasFatal) {
+              fatal = result.fatal;
+              hasFatal = true;
             }
-          } else
-            rd.folders = [
-              {
-                fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+            continue;
+          }
+          if (!hasFatal)
+            switch (result.outcome) {
+              case "loaded": {
+                loadedCount++;
+                const rd = result.resource;
+                for (const file of result.files)
+                  if (!solutionFiles.some((sf) => sf.name === file.name && sf.kind === file.kind))
+                    solutionFiles.push(file);
+                resources.push(rd);
+                const resourceKey = rd.key;
+                const normalizedFullPath = result.normalizedPath;
+                if (!pathsByKind.has(rd.kind))
+                  pathsByKind.set(rd.kind, []);
+                const kindPaths = pathsByKind.get(rd.kind);
+                if (kindPaths)
+                  kindPaths.push({
+                    name: rd.name,
+                    key: rd.key,
+                    path: normalizedFullPath
+                  });
+                if (!context.isReadOnly && hashes && paths) {
+                  paths.set(resourceKey, normalizedFullPath);
+                  hashes.set(resourceKey, result.hash);
+                }
+                break;
               }
-            ];
-          resources.push(rd);
-          const resourceKey = rd.key;
-          const normalizedFullPath = this.getNormalizedPath(resourceFile);
-          if (!pathsByKind.has(rd.kind))
-            pathsByKind.set(rd.kind, []);
-          const kindPaths = pathsByKind.get(rd.kind);
-          if (kindPaths)
-            kindPaths.push({
-              name: rd.name,
-              key: rd.key,
-              path: normalizedFullPath
+              case "missing":
+                missingFiles.push(result.file);
+                break;
+              case "invalid":
+                invalidFiles.push(result.file);
+                break;
+              case "parseError":
+                parseErrors.push(result.file);
+                break;
+            }
+        }
+      if (hasFatal) {
+        logReadMetrics("Fatal");
+        throw fatal;
+      }
+      if (missingFiles.length > 0) {
+        logReadMetrics("MissingFiles");
+        throw new BadRequestException(ErrorCodes.Resources.MissingFileDependencies, `Solution has missing files: ${missingFiles.join(", ")}`);
+      }
+      if (invalidFiles.length > 0) {
+        logReadMetrics("InvalidFiles");
+        throw new BadRequestException(ErrorCodes.Resources.InvalidResourceFile, `Solution has resource files with invalid content: ${invalidFiles.join(", ")}`);
+      }
+      if (parseErrors.length > 0) {
+        logReadMetrics("ParseErrors");
+        throw new Error(`Failed to read resource files for solution ${context.path}: ${parseErrors.join(", ")}`);
+      }
+      const folderMap = new Map;
+      const rootFolder = this.buildRootFolder(solutionKey, SolutionConstants.ROOT_FOLDER_NAME);
+      folderMap.set(rootFolder.fullyQualifiedName.toLowerCase(), rootFolder);
+      for (const res of resources)
+        for (const fdep of res.folders ?? []) {
+          const fqnLower = fdep.fullyQualifiedName.toLowerCase();
+          if (!folderMap.has(fqnLower)) {
+            const folderKey = this.generateGuidFromString(fdep.fullyQualifiedName);
+            const pathSegments = fdep.fullyQualifiedName.split("/").filter((s) => s.length > 0).map((p) => {
+              if (p.toLowerCase() !== SolutionConstants.ROOT_FOLDER_NAME.toLowerCase())
+                return this.generateGuidFromString(SolutionConstants.ROOT_FOLDER_NAME);
+              return rootFolder.key;
+            });
+            const folderPath = pathSegments.join(".");
+            folderMap.set(fqnLower, {
+              key: folderKey,
+              fullyQualifiedName: fdep.fullyQualifiedName,
+              path: folderPath
             });
-          if (!context.isReadOnly && hashes && paths) {
-            paths.set(resourceKey, normalizedFullPath);
-            hashes.set(resourceKey, await this.computeHash(content));
           }
-        } else {
-          this.logger.error("Failed to read resource file %s for solution %s: invalid content", undefined, resourceFile, context.path);
-          invalidFiles.push(resourceFile);
-        }
-      } catch (ex) {
-        if (ex instanceof OperationCancelledException || cancellationToken?.aborted) {
-          this.logger.warn("Operation cancelled while reading file %s for solution %s", resourceFile, context.path);
-          throw ex instanceof OperationCancelledException ? ex : new OperationCancelledException;
-        }
-        if (ex instanceof TimeoutException)
-          throw new TimeoutException(`Reading resource file ${resourceFile} for solution ${context.path} timed out: ${ex.message}`, ex.timeoutMs);
-        if (isFileNotFoundError(ex)) {
-          this.logger.warn("Resource file listed but missing in storage for solution %s: %s", resourceFile, context.path);
-          missingFiles.push(resourceFile);
-        } else {
-          this.logger.error("Failed to read resource file %s for solution %s", ex, resourceFile, context.path);
-          parseErrors.push(resourceFile);
         }
+      const solution = {
+        key: solutionKey,
+        docVersion: SolutionConstants.CURRENT_DOC_VERSION,
+        folders: Array.from(folderMap.values()),
+        resources,
+        files: solutionFiles
+      };
+      await this.replaceDuplicateKeysAsync(solution, cancellationToken);
+      if (!context.isReadOnly && tree) {
+        const orderedResourceKeys = getTopologicalIdsOrdering(buildDependencyGraph(solution.resources));
+        tree.push(...orderedResourceKeys);
       }
-    if (missingFiles.length > 0)
-      throw new BadRequestException(ErrorCodes.Resources.MissingFileDependencies, `Solution has missing files: ${missingFiles.join(", ")}`);
-    if (invalidFiles.length > 0)
-      throw new BadRequestException(ErrorCodes.Resources.InvalidResourceFile, `Solution has resource files with invalid content: ${invalidFiles.join(", ")}`);
-    if (parseErrors.length > 0)
-      throw new Error(`Failed to read resource files for solution ${context.path}: ${parseErrors.join(", ")}`);
-    const folderMap = new Map;
-    const rootFolder = this.buildRootFolder(solutionKey, SolutionConstants.ROOT_FOLDER_NAME);
-    folderMap.set(rootFolder.fullyQualifiedName.toLowerCase(), rootFolder);
-    for (const res of resources)
-      for (const fdep of res.folders ?? []) {
-        const fqnLower = fdep.fullyQualifiedName.toLowerCase();
-        if (!folderMap.has(fqnLower)) {
-          const folderKey = this.generateGuidFromString(fdep.fullyQualifiedName);
-          const pathSegments = fdep.fullyQualifiedName.split("/").filter((s) => s.length > 0).map((p) => {
-            if (p.toLowerCase() !== SolutionConstants.ROOT_FOLDER_NAME.toLowerCase())
-              return this.generateGuidFromString(SolutionConstants.ROOT_FOLDER_NAME);
-            return rootFolder.key;
-          });
-          const folderPath = pathSegments.join(".");
-          folderMap.set(fqnLower, {
-            key: folderKey,
-            fullyQualifiedName: fdep.fullyQualifiedName,
-            path: folderPath
-          });
-        }
+      logReadMetrics("Success");
+      return solution;
+    };
+    try {
+      return await readCore();
+    } catch (ex) {
+      if (!metricsLogged)
+        logReadMetrics("Fatal");
+      throw ex;
+    }
+  }
+  async readResourceFilesAsync(context, fileStorageProvider, resourceFiles, cancellationToken) {
+    const results = Array.from({
+      length: resourceFiles.length
+    }, () => {
+      return;
+    });
+    if (resourceFiles.length === 0)
+      return results;
+    const computeHash = !context.isReadOnly;
+    const degreeOfParallelism = Math.min(resolveMaxDegreeOfParallelism(this.options), resourceFiles.length);
+    let nextIndex = 0;
+    let stopRequested = false;
+    const runWorkerAsync = async () => {
+      while (!stopRequested && nextIndex < resourceFiles.length) {
+        const index = nextIndex++;
+        const resourceFile = resourceFiles[index];
+        const result = await this.readResourceFileAsync(context, fileStorageProvider, resourceFile, computeHash, cancellationToken);
+        results[index] = result;
+        if (result.fatal !== undefined)
+          stopRequested = true;
       }
-    const solution = {
-      key: solutionKey,
-      docVersion: SolutionConstants.CURRENT_DOC_VERSION,
-      folders: Array.from(folderMap.values()),
-      resources,
-      files: solutionFiles
     };
-    await this.replaceDuplicateKeysAsync(solution, cancellationToken);
-    if (!context.isReadOnly && tree) {
-      const orderedResourceKeys = getTopologicalIdsOrdering(buildDependencyGraph(solution.resources));
-      tree.push(...orderedResourceKeys);
+    const workers = [];
+    for (let i = 0;i < degreeOfParallelism; i++)
+      workers.push(runWorkerAsync());
+    await Promise.all(workers);
+    if (cancellationToken?.aborted && !results.some((result) => result?.fatal !== undefined))
+      throw cancellationError(cancellationToken);
+    return results;
+  }
+  async readResourceFileAsync(context, fileStorageProvider, resourceFile, computeHash, cancellationToken) {
+    const started = nowMs();
+    let ioMs;
+    let content;
+    const failureTimings = () => {
+      const elapsed = nowMs() - started;
+      return ioMs === undefined ? {
+        ioMs: elapsed,
+        parseMs: 0,
+        hashMs: 0,
+        chars: 0
+      } : {
+        ioMs,
+        parseMs: elapsed - ioMs,
+        hashMs: 0,
+        chars: content?.length ?? 0
+      };
+    };
+    try {
+      if (cancellationToken?.aborted)
+        throw cancellationError(cancellationToken);
+      const stream = await fileStorageProvider.openFileAsync(resourceFile, cancellationToken);
+      content = await this.streamToString(stream);
+      ioMs = nowMs() - started;
+      const parseStarted = nowMs();
+      const wrapper = this.caseInsensitiveSerializer.deserialize(content);
+      if (!wrapper?.resource) {
+        this.logger.error("Failed to read resource file %s for solution %s: invalid content", undefined, resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "invalid",
+          timings: failureTimings()
+        };
+      }
+      const files = [];
+      const rd = this.fromSerializable(wrapper.resource, files);
+      this.applyFolders(rd, resourceFile);
+      const parseMs = nowMs() - parseStarted;
+      let hash;
+      let hashMs = 0;
+      if (computeHash) {
+        const hashStarted = nowMs();
+        hash = await this.computeHash(content);
+        hashMs = nowMs() - hashStarted;
+      }
+      return {
+        file: resourceFile,
+        outcome: "loaded",
+        resource: rd,
+        files,
+        normalizedPath: this.getNormalizedPath(resourceFile),
+        hash,
+        timings: {
+          ioMs,
+          parseMs,
+          hashMs,
+          chars: content.length
+        }
+      };
+    } catch (ex) {
+      if (ex instanceof OperationCancelledException || cancellationToken?.aborted) {
+        this.logger.warn("Operation cancelled while reading file %s for solution %s", resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "fatal",
+          fatal: ex instanceof OperationCancelledException ? ex : cancellationError(cancellationToken),
+          timings: failureTimings()
+        };
+      }
+      if (ex instanceof TimeoutException)
+        return {
+          file: resourceFile,
+          outcome: "fatal",
+          fatal: new TimeoutException(`Reading resource file ${resourceFile} for solution ${context.path} timed out: ${ex.message}`, ex.timeoutMs),
+          timings: failureTimings()
+        };
+      if (isFileNotFoundError(ex)) {
+        this.logger.warn("Resource file listed but missing in storage for solution %s: %s", resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "missing",
+          timings: failureTimings()
+        };
+      }
+      this.logger.error("Failed to read resource file %s for solution %s", ex, resourceFile, context.path);
+      return {
+        file: resourceFile,
+        outcome: "parseError",
+        timings: failureTimings()
+      };
     }
-    return solution;
+  }
+  applyFolders(resource, resourceFile) {
+    const relPath = resourceFile.replace(/\\/g, "/");
+    const segments = relPath.split("/").filter((s) => s.length > 0);
+    const firstSegment = segments[0];
+    if (segments.length >= 3 && firstSegment && firstSegment.toLowerCase() === SolutionConstants.RESOURCE_FILES_FOLDER_NAME.toLowerCase()) {
+      const hasType = !!resource.type;
+      const folderSegmentCount = hasType ? segments.length - 3 : segments.length - 2;
+      if (folderSegmentCount < 1)
+        resource.folders = [
+          {
+            fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+          }
+        ];
+      else {
+        const segmentsToUse = segments.slice(1, folderSegmentCount);
+        const folderFqn = segmentsToUse.join("/");
+        resource.folders = [
+          {
+            fullyQualifiedName: folderFqn
+          }
+        ];
+      }
+    } else
+      resource.folders = [
+        {
+          fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+        }
+      ];
   }
   async writeAsync(context, solution, cancellationToken) {
     if (context.isReadOnly)
@@ -4750,7 +5010,7 @@ class MultiFileSolutionDefinitionFactory {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/embedded-files-default.js
 async function createDefaultEmbeddedFileReaderAsync() {
   const [{ EmbeddedFileReader }, { JsonSerializerFactory: JsonSerializerFactory2 }] = await Promise.all([
-    import("../embedded-file-reader-rf2g1kfj.js"),
+    import("../embedded-file-reader-z4becc02.js"),
     import("../index-dqa169gp.js")
   ]);
   return new EmbeddedFileReader(new JsonSerializerFactory2);
@@ -4768,6 +5028,7 @@ var ServiceTokens = {
   SecretsProvider: "ISecretsProvider",
   FileStorageProviderFactory: "IFileStorageProviderFactory",
   IpRangeBypassSecretProvider: "IIpRangeBypassSecretProvider",
+  FeatureFlagProvider: "IFeatureFlagProvider",
   SolutionDefinitionProvider: "ISolutionDefinitionProvider",
   SolutionDefinitionFactory: "ISolutionDefinitionFactory",
   ArtifactResourceSpecEnhancer: "IArtifactResourceSpecEnhancer",
@@ -5118,6 +5379,9 @@ function getBindingType(resourceKind, resourceType) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/bindings-metadata-serializer.js
+var SUPPORTED_SCHEMA_MAJOR_VERSION = 2;
+var INT32_MAX_VALUE = 2147483647;
+
 class BindingsMetadataSerializer {
   tryDeserialize(input) {
     if (!input)
@@ -5128,30 +5392,52 @@ class BindingsMetadataSerializer {
       let cleanInput = input.charCodeAt(0) === 65279 ? input.slice(1) : input;
       if (cleanInput.charCodeAt(cleanInput.length - 1) === 26)
         cleanInput = cleanInput.slice(0, -1);
-      const jsonObject = JSON.parse(cleanInput);
+      const root = JSON.parse(cleanInput);
+      if (root === null || typeof root != "object" || Array.isArray(root)) {
+        this.logger.warn("Invalid bindings: content is not a JSON object");
+        return {
+          success: false
+        };
+      }
+      const jsonObject = root;
       const versionValue = jsonObject[BindingsKnownKeys.Version];
-      if (!versionValue)
+      if (typeof versionValue != "string") {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Version}' is missing or not a string`);
+        return {
+          success: false
+        };
+      }
+      const majorVersion = BindingsMetadataSerializer.tryParseMajorVersion(versionValue);
+      if (majorVersion === undefined) {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Version}' is not a valid version`);
         return {
           success: false
         };
-      const versionParts = versionValue.split(".").map(Number);
-      const majorVersion = versionParts[0];
-      if (majorVersion !== 2)
-        throw new Error("Unsupported bindings schema");
+      }
+      if (majorVersion !== SUPPORTED_SCHEMA_MAJOR_VERSION) {
+        this.logger.warn(`Invalid bindings: unsupported schema major version ${majorVersion}`);
+        return {
+          success: false
+        };
+      }
+      const resources = jsonObject[BindingsKnownKeys.Resources];
+      if (!Array.isArray(resources)) {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Resources}' is missing or not an array`);
+        return {
+          success: false
+        };
+      }
       const metadata = {
         version: versionValue,
         resources: []
       };
-      const resources = jsonObject[BindingsKnownKeys.Resources];
-      if (Array.isArray(resources))
-        for (const resourceElement of resources) {
-          if (resourceElement == null) {
-            this.logger.warn("Skipping null bindings resource element");
-            continue;
-          }
-          const resource = this.getBindingsResourceV2(resourceElement);
-          metadata.resources.push(resource);
+      for (const resourceElement of resources) {
+        if (resourceElement == null) {
+          this.logger.warn("Skipping null bindings resource element");
+          continue;
         }
+        metadata.resources.push(this.getBindingsResourceV2(resourceElement));
+      }
       this.linkDependencies(metadata.resources);
       return {
         success: true,
@@ -5164,6 +5450,22 @@ class BindingsMetadataSerializer {
       };
     }
   }
+  static tryParseMajorVersion(value) {
+    const parts = value.split(".");
+    if (parts.length < 2 || parts.length > 4)
+      return;
+    let major;
+    for (const [index, part] of parts.entries()) {
+      if (!/^\s*[+-]?\d+\s*$/.test(part))
+        return;
+      const component = Number(part);
+      if (component < 0 || component > INT32_MAX_VALUE)
+        return;
+      if (index === 0)
+        major = component === 0 ? 0 : component;
+    }
+    return major;
+  }
   linkDependencies(resources) {
     for (const resource of resources) {
       const propertyMeta = resource.metadata;
@@ -5350,8 +5652,7 @@ class BindingOverwritesHandler {
           [BindingsKnownKeys.FolderKeyPropertyName]: resourceOverwrite.folderKey ?? ""
         };
       else {
-        const isBusinessRule = bindingResource.binding.resourceType === models_BindingsResourceType.BusinessRule;
-        const folderPath = bindingResource.isArtefactResource && !isBusinessRule ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
+        const folderPath = bindingResource.isArtefactResource && !bindingResource.isCodedApp ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
         overwrite = {
           [BindingsKnownKeys.FolderPathPropertyName]: folderPath,
           [BindingsKnownKeys.NamePropertyName]: resourceOverwrite.resourceName
@@ -5384,6 +5685,11 @@ function removeTimeTriggerBindings(bindings) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/binding-overwrites-mapping-handler.js
+function isCodedAppType(type) {
+  const normalized = type?.toLowerCase();
+  return normalized === "coded" || normalized === "codedaction";
+}
+
 class BindingOverwritesMappingRequestHandler {
   async handleAsync(request, cancellationToken) {
     const solutionBindings = request.bindings.resources.filter((x) => isSolutionResource(x.metadata));
@@ -5409,7 +5715,8 @@ class BindingOverwritesMappingRequestHandler {
           result.push({
             binding: bindingsResource,
             resourceKey: resource.key,
-            isArtefactResource: resource.projectKey != null
+            isArtefactResource: resource.projectKey != null,
+            isCodedApp: bindingsResource.resourceType === models_BindingsResourceType.App && isCodedAppType(resource.type)
           });
       } else {
         this.logger.error(`Solution does not contain binding resource of type ${models_BindingsResourceType[bindingsResource.resourceType]}.`);
@@ -6414,6 +6721,9 @@ class SolutionPublishLocationRequest {
 }
 
 class SolutionPublishLocationRequestV2 {
+  constructor(permissionType) {
+    this.permissionType = permissionType;
+  }
 }
 
 class SettingsRequest {
@@ -6578,12 +6888,13 @@ function _ts_param3(paramIndex, decorator) {
 }
 
 class SolutionPublishLocationRequestV2Handler {
-  async handleAsync(_request, cancellationToken) {
+  async handleAsync(request, cancellationToken) {
     try {
       const orchestratorClient = await this.orchestratorClientFactory.getClientAsync(cancellationToken);
       if (!orchestratorClient)
         throw new InvalidOperationException("Failed to create Orchestrator client");
-      return await orchestratorClient.getPublishLocationsAsync(cancellationToken);
+      const { permissionType } = request;
+      return permissionType == null ? await orchestratorClient.getPublishLocationsAsync(cancellationToken) : await orchestratorClient.getAccessiblePublishLocationsAsync(permissionType, cancellationToken);
     } catch (error) {
       this.logger.error("An unexpected error occurred while retrieving publish locations from Automation Solutions service.", error);
       throw error;
@@ -8613,7 +8924,7 @@ class GetResourceKeyForProjectRequestHandler {
       projectKey: request.projectKey,
       solution: request.context.path
     });
-    const cacheKey = `prk:${request.projectKey}`;
+    const cacheKey = `prk:${request.context.path}:${request.projectKey}`;
     const cached = await this.cacheProvider.getAsync(cacheKey, cancellationToken);
     if (cached && typeof cached == "object" && "resourceKey" in cached) {
       this.logger.info("Cache hit for project {projectKey} resource key.", {
@@ -9441,7 +9752,11 @@ class UpdateResourceConfigurationCommandHandler {
     for (const prop of command.properties) {
       const propKey = prop.property.toLowerCase();
       const metadata = propertiesMetadata.get(propKey);
-      if (!(!metadata || isAnyReferenceProperty(metadata)) && metadata.readOnly !== true) {
+      if (metadata && metadata.readOnly !== true) {
+        if (isAnyReferenceProperty(metadata)) {
+          updated = this.setSolutionReference(solution, resource, currentConfiguration, propertiesMetadata, metadata, prop.configuredValue) || updated;
+          continue;
+        }
         if (isSecretProperty(metadata)) {
           const secretValue = prop.configuredValue?.toString() || "";
           const existingKey = currentConfiguration[metadata.property]?.toString();
@@ -9485,6 +9800,38 @@ class UpdateResourceConfigurationCommandHandler {
     await command.context.saveChangesAsync(cancellationToken);
     return resourceConfiguration;
   }
+  setSolutionReference(solution, resource, currentConfiguration, propertiesMetadata, metadata, configuredValue) {
+    const referenceKind = metadata["referenceKind"];
+    if (!isSingleReferenceProperty(metadata) || isFileReferenceProperty(metadata) || typeof referenceKind != "string" || !referenceKind)
+      return false;
+    const requested = asReference(configuredValue);
+    const target = requested?.key ? solution.resources.find((r) => invariantEquals(r.key, requested.key) && invariantEquals(r.kind, referenceKind)) : undefined;
+    if (!requested || !target || invariantEquals(target.key, resource.key))
+      return false;
+    const dependencies = resource.dependencies ??= [];
+    const previous = asReference(currentConfiguration[metadata.property]);
+    const previousKey = previous?.key;
+    const isReferencedElsewhere = (key) => [
+      ...propertiesMetadata.values()
+    ].some((p) => isAnyReferenceProperty(p) && !isFileReferenceProperty(p) && typeof p["referenceKind"] == "string" && invariantEquals(p["referenceKind"], target.kind) && !invariantEquals(p.property, metadata.property) && asReferences(currentConfiguration[p.property]).some((r) => r.key !== undefined && invariantEquals(r.key, key)));
+    if (previousKey && !invariantEquals(previousKey, target.key) && !isReferencedElsewhere(previousKey)) {
+      const previousName = solution.resources.find((r) => invariantEquals(r.key, previousKey) && invariantEquals(r.kind, target.kind))?.name ?? previous?.name ?? "";
+      resource.dependencies = dependencies.filter((d) => !(invariantEquals(d.kind, target.kind) && invariantEquals(d.name, previousName)));
+    }
+    if (!resource.dependencies.some((d) => invariantEquals(d.kind, target.kind) && invariantEquals(d.name, target.name)))
+      resource.dependencies.push({
+        kind: target.kind,
+        name: target.name
+      });
+    currentConfiguration[metadata.property] = {
+      name: target.name,
+      key: target.key,
+      folderKey: requested.folderKey ?? null,
+      lookupStrategy: null,
+      info: null
+    };
+    return true;
+  }
   async updateReferencesName(solutionDefinition, resource, oldName, cancellationToken) {
     const resourcesToBeChanged = solutionDefinition.resources.filter((r) => r.key !== resource.key && (r.dependencies ?? []).some((d) => invariantEquals(d.kind, resource.kind) && invariantEquals(d.name, oldName)));
     if (resourcesToBeChanged.length === 0)
@@ -9771,6 +10118,28 @@ class UpsertResourceSecretCommandHandler {
     this.secretsProvider = secretsProvider;
   }
 }
+function asReference(value) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    return;
+  const record = value;
+  const pick = (name) => {
+    const entry = Object.entries(record).find(([k]) => k.toLowerCase() === name.toLowerCase());
+    return typeof entry?.[1] == "string" ? entry[1] : undefined;
+  };
+  return {
+    key: pick("key"),
+    name: pick("name"),
+    folderKey: pick("folderKey")
+  };
+}
+function asReferences(value) {
+  if (Array.isArray(value))
+    return value.map(asReference).filter((r) => r !== undefined);
+  const single = asReference(value);
+  return single ? [
+    single
+  ] : [];
+}
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/handlers/solution-handlers.js
 var DUPLICATE_NAMES_SUPPORTED_KINDS = new Set([
@@ -10742,6 +11111,9 @@ class ResourceCatalogApi extends HttpClient {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/clients/resource-catalog/resource-catalog-client.factory.js
 var RESOURCE_CATALOG_SCOPE = "RCS.FolderAuthorization";
 var RESOURCE_CATALOG_SERVICE_NAME = "resourcecatalog";
+function trimTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
 
 class ResourceCatalogClientFactory {
   async getClientAsync(cancellationToken) {
@@ -10755,9 +11127,8 @@ class ResourceCatalogClientFactory {
     ], true, cancellationToken);
     const ipRangeBypassSecret = await this.ipRangeBypassSecretProvider?.getIpRangeBypassSecretAsync(cancellationToken);
     const gatewayIntegrationEnabled = this.resourceBuilderAccessProvider.isGatewayIntegrationEnabled();
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
     const client = new ResourceCatalogApi({
-      baseUrl: normalizedBaseUrl,
+      baseUrl: trimTrailingSlashes(baseUrl),
       securityWorker: (securityData) => {
         if (!securityData)
           return {};
@@ -10800,7 +11171,7 @@ class ResourceCatalogClientFactory {
     if (!accountKey)
       throw new Error("Unable to obtain account key");
     const client = new ResourceCatalogApi({
-      baseUrl,
+      baseUrl: trimTrailingSlashes(baseUrl),
       securityWorker: (securityData) => {
         if (!securityData)
           return {};
@@ -13019,7 +13390,16 @@ class AutomationSolutionsClientProxy2 {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/clients/orchestrator/orchestrator-client.js
 class OrchestratorClient {
   async getPublishLocationsAsync(cancellationToken) {
-    const url = `${this.options.baseUrl}api/v2/AutomationSolutions/publish_locations`;
+    return this.getPublishLocationsFromAsync(this.publishLocationsUrl(), cancellationToken);
+  }
+  async getAccessiblePublishLocationsAsync(permissionType, cancellationToken) {
+    const url = `${this.publishLocationsUrl()}?permissionType=${encodeURIComponent(permissionType)}`;
+    return this.getPublishLocationsFromAsync(url, cancellationToken);
+  }
+  publishLocationsUrl() {
+    return `${this.options.baseUrl}api/v2/AutomationSolutions/publish_locations`;
+  }
+  async getPublishLocationsFromAsync(url, cancellationToken) {
     const headers = OrchestratorClientFactory.buildHeaders(this.options.securityData);
     const response = await fetch(url, {
       method: "GET",
@@ -13709,7 +14089,7 @@ class ReconcileProjectsCommandHandler {
     } : {
       resourceKey: undefined
     };
-    await this.cacheProvider.setAsync(`prk:${projectKey}`, result, cancellationToken);
+    await this.cacheProvider.setAsync(`prk:${context.path}:${projectKey}`, result, cancellationToken);
   }
   groupByProjectKey(artefactResources) {
     const map = new Map;
@@ -14583,6 +14963,11 @@ class ResourceBuilder {
     const request = new SolutionPublishLocationRequestV2;
     return this._mediator.sendAsync(request, cancellationToken);
   }
+  async getAccessiblePublishLocationsAsync(permissionType, cancellationToken) {
+    this.throwIfCancelled(cancellationToken);
+    const request = new SolutionPublishLocationRequestV2(permissionType);
+    return this._mediator.sendAsync(request, cancellationToken);
+  }
   async getSettingsAsync(cancellationToken) {
     this.throwIfCancelled(cancellationToken);
     const request = new SettingsRequest;
@@ -15142,9 +15527,9 @@ class UnconfiguredEmbeddedFileReader {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/container.js
-function createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, embeddedFileReader, solutionContextOptions) {
+function createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, embeddedFileReader, solutionContextOptions, featureFlagProvider) {
   const childContainer = import_tsyringe6.container.createChildContainer();
-  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions);
+  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions, featureFlagProvider);
   registerServices(childContainer, embeddedFileReader);
   registerHandlers(childContainer);
   childContainer.register(ServiceTokens.Mediator, {
@@ -15168,11 +15553,15 @@ function registerProvider(diContainer, token, provider) {
       break;
   }
 }
-function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions) {
+function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions, featureFlagProvider) {
   registerProvider(diContainer, ServiceTokens.AccessProvider, accessProvider);
   registerProvider(diContainer, ServiceTokens.CacheProvider, cacheProvider);
   registerProvider(diContainer, ServiceTokens.SecretsProvider, secretsProvider);
   registerProvider(diContainer, ServiceTokens.IpRangeBypassSecretProvider, ipRangeBypassSecretProvider);
+  registerProvider(diContainer, ServiceTokens.FeatureFlagProvider, featureFlagProvider ?? {
+    instance: new NullFeatureFlagProvider,
+    lifetime: service_tokens_ServiceLifetime.Singleton
+  });
   registerProvider(diContainer, ServiceTokens.FileStorageProviderFactory, fileStorageProviderFactory);
   registerProvider(diContainer, ServiceTokens.SolutionDefinitionProvider, solutionDefinitionProvider);
   registerProvider(diContainer, ServiceTokens.SolutionDefinitionFactory, solutionDefinitionFactory);
@@ -15899,6 +16288,11 @@ class ResourceBuilderConfiguration {
     this._ipRangeBypassSecretProviderLifetime = lifetime;
     return this;
   }
+  addFeatureFlagProvider(provider, lifetime = service_tokens_ServiceLifetime.Scoped) {
+    this._featureFlagProviderProvider = provider;
+    this._featureFlagProviderLifetime = lifetime;
+    return this;
+  }
   addSolutionDefinitionProvider(provider, lifetime = service_tokens_ServiceLifetime.Scoped) {
     this._solutionDefinitionProviderProvider = provider;
     this._solutionDefinitionProviderLifetime = lifetime;
@@ -15952,6 +16346,11 @@ class ResourceBuilderConfiguration {
       instance: ipRangeBypassSecretProviderInstance,
       lifetime: this._ipRangeBypassSecretProviderLifetime
     };
+    const featureFlagProviderInstance = this._featureFlagProviderProvider ? await resolveProvider(this._featureFlagProviderProvider) : new NullFeatureFlagProvider;
+    const featureFlagProvider = {
+      instance: featureFlagProviderInstance,
+      lifetime: this._featureFlagProviderLifetime
+    };
     const secretsProviderInstance = this._secretsProviderProvider ? await resolveProvider(this._secretsProviderProvider) : new NullSecretsProvider;
     const secretsProvider = {
       instance: secretsProviderInstance,
@@ -15995,7 +16394,7 @@ class ResourceBuilderConfiguration {
       lifetime: this._artifactResourceSpecEnhancerLifetime
     };
     const embeddedFileReader = await createDefaultEmbeddedFileReaderAsync();
-    const container3 = createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, this._httpReaderOptions, loggerFactory, embeddedFileReader, this._solutionContextOptions);
+    const container3 = createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, this._httpReaderOptions, loggerFactory, embeddedFileReader, this._solutionContextOptions, featureFlagProvider);
     return new ResourceBuilderServices(container3);
   }
   async buildServices() {
@@ -16007,6 +16406,7 @@ class ResourceBuilderConfiguration {
     this._secretsProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._fileStorageProviderFactoryLifetime = service_tokens_ServiceLifetime.Singleton;
     this._ipRangeBypassSecretProviderLifetime = service_tokens_ServiceLifetime.Scoped;
+    this._featureFlagProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._solutionDefinitionProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._solutionDefinitionFactoryLifetime = service_tokens_ServiceLifetime.Scoped;
     this._artifactResourceSpecEnhancerLifetime = service_tokens_ServiceLifetime.Scoped;
@@ -16118,8 +16518,59 @@ var ARTEFACT_KIND_APP = "app";
 var ARTEFACT_KIND_APP_VERSION = "appversion";
 var ARTEFACT_KIND_PACKAGE = "package";
 var SPEC_KEY_PACKAGE = "package";
+var RESOURCE_FILES_FOLDER_NAME = "resources";
+var RESOURCE_FILE_PATTERN = "*.json";
+var FIX_SHARED_KEY = "Delete all but one file for each key, then retry.";
+var FIX_KEYLESS = 'Give each file without a key its own unique "key", then retry.';
+
+class DuplicateKeysError extends Error {
+  keys;
+  constructor(keys) {
+    super(`Duplicate resource keys: ${keys.map(describeKey).join(", ")}`);
+    this.keys = keys;
+  }
+}
 
 class ArtefactPairBindingProvider extends MultiFileSolutionDefinitionProvider {
+  async readAsync(context, cancellationToken) {
+    const [readError, solution] = await catchError(super.readAsync(context, cancellationToken));
+    if (!readError)
+      return solution;
+    if (!(readError instanceof DuplicateKeysError))
+      throw readError;
+    const [describeError, message] = await catchError(this.describeDuplicateKeys(context, readError.keys, cancellationToken));
+    throw describeError ? readError : new Error(message);
+  }
+  async replaceDuplicateKeysAsync(solution) {
+    const keys = findDuplicateKeys(solution);
+    if (keys.length > 0)
+      throw new DuplicateKeysError(keys);
+  }
+  async describeDuplicateKeys(context, keys, cancellationToken) {
+    const storage = await this.getFileStorageProviderAsync(context, cancellationToken);
+    const files = await storage.getFilesAsync(RESOURCE_FILES_FOLDER_NAME, RESOURCE_FILE_PATTERN, cancellationToken);
+    const pathsByKey = new Map(keys.map((key) => [key, []]));
+    for (const file of [...files].sort()) {
+      const [readError, key] = await catchError(this.readResourceKey(storage, file, cancellationToken));
+      if (readError)
+        continue;
+      pathsByKey.get(key)?.push(toPortableRelativePath(file));
+    }
+    const lines = [...pathsByKey].map(([key, paths]) => `Resource key ${describeKey(key)} is used by: ${paths.join(", ")}`);
+    const fixes = [
+      keys.some((key) => !isKeyless(key)) && FIX_SHARED_KEY,
+      keys.some(isKeyless) && FIX_KEYLESS
+    ].filter(Boolean);
+    return [...lines, ...fixes].join(`
+`);
+  }
+  async readResourceKey(storage, file, cancellationToken) {
+    const content = await storage.readFileToEndAsync(file, cancellationToken);
+    const wrapper = this.caseInsensitiveSerializer.deserialize(content);
+    if (!wrapper?.resource)
+      throw new Error(`No resource in ${file}`);
+    return wrapper.resource.key;
+  }
   async writeAsync(context, solution, cancellationToken) {
     patchAppPackageLinkage(solution);
     return super.writeAsync(context, solution, cancellationToken);
@@ -16131,6 +16582,22 @@ class ArtefactPairBindingSolutionDefinitionFactory extends MultiFileSolutionDefi
     return new ArtefactPairBindingProvider(this.fileStorageProviderFactory, this.jsonSerializerFactory, this.loggerFactory);
   }
 }
+function findDuplicateKeys(solution) {
+  const counts = new Map;
+  for (const resource of solution.resources ?? []) {
+    const key = resource.key;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts].filter(([, count]) => count > 1).map(([key]) => key);
+}
+function isKeyless(key) {
+  return typeof key !== "string" || !key;
+}
+function describeKey(key) {
+  if (typeof key === "string" && key)
+    return key;
+  return key === undefined ? "(missing)" : JSON.stringify(key);
+}
 function patchAppPackageLinkage(solution) {
   const resources = solution.resources ?? [];
   const projectKeys = new Set;
@@ -16624,7 +17091,7 @@ var package_default = {
   name: "@uipath/orchestrator-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0",
+  version: "1.205.0",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -16676,77 +17143,6 @@ var package_default = {
 // ../orchestrator-sdk/src/user-agent.ts
 var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
 installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
-// ../orchestrator-sdk/generated/src/models/PrivilegeOfAccessType.ts
-function PrivilegeOfAccessTypeFromJSON(json) {
-  return PrivilegeOfAccessTypeFromJSONTyped(json, false);
-}
-function PrivilegeOfAccessTypeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : json["value"],
-    type: json["type"] == null ? undefined : json["type"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/PrivilegeGroupDto.ts
-function PrivilegeGroupDtoFromJSON(json) {
-  return PrivilegeGroupDtoFromJSONTyped(json, false);
-}
-function PrivilegeGroupDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    name: json["name"] == null ? undefined : json["name"],
-    id: json["id"] == null ? undefined : json["id"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/InheritedPrivilegeOfAccessType.ts
-function InheritedPrivilegeOfAccessTypeFromJSON(json) {
-  return InheritedPrivilegeOfAccessTypeFromJSONTyped(json, false);
-}
-function InheritedPrivilegeOfAccessTypeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    groups: json["groups"] == null ? undefined : json["groups"].map(PrivilegeGroupDtoFromJSON),
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : json["value"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/ExplicitPrivilegeOfAccessType.ts
-function ExplicitPrivilegeOfAccessTypeFromJSON(json) {
-  return ExplicitPrivilegeOfAccessTypeFromJSONTyped(json, false);
-}
-function ExplicitPrivilegeOfAccessTypeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : json["value"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/AccessPrivilege.ts
-function AccessPrivilegeFromJSON(json) {
-  return AccessPrivilegeFromJSONTyped(json, false);
-}
-function AccessPrivilegeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    explicit: json["explicit"] == null ? undefined : ExplicitPrivilegeOfAccessTypeFromJSON(json["explicit"]),
-    inherited: json["inherited"] == null ? undefined : json["inherited"].map(InheritedPrivilegeOfAccessTypeFromJSON),
-    effective: json["effective"] == null ? undefined : PrivilegeOfAccessTypeFromJSON(json["effective"])
-  };
-}
 // ../orchestrator-sdk/generated/src/models/AttendedRobotDto.ts
 function AttendedRobotDtoFromJSON(json) {
   return AttendedRobotDtoFromJSONTyped(json, false);
@@ -16776,127 +17172,29 @@ function AttendedRobotDtoToJSONTyped(value, ignoreDiscriminator = false) {
     RobotType: value["robotType"]
   };
 }
-// ../orchestrator-sdk/generated/src/models/ExplicitPrivilegeOfBoolean.ts
-function ExplicitPrivilegeOfBooleanFromJSON(json) {
-  return ExplicitPrivilegeOfBooleanFromJSONTyped(json, false);
+// ../orchestrator-sdk/generated/src/models/UpdatePolicyDto.ts
+function UpdatePolicyDtoFromJSON(json) {
+  return UpdatePolicyDtoFromJSONTyped(json, false);
 }
-function ExplicitPrivilegeOfBooleanFromJSONTyped(json, ignoreDiscriminator) {
+function UpdatePolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
   if (json == null) {
     return json;
   }
   return {
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : json["value"]
+    type: json["Type"] == null ? undefined : json["Type"],
+    specificVersion: json["SpecificVersion"] == null ? undefined : json["SpecificVersion"]
   };
 }
-
-// ../orchestrator-sdk/generated/src/models/InheritedPrivilegeOfBoolean.ts
-function InheritedPrivilegeOfBooleanFromJSON(json) {
-  return InheritedPrivilegeOfBooleanFromJSONTyped(json, false);
+function UpdatePolicyDtoToJSON(json) {
+  return UpdatePolicyDtoToJSONTyped(json, false);
 }
-function InheritedPrivilegeOfBooleanFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
+function UpdatePolicyDtoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
   }
   return {
-    groups: json["groups"] == null ? undefined : json["groups"].map(PrivilegeGroupDtoFromJSON),
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : json["value"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/PrivilegeOfBoolean.ts
-function PrivilegeOfBooleanFromJSON(json) {
-  return PrivilegeOfBooleanFromJSONTyped(json, false);
-}
-function PrivilegeOfBooleanFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : json["value"],
-    type: json["type"] == null ? undefined : json["type"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/BooleanPrivilege.ts
-function BooleanPrivilegeFromJSON(json) {
-  return BooleanPrivilegeFromJSONTyped(json, false);
-}
-function BooleanPrivilegeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    explicit: json["explicit"] == null ? undefined : ExplicitPrivilegeOfBooleanFromJSON(json["explicit"]),
-    inherited: json["inherited"] == null ? undefined : InheritedPrivilegeOfBooleanFromJSON(json["inherited"]),
-    effective: json["effective"] == null ? undefined : PrivilegeOfBooleanFromJSON(json["effective"])
-  };
-}
-// ../orchestrator-sdk/generated/src/models/RolePrivilegeDto.ts
-function RolePrivilegeDtoFromJSON(json) {
-  return RolePrivilegeDtoFromJSONTyped(json, false);
-}
-function RolePrivilegeDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    name: json["name"] == null ? undefined : json["name"],
-    id: json["id"] == null ? undefined : json["id"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/ExplicitPrivilegeOfRolePrivilegeDto.ts
-function ExplicitPrivilegeOfRolePrivilegeDtoFromJSON(json) {
-  return ExplicitPrivilegeOfRolePrivilegeDtoFromJSONTyped(json, false);
-}
-function ExplicitPrivilegeOfRolePrivilegeDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : RolePrivilegeDtoFromJSON(json["value"])
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UpdatePolicyDto.ts
-function UpdatePolicyDtoFromJSON(json) {
-  return UpdatePolicyDtoFromJSONTyped(json, false);
-}
-function UpdatePolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    type: json["Type"] == null ? undefined : json["Type"],
-    specificVersion: json["SpecificVersion"] == null ? undefined : json["SpecificVersion"]
-  };
-}
-function UpdatePolicyDtoToJSON(json) {
-  return UpdatePolicyDtoToJSONTyped(json, false);
-}
-function UpdatePolicyDtoToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    Type: value["type"],
-    SpecificVersion: value["specificVersion"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/ExplicitPrivilegeOfUpdatePolicyDto.ts
-function ExplicitPrivilegeOfUpdatePolicyDtoFromJSON(json) {
-  return ExplicitPrivilegeOfUpdatePolicyDtoFromJSONTyped(json, false);
-}
-function ExplicitPrivilegeOfUpdatePolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : UpdatePolicyDtoFromJSON(json["value"])
+    Type: value["type"],
+    SpecificVersion: value["specificVersion"]
   };
 }
 // ../orchestrator-sdk/generated/src/models/OrganizationUnitDto.ts
@@ -17048,7 +17346,6 @@ function UnattendedRobotDtoToJSONTyped(value, ignoreDiscriminator = false) {
     MachineMappingsCount: value["machineMappingsCount"]
   };
 }
-
 // ../orchestrator-sdk/generated/src/models/UserDto.ts
 function UserDtoFromJSON(json) {
   return UserDtoFromJSONTyped(json, false);
@@ -17158,158 +17455,6 @@ function UserDtoToJSONTyped(value, ignoreDiscriminator = false) {
     Id: value["id"]
   };
 }
-// ../orchestrator-sdk/generated/src/models/FolderDto.ts
-function FolderDtoFromJSON(json) {
-  return FolderDtoFromJSONTyped(json, false);
-}
-function FolderDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    key: json["Key"] == null ? undefined : json["Key"],
-    displayName: json["DisplayName"],
-    fullyQualifiedName: json["FullyQualifiedName"] == null ? undefined : json["FullyQualifiedName"],
-    description: json["Description"] == null ? undefined : json["Description"],
-    folderType: json["FolderType"] == null ? undefined : json["FolderType"],
-    isPersonal: json["IsPersonal"] == null ? undefined : json["IsPersonal"],
-    provisionType: json["ProvisionType"] == null ? undefined : json["ProvisionType"],
-    permissionModel: json["PermissionModel"] == null ? undefined : json["PermissionModel"],
-    parentId: json["ParentId"] == null ? undefined : json["ParentId"],
-    parentKey: json["ParentKey"] == null ? undefined : json["ParentKey"],
-    feedType: json["FeedType"] == null ? undefined : json["FeedType"],
-    id: json["Id"] == null ? undefined : json["Id"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/UserPreferencesDto.ts
-function UserPreferencesDtoFromJSON(json) {
-  return UserPreferencesDtoFromJSONTyped(json, false);
-}
-function UserPreferencesDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    redesignPreference: json["redesignPreference"] == null ? undefined : json["redesignPreference"],
-    remoteControlPreference: json["remoteControlPreference"] == null ? undefined : json["remoteControlPreference"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/ExtendedUserDto.ts
-function ExtendedUserDtoFromJSON(json) {
-  return ExtendedUserDtoFromJSONTyped(json, false);
-}
-function ExtendedUserDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    personalWorkspace: json["PersonalWorkspace"] == null ? undefined : FolderDtoFromJSON(json["PersonalWorkspace"]),
-    personalWorskpaceFeedId: json["PersonalWorskpaceFeedId"] == null ? undefined : json["PersonalWorskpaceFeedId"],
-    virtualFolderId: json["VirtualFolderId"] == null ? undefined : json["VirtualFolderId"],
-    virtualFolderPath: json["VirtualFolderPath"] == null ? undefined : json["VirtualFolderPath"],
-    preferences: json["Preferences"] == null ? undefined : UserPreferencesDtoFromJSON(json["Preferences"]),
-    name: json["Name"] == null ? undefined : json["Name"],
-    surname: json["Surname"] == null ? undefined : json["Surname"],
-    userName: json["UserName"] == null ? undefined : json["UserName"],
-    domain: json["Domain"] == null ? undefined : json["Domain"],
-    directoryIdentifier: json["DirectoryIdentifier"] == null ? undefined : json["DirectoryIdentifier"],
-    fullName: json["FullName"] == null ? undefined : json["FullName"],
-    emailAddress: json["EmailAddress"] == null ? undefined : json["EmailAddress"],
-    lastLoginTime: json["LastLoginTime"] == null ? undefined : new Date(json["LastLoginTime"]),
-    isActive: json["IsActive"] == null ? undefined : json["IsActive"],
-    creationTime: json["CreationTime"] == null ? undefined : new Date(json["CreationTime"]),
-    authenticationSource: json["AuthenticationSource"] == null ? undefined : json["AuthenticationSource"],
-    organizationUnits: json["OrganizationUnits"] == null ? undefined : json["OrganizationUnits"].map(OrganizationUnitDtoFromJSON),
-    password: json["Password"] == null ? undefined : json["Password"],
-    isExternalLicensed: json["IsExternalLicensed"] == null ? undefined : json["IsExternalLicensed"],
-    userRoles: json["UserRoles"] == null ? undefined : json["UserRoles"].map(UserRoleDtoFromJSON),
-    rolesList: json["RolesList"] == null ? undefined : json["RolesList"],
-    loginProviders: json["LoginProviders"] == null ? undefined : json["LoginProviders"],
-    tenantId: json["TenantId"] == null ? undefined : json["TenantId"],
-    tenancyName: json["TenancyName"] == null ? undefined : json["TenancyName"],
-    tenantDisplayName: json["TenantDisplayName"] == null ? undefined : json["TenantDisplayName"],
-    tenantKey: json["TenantKey"] == null ? undefined : json["TenantKey"],
-    type: json["Type"] == null ? undefined : json["Type"],
-    provisionType: json["ProvisionType"] == null ? undefined : json["ProvisionType"],
-    licenseType: json["LicenseType"] == null ? undefined : json["LicenseType"],
-    robotProvision: json["RobotProvision"] == null ? undefined : AttendedRobotDtoFromJSON(json["RobotProvision"]),
-    unattendedRobot: json["UnattendedRobot"] == null ? undefined : UnattendedRobotDtoFromJSON(json["UnattendedRobot"]),
-    notificationSubscription: json["NotificationSubscription"] == null ? undefined : UserNotificationSubscriptionFromJSON(json["NotificationSubscription"]),
-    key: json["Key"] == null ? undefined : json["Key"],
-    mayHaveUserSession: json["MayHaveUserSession"] == null ? undefined : json["MayHaveUserSession"],
-    mayHaveRobotSession: json["MayHaveRobotSession"] == null ? undefined : json["MayHaveRobotSession"],
-    mayHaveUnattendedSession: json["MayHaveUnattendedSession"] == null ? undefined : json["MayHaveUnattendedSession"],
-    mayHavePersonalWorkspace: json["MayHavePersonalWorkspace"] == null ? undefined : json["MayHavePersonalWorkspace"],
-    restrictToPersonalWorkspace: json["RestrictToPersonalWorkspace"] == null ? undefined : json["RestrictToPersonalWorkspace"],
-    updatePolicy: json["UpdatePolicy"] == null ? undefined : UpdatePolicyDtoFromJSON(json["UpdatePolicy"]),
-    accountId: json["AccountId"] == null ? undefined : json["AccountId"],
-    hasOnlyInheritedPrivileges: json["HasOnlyInheritedPrivileges"] == null ? undefined : json["HasOnlyInheritedPrivileges"],
-    explicitMayHaveUserSession: json["ExplicitMayHaveUserSession"] == null ? undefined : json["ExplicitMayHaveUserSession"],
-    explicitMayHaveRobotSession: json["ExplicitMayHaveRobotSession"] == null ? undefined : json["ExplicitMayHaveRobotSession"],
-    explicitMayHavePersonalWorkspace: json["ExplicitMayHavePersonalWorkspace"] == null ? undefined : json["ExplicitMayHavePersonalWorkspace"],
-    explicitRestrictToPersonalWorkspace: json["ExplicitRestrictToPersonalWorkspace"] == null ? undefined : json["ExplicitRestrictToPersonalWorkspace"],
-    lastModificationTime: json["LastModificationTime"] == null ? undefined : new Date(json["LastModificationTime"]),
-    lastModifierUserId: json["LastModifierUserId"] == null ? undefined : json["LastModifierUserId"],
-    creatorUserId: json["CreatorUserId"] == null ? undefined : json["CreatorUserId"],
-    id: json["Id"] == null ? undefined : json["Id"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/GetUsersModel.ts
-function GetUsersModelToJSON(json) {
-  return GetUsersModelToJSONTyped(json, false);
-}
-function GetUsersModelToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    permissions: value["permissions"],
-    folderKeys: value["folderKeys"],
-    token: value["token"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/InheritedPrivilegeOfRolePrivilegeDto.ts
-function InheritedPrivilegeOfRolePrivilegeDtoFromJSON(json) {
-  return InheritedPrivilegeOfRolePrivilegeDtoFromJSONTyped(json, false);
-}
-function InheritedPrivilegeOfRolePrivilegeDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    groups: json["groups"] == null ? undefined : json["groups"].map(PrivilegeGroupDtoFromJSON),
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : RolePrivilegeDtoFromJSON(json["value"])
-  };
-}
-// ../orchestrator-sdk/generated/src/models/InheritedPrivilegeOfUpdatePolicyDto.ts
-function InheritedPrivilegeOfUpdatePolicyDtoFromJSON(json) {
-  return InheritedPrivilegeOfUpdatePolicyDtoFromJSONTyped(json, false);
-}
-function InheritedPrivilegeOfUpdatePolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    groups: json["groups"] == null ? undefined : json["groups"].map(PrivilegeGroupDtoFromJSON),
-    type: json["type"] == null ? undefined : json["type"],
-    value: json["value"] == null ? undefined : UpdatePolicyDtoFromJSON(json["value"])
-  };
-}
-// ../orchestrator-sdk/generated/src/models/ODataValueOfIDictionaryOfInt64Boolean.ts
-function ODataValueOfIDictionaryOfInt64BooleanFromJSON(json) {
-  return ODataValueOfIDictionaryOfInt64BooleanFromJSONTyped(json, false);
-}
-function ODataValueOfIDictionaryOfInt64BooleanFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : json["value"]
-  };
-}
 // ../orchestrator-sdk/generated/src/models/ODataValueOfIEnumerableOfUserDto.ts
 function ODataValueOfIEnumerableOfUserDtoFromJSON(json) {
   return ODataValueOfIEnumerableOfUserDtoFromJSONTyped(json, false);
@@ -17322,39 +17467,6 @@ function ODataValueOfIEnumerableOfUserDtoFromJSONTyped(json, ignoreDiscriminator
     value: json["value"] == null ? undefined : json["value"].map(UserDtoFromJSON)
   };
 }
-// ../orchestrator-sdk/generated/src/models/UserPermissionsExtended.ts
-function UserPermissionsExtendedFromJSON(json) {
-  return UserPermissionsExtendedFromJSONTyped(json, false);
-}
-function UserPermissionsExtendedFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    userId: json["UserId"] == null ? undefined : json["UserId"],
-    folderKey: json["FolderKey"] == null ? undefined : json["FolderKey"],
-    folderName: json["FolderName"] == null ? undefined : json["FolderName"],
-    folderType: json["FolderType"] == null ? undefined : json["FolderType"],
-    folderPath: json["FolderPath"] == null ? undefined : json["FolderPath"],
-    folderCode: json["FolderCode"] == null ? undefined : json["FolderCode"],
-    isPersonalWorkspace: json["IsPersonalWorkspace"] == null ? undefined : json["IsPersonalWorkspace"],
-    path: json["Path"] == null ? undefined : json["Path"],
-    permissions: json["Permissions"] == null ? undefined : json["Permissions"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/ODataValueOfIEnumerableOfUserPermissionsExtended.ts
-function ODataValueOfIEnumerableOfUserPermissionsExtendedFromJSON(json) {
-  return ODataValueOfIEnumerableOfUserPermissionsExtendedFromJSONTyped(json, false);
-}
-function ODataValueOfIEnumerableOfUserPermissionsExtendedFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : json["value"].map(UserPermissionsExtendedFromJSON)
-  };
-}
 // ../orchestrator-sdk/generated/src/models/ODataValueOfInt64.ts
 function ODataValueOfInt64FromJSON(json) {
   return ODataValueOfInt64FromJSONTyped(json, false);
@@ -17367,72 +17479,6 @@ function ODataValueOfInt64FromJSONTyped(json, ignoreDiscriminator) {
     value: json["value"] == null ? undefined : json["value"]
   };
 }
-// ../orchestrator-sdk/generated/src/models/PrivilegeOfRolePrivilegeDto.ts
-function PrivilegeOfRolePrivilegeDtoFromJSON(json) {
-  return PrivilegeOfRolePrivilegeDtoFromJSONTyped(json, false);
-}
-function PrivilegeOfRolePrivilegeDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : RolePrivilegeDtoFromJSON(json["value"]),
-    type: json["type"] == null ? undefined : json["type"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/PrivilegeOfUpdatePolicyDto.ts
-function PrivilegeOfUpdatePolicyDtoFromJSON(json) {
-  return PrivilegeOfUpdatePolicyDtoFromJSONTyped(json, false);
-}
-function PrivilegeOfUpdatePolicyDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    value: json["value"] == null ? undefined : UpdatePolicyDtoFromJSON(json["value"]),
-    type: json["type"] == null ? undefined : json["type"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/RevokeExplicitPrivilegesRequest.ts
-function RevokeExplicitPrivilegesRequestToJSON(json) {
-  return RevokeExplicitPrivilegesRequestToJSONTyped(json, false);
-}
-function RevokeExplicitPrivilegesRequestToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    userIds: value["userIds"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/RolePrivileges.ts
-function RolePrivilegesFromJSON(json) {
-  return RolePrivilegesFromJSONTyped(json, false);
-}
-function RolePrivilegesFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    explicit: json["explicit"] == null ? undefined : json["explicit"].map(ExplicitPrivilegeOfRolePrivilegeDtoFromJSON),
-    inherited: json["inherited"] == null ? undefined : json["inherited"].map(InheritedPrivilegeOfRolePrivilegeDtoFromJSON),
-    effective: json["effective"] == null ? undefined : json["effective"].map(PrivilegeOfRolePrivilegeDtoFromJSON)
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UpdatePolicyPrivilege.ts
-function UpdatePolicyPrivilegeFromJSON(json) {
-  return UpdatePolicyPrivilegeFromJSONTyped(json, false);
-}
-function UpdatePolicyPrivilegeFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    explicit: json["explicit"] == null ? undefined : ExplicitPrivilegeOfUpdatePolicyDtoFromJSON(json["explicit"]),
-    inherited: json["inherited"] == null ? undefined : json["inherited"].map(InheritedPrivilegeOfUpdatePolicyDtoFromJSON),
-    effective: json["effective"] == null ? undefined : PrivilegeOfUpdatePolicyDtoFromJSON(json["effective"])
-  };
-}
 // ../orchestrator-sdk/generated/src/models/UserAssignRolesRequest.ts
 function UserAssignRolesRequestToJSON(json) {
   return UserAssignRolesRequestToJSONTyped(json, false);
@@ -17445,197 +17491,31 @@ function UserAssignRolesRequestToJSONTyped(value, ignoreDiscriminator = false) {
     roleIds: value["roleIds"]
   };
 }
-// ../orchestrator-sdk/generated/src/models/UserChangeCultureRequest.ts
-function UserChangeCultureRequestToJSON(json) {
-  return UserChangeCultureRequestToJSONTyped(json, false);
-}
-function UserChangeCultureRequestToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    culture: value["culture"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UserIdTypeDto.ts
-function UserIdTypeDtoFromJSON(json) {
-  return UserIdTypeDtoFromJSONTyped(json, false);
-}
-function UserIdTypeDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
+// ../orchestrator-sdk/generated/src/apis/UsersApi.ts
+class UsersApi extends BaseAPI {
+  async usersAssignRolesByIdRaw(requestParameters, initOverrides) {
+    if (requestParameters["key"] == null) {
+      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersAssignRolesById().');
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
+    if (this.configuration && this.configuration.accessToken) {
+      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
+    }
+    let urlPath = `/odata/Users({key})/UiPath.Server.Configuration.OData.AssignRoles`;
+    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    const response = await this.request({
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UserAssignRolesRequestToJSON(requestParameters["body"])
+    }, initOverrides);
+    return new VoidApiResponse(response);
   }
-  return {
-    id: json["id"] == null ? undefined : json["id"],
-    type: json["type"] == null ? undefined : json["type"]
-  };
-}
-
-// ../orchestrator-sdk/generated/src/models/UserIdTypeCollectionDto.ts
-function UserIdTypeCollectionDtoFromJSON(json) {
-  return UserIdTypeCollectionDtoFromJSONTyped(json, false);
-}
-function UserIdTypeCollectionDtoFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    users: json["users"] == null ? undefined : json["users"].map(UserIdTypeDtoFromJSON),
-    token: json["token"] == null ? undefined : json["token"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UserPermissionsCollection.ts
-function UserPermissionsCollectionFromJSON(json) {
-  return UserPermissionsCollectionFromJSONTyped(json, false);
-}
-function UserPermissionsCollectionFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    userId: json["UserId"] == null ? undefined : json["UserId"],
-    permissions: json["Permissions"] == null ? undefined : json["Permissions"]
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UserPrivileges.ts
-function UserPrivilegesFromJSON(json) {
-  return UserPrivilegesFromJSONTyped(json, false);
-}
-function UserPrivilegesFromJSONTyped(json, ignoreDiscriminator) {
-  if (json == null) {
-    return json;
-  }
-  return {
-    userId: json["userId"] == null ? undefined : json["userId"],
-    roles: json["roles"] == null ? undefined : RolePrivilegesFromJSON(json["roles"]),
-    access: json["access"] == null ? undefined : AccessPrivilegeFromJSON(json["access"]),
-    attendedSession: json["attendedSession"] == null ? undefined : BooleanPrivilegeFromJSON(json["attendedSession"]),
-    personalWorkspace: json["personalWorkspace"] == null ? undefined : BooleanPrivilegeFromJSON(json["personalWorkspace"]),
-    updatePolicy: json["updatePolicy"] == null ? undefined : UpdatePolicyPrivilegeFromJSON(json["updatePolicy"])
-  };
-}
-// ../orchestrator-sdk/generated/src/models/UsersToggleRoleRequest.ts
-function UsersToggleRoleRequestToJSON(json) {
-  return UsersToggleRoleRequestToJSONTyped(json, false);
-}
-function UsersToggleRoleRequestToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    role: value["role"],
-    toggle: value["toggle"]
-  };
-}
-// ../orchestrator-sdk/generated/src/apis/UsersApi.ts
-class UsersApi extends BaseAPI {
-  async usersAcquireLicenseRaw(initOverrides) {
-    const queryParameters = {};
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/api/Users/AcquireLicense`;
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersAcquireLicense(initOverrides) {
-    await this.usersAcquireLicenseRaw(initOverrides);
-  }
-  async usersAssignRolesByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersAssignRolesById().');
-    }
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users({key})/UiPath.Server.Configuration.OData.AssignRoles`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: UserAssignRolesRequestToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersAssignRolesById(requestParameters, initOverrides) {
-    await this.usersAssignRolesByIdRaw(requestParameters, initOverrides);
-  }
-  async usersChangeCultureRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.ChangeCulture`;
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: UserChangeCultureRequestToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersChangeCulture(requestParameters = {}, initOverrides) {
-    await this.usersChangeCultureRaw(requestParameters, initOverrides);
-  }
-  async usersChangeUserCultureByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersChangeUserCultureById().');
-    }
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users({key})/UiPath.Server.Configuration.OData.ChangeUserCulture`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: UserChangeCultureRequestToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersChangeUserCultureById(requestParameters, initOverrides) {
-    await this.usersChangeUserCultureByIdRaw(requestParameters, initOverrides);
-  }
-  async usersDeleteByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersDeleteById().');
-    }
-    const queryParameters = {};
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users({key})`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "DELETE",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersDeleteById(requestParameters, initOverrides) {
-    await this.usersDeleteByIdRaw(requestParameters, initOverrides);
+  async usersAssignRolesById(requestParameters, initOverrides) {
+    await this.usersAssignRolesByIdRaw(requestParameters, initOverrides);
   }
   async usersGetRaw(requestParameters, initOverrides) {
     const queryParameters = {};
@@ -17677,69 +17557,6 @@ class UsersApi extends BaseAPI {
     const response = await this.usersGetRaw(requestParameters, initOverrides);
     return await response.value();
   }
-  async usersGetAllPermissionsExtendedRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    if (requestParameters["$filter"] != null) {
-      queryParameters["$filter"] = requestParameters["$filter"];
-    }
-    if (requestParameters["$orderby"] != null) {
-      queryParameters["$orderby"] = requestParameters["$orderby"];
-    }
-    if (requestParameters["$count"] != null) {
-      queryParameters["$count"] = requestParameters["$count"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetAllPermissionsExtended`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => ODataValueOfIEnumerableOfUserPermissionsExtendedFromJSON(jsonValue));
-  }
-  async usersGetAllPermissionsExtended(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetAllPermissionsExtendedRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
-  async usersGetByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersGetById().');
-    }
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users({key})`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserDtoFromJSON(jsonValue));
-  }
-  async usersGetById(requestParameters, initOverrides) {
-    const response = await this.usersGetByIdRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
   async usersGetByKeyByIdentifierRaw(requestParameters, initOverrides) {
     if (requestParameters["identifier"] == null) {
       throw new RequiredError("identifier", 'Required parameter "identifier" was null or undefined when calling usersGetByKeyByIdentifier().');
@@ -17784,56 +17601,6 @@ class UsersApi extends BaseAPI {
     const response = await this.usersGetByKeyByIdentifierRaw(requestParameters, initOverrides);
     return await response.value();
   }
-  async usersGetCurrentPermissionsRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetCurrentPermissions`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserPermissionsCollectionFromJSON(jsonValue));
-  }
-  async usersGetCurrentPermissions(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetCurrentPermissionsRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
-  async usersGetCurrentPermissionsExtendedRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetCurrentPermissionsExtended`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserPermissionsExtendedFromJSON(jsonValue));
-  }
-  async usersGetCurrentPermissionsExtended(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetCurrentPermissionsExtendedRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
   async usersGetCurrentUserRaw(requestParameters, initOverrides) {
     const queryParameters = {};
     if (requestParameters["$select"] != null) {
@@ -17861,163 +17628,39 @@ class UsersApi extends BaseAPI {
       case 200:
         return await response.value();
       case 204:
-        return null;
-      default:
-        return await response.value();
-    }
-  }
-  async usersGetCurrentUserExtendedRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetCurrentUserExtended`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => ExtendedUserDtoFromJSON(jsonValue));
-  }
-  async usersGetCurrentUserExtended(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetCurrentUserExtendedRaw(requestParameters, initOverrides);
-    switch (response.raw.status) {
-      case 200:
-        return await response.value();
-      case 204:
-        return null;
-      default:
-        return await response.value();
-    }
-  }
-  async usersGetDirectoryPrivilegesRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["identifier"] != null) {
-      queryParameters["identifier"] = requestParameters["identifier"];
-    }
-    if (requestParameters["type"] != null) {
-      queryParameters["type"] = requestParameters["type"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/api/Users/GetDirectoryPrivileges`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserPrivilegesFromJSON(jsonValue));
-  }
-  async usersGetDirectoryPrivileges(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetDirectoryPrivilegesRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
-  async usersGetPrivilegesRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    if (requestParameters["userId"] != null) {
-      queryParameters["userId"] = requestParameters["userId"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/api/Users/GetPrivileges`;
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserPrivilegesFromJSON(jsonValue));
-  }
-  async usersGetPrivileges(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetPrivilegesRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
-  async usersGetUserIdByUserkeyRaw(requestParameters, initOverrides) {
-    if (requestParameters["userKey"] == null) {
-      throw new RequiredError("userKey", 'Required parameter "userKey" was null or undefined when calling usersGetUserIdByUserkey().');
-    }
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetUserId(userKey='{userKey}')`;
-    urlPath = urlPath.replace(`{${"userKey"}}`, encodeURIComponent(String(requestParameters["userKey"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => ODataValueOfInt64FromJSON(jsonValue));
-  }
-  async usersGetUserIdByUserkey(requestParameters, initOverrides) {
-    const response = await this.usersGetUserIdByUserkeyRaw(requestParameters, initOverrides);
-    return await response.value();
-  }
-  async usersGetUsersWithPermissionsRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/api/Users/GetUsersWithPermissions`;
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: GetUsersModelToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => UserIdTypeCollectionDtoFromJSON(jsonValue));
-  }
-  async usersGetUsersWithPermissions(requestParameters = {}, initOverrides) {
-    const response = await this.usersGetUsersWithPermissionsRaw(requestParameters, initOverrides);
-    return await response.value();
+        return null;
+      default:
+        return await response.value();
+    }
   }
-  async usersPatchByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersPatchById().');
+  async usersGetUserIdByUserkeyRaw(requestParameters, initOverrides) {
+    if (requestParameters["userKey"] == null) {
+      throw new RequiredError("userKey", 'Required parameter "userKey" was null or undefined when calling usersGetUserIdByUserkey().');
     }
     const queryParameters = {};
+    if (requestParameters["$select"] != null) {
+      queryParameters["$select"] = requestParameters["$select"];
+    }
+    if (requestParameters["$expand"] != null) {
+      queryParameters["$expand"] = requestParameters["$expand"];
+    }
     const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
     if (this.configuration && this.configuration.accessToken) {
       headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
     }
-    let urlPath = `/odata/Users({key})`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
+    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.GetUserId(userKey='{userKey}')`;
+    urlPath = urlPath.replace(`{${"userKey"}}`, encodeURIComponent(String(requestParameters["userKey"])));
     const response = await this.request({
       path: urlPath,
-      method: "PATCH",
+      method: "GET",
       headers: headerParameters,
-      query: queryParameters,
-      body: UserDtoToJSON(requestParameters["body"])
+      query: queryParameters
     }, initOverrides);
-    return new VoidApiResponse(response);
+    return new JSONApiResponse(response, (jsonValue) => ODataValueOfInt64FromJSON(jsonValue));
   }
-  async usersPatchById(requestParameters, initOverrides) {
-    await this.usersPatchByIdRaw(requestParameters, initOverrides);
+  async usersGetUserIdByUserkey(requestParameters, initOverrides) {
+    const response = await this.usersGetUserIdByUserkeyRaw(requestParameters, initOverrides);
+    return await response.value();
   }
   async usersPostRaw(requestParameters, initOverrides) {
     const queryParameters = {};
@@ -18064,89 +17707,37 @@ class UsersApi extends BaseAPI {
   async usersPutById(requestParameters, initOverrides) {
     await this.usersPutByIdRaw(requestParameters, initOverrides);
   }
-  async usersRevokeExplicitPrivilegesRaw(requestParameters, initOverrides) {
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/api/Users/RevokeExplicitPrivileges`;
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: RevokeExplicitPrivilegesRequestToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersRevokeExplicitPrivileges(requestParameters = {}, initOverrides) {
-    await this.usersRevokeExplicitPrivilegesRaw(requestParameters, initOverrides);
-  }
-  async usersToggleRoleByIdRaw(requestParameters, initOverrides) {
-    if (requestParameters["key"] == null) {
-      throw new RequiredError("key", 'Required parameter "key" was null or undefined when calling usersToggleRoleById().');
-    }
-    const queryParameters = {};
-    const headerParameters = {};
-    headerParameters["Content-Type"] = "application/json;odata.metadata=minimal;odata.streaming=true";
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users({key})/UiPath.Server.Configuration.OData.ToggleRole`;
-    urlPath = urlPath.replace(`{${"key"}}`, encodeURIComponent(String(requestParameters["key"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "POST",
-      headers: headerParameters,
-      query: queryParameters,
-      body: UsersToggleRoleRequestToJSON(requestParameters["body"])
-    }, initOverrides);
-    return new VoidApiResponse(response);
-  }
-  async usersToggleRoleById(requestParameters, initOverrides) {
-    await this.usersToggleRoleByIdRaw(requestParameters, initOverrides);
-  }
-  async usersValidateByUseridsRaw(requestParameters, initOverrides) {
-    if (requestParameters["userIds"] == null) {
-      throw new RequiredError("userIds", 'Required parameter "userIds" was null or undefined when calling usersValidateByUserids().');
-    }
-    const queryParameters = {};
-    if (requestParameters["$select"] != null) {
-      queryParameters["$select"] = requestParameters["$select"];
-    }
-    if (requestParameters["$expand"] != null) {
-      queryParameters["$expand"] = requestParameters["$expand"];
-    }
-    if (requestParameters["$filter"] != null) {
-      queryParameters["$filter"] = requestParameters["$filter"];
-    }
-    if (requestParameters["$orderby"] != null) {
-      queryParameters["$orderby"] = requestParameters["$orderby"];
-    }
-    if (requestParameters["$count"] != null) {
-      queryParameters["$count"] = requestParameters["$count"];
-    }
-    const headerParameters = {};
-    if (this.configuration && this.configuration.accessToken) {
-      headerParameters["Authorization"] = await this.configuration.accessToken("OAuth2", []);
-    }
-    let urlPath = `/odata/Users/UiPath.Server.Configuration.OData.Validate(userIds=[{userIds}])`;
-    urlPath = urlPath.replace(`{${"userIds"}}`, encodeURIComponent(String(requestParameters["userIds"])));
-    const response = await this.request({
-      path: urlPath,
-      method: "GET",
-      headers: headerParameters,
-      query: queryParameters
-    }, initOverrides);
-    return new JSONApiResponse(response, (jsonValue) => ODataValueOfIDictionaryOfInt64BooleanFromJSON(jsonValue));
-  }
-  async usersValidateByUserids(requestParameters, initOverrides) {
-    const response = await this.usersValidateByUseridsRaw(requestParameters, initOverrides);
-    return await response.value();
+}
+// ../common/src/session-kind.ts
+var SESSION_KIND_KEY = Symbol.for("@uipath/common/SessionKind");
+function attachSessionKind(carrier, kind) {
+  if (!kind)
+    return carrier;
+  Object.defineProperty(carrier, SESSION_KIND_KEY, {
+    value: {
+      __brand: "SessionKind",
+      type: kind.type,
+      ...kind.clientId ? { clientId: kind.clientId } : {},
+      ...kind.applicationSubtype ? { applicationSubtype: kind.applicationSubtype } : {}
+    },
+    enumerable: false,
+    configurable: true
+  });
+  const clone = carrier.clone;
+  if (typeof clone === "function") {
+    Object.defineProperty(carrier, "clone", {
+      value: function stampedClone(...args) {
+        const copy = clone.apply(this, args);
+        return typeof copy === "object" && copy !== null ? attachSessionKind(copy, kind) : copy;
+      },
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
   }
+  return carrier;
 }
+
 // ../orchestrator-sdk/src/client-factory.ts
 async function createOrchestratorConfig(options) {
   const ctx = await getAuthContext({
@@ -18169,9 +17760,15 @@ async function createOrchestratorConfig(options) {
   }
   return new Configuration({
     basePath: orchestratorBasePath,
-    headers
+    headers,
+    fetchApi: sessionKindStampingFetch(ctx.identity ?? resolveSessionIdentity(ctx.accessToken))
   });
 }
+function sessionKindStampingFetch(kind) {
+  if (!kind)
+    return;
+  return async (...args) => attachSessionKind(await fetch(...args), kind);
+}
 async function createApiClient(ApiClass, options) {
   const config = await createOrchestratorConfig(options);
   return new ApiClass(config);
@@ -18414,6 +18011,108 @@ async function createProjectInSolutionBuilder(solutionDir, projectId, projectNam
   await catchError(solutionBuilder.disposeAsync());
   return createError;
 }
+// src/resources/services/catalog-lookup-failure.ts
+var NO_CLIENT_MESSAGE = "Unable to create Resource Catalog client";
+function classifyCatalogFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes(NO_CLIENT_MESSAGE)) {
+    return { message, kind: "no_session" };
+  }
+  const match = /\bHTTP (\d{3})\b/.exec(message);
+  const status = match ? Number(match[1]) : undefined;
+  if (status === 401 || status === 403) {
+    return { message, kind: "refused", status };
+  }
+  return { message, kind: "failed", ...status ? { status } : {} };
+}
+function stopsCatalogLookups(failure) {
+  return failure.kind !== "failed";
+}
+function describeBindings(bindings) {
+  return bindings.map((b) => `${b.kind} "${b.name}"`).join(", ");
+}
+function describeCause(failure) {
+  switch (failure.kind) {
+    case "no_session":
+      return "There is no login, so the Resource Catalog could not be searched";
+    case "refused":
+      return `The Resource Catalog refused this login (${failure.message})`;
+    default:
+      return `A Resource Catalog call failed (${failure.message})`;
+  }
+}
+function classify(failure) {
+  const refreshAndCommit = "or run 'uip solution resources refresh' under a login the Resource Catalog accepts and commit the solution's resources. The resources already in the solution are used as they are.";
+  if (failure.kind === "no_session") {
+    return {
+      errorCode: "authentication_required",
+      retry: "RetryWillNotFix",
+      instructions: `Run 'uip login', then re-run; ${refreshAndCommit}`
+    };
+  }
+  if (failure.kind === "refused") {
+    return {
+      errorCode: "permission_denied",
+      retry: "RetryWillNotFix",
+      instructions: `Use a login the Resource Catalog accepts (a user login: 'uip login'), ${refreshAndCommit}`
+    };
+  }
+  const status = failure.status;
+  if (status === 429) {
+    return {
+      errorCode: "rate_limited",
+      retry: "RetryLater",
+      instructions: `Wait, then re-run; ${refreshAndCommit}`
+    };
+  }
+  if (status !== undefined && status >= 500) {
+    return {
+      errorCode: "server_error",
+      retry: "RetryLater",
+      instructions: `Retry once the Resource Catalog is back; ${refreshAndCommit}`
+    };
+  }
+  if (status !== undefined && status >= 400) {
+    return {
+      errorCode: "unknown_error",
+      retry: "RetryWillNotFix",
+      instructions: `The Resource Catalog rejected the lookup for these bindings, so a retry gets the same answer. Check them in the project's bindings, ${refreshAndCommit}`
+    };
+  }
+  return {
+    errorCode: "unknown_error",
+    retry: "RetryLater",
+    instructions: `Retry; if it keeps failing, ${refreshAndCommit}`
+  };
+}
+function catalogLookupWarning(failure, kept, unresolved) {
+  const parts = [
+    `${describeCause(failure)}, so ${kept + unresolved.length} binding(s) were not checked against the cloud.`
+  ];
+  if (kept > 0) {
+    parts.push(`${kept} already in the solution were kept as they are.`);
+  }
+  if (unresolved.length > 0) {
+    parts.push(`Not added to the solution: ${describeBindings(unresolved)}.`);
+  }
+  return parts.join(" ");
+}
+
+class CatalogLookupError extends Error {
+  errorCode;
+  retry;
+  instructions;
+  unresolved;
+  constructor(failure, unresolved) {
+    super(`${describeCause(failure)}, so these bindings could not be resolved and are not in the solution: ${describeBindings(unresolved)}.`);
+    this.name = "CatalogLookupError";
+    const { errorCode, retry, instructions } = classify(failure);
+    this.errorCode = errorCode;
+    this.retry = retry;
+    this.instructions = instructions;
+    this.unresolved = unresolved;
+  }
+}
 // src/resources/services/local-resource-matcher.ts
 function normalizeFolderPath(path) {
   if (!path)
@@ -18519,6 +18218,20 @@ async function findCatalogEntityAsync(catalog, query, match) {
   } while (pageCursor);
   return;
 }
+async function findCatalogEntitiesAsync(catalog, query, match) {
+  const found = [];
+  let pageCursor;
+  do {
+    const page = await catalog.searchFolderEntities({
+      ...query,
+      pageSize: 100,
+      pageCursor
+    });
+    found.push(...(page.items ?? []).filter(match));
+    pageCursor = page.nextPage ?? undefined;
+  } while (pageCursor);
+  return found;
+}
 function toResourceReference(entity) {
   return toCatalogReference({
     kind: entity.entityType ?? "",
@@ -18572,7 +18285,7 @@ function parseJsonString(raw) {
   return error ? undefined : parsed;
 }
 // src/resources/services/resource-casing.ts
-var RESOURCE_FILES_FOLDER_NAME = "resources";
+var RESOURCE_FILES_FOLDER_NAME2 = "resources";
 function lowerFirstChar(value) {
   return value ? value.charAt(0).toLowerCase() + value.slice(1) : value;
 }
@@ -18601,7 +18314,7 @@ async function saveCasingNormalized(builder) {
 }
 async function normalizeResourceFileCasing(solutionDir) {
   const fs = getFileSystem();
-  const root = fs.path.join(solutionDir, RESOURCE_FILES_FOLDER_NAME);
+  const root = fs.path.join(solutionDir, RESOURCE_FILES_FOLDER_NAME2);
   if (!await fs.exists(root))
     return [];
   const byTarget = new Map;
@@ -18649,13 +18362,17 @@ function targetSegments(segments, kind, type) {
   const kindIndex = type ? target.length - 3 : target.length - 2;
   if (kindIndex < 0)
     return target;
-  if (target[kindIndex] === kind)
+  if (sameIgnoringCase(target[kindIndex], kind)) {
     target[kindIndex] = lowerFirstChar(kind);
-  if (type && target[kindIndex + 1] === type) {
+  }
+  if (type && sameIgnoringCase(target[kindIndex + 1], type)) {
     target[kindIndex + 1] = lowerFirstChar(type);
   }
   return target;
 }
+function sameIgnoringCase(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
 async function collectResourceFiles(root, segments) {
   const fs = getFileSystem();
   const [readError, names] = await catchError(fs.readdir(fs.path.join(root, ...segments)));
@@ -18728,6 +18445,118 @@ function parseResourceHeader(content) {
     return null;
   }
 }
+// src/resources/services/resource-configurations.ts
+var ROOT_RESOURCE_TYPES = new Set(["resource", "solutionresource"]);
+var KEY_NOT_FOUND = /^(?:Solution)?Resource with key '([^']+)' was not found$/i;
+function isResourceKeyNotFound(error, resourceKey) {
+  if (!(error instanceof Error))
+    return false;
+  const typed = error;
+  const sameKey = (key) => key !== undefined && key.toLowerCase() === resourceKey.toLowerCase();
+  if (typeof typed.resourceType === "string" && typeof typed.resourceKey === "string") {
+    return ROOT_RESOURCE_TYPES.has(typed.resourceType.toLowerCase()) && sameKey(typed.resourceKey);
+  }
+  return sameKey(KEY_NOT_FOUND.exec(error.message.trim())?.[1]);
+}
+async function refreshArtefactSpecsAsync(builder, configurations) {
+  const resources = new Map;
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError || !solution)
+    return resources;
+  for (const configuration of configurations) {
+    const resource = solution.resources.find((r) => r.key === configuration?.key);
+    if (!resource)
+      continue;
+    resources.set(resource.key, resource);
+    if (!resource.projectKey)
+      continue;
+    configuration.spec = await applyEntryPointEnhancementAsync(builder.context, resource, configuration.spec ?? {});
+  }
+  return resources;
+}
+async function exportResourceConfigurationsAsync(services2, resourceKey, hint = {}) {
+  const { catalog, importer } = getRemoteResourceClients(services2);
+  const byKey = (item) => item.entityKey === resourceKey;
+  const entity = (hint.name ? await findCatalogEntityAsync(catalog, { name: hint.name }, byKey) : undefined) ?? await findCatalogEntityAsync(catalog, {}, byKey);
+  if (!entity) {
+    throw new Error(`Resource '${resourceKey}' was not found in the solution or in the resource catalog`);
+  }
+  const payload = await importer.exportResourceAsync(toResourceReference(entity));
+  const definitions = payload.resourceDefinitions ?? [];
+  if (definitions.length === 0) {
+    throw new Error(`FPS export for '${resourceKey}' returned no resource definitions`);
+  }
+  return {
+    resources: definitions.map((d) => ({
+      key: d.key ?? "",
+      spec: d.spec ?? {},
+      locks: d.locks ?? [],
+      apiVersion: d.apiVersion,
+      isOverridable: d.isOverridable,
+      name: d.name ?? "",
+      kind: d.kind ?? "",
+      dependencies: (d.dependencies ?? []).map((dep) => ({
+        kind: dep.kind ?? "",
+        name: dep.name ?? ""
+      }))
+    }))
+  };
+}
+async function readLocalAsync(builder, resourceKey, read) {
+  if (!builder)
+    return;
+  const [error, value] = await catchError(read(builder));
+  if (!error)
+    return { builder, value };
+  if (isResourceKeyNotFound(error, resourceKey))
+    return;
+  throw error;
+}
+async function readResourceConfigurationsAsync(services2, builder, resourceKey, hint = {}) {
+  const local = await readLocalAsync(builder, resourceKey, (b) => b.getAllConfigurationsAsync(resourceKey));
+  if (!local) {
+    return exportResourceConfigurationsAsync(services2, resourceKey, hint);
+  }
+  await refreshArtefactSpecsAsync(local.builder, local.value?.resources ?? []);
+  return local.value;
+}
+async function readResourceConfigurationAsync(services2, builder, resourceKey) {
+  const local = await readLocalAsync(builder, resourceKey, (b) => b.getConfigurationAsync(resourceKey));
+  if (local) {
+    const configuration = local.value;
+    const resources2 = await refreshArtefactSpecsAsync(local.builder, [
+      configuration
+    ]);
+    return { configuration, resource: resources2.get(configuration.key) };
+  }
+  const { resources } = await exportResourceConfigurationsAsync(services2, resourceKey);
+  const primary = resources.find((r) => r.key === resourceKey) ?? resources[0];
+  const { key, spec, locks, apiVersion, isOverridable } = primary;
+  return { configuration: { key, spec, locks, apiVersion, isOverridable } };
+}
+// src/resources/services/resource-lookup.ts
+async function findResourcesByNameAsync(services2, builder, { kind, name, subTypes, folderKey }) {
+  const same = (a, b) => (a ?? "").toLowerCase() === b.toLowerCase();
+  const ofSubType = (type) => subTypes === undefined || subTypes.some((t) => same(type, t));
+  if (builder) {
+    const solution = await builder.context.loadAsync();
+    const local = solution.resources.filter((r) => same(r.kind, kind) && same(r.name, name) && ofSubType(r.type)).map((r) => ({
+      key: r.key,
+      local: true,
+      folderPath: r.folders?.[0]?.fullyQualifiedName
+    }));
+    if (local.length > 0)
+      return local;
+  }
+  const { catalog } = getRemoteResourceClients(services2);
+  const rows = await findCatalogEntitiesAsync(catalog, { name, entityTypes: [kind] }, (row) => same(row.entityType, kind) && same(row.entityName, name) && ofSubType(row.entitySubType) && (folderKey === undefined || same(row.folderKey, folderKey)));
+  return rows.map((row) => ({
+    key: row.entityKey ?? "",
+    local: false,
+    folderPath: row.fullyQualifiedName ?? undefined,
+    folderKey: row.folderKey ?? undefined
+  }));
+}
 // src/resources/services/resource-name.ts
 var MAX_RESOURCE_NAME_LENGTH = 256;
 var UNSAFE_NAME_CHARS = /[\\/:*?"<>|]/;
@@ -18775,6 +18604,9 @@ var TYPE_IS_IDENTITY_REPLACE_OPTIONS = new Set([
   "SameNameAndType"
 ]);
 var BINDINGS_JSON_FALLBACK_TYPES = new Set(["agent", "function"]);
+
+class OverwriteRefreshError extends Error {
+}
 function placeholderForType(type) {
   switch ((type ?? "string").toLowerCase()) {
     case "boolean":
@@ -18875,13 +18707,15 @@ function resolveBindingResourceIdentity(binding) {
       };
   }
 }
-async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTypes) {
+async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTypes, projectBindings) {
   const result = {
     created: 0,
     imported: 0,
     skipped: 0,
     pruned: 0,
-    warnings: []
+    projectResourcesCreated: 0,
+    warnings: [],
+    unresolved: []
   };
   const uipxProjects = await readUipxProjects(solutionDir);
   const paths = projectPaths ?? uipxProjects.map((p) => p.path);
@@ -18895,7 +18729,7 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     return result;
   }
   const serializer = services2.container.resolve(Tokens.IBindingsMetadataSerializer);
-  const { bindings: allBindings, parseErrors } = await collectBindings(solutionDir, paths, bindingsJsonFallbackDirs, serializer);
+  const { bindings: allBindings, parseErrors } = await collectBindings(bindingsJsonFallbackDirs, serializer, bindingSources(solutionDir, paths, uipxProjects, projectBindings));
   if (parseErrors.length > 0) {
     const detail = parseErrors.map((e) => `${e.path}: ${e.reason}`).join("; ");
     throw new Error(`Invalid bindings file — ${detail}`);
@@ -18909,7 +18743,8 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     logger.warn(`Failed to get solution builder: ${builderError.message}`);
     return result;
   }
-  await reconcileSolutionProjects(builder, solutionDir, projectSubTypes);
+  const reconcileOutcome = await reconcileSolutionProjects(builder, solutionDir, projectSubTypes);
+  result.projectResourcesCreated = reconcileOutcome.resourcesAdded;
   const memberProjectKeys = new Set(uipxProjects.map((project) => project.id.toLowerCase()));
   await pruneMemberClones(builder, memberProjectKeys, result);
   if (allBindings.length === 0) {
@@ -18924,6 +18759,28 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
   const resolveKindMetadata = await buildKindResolver(metadataReader);
   const solution = await builder.context.loadAsync();
   const knownResourceKeys = new Set((solution.resources ?? []).map((r) => r.key?.toLowerCase()).filter((k) => !!k));
+  let keptUnchecked = 0;
+  const resolvedKeys = new Set;
+  const overwrittenKeys = new Set;
+  const bindingKey = (kind, name) => `${kind}:${name ?? ""}`.toLowerCase();
+  const recordUnchecked = async (error, kind, name, directCloudKey) => {
+    if (error) {
+      const failure = classifyCatalogFailure(error);
+      if (!result.catalogLookupFailure || stopsCatalogLookups(failure) && !stopsCatalogLookups(result.catalogLookupFailure)) {
+        result.catalogLookupFailure = failure;
+      }
+    }
+    const covered = await isUncheckedBindingCovered(builder, knownResourceKeys, kind, name, directCloudKey);
+    if (covered) {
+      keptUnchecked++;
+      result.skipped++;
+      return;
+    }
+    result.unresolved.push({
+      kind,
+      name: directCloudKey ?? name
+    });
+  };
   const virtualCandidates = [];
   for (const binding of allBindings) {
     const identity = resolveBindingResourceIdentity(binding);
@@ -18953,7 +18810,12 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
       logger.info(`Skipping ${kind} "${name}" — the solution provisions this project itself; its member declaration covers the binding`);
       continue;
     }
-    const rcsMatch = directCloudKey ? await findResourceByKeyInRcs(builder, kind, directCloudKey, folderPath) : await findResourceInRcs(builder, kind, name, folderPath);
+    const lookupsStopped = !!result.catalogLookupFailure && stopsCatalogLookups(result.catalogLookupFailure);
+    const [lookupError, rcsMatch] = lookupsStopped ? [undefined, undefined] : await catchError(directCloudKey ? findResourceByKeyInRcs(builder, kind, directCloudKey, folderPath, true) : findResourceInRcs(builder, kind, name, folderPath, true));
+    if (lookupsStopped || lookupError) {
+      await recordUnchecked(lookupError, kind, name, directCloudKey);
+      continue;
+    }
     const resolvedType = identity.type ?? rcsMatch?.type ?? metadata?.type;
     if (!rcsMatch) {
       if (isConnection) {
@@ -18972,30 +18834,48 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     }
     if (!isConnection && rcsMatch.key && knownResourceKeys.has(rcsMatch.key.toLowerCase())) {
       result.skipped++;
+      resolvedKeys.add(bindingKey(kind, name));
       continue;
     }
     const callType = isConnection ? binding.metadata?.connector : resolvedType;
-    const [importError] = await catchError(builder.addOrUpdateResourceToSolutionAsync({
+    const wasKnown = !!rcsMatch.key && knownResourceKeys.has(rcsMatch.key.toLowerCase());
+    const reference = {
       kind,
       type: callType,
       key: rcsMatch.key,
       name: rcsMatch.name,
       folder: rcsMatch.folder
-    }, true));
+    };
+    const [importError] = await catchError(wasKnown ? refreshKnownResource(services2, builder, reference, overwrittenKeys) : builder.addOrUpdateResourceToSolutionAsync(reference, true));
     if (!importError) {
+      resolvedKeys.add(bindingKey(kind, directCloudKey ?? name));
+      if (wasKnown) {
+        result.skipped++;
+        logger.info(`Refreshed ${kind} "${rcsMatch.name}" (key: ${rcsMatch.key}), already in solution`);
+        continue;
+      }
       if (rcsMatch.key) {
         knownResourceKeys.add(rcsMatch.key.toLowerCase());
+        overwrittenKeys.add(rcsMatch.key.toLowerCase());
       }
       result.imported++;
       logger.info(`Imported ${kind} "${rcsMatch.name}" (key: ${rcsMatch.key}) into solution`);
       continue;
     }
+    if (stopsCatalogLookups(classifyCatalogFailure(importError))) {
+      await recordUnchecked(importError, kind, name, directCloudKey);
+      continue;
+    }
     if (isConnection) {
-      result.warnings.push(`Failed to import connection ${directCloudKey}: ${importError.message}`);
-      logger.warn(`Failed to import connection ${directCloudKey}: ${importError.message}`);
+      const failedStep = importError instanceof OverwriteRefreshError ? "refresh the debug overwrite for" : "import";
+      const warning = `Failed to ${failedStep} connection ${directCloudKey}: ${importError.message}`;
+      result.warnings.push(warning);
+      logger.warn(warning);
       continue;
     }
-    logger.warn(`Failed to import ${kind} "${name}" from Orchestrator: ${importError.message}. Will create locally instead.`);
+    const importWarning = `Failed to import ${kind} "${name}" from Orchestrator: ${importError.message}. Created it locally instead; link it before deploy if it must point at the cloud resource.`;
+    result.warnings.push(importWarning);
+    logger.warn(importWarning);
     virtualCandidates.push({
       binding,
       kind,
@@ -19014,11 +18894,29 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     return true;
   });
   for (const candidate of dedupedVirtuals) {
-    const [syncError] = await catchError(createVirtualForBinding(builder, candidate.binding, candidate.kind, candidate.type, candidate.metadata, candidate.name, candidate.folderPath, result));
+    const [syncError, created] = await catchError(createVirtualForBinding(builder, candidate.binding, candidate.kind, candidate.type, candidate.metadata, candidate.name, candidate.folderPath, result));
     if (syncError) {
       logger.warn(`Failed to create virtual ${candidate.kind}/${candidate.name}: ${syncError.message}`);
+    } else if (created) {
+      resolvedKeys.add(bindingKey(candidate.kind, candidate.name));
     }
   }
+  if (result.catalogLookupFailure) {
+    const seen = new Set;
+    result.unresolved = result.unresolved.filter((b) => {
+      const key = bindingKey(b.kind, b.name);
+      if (resolvedKeys.has(key)) {
+        keptUnchecked++;
+        result.skipped++;
+        return false;
+      }
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+    result.warnings.push(catalogLookupWarning(result.catalogLookupFailure, keptUnchecked, result.unresolved));
+  }
   const saveError = await saveAndDisposeBuilder(builder, solutionDir);
   if (saveError) {
     throw new Error(`Failed to save solution changes: ${saveError.message}`);
@@ -19046,6 +18944,43 @@ async function pruneMemberClones(builder, memberProjectKeys, result) {
     logger.info(`Removed duplicate ${clone.kind} "${clone.name}" (key: ${clone.key}) — the solution provisions this project itself`);
   }
 }
+async function isUncheckedBindingCovered(builder, knownResourceKeys, kind, name, directCloudKey) {
+  if (directCloudKey) {
+    return knownResourceKeys.has(directCloudKey.toLowerCase());
+  }
+  const solution = await builder.context.loadAsync();
+  return !!findMatchingLocalResource(solution.resources ?? [], kind, name, undefined);
+}
+async function refreshKnownResource(services2, builder, reference, overwrittenKeys) {
+  const solution = await builder.context.loadAsync();
+  const referenceKey = reference.key.toLowerCase();
+  const existing = (solution.resources ?? []).find((resource) => resource.key?.toLowerCase() === referenceKey);
+  const mediator = services2.container.resolve(Tokens.IMediator);
+  const response = await mediator.sendCommandAsync(new AddOrUpdateResourceToSolutionCommand(builder.context, reference, true, existing?.key));
+  const sdkWroteOverwrite = response.saved && existing?.key === reference.key;
+  if (!existing || sdkWroteOverwrite || overwrittenKeys.has(referenceKey)) {
+    overwrittenKeys.add(referenceKey);
+    return response;
+  }
+  const [overwriteError] = await catchError(refreshOverwrite(services2, builder, reference, existing.key));
+  if (overwriteError)
+    throw new OverwriteRefreshError(overwriteError.message);
+  overwrittenKeys.add(referenceKey);
+  return response;
+}
+async function refreshOverwrite(services2, builder, reference, solutionResourceKey) {
+  const importer = services2.container.resolve(Tokens.IImportResourceHelper);
+  const payload = await importer.exportResourceAsync(reference);
+  const referenceKey = reference.key.toLowerCase();
+  const overwrite = [...payload.overwrites].find(([key]) => key.toLowerCase() === referenceKey)?.[1];
+  if (!overwrite) {
+    throw new Error(`Overwrite not found for resource key '${reference.key}' in exported payload`);
+  }
+  const overwrites = services2.container.resolve(Tokens.IResourceOverwritesService);
+  await overwrites.manageSolutionOverwritesAsync(builder.context, [
+    { solutionResourceKey, overwrite }
+  ]);
+}
 async function saveAndDisposeBuilder(builder, solutionDir) {
   const context = builder.context;
   if (!context?.forceSaveChangesAsync) {
@@ -19115,11 +19050,11 @@ async function createVirtualForBinding(builder, _binding, kind, type, metadata,
   if (alreadyVirtualized) {
     result.skipped++;
     logger.info(`Skipping virtual ${kind} "${name}" — existing resource "${alreadyVirtualized.name}" in solution_folder already covers this binding (requested folder "${folderPath}")`);
-    return;
+    return true;
   }
   const minted = await mintVirtualResource(builder, kind, type, name, metadata);
   if (!minted)
-    return;
+    return false;
   result.created++;
   logger.info(`Created ${kind} "${name}" in solution`);
   if (!virtualizable) {
@@ -19127,6 +19062,7 @@ async function createVirtualForBinding(builder, _binding, kind, type, metadata,
     result.warnings.push(warning);
     logger.warn(warning);
   }
+  return true;
 }
 async function findResourceByKeyInRcs(builder, kind, expectedKey, folderPath, propagateErrors = false) {
   const expectedLower = expectedKey.toLowerCase();
@@ -19204,8 +19140,8 @@ async function searchRcsResourcesStrict(builder, kind, name) {
   } while (pageCursor);
   return allMatches;
 }
-async function findResourceInRcs(builder, kind, name, folderPath) {
-  const allMatches = await searchRcsResources(builder, kind, name);
+async function findResourceInRcs(builder, kind, name, folderPath, propagateErrors = false) {
+  const allMatches = propagateErrors ? await searchRcsResourcesStrict(builder, kind, name) : await searchRcsResources(builder, kind, name);
   if (allMatches.length === 0) {
     return;
   }
@@ -19303,9 +19239,15 @@ async function readUiprojName(uiprojPath) {
     return;
   }
 }
+async function snapshotResourceIdentities(builder) {
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError || !solution)
+    return;
+  return new Set((solution.resources ?? []).map((resource) => resource.key ? resource.key.toLowerCase() : `${resource.kind}:${resource.name}`.toLowerCase()));
+}
 async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes) {
   const fs = getFileSystem();
-  const outcome = { projectsCount: 0 };
+  const outcome = { projectsCount: 0, resourcesAdded: 0 };
   const uipxProjects = await readUipxProjects(solutionDir);
   const projectDetails = uipxProjects.flatMap((project) => {
     const reconcileType = mapUipxTypeToReconcileType(project.type);
@@ -19323,6 +19265,7 @@ async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes)
   if (projectDetails.length === 0)
     return outcome;
   const solutionName = fs.path.basename(solutionDir);
+  const before = await snapshotResourceIdentities(builder);
   const [reconcileError] = await catchError(builder.reconcileProjectsAsync({
     solutionName,
     projects: projectDetails
@@ -19332,6 +19275,10 @@ async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes)
     return outcome;
   }
   outcome.projectsCount = projectDetails.length;
+  const after = before && await snapshotResourceIdentities(builder);
+  if (before && after) {
+    outcome.resourcesAdded = [...after].filter((identity) => !before.has(identity)).length;
+  }
   logger.info(`Reconciled ${projectDetails.length} .uipx project(s) in solution ${solutionName}`);
   return outcome;
 }
@@ -19373,12 +19320,48 @@ function findBindingsSchemaError(content) {
   }
   return null;
 }
-async function collectBindings(solutionDir, projectPaths, bindingsJsonFallbackDirs, serializer) {
+function bindingSources(solutionDir, projectPaths, projects, projectBindings) {
+  const sources = [{ directory: solutionDir }];
+  const fileDirectories = new Set([solutionDir]);
+  const contributedIds = new Set;
+  for (const directory of new Set(projectPaths)) {
+    const owners = projects.filter((project) => project.path === directory);
+    for (const project of owners) {
+      const bindings = projectBindings?.get(project.id);
+      if (bindings === undefined || contributedIds.has(project.id))
+        continue;
+      contributedIds.add(project.id);
+      sources.push({
+        directory,
+        contribution: { projectId: project.id, bindings }
+      });
+    }
+    const needsFile = owners.length === 0 || owners.some((project) => !projectBindings?.has(project.id));
+    if (needsFile && !fileDirectories.has(directory)) {
+      fileDirectories.add(directory);
+      sources.push({ directory });
+    }
+  }
+  return sources;
+}
+async function collectBindings(bindingsJsonFallbackDirs, serializer, sources) {
   const fs = getFileSystem();
   const allBindings = [];
   const parseErrors = [];
-  const candidateDirs = [solutionDir, ...projectPaths];
-  for (const dir of candidateDirs) {
+  for (const { directory: dir, contribution } of sources) {
+    if (contribution) {
+      if (contribution.bindings.length === 0)
+        continue;
+      const parsed2 = deserializeBindings(JSON.stringify({
+        version: "2.0",
+        resources: contribution.bindings
+      }), `${dir} (bindings contributed by the project's tool; project ${contribution.projectId})`, serializer);
+      if ("error" in parsed2)
+        parseErrors.push(parsed2.error);
+      else
+        allBindings.push(...parsed2.resources);
+      continue;
+    }
     const v2Path = fs.path.join(dir, "bindings_v2.json");
     let bindingsPath = v2Path;
     let exists = await fs.exists(v2Path);
@@ -19397,37 +19380,44 @@ async function collectBindings(solutionDir, projectPaths, bindingsJsonFallbackDi
       });
       continue;
     }
-    const decoded = new TextDecoder().decode(content);
-    let success;
-    let metadata;
-    try {
-      const result = serializer.tryDeserialize(decoded);
-      success = result.success;
-      metadata = result.metadata;
-    } catch (err) {
-      parseErrors.push({
-        path: bindingsPath,
+    const parsed = deserializeBindings(new TextDecoder().decode(content), bindingsPath, serializer);
+    if ("error" in parsed)
+      parseErrors.push(parsed.error);
+    else
+      allBindings.push(...parsed.resources);
+  }
+  return { bindings: allBindings, parseErrors };
+}
+function deserializeBindings(decoded, source, serializer) {
+  let success;
+  let metadata;
+  try {
+    const result = serializer.tryDeserialize(decoded);
+    success = result.success;
+    metadata = result.metadata;
+  } catch (err) {
+    return {
+      error: {
+        path: source,
         reason: findBindingsSchemaError(decoded) ?? `does not match the expected v2 bindings schema — check each resource's 'kind' and required fields${err instanceof Error ? ` (${err.message})` : ""}`
-      });
-      continue;
-    }
-    if (!success) {
-      parseErrors.push({
-        path: bindingsPath,
+      }
+    };
+  }
+  if (!success) {
+    return {
+      error: {
+        path: source,
         reason: findBindingsSchemaError(decoded) ?? "does not match the expected v2 bindings schema (the serializer rejected it)"
-      });
-      continue;
-    }
-    if (!metadata?.resources?.length) {
-      continue;
-    }
-    allBindings.push(...metadata.resources);
+      }
+    };
   }
-  return { bindings: allBindings, parseErrors };
+  return { resources: metadata?.resources ?? [] };
 }
-async function syncAndLog(solutionDir, projectSubTypes) {
-  const [syncError, syncResult] = await catchError(syncResourcesFromBindings(solutionDir, undefined, projectSubTypes));
+async function syncAndLog(solutionDir, projectSubTypes, options) {
+  const [syncError, syncResult] = await catchError(syncResourcesFromBindings(solutionDir, undefined, projectSubTypes, options?.projectBindings));
   if (syncError) {
+    if (options?.failOnUnresolved)
+      throw syncError;
     logger.warn(`Resource sync failed: ${syncError.message}. Continuing.`);
     return;
   }
@@ -19437,6 +19427,9 @@ async function syncAndLog(solutionDir, projectSubTypes) {
   for (const warning of syncResult.warnings) {
     logger.warn(warning);
   }
+  if (options?.failOnUnresolved && syncResult.catalogLookupFailure && syncResult.unresolved.length > 0) {
+    throw new CatalogLookupError(syncResult.catalogLookupFailure, syncResult.unresolved);
+  }
 }
 
 // src/resources/services/resource-refresh-service.ts
@@ -19473,7 +19466,11 @@ async function resourceRefreshAsync(solutionPath = ".", options = {}) {
   const resolverWarnings = subTypesError ? [
     `Could not resolve project subTypes: ${subTypesError.message}. Project artefacts for types that need a variant were left as they are; fix the tool install and re-run 'uip solution resources refresh'.`
   ] : [];
-  const [syncError, result] = await catchError(syncResourcesFromBindings(resolvedPath, undefined, projectSubTypes ?? new Map));
+  const [bindingsError, projectBindings] = await catchError(options.resolveProjectBindingsAsync?.() ?? Promise.resolve(new Map));
+  if (bindingsError) {
+    resolverWarnings.push(`Could not read the bindings projects contribute: ${bindingsError.message}. Those projects were synced from any bindings_v2.json on disk instead; fix the tool install and re-run 'uip solution resources refresh'.`);
+  }
+  const [syncError, result] = await catchError(syncResourcesFromBindings(resolvedPath, undefined, projectSubTypes ?? new Map, projectBindings ?? new Map));
   if (syncError) {
     return {
       ok: false,
@@ -19487,6 +19484,7 @@ async function resourceRefreshAsync(solutionPath = ".", options = {}) {
     imported: result.imported,
     skipped: result.skipped,
     pruned: result.pruned,
+    projectResourcesCreated: result.projectResourcesCreated,
     warnings: [...resolverWarnings, ...result.warnings]
   };
 }
@@ -19668,6 +19666,7 @@ function sortKeysDeep(value) {
   return sorted;
 }
 export {
+  CatalogLookupError,
   EntryPointSpecEnhancer,
   MAX_RESOURCE_NAME_LENGTH,
   ProjectManifestError,
@@ -19680,7 +19679,9 @@ export {
   createProjectInSolutionBuilder,
   createResourceBuilderServices,
   createResourceKindMetadataResolver,
+  exportResourceConfigurationsAsync,
   exportResourceDefinitionAsync,
+  findCatalogEntitiesAsync,
   findCatalogEntityAsync,
   findMatchingLocalResource,
   findMatchingMemberResource,
@@ -19688,21 +19689,26 @@ export {
   findProjectFile,
   findResourceByKeyInRcs,
   findResourceInRcs,
+  findResourcesByNameAsync,
   formatResourceSubtypes,
   getRemoteResourceClients,
   hasAnyTemplateRow,
   hasBareTemplateRow,
   isMissingProjectTypeError,
   isProjectManifestError,
+  isResourceKeyNotFound,
   normalizeFolderPath,
   normalizeResourceCasing,
   normalizeResourceFileCasing,
   readProjectFile,
+  readResourceConfigurationAsync,
+  readResourceConfigurationsAsync,
   readSolutionFile,
   readSolutionManifest,
   readSpecEntryPoints,
   readSpecProperty,
   readUipxProjects,
+  refreshArtefactSpecsAsync,
   resolveProjectDirFromManifest,
   resolveResourceKindMetadata,
   resolveSolutionFilePath,
@@ -19722,4 +19728,4 @@ export {
   writeSolutionFile
 };
 
-//# debugId=177609A48706C50164756E2164756E21
+//# debugId=6996E99F6A38BCF964756E2164756E21