@uipath/solution-tool 1.202.1 → 1.203.0-preview.180

package/dist/{packager-tool-arkenm6k.js → packager-tool-40yp3re0.js}

@@ -1,15 +1,17 @@
 import {
   getAvailablePublishLocationsV2
-} from "./packager-tool-d83m85g9.js";
+} from "./packager-tool-f9vfa06w.js";
 import {
   PersonalWorkspacesApi,
   createOrchestratorConfig
-} from "./packager-tool-7s77bznz.js";
+} from "./packager-tool-2syrt51a.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-3jrq7smt.js";
 import {
-  getLoginStatusAsync,
   getSdkUserAgentToken,
   installSdkUserAgentHeader
-} from "./packager-tool-rqvyf18m.js";
+} from "./packager-tool-0f0wt9vh.js";
 
 // ../pipelines-sdk/generated/src/runtime.ts
 var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
@@ -1297,8 +1299,9 @@ class PipelinesApi extends BaseAPI {
 // ../pipelines-sdk/package.json
 var package_default = {
   name: "@uipath/pipelines-sdk",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.203.0",
   description: "Generated TypeScript client for UiPath Pipelines API (CI/CD deployment lifecycle)",
   repository: {
     type: "git",
@@ -1474,4 +1477,4 @@ function matchFeed(feed, locations) {
 
 export { Configuration, PipelinesApi, resolvePersonalWorkspace, listSelectablePublishLocations, folderKeyInitOverride, feedScopeInitOverride, feedResolutionFailureInstructions, resolveFeedScope };
 
-//# debugId=80324A817368E68564756E2164756E21
+//# debugId=97ECE629FDAB1F6864756E2164756E21

package/dist/packager-tool-53w8skv5.js

@@ -0,0 +1,262 @@
+// ../../node_modules/@uipath/resource-builder-sdk/dist/clients/generated/first-party-service.js
+var first_party_service_DeploymentAction = /* @__PURE__ */ function(DeploymentAction) {
+  DeploymentAction["Install"] = "Install";
+  DeploymentAction["Link"] = "Link";
+  DeploymentAction["Uninstall"] = "Uninstall";
+  DeploymentAction["Unlink"] = "Unlink";
+  DeploymentAction["Merge"] = "Merge";
+  DeploymentAction["UseExisting"] = "UseExisting";
+  DeploymentAction["Activate"] = "Activate";
+  return DeploymentAction;
+}({});
+var first_party_service_SolutionDeploymentAction = /* @__PURE__ */ function(SolutionDeploymentAction) {
+  SolutionDeploymentAction["Install"] = "Install";
+  SolutionDeploymentAction["Uninstall"] = "Uninstall";
+  SolutionDeploymentAction["Upgrade"] = "Upgrade";
+  SolutionDeploymentAction["Rollback"] = "Rollback";
+  SolutionDeploymentAction["Activate"] = "Activate";
+  return SolutionDeploymentAction;
+}({});
+var first_party_service_SolutionStatus = /* @__PURE__ */ function(SolutionStatus) {
+  SolutionStatus["Installed"] = "Installed";
+  SolutionStatus["Uninstalled"] = "Uninstalled";
+  SolutionStatus["Installing"] = "Installing";
+  SolutionStatus["Uninstalling"] = "Uninstalling";
+  SolutionStatus["InstallError"] = "InstallError";
+  SolutionStatus["UninstallError"] = "UninstallError";
+  SolutionStatus["Unknown"] = "Unknown";
+  return SolutionStatus;
+}({});
+var first_party_service_QueryOptions = /* @__PURE__ */ function(QueryOptions) {
+  QueryOptions["Contains"] = "Contains";
+  QueryOptions["Equals"] = "Equals";
+  return QueryOptions;
+}({});
+var first_party_service_DeploymentResourceValidationErrorLevel = /* @__PURE__ */ function(DeploymentResourceValidationErrorLevel) {
+  DeploymentResourceValidationErrorLevel["Error"] = "Error";
+  DeploymentResourceValidationErrorLevel["Warning"] = "Warning";
+  DeploymentResourceValidationErrorLevel["Info"] = "Info";
+  return DeploymentResourceValidationErrorLevel;
+}({});
+var first_party_service_DeploymentResourceValidationErrorKind = /* @__PURE__ */ function(DeploymentResourceValidationErrorKind) {
+  DeploymentResourceValidationErrorKind["Conflict"] = "Conflict";
+  DeploymentResourceValidationErrorKind["ConfigurationError"] = "ConfigurationError";
+  return DeploymentResourceValidationErrorKind;
+}({});
+var first_party_service_DeploymentResourceValidationAction = /* @__PURE__ */ function(DeploymentResourceValidationAction) {
+  DeploymentResourceValidationAction["RenameExisting"] = "RenameExisting";
+  DeploymentResourceValidationAction["RenameInSolution"] = "RenameInSolution";
+  DeploymentResourceValidationAction["UseExisting"] = "UseExisting";
+  DeploymentResourceValidationAction["FixConfiguration"] = "FixConfiguration";
+  DeploymentResourceValidationAction["Delete"] = "Delete";
+  DeploymentResourceValidationAction["SkipDelete"] = "SkipDelete";
+  DeploymentResourceValidationAction["MergeConfiguration"] = "MergeConfiguration";
+  DeploymentResourceValidationAction["Replace"] = "Replace";
+  return DeploymentResourceValidationAction;
+}({});
+var first_party_service_ContentType = /* @__PURE__ */ function(ContentType) {
+  ContentType["Json"] = "application/json";
+  ContentType["JsonApi"] = "application/vnd.api+json";
+  ContentType["FormData"] = "multipart/form-data";
+  ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+  ContentType["Text"] = "text/plain";
+  return ContentType;
+}({});
+
+class HttpClient {
+  encodeQueryParam(key, value) {
+    const encodedKey = encodeURIComponent(key);
+    return `${encodedKey}=${encodeURIComponent(typeof value == "number" ? value : `${value}`)}`;
+  }
+  addQueryParam(query, key) {
+    return this.encodeQueryParam(key, query[key]);
+  }
+  addArrayQueryParam(query, key) {
+    const value = query[key];
+    return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+  }
+  toQueryString(rawQuery) {
+    const query = rawQuery || {};
+    const keys = Object.keys(query).filter((key) => query[key] !== undefined);
+    return keys.map((key) => Array.isArray(query[key]) ? this.addArrayQueryParam(query, key) : this.addQueryParam(query, key)).join("&");
+  }
+  addQueryParams(rawQuery) {
+    const queryString = this.toQueryString(rawQuery);
+    return queryString ? `?${queryString}` : "";
+  }
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2 || {},
+      headers: {
+        ...this.baseApiParams.headers || {},
+        ...params1.headers || {},
+        ...params2 && params2.headers || {}
+      }
+    };
+  }
+  constructor(apiConfig = {}) {
+    this.baseUrl = "https://localhost:7008";
+    this.securityData = null;
+    this.abortControllers = new Map;
+    this.customFetch = (...fetchParams) => fetch(...fetchParams);
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.setSecurityData = (data) => {
+      this.securityData = data;
+    };
+    this.contentFormatters = {
+      ["application/json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["application/vnd.api+json"]: (input) => input !== null && (typeof input == "object" || typeof input == "string") ? JSON.stringify(input) : input,
+      ["text/plain"]: (input) => input !== null && typeof input != "string" ? JSON.stringify(input) : input,
+      ["multipart/form-data"]: (input) => {
+        if (input instanceof FormData)
+          return input;
+        return Object.keys(input || {}).reduce((formData, key) => {
+          const property = input[key];
+          formData.append(key, property instanceof Blob ? property : typeof property == "object" && property !== null ? JSON.stringify(property) : `${property}`);
+          return formData;
+        }, new FormData);
+      },
+      ["application/x-www-form-urlencoded"]: (input) => this.toQueryString(input)
+    };
+    this.createAbortSignal = (cancelToken) => {
+      if (this.abortControllers.has(cancelToken)) {
+        const abortController2 = this.abortControllers.get(cancelToken);
+        if (abortController2)
+          return abortController2.signal;
+        return;
+      }
+      const abortController = new AbortController;
+      this.abortControllers.set(cancelToken, abortController);
+      return abortController.signal;
+    };
+    this.abortRequest = (cancelToken) => {
+      const abortController = this.abortControllers.get(cancelToken);
+      if (abortController) {
+        abortController.abort();
+        this.abortControllers.delete(cancelToken);
+      }
+    };
+    this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+      const secureParams = (typeof secure == "boolean" ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData) || {};
+      const requestParams = this.mergeRequestParams(params, secureParams);
+      const queryString = query && this.toQueryString(query);
+      const payloadFormatter = this.contentFormatters[type || "application/json"];
+      const responseFormat = format || requestParams.format;
+      return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+        ...requestParams,
+        headers: {
+          ...requestParams.headers || {},
+          ...type && type !== "multipart/form-data" ? {
+            "Content-Type": type
+          } : {}
+        },
+        signal: (cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal) || null,
+        body: body == null ? null : payloadFormatter(body)
+      }).then(async (response) => {
+        const r = response;
+        r.data = null;
+        r.error = null;
+        const responseToParse = responseFormat ? response.clone() : response;
+        const data = responseFormat ? await responseToParse[responseFormat]().then((data2) => {
+          if (r.ok)
+            r.data = data2;
+          else
+            r.error = data2;
+          return r;
+        }).catch((e) => {
+          r.error = e;
+          return r;
+        }) : r;
+        if (cancelToken)
+          this.abortControllers.delete(cancelToken);
+        if (!response.ok)
+          throw data;
+        return data.data;
+      });
+    };
+    Object.assign(this, apiConfig);
+  }
+}
+
+class FirstPartyServiceApi extends HttpClient {
+  constructor(...args) {
+    super(...args), this.v2 = {
+      automationSolutionsGetMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "GET",
+        ...params
+      }),
+      automationSolutionsHeadMetadata: (params = {}) => this.request({
+        path: "/v2/automationsolutions/metadata",
+        method: "HEAD",
+        ...params
+      }),
+      automationSolutionsSetState: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PATCH",
+        query,
+        body: data,
+        type: "application/json",
+        ...params
+      }),
+      automationSolutionsInstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "PUT",
+        query,
+        body: data,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsUninstall: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions",
+        method: "DELETE",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsExport: (data, params = {}) => this.request({
+        path: "/v2/automationsolutions/export",
+        method: "POST",
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsGetTranslations: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/translations",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      }),
+      automationSolutionsValidate: (data, query, params = {}) => this.request({
+        path: "/v2/automationsolutions/validate",
+        method: "POST",
+        query,
+        body: data,
+        type: "application/json",
+        format: "json",
+        ...params
+      }),
+      automationSolutionsLookup: (query, params = {}) => this.request({
+        path: "/v2/automationsolutions/lookup",
+        method: "GET",
+        query,
+        format: "json",
+        ...params
+      })
+    };
+  }
+}
+export { first_party_service_DeploymentAction, first_party_service_SolutionDeploymentAction, first_party_service_SolutionStatus, first_party_service_QueryOptions, first_party_service_DeploymentResourceValidationErrorLevel, first_party_service_DeploymentResourceValidationErrorKind, first_party_service_DeploymentResourceValidationAction, first_party_service_ContentType, HttpClient, FirstPartyServiceApi };
+
+//# debugId=AC88CC622210E15664756E2164756E21

package/dist/{packager-tool-svcjmtbs.js → packager-tool-6byq9bhj.js}

@@ -3,14 +3,14 @@ import {
   PipelinesApi,
   feedScopeInitOverride,
   resolveFeedScope
-} from "./packager-tool-arkenm6k.js";
+} from "./packager-tool-40yp3re0.js";
 import {
   Configuration as Configuration2,
   PackagesApi
-} from "./packager-tool-d83m85g9.js";
+} from "./packager-tool-f9vfa06w.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-7s77bznz.js";
+} from "./packager-tool-2syrt51a.js";
 import {
   PollOutcome,
   catchError,
@@ -19,7 +19,7 @@ import {
   logger,
   mapPollFailure,
   pollUntil
-} from "./packager-tool-rqvyf18m.js";
+} from "./packager-tool-0f0wt9vh.js";
 import {
   strFromU8,
   strToU8,

package/dist/packager-tool-7znqtw3f.js

@@ -0,0 +1,244 @@
+import {
+  applyProjectContributions,
+  assertNoContributionErrors,
+  collectProjectContributions,
+  contributionErrorMessages
+} from "./packager-tool-znakt6yw.js";
+import {
+  ensurePackagerTools
+} from "./packager-tool-k4mskzww.js";
+import {
+  Tokens,
+  createResourceBuilderServices,
+  findResourceInRcs,
+  getFolderPathProperty,
+  getResourceKindForBinding,
+  getResourceName,
+  models_BindingsResourceType,
+  readUipxProjects,
+  syncAndLog
+} from "./packager-tool-bkwnetqn.js";
+import {
+  catchError,
+  getFileSystem,
+  logger
+} from "./packager-tool-0f0wt9vh.js";
+
+// src/services/emit-runtime-dependencies.ts
+import { createHash } from "node:crypto";
+function csharpGuidFromString(input) {
+  const b = createHash("sha256").update(input, "utf8").digest().subarray(0, 16);
+  const h = (n) => n.toString(16).padStart(2, "0");
+  return [
+    h(b[3]) + h(b[2]) + h(b[1]) + h(b[0]),
+    h(b[5]) + h(b[4]),
+    h(b[7]) + h(b[6]),
+    h(b[8]) + h(b[9]),
+    h(b[10]) + h(b[11]) + h(b[12]) + h(b[13]) + h(b[14]) + h(b[15])
+  ].join("-");
+}
+var solutionFolderKeyCache;
+function solutionFolderKey() {
+  solutionFolderKeyCache ??= csharpGuidFromString("solution_folder");
+  return solutionFolderKeyCache;
+}
+async function emitRuntimeDependenciesForProcesses(solutionDir) {
+  const result = {
+    processed: 0,
+    warnings: []
+  };
+  const [servicesError, services] = await catchError(createResourceBuilderServices());
+  if (servicesError) {
+    result.warnings.push(`Failed to create resource builder services: ${servicesError.message}`);
+    return result;
+  }
+  const [builderError, builder] = await catchError(services.getSolutionBuilder(solutionDir));
+  if (builderError) {
+    result.warnings.push(`Failed to get solution builder: ${builderError.message}`);
+    return result;
+  }
+  try {
+    const [loadError, solution] = await catchError(builder.context.loadAsync());
+    if (loadError || !solution) {
+      result.warnings.push(`Failed to load solution: ${loadError?.message ?? "unknown"}`);
+      return result;
+    }
+    const processes = (solution.resources ?? []).filter((r) => r.kind?.toLowerCase() === "process" && typeof r.projectKey === "string" && r.projectKey.length > 0);
+    if (processes.length === 0) {
+      return result;
+    }
+    const overwritesService = services.container.resolve(Tokens.IResourceOverwritesService);
+    const [owErr, tenantOverwrites] = await catchError(overwritesService.getTenantResourceOverwritesAsync(builder.context));
+    if (owErr) {
+      result.warnings.push(`Failed to read tenant resource overwrites: ${owErr.message}`);
+    }
+    const overwrites = tenantOverwrites ?? [];
+    const projects = await readUipxProjects(solutionDir);
+    const projectsById = new Map(projects.map((p) => [p.id, p]));
+    const serializer = services.container.resolve(Tokens.IBindingsMetadataSerializer);
+    const fs = getFileSystem();
+    for (const proc of processes) {
+      const project = projectsById.get(proc.projectKey ?? "");
+      if (!project) {
+        result.warnings.push(`Process resource "${proc.name}" has projectKey "${proc.projectKey}" but no matching project in .uipx; skipping`);
+        continue;
+      }
+      const bindings = await readBindings(project.path, serializer, fs, result.warnings);
+      proc.runtimeDependencies = await buildRuntimeDeps(bindings, solution.resources ?? [], overwrites, builder, result.warnings);
+      result.processed += 1;
+      logger.info(`Emitted ${proc.runtimeDependencies.length} runtime dependencies for process "${proc.name}" (project "${project.name}")`);
+    }
+    for (const r of solution.resources ?? []) {
+      if (r.isOverridable === undefined || r.isOverridable === null) {
+        r.isOverridable = true;
+      }
+    }
+    const [saveErr] = await catchError(builder.context.saveAsync(solution));
+    if (saveErr) {
+      result.warnings.push(`Failed to persist runtime dependencies: ${saveErr.message}`);
+    }
+    return result;
+  } finally {
+    const dispose = builder.disposeAsync;
+    if (typeof dispose === "function") {
+      const [disposeErr] = await catchError(dispose.call(builder));
+      if (disposeErr) {
+        logger.warn(`Failed to dispose solution builder after emitting runtime dependencies: ${disposeErr.message}`);
+      }
+    }
+  }
+}
+async function readBindings(projectDir, serializer, fs, warnings) {
+  const bindingsPath = fs.path.join(projectDir, "bindings_v2.json");
+  if (!await fs.exists(bindingsPath))
+    return [];
+  const [readErr, raw] = await catchError(fs.readFile(bindingsPath));
+  if (readErr || !raw) {
+    warnings.push(`Failed to read ${bindingsPath}: ${readErr?.message ?? "empty"}`);
+    return [];
+  }
+  const parsed = serializer.tryDeserialize(new TextDecoder().decode(raw));
+  if (!parsed.success || !parsed.metadata) {
+    warnings.push(`Failed to parse ${bindingsPath}`);
+    return [];
+  }
+  return parsed.metadata.resources ?? [];
+}
+async function buildRuntimeDeps(bindings, allResources, overwrites, builder, warnings) {
+  const resourcesByKey = new Map(allResources.filter((r) => !!r.key).map((r) => [r.key.toLowerCase(), r]));
+  const overwritesBySolutionKey = new Map(overwrites.filter((o) => !!o.solutionResourceKey).map((o) => [o.solutionResourceKey.toLowerCase(), o]));
+  const out = [];
+  for (const binding of bindings ?? []) {
+    const dep = mapBindingToRuntimeDependency(binding);
+    const matchedKey = await findSolutionResourceKeyForBinding(binding, overwrites, builder, warnings);
+    if (matchedKey) {
+      const matched = resourcesByKey.get(matchedKey.toLowerCase());
+      if (matched) {
+        dep.resourceKey = matched.key;
+        dep.resourceName = matched.name;
+        const ow = overwritesBySolutionKey.get(matchedKey.toLowerCase());
+        dep.folderKey = ow?.overwrite?.folderKey ?? solutionFolderKey();
+      }
+    }
+    out.push(dep);
+  }
+  return out;
+}
+async function findSolutionResourceKeyForBinding(binding, overwrites, builder, warnings) {
+  const bindingKind = getResourceKindForBinding(binding.resourceType);
+  const bindingKindLower = bindingKind.toLowerCase();
+  const bindingName = getResourceName(binding);
+  const bindingFolder = getFolderPathProperty(binding).defaultValue;
+  if (binding.bindingKey && !bindingName) {
+    return binding.bindingKey;
+  }
+  if (!bindingName)
+    return;
+  const lname = bindingName.toLowerCase();
+  const candidates = overwrites.filter((o) => o.overwrite?.resourceName?.toLowerCase() === lname && (!o.overwrite?.kind || o.overwrite.kind.toLowerCase() === bindingKindLower));
+  if (candidates.length === 0)
+    return;
+  if (candidates.length === 1)
+    return candidates[0].solutionResourceKey;
+  if (!bindingFolder) {
+    warnings.push(`Ambiguous solution resource match for binding "${bindingName}" (kind ${bindingKind}) — ${candidates.length} candidates and no binding folderPath to disambiguate`);
+    return;
+  }
+  const [rcsErr, rcsMatch] = await catchError(findResourceInRcs(builder, bindingKind, bindingName, bindingFolder));
+  if (rcsErr) {
+    warnings.push(`RCS folder disambiguation failed for "${bindingName}" (folder "${bindingFolder}"): ${rcsErr.message}`);
+    return;
+  }
+  if (!rcsMatch) {
+    warnings.push(`RCS could not resolve "${bindingName}" in folder "${bindingFolder}" — ${candidates.length} same-name overwrites still ambiguous`);
+    return;
+  }
+  const rcsKeyLower = rcsMatch.key.toLowerCase();
+  const matched = candidates.find((o) => o.solutionResourceKey?.toLowerCase() === rcsKeyLower);
+  if (!matched) {
+    warnings.push(`Binding "${bindingName}" resolved to cloud key ${rcsMatch.key} but no overwrite carries that solutionResourceKey`);
+    return;
+  }
+  return matched.solutionResourceKey;
+}
+function mapBindingToRuntimeDependency(binding) {
+  return {
+    bindingType: binding.originalResourceType,
+    bindingKey: binding.bindingKey,
+    bindingValues: binding.dynamicValues,
+    bindingMetadata: binding.metadata,
+    resourceKind: getResourceKindForBinding(binding.resourceType),
+    resourceType: resolveResourceType(binding)
+  };
+}
+function resolveResourceType(binding) {
+  if (binding.resourceType === models_BindingsResourceType.QueueTrigger) {
+    return;
+  }
+  if (binding.resourceType === models_BindingsResourceType.EventTrigger) {
+    return binding.metadata?.connector;
+  }
+  if (binding.resourceType === models_BindingsResourceType.Connection) {
+    return binding.metadata?.connector;
+  }
+  return binding.metadata?.subType;
+}
+
+// src/services/prepare-solution-resources.ts
+function projectSubTypesFrom(contributions) {
+  const subTypes = new Map;
+  for (const [projectKey, contribution] of contributions.byProject) {
+    if (contribution.projectSubType) {
+      subTypes.set(projectKey, contribution.projectSubType);
+    }
+  }
+  return subTypes;
+}
+async function prepareSolutionResources(solutionDir, fs, options) {
+  const gate = options?.gate ?? true;
+  const warnings = [];
+  await ensurePackagerTools(solutionDir, fs);
+  const contributions = await collectProjectContributions(solutionDir, fs);
+  if (gate) {
+    assertNoContributionErrors(contributions);
+  } else {
+    warnings.push(...contributionErrorMessages(contributions));
+  }
+  await syncAndLog(solutionDir, projectSubTypesFrom(contributions));
+  const applied = await applyProjectContributions(solutionDir, contributions, { failOnUnmatchedPatch: gate }, fs);
+  warnings.push(...applied.warnings);
+  for (const warning of applied.warnings)
+    logger.warn(warning);
+  if (applied.updated > 0) {
+    logger.info(`Applied project resource contributions to ${applied.updated} resource(s)`);
+  }
+  const rtd = await emitRuntimeDependenciesForProcesses(solutionDir);
+  warnings.push(...rtd.warnings);
+  for (const warning of rtd.warnings)
+    logger.warn(warning);
+  return { warnings, updated: applied.updated };
+}
+
+export { projectSubTypesFrom, prepareSolutionResources };
+
+//# debugId=66D4CB702D8B08F964756E2164756E21