@uipath/maestro-tool 1.204.0 → 1.205.0-preview.258

package/dist/bpmn-validate-service-7e3q83nh.js

@@ -0,0 +1,16 @@
+import {
+  BpmnValidateService
+} from "./packager-tool-jt51hwvr.js";
+import"./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
+import"./packager-tool-hdxtgckw.js";
+import"./packager-tool-yvcrdbgp.js";
+import"./packager-tool-cza49qc1.js";
+import"./packager-tool-sm8ertv4.js";
+import"./packager-tool-wv85dhy2.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  BpmnValidateService
+};
+
+//# debugId=BCA3978C49918B2164756E2164756E21

package/dist/{business-rule-export-j6xxtp5s.js → business-rule-export-xa719ws5.js}

@@ -4,14 +4,14 @@ import {
 
 // ../case-tool/src/services/business-rule-export.ts
 async function readBusinessRuleEntryPointAsync(entry) {
-  const { getSolutionAuthContext } = await import("./solution-auth-kddmbm0p.js");
+  const { getSolutionAuthContext } = await import("./solution-auth-30yycqtv.js");
   const {
     createResourceBuilderServices,
     exportResourceDefinitionAsync,
     getRemoteResourceClients,
     readSpecEntryPoints,
     toCatalogReference
-  } = await import("./index-1htnjt3c.js");
+  } = await import("./index-ewv0axs9.js");
   await getSolutionAuthContext({});
   const { importer } = getRemoteResourceClients(await createResourceBuilderServices());
   const folder = entry.folders?.[0];

package/dist/canvas-notes-xc2ejzqj.js

@@ -0,0 +1,23 @@
+import {
+  STICKY_NOTE_TYPE,
+  carryCanvasNotes,
+  carryCanvasNotesFrom,
+  emitCanvasNotes,
+  sddNoteId
+} from "./packager-tool-kvp4ttef.js";
+import"./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
+import"./packager-tool-hdxtgckw.js";
+import"./packager-tool-yvcrdbgp.js";
+import"./packager-tool-sm8ertv4.js";
+import"./packager-tool-wv85dhy2.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  STICKY_NOTE_TYPE,
+  carryCanvasNotes,
+  carryCanvasNotesFrom,
+  emitCanvasNotes,
+  sddNoteId
+};
+
+//# debugId=ADE71172E180A4A364756E2164756E21

package/dist/{case-api-bxcxbgm9.js → case-api-v64traxv.js}

@@ -1,25 +1,27 @@
 import {
   parseJsonInputOrFile
-} from "./packager-tool-2k0hp4st.js";
+} from "./packager-tool-sb08yxk6.js";
 import"./packager-tool-eypvc2kv.js";
 import {
   JobsApi,
   ReleasesApi,
   createOrchestratorConfig,
   resolveFolder
-} from "./packager-tool-znhjsec2.js";
-import"./packager-tool-v99ygh9f.js";
+} from "./packager-tool-wwbk750c.js";
+import"./packager-tool-yn33pw57.js";
 import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
 import"./packager-tool-yc4kw997.js";
 import {
   OutputFormatter
-} from "./packager-tool-yv10w46z.js";
-import"./packager-tool-xdxr3ync.js";
+} from "./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
+import"./packager-tool-hdxtgckw.js";
 import"./packager-tool-yvcrdbgp.js";
+import"./packager-tool-sm8ertv4.js";
 import {
   catchError
-} from "./packager-tool-z1qbc0qf.js";
+} from "./packager-tool-wv85dhy2.js";
 import"./packager-tool-1yh8g550.js";
 
 // ../case-tool/src/services/http-client.ts
@@ -381,4 +383,4 @@ export {
   validateCaseInputs
 };
 
-//# debugId=4A044FFDD694ADA164756E2164756E21
+//# debugId=67889F40CAAE00D164756E2164756E21

package/dist/case-bindings-service-hwz2h03e.js

@@ -0,0 +1,434 @@
+import {
+  BINDINGS_V2_FILE_NAME,
+  CONNECTION_ID_PROPERTY,
+  FOLDER_KEY_PROPERTY,
+  RESOURCE_BINDINGS_VERSION,
+  deriveEventTriggerResources,
+  diffBindingsV2,
+  hasBindingsV2Difference,
+  readBindingsV2Resources,
+  readEntryPointIds,
+  serializeBindingsV2File
+} from "./packager-tool-s7frnjqb.js";
+import"./packager-tool-r00e2fb3.js";
+import"./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
+import {
+  getFileSystem
+} from "./packager-tool-hdxtgckw.js";
+import"./packager-tool-yvcrdbgp.js";
+import"./packager-tool-sm8ertv4.js";
+import {
+  catchError
+} from "./packager-tool-wv85dhy2.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/case-bindings-service.ts
+var asBinding = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  return typeof record.id === "string" && typeof record.resource === "string" && typeof record.resourceKey === "string" && record.resourceKey !== "" && typeof record.propertyAttribute === "string" && (record.default === undefined || typeof record.default === "string") ? value : undefined;
+};
+var CONNECTION_RESOURCE = "Connection";
+var IMPLICIT_CONNECTION = "ImplicitConnection";
+var DROPPED_RESOURCES = new Set([
+  "connection",
+  "eventtrigger"
+]);
+var bindingIdentity = (resource, key) => `${resource.toLowerCase()}:${key}`;
+var NAME_ATTRIBUTE = "name";
+var FOLDER_PATH_ATTRIBUTE = "folderPath";
+var SOLUTION_FOLDER_PREFIX = "solution_folder.";
+var SOLUTION_FOLDER_SENTINEL = "solution_folder";
+var BINDING_REFERENCE_PREFIX = "=bindings.";
+var CONNECTOR_KEY_ENTRY = "connectorKey";
+var CONNECTION_ENTRY = "connection";
+var readConnectorContext = (value) => {
+  if (!Array.isArray(value))
+    return;
+  const byName = new Map;
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+      return;
+    const { name, value: entryValue } = entry;
+    if (typeof name !== "string")
+      return;
+    if (typeof entryValue === "string")
+      byName.set(name, entryValue);
+  }
+  return byName.has(CONNECTOR_KEY_ENTRY) ? byName : undefined;
+};
+var ownLabel = (node) => {
+  const record = node;
+  for (const candidate of [
+    record.displayName,
+    record.display?.label,
+    record.label
+  ]) {
+    if (typeof candidate === "string" && candidate !== "")
+      return candidate;
+  }
+  return;
+};
+var walkLabelled = (document, visit) => {
+  const walk = (node, label) => {
+    visit(node, label);
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item, label);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    const scoped = ownLabel(node) ?? label;
+    for (const value of Object.values(node))
+      walk(value, scoped);
+  };
+  walk(document, undefined);
+};
+var httpTargetConnector = (node) => {
+  if (node === null || typeof node !== "object" || Array.isArray(node))
+    return;
+  const task = node;
+  if (task.type !== "http-request" || !Array.isArray(task.data?.inputs))
+    return;
+  for (const input of task.data.inputs) {
+    const body = input?.body;
+    if (input.name === "body" && typeof body?.targetConnector === "string" && body.targetConnector !== "") {
+      return body.targetConnector;
+    }
+  }
+  return;
+};
+var collectConnectorKeys = (document) => {
+  const byBindingId = new Map;
+  walkLabelled(document, (node, label) => {
+    const target = httpTargetConnector(node);
+    if (target !== undefined) {
+      const context = readConnectorContext(node.data?.context);
+      const connection = context?.get(CONNECTION_ENTRY);
+      if (connection?.startsWith(BINDING_REFERENCE_PREFIX)) {
+        const bindingId = connection.slice(BINDING_REFERENCE_PREFIX.length);
+        if (!byBindingId.has(bindingId)) {
+          byBindingId.set(bindingId, {
+            connectorKey: target,
+            activityName: ownLabel(node) ?? label
+          });
+        }
+      }
+    }
+    if (Array.isArray(node)) {
+      const context = readConnectorContext(node);
+      const connection = context?.get(CONNECTION_ENTRY);
+      const connectorKey = context?.get(CONNECTOR_KEY_ENTRY);
+      const bindingId = connection?.startsWith(BINDING_REFERENCE_PREFIX) ? connection.slice(BINDING_REFERENCE_PREFIX.length) : undefined;
+      if (connectorKey !== undefined && bindingId !== undefined && !byBindingId.has(bindingId)) {
+        byBindingId.set(bindingId, {
+          connectorKey,
+          activityName: label
+        });
+      }
+    }
+  });
+  return byBindingId;
+};
+var attributeDefault = (group, attribute) => group.find((binding) => binding.propertyAttribute === attribute)?.default;
+var connectionEntry = (group, connectorKeys) => {
+  const key = group[0].resourceKey;
+  const use = group.map((binding) => connectorKeys.get(binding.id)).find((found) => found !== undefined);
+  const displayLabel = (group.find((binding) => binding.propertyAttribute === CONNECTION_ID_PROPERTY) ?? group[0]).name;
+  const value = {
+    [CONNECTION_ID_PROPERTY]: {
+      defaultValue: attributeDefault(group, CONNECTION_ID_PROPERTY) ?? key,
+      isExpression: false,
+      ...typeof displayLabel === "string" && displayLabel !== "" && { displayName: displayLabel }
+    }
+  };
+  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined) {
+    value[FOLDER_KEY_PROPERTY] = { defaultValue: folderKey };
+  }
+  return {
+    resource: CONNECTION_RESOURCE,
+    key,
+    id: `${CONNECTION_RESOURCE}${key}`,
+    value,
+    metadata: {
+      ...use?.activityName !== undefined && {
+        ActivityName: use.activityName
+      },
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      ...typeof displayLabel === "string" && displayLabel !== "" && { DisplayLabel: displayLabel },
+      UseConnectionService: "true",
+      ...use !== undefined && { Connector: use.connectorKey }
+    }
+  };
+};
+var SLOT_DISPLAY_NAMES = {
+  app: { name: "App name", folderPath: "Folder path" },
+  process: { name: "Process name", folderPath: "Folder path" }
+};
+var designerResourceEntry = (group, labels, names) => {
+  const key = group[0].resourceKey;
+  const resource = group[0].resource;
+  const value = {};
+  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
+  if (folderPath !== undefined) {
+    value.folderPath = {
+      defaultValue: folderPath,
+      isExpression: false,
+      displayName: names.folderPath
+    };
+  }
+  const name = attributeDefault(group, NAME_ATTRIBUTE);
+  if (name !== undefined) {
+    value.name = {
+      defaultValue: name,
+      isExpression: false,
+      displayName: names.name
+    };
+  }
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  const activityName = group.map((binding) => labels.get(binding.id)).find((found) => found !== undefined);
+  return {
+    resource,
+    key,
+    id: `${resource}${key}`,
+    value,
+    metadata: {
+      ...activityName !== undefined && { ActivityName: activityName },
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      DisplayLabel: NAME_ATTRIBUTE,
+      SolutionsSupport: "true",
+      ...subType !== undefined && { subType }
+    }
+  };
+};
+var collectBindingLabels = (document) => {
+  const found = new Map;
+  walkLabelled(document.nodes ?? [], (node, label) => {
+    if (typeof node !== "string" || label === undefined || !node.startsWith(BINDING_REFERENCE_PREFIX)) {
+      return;
+    }
+    const id = node.slice(BINDING_REFERENCE_PREFIX.length);
+    if (!found.has(id))
+      found.set(id, label);
+  });
+  return found;
+};
+var resourceEntry = (group, labels = new Map) => {
+  const names = SLOT_DISPLAY_NAMES[group[0].resource];
+  if (names !== undefined)
+    return designerResourceEntry(group, labels, names);
+  const key = group[0].resourceKey;
+  const value = {};
+  const name = attributeDefault(group, NAME_ATTRIBUTE);
+  if (name !== undefined)
+    value.name = { defaultValue: name };
+  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
+  if (folderPath !== undefined) {
+    value.folderPath = { defaultValue: folderPath };
+  }
+  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
+  if (folderKey !== undefined)
+    value.folderKey = { defaultValue: folderKey };
+  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
+  return {
+    resource: group[0].resource,
+    key,
+    value,
+    metadata: {
+      BindingsVersion: RESOURCE_BINDINGS_VERSION,
+      ...subType !== undefined && { subType }
+    }
+  };
+};
+var asStoredResource = (entry) => {
+  if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+    return;
+  }
+  const record = entry;
+  const resource = typeof record.resource === "string" ? record.resource : "";
+  if (resource === "" || typeof record.key !== "string" || DROPPED_RESOURCES.has(resource.toLowerCase())) {
+    return;
+  }
+  const value = {};
+  for (const [name, slot] of Object.entries(record.value ?? {})) {
+    const defaultValue = slot?.defaultValue;
+    if (typeof defaultValue === "string")
+      value[name] = { defaultValue };
+  }
+  const metadata = {};
+  for (const [name, meta] of Object.entries(record.metadata ?? {})) {
+    if (typeof meta === "string")
+      metadata[name] = meta;
+  }
+  return {
+    resource,
+    key: record.key,
+    value,
+    ...Object.keys(metadata).length > 0 && { metadata }
+  };
+};
+var storedBindingResources = (document) => {
+  const found = new Map;
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node)
+        visit(item);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    const record = node;
+    const body = record.body;
+    if (record.name === "metadata" && Array.isArray(body?.bindings)) {
+      for (const entry of body.bindings) {
+        const resource = asStoredResource(entry);
+        if (resource === undefined)
+          continue;
+        const id = bindingIdentity(resource.resource, resource.key);
+        if (found.has(id))
+          continue;
+        found.set(id, resource);
+      }
+    }
+    for (const value of Object.values(record))
+      visit(value);
+  };
+  visit(document);
+  return found;
+};
+var withActivityMetadata = (derived, fromActivity) => {
+  return {
+    ...derived,
+    metadata: { ...fromActivity.metadata, ...derived.metadata }
+  };
+};
+var deriveCaseBindingsV2 = (document, entryPointIds = new Map) => {
+  const connectorKeys = collectConnectorKeys(document);
+  const labels = collectBindingLabels(document);
+  const groups = new Map;
+  const bindings = [];
+  for (const entry of Array.isArray(document.bindings) ? document.bindings : []) {
+    const binding = asBinding(entry);
+    if (binding === undefined)
+      continue;
+    if (binding.resource === CONNECTION_RESOURCE && binding.resourceKey === IMPLICIT_CONNECTION) {
+      continue;
+    }
+    bindings.push(binding);
+    const groupKey = `${binding.resource}:${binding.resourceKey}`;
+    const group = groups.get(groupKey);
+    if (group === undefined)
+      groups.set(groupKey, [binding]);
+    else
+      group.push(binding);
+  }
+  const stored = storedBindingResources(document);
+  const derived = [...groups.values()].map((group) => {
+    const entry = group[0].resource === CONNECTION_RESOURCE ? connectionEntry(group, connectorKeys) : resourceEntry(group, labels);
+    const fromActivity = stored.get(bindingIdentity(entry.resource, entry.key));
+    return fromActivity === undefined ? entry : withActivityMetadata(entry, fromActivity);
+  });
+  const identity = (entry) => bindingIdentity(entry.resource, entry.key);
+  const merged = new Set(derived.map(identity));
+  const triggerEntries = deriveEventTriggerResources(document.nodes, bindings, entryPointIds).filter((entry) => !merged.has(identity(entry)));
+  for (const entry of triggerEntries)
+    merged.add(identity(entry));
+  return [
+    ...derived,
+    ...triggerEntries,
+    ...[...stored.values()].filter((entry) => !merged.has(identity(entry)))
+  ];
+};
+var bindingsV2PathFor = (casePlanPath) => {
+  const fs = getFileSystem();
+  return fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), BINDINGS_V2_FILE_NAME);
+};
+var compareCaseBindingsV2 = async (casePlanPath, document) => {
+  const fs = getFileSystem();
+  const path = bindingsV2PathFor(casePlanPath);
+  const entryPoints = await readEntryPointIds(casePlanPath);
+  if ("error" in entryPoints) {
+    return {
+      status: "entry-points-unreadable",
+      path: entryPoints.path,
+      expectedCount: 0,
+      reason: entryPoints.error
+    };
+  }
+  const expected = deriveCaseBindingsV2(document, entryPoints.ids);
+  const expectedCount = expected.length;
+  if (!await fs.exists(path))
+    return { status: "absent", path, expectedCount };
+  const [readError, raw] = await catchError(fs.readFile(path, "utf-8"));
+  if (readError || raw == null)
+    return { status: "unreadable", path, expectedCount };
+  const actual = readBindingsV2Resources(raw);
+  if (actual === undefined)
+    return { status: "unreadable", path, expectedCount };
+  const difference = diffBindingsV2(expected, actual);
+  return hasBindingsV2Difference(difference) ? { status: "differs", path, expectedCount, difference } : { status: "match", path, expectedCount };
+};
+var syncCaseBindings = async (casePlanPath) => {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(casePlanPath);
+  if (!await fs.exists(resolved)) {
+    return {
+      ok: false,
+      message: `Case plan file not found: ${resolved}`,
+      instructions: "Pass the path to an existing caseplan JSON file, for example 'uip maestro case bindings sync case.json'."
+    };
+  }
+  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      ok: false,
+      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
+      instructions: `Verify read permissions on ${resolved}.`
+    };
+  }
+  const [parseError, document] = catchError(() => JSON.parse(raw));
+  if (parseError || document == null || typeof document !== "object" || Array.isArray(document)) {
+    return {
+      ok: false,
+      message: `Case plan is not valid JSON: ${parseError?.message ?? "not a JSON object"}`,
+      instructions: `Verify the contents of ${resolved}.`
+    };
+  }
+  const entryPoints = await readEntryPointIds(resolved);
+  if ("error" in entryPoints) {
+    return {
+      ok: false,
+      message: entryPoints.error,
+      instructions: `Fix or remove ${entryPoints.path}, then run \`uip maestro case bindings sync\` again.`
+    };
+  }
+  const resources = deriveCaseBindingsV2(document, entryPoints.ids);
+  const path = bindingsV2PathFor(resolved);
+  const [writeError] = await catchError(fs.writeFile(path, serializeBindingsV2File(resources)));
+  if (writeError) {
+    return {
+      ok: false,
+      message: `Failed to write bindings file: ${writeError.message}`,
+      instructions: `Verify write permissions on ${fs.path.dirname(path)}.`
+    };
+  }
+  return {
+    ok: true,
+    path,
+    resourceCount: resources.length,
+    connectionCount: resources.filter((entry) => entry.resource === CONNECTION_RESOURCE).length
+  };
+};
+export {
+  bindingsV2PathFor,
+  compareCaseBindingsV2,
+  deriveCaseBindingsV2,
+  syncCaseBindings
+};
+
+//# debugId=FF098391E9C22F9364756E2164756E21

package/dist/case-debug-solution-projects-xae2d4vj.js

@@ -0,0 +1,34 @@
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../case-tool/src/services/case-debug-solution-projects.ts
+var caseSolutionProjects = async (solutionDir, uploaded, solutionId) => {
+  const { readSolutionAt } = await import("./index-1a83vhkx.js");
+  const context = await readSolutionAt(solutionDir);
+  if (context === null)
+    return [];
+  const { readLocalResourcesForType } = await import("./localSolutionDiscovery-3fs774b8.js");
+  const rules = await readLocalResourcesForType(context, "businessRule");
+  const descriptors = [];
+  for (const rule of rules) {
+    if (rule.name === undefined)
+      continue;
+    const project = uploaded.find((one) => one.name === rule.name);
+    if (project === undefined)
+      continue;
+    descriptors.push({
+      name: rule.name,
+      projectId: project.id,
+      projectType: "BusinessRules",
+      entryPoint: "",
+      solutionId
+    });
+  }
+  return descriptors;
+};
+export {
+  caseSolutionProjects
+};
+
+//# debugId=E38936440B66EA9764756E2164756E21

package/dist/{case-debug-studio-web-service-kt5efenk.js → case-debug-studio-web-service-5h6djff3.js}

@@ -1,21 +1,22 @@
 import {
   loadCaseSchemaAsync
-} from "./packager-tool-5s7249f4.js";
+} from "./packager-tool-ms1smy5t.js";
+import {
+  uploadAndDebugSolution
+} from "./packager-tool-ajhgr4bs.js";
+import"./packager-tool-mrskd7mn.js";
 import {
   buildSolutionPackageFromDir,
   uploadOrOverwriteSolution
-} from "./packager-tool-kme3q8xv.js";
+} from "./packager-tool-8tv6dvs5.js";
 import {
   findSolutionFile,
   updateSolutionFile
-} from "./packager-tool-j6q8v3kc.js";
-import {
-  uploadAndDebugSolution
-} from "./packager-tool-npr79108.js";
-import"./packager-tool-8xhjr5ya.js";
+} from "./packager-tool-1q0ee9ht.js";
 import {
   logger
-} from "./packager-tool-yv10w46z.js";
+} from "./packager-tool-zgm0r4yp.js";
+import"./packager-tool-6sm17vbx.js";
 import {
   CasePlanFileNames,
   buildCasePackageDescriptor,
@@ -25,15 +26,18 @@ import {
   misnamedEntryPointBpmn,
   normalizeEntryPointPath,
   resolveDeclaredFileName
-} from "./packager-tool-b4t0wt7a.js";
-import"./packager-tool-nase5ajk.js";
+} from "./packager-tool-3kx2vrwn.js";
+import"./packager-tool-rp7pny4t.js";
 import"./packager-tool-nkrmjr3a.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
+} from "./packager-tool-hdxtgckw.js";
 import"./packager-tool-yvcrdbgp.js";
-import"./packager-tool-z1qbc0qf.js";
-import"./packager-tool-1yh8g550.js";
+import"./packager-tool-sm8ertv4.js";
+import"./packager-tool-wv85dhy2.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
 
 // ../case-tool/src/services/case-debug-studio-web-service.ts
 class CaseDebugStudioWebService {
@@ -123,6 +127,10 @@ class CaseDebugStudioWebService {
       projectName,
       entryPoint,
       projectType: "CaseManagement",
+      buildSolutionProjects: async (uploadedProjects, solutionId) => {
+        const { caseSolutionProjects } = await import("./case-debug-solution-projects-xae2d4vj.js");
+        return caseSolutionProjects(solutionDir, uploadedProjects, solutionId);
+      },
       apiConfig,
       organizationName: config.organizationName,
       callbacks,
@@ -134,4 +142,4 @@ export {
   CaseDebugStudioWebService
 };
 
-//# debugId=9CB733FAE9EA52B364756E2164756E21
+//# debugId=B29C14B71C443B8B64756E2164756E21