@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/resourcesSyncService-mrmmwaqr.js

@@ -0,0 +1,683 @@
+import"./packager-tool-134mvmcm.js";
+import {
+  findSolutionFromCwd
+} from "./packager-tool-rqvr63x5.js";
+import"./packager-tool-885mmrvr.js";
+import"./packager-tool-mp59jtpm.js";
+import {
+  loadIndexMetadata,
+  loadResourceIndex,
+  saveIndexMetadata,
+  saveResourceIndex
+} from "./packager-tool-s12392rd.js";
+import"./packager-tool-jhdf8gt1.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-37zvccmt.js";
+import"./packager-tool-j9rfdrdm.js";
+import {
+  GET_SEARCHABLE_TYPES,
+  RESOURCE_TYPES
+} from "./packager-tool-r84ng21s.js";
+import"./packager-tool-9scn4b15.js";
+import"./packager-tool-3ze5vt52.js";
+import"./packager-tool-vepqrsse.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-dqs5qy9s.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  catchError,
+  hashContent,
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/action-app-api.ts
+var ACTION_APP_BATCH_SIZE = 100;
+async function listActionApps() {
+  const loginStatus = await getLoginStatusAsync();
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.organizationId || !loginStatus.tenantId || !loginStatus.accessToken) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  const all = [];
+  const MAX_PAGES = 100;
+  let pageNumber = 0;
+  while (pageNumber < MAX_PAGES) {
+    if (pageNumber === MAX_PAGES - 1) {
+      logger.warn(`Fetching the last allowed page (${MAX_PAGES}). Results may be truncated.`);
+    }
+    const query = new URLSearchParams({
+      state: "deployed",
+      pageNumber: String(pageNumber),
+      limit: String(ACTION_APP_BATCH_SIZE)
+    });
+    const url = `${loginStatus.baseUrl}/${loginStatus.organizationId}/apps_/default/api/v1/default/action-apps?${query}`;
+    logger.debug(`Listing action apps with URL: ${url}`);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${loginStatus.accessToken}`,
+        "Content-Type": "application/json",
+        "X-Uipath-Tenantid": loginStatus.tenantId,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(`Error response body: ${errorText}`);
+      throw new Error(`Action apps list failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    const page = data.deployed ?? [];
+    all.push(...page);
+    if (page.length < ACTION_APP_BATCH_SIZE)
+      break;
+    pageNumber += 1;
+  }
+  return all;
+}
+
+// src/services/filterEngine.ts
+function readField(resource, field) {
+  const direct = resource[field];
+  if (direct !== undefined)
+    return direct;
+  const cfg = resource.configuration;
+  if (typeof cfg === "string") {
+    try {
+      const parsed = JSON.parse(cfg);
+      return parsed[field];
+    } catch {
+      return;
+    }
+  }
+  return;
+}
+function matchesKeyword(resource, keyword) {
+  const lower = keyword.toLowerCase();
+  const searchFields = [
+    "name",
+    "title",
+    "displayName",
+    "description",
+    "category",
+    "connectorKey",
+    "systemName",
+    "tags"
+  ];
+  return searchFields.some((field) => {
+    const val = readField(resource, field);
+    if (typeof val === "string")
+      return val.toLowerCase().includes(lower);
+    if (Array.isArray(val))
+      return val.some((v) => typeof v === "string" && v.toLowerCase().includes(lower));
+    return false;
+  });
+}
+function matchesFilter(resource, field, operator, value) {
+  const raw = readField(resource, field) ?? (field === "name" ? resource.displayName : undefined);
+  const fieldValues = Array.isArray(raw) ? raw.filter((v) => typeof v === "string") : typeof raw === "string" ? [raw] : [];
+  const lowerValue = value.toLowerCase();
+  return fieldValues.some((v) => {
+    const lv = v.toLowerCase();
+    switch (operator) {
+      case "equals":
+        return lv === lowerValue;
+      case "contains":
+        return lv.includes(lowerValue);
+      case "startsWith":
+        return lv.startsWith(lowerValue);
+      case "endsWith":
+        return lv.endsWith(lowerValue);
+      case "in":
+        return lowerValue.split("|").map((s) => s.trim()).includes(lv);
+      default:
+        return false;
+    }
+  });
+}
+function searchWithFilters(resources, keyword, filters) {
+  return resources.filter((resource) => {
+    if (keyword && !matchesKeyword(resource, keyword))
+      return false;
+    if (filters && filters.filters.length > 0) {
+      const filterResults = filters.filters.map(({ field, operator, value }) => matchesFilter(resource, field, operator, value));
+      if (filters.logic === "AND")
+        return filterResults.every(Boolean);
+      return filterResults.some(Boolean);
+    }
+    return true;
+  });
+}
+
+// src/services/localSolutionDiscovery.ts
+var LOCAL_RESOURCE_TYPES = new Set([
+  "agent",
+  "process",
+  "api",
+  "processOrchestration",
+  "caseManagement"
+]);
+var PROJECT_TYPE_TO_RESOURCE = {
+  Agent: "agent",
+  Process: "process",
+  Api: "api",
+  ProcessOrchestration: "processOrchestration",
+  CaseManagement: "caseManagement"
+};
+var PROJECT_TYPE_TO_RESOURCE_LC = Object.fromEntries(Object.entries(PROJECT_TYPE_TO_RESOURCE).map(([k, v]) => [
+  k.toLowerCase(),
+  v
+]));
+var PROCESS_SUBDIR = ["resources", "solution_folder", "process"];
+function isUnder(parent, child) {
+  if (child === parent)
+    return true;
+  const fs = getFileSystem();
+  const rel = fs.path.relative(parent, child);
+  return rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel);
+}
+async function parseEnrichmentFile(filePath) {
+  const fs = getFileSystem();
+  const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+  if (readErr || !content)
+    return null;
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !parsed.resource?.projectKey)
+    return null;
+  const r = parsed.resource;
+  return [
+    r.projectKey,
+    {
+      key: r.key,
+      name: r.name,
+      folders: r.folders && r.folders.length > 0 ? r.folders.map((f) => ({
+        fullyQualifiedName: f.fullyQualifiedName ?? "solution_folder"
+      })) : undefined,
+      packageName: r.spec?.packageName
+    }
+  ];
+}
+async function loadResourceEnrichmentMap(solutionDir) {
+  const fs = getFileSystem();
+  const map = new Map;
+  const processDir = fs.path.join(solutionDir, ...PROCESS_SUBDIR);
+  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  if (dirErr || !Array.isArray(typeDirs))
+    return map;
+  for (const typeDir of typeDirs) {
+    const typePath = fs.path.join(processDir, typeDir);
+    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    if (filesErr || !Array.isArray(files))
+      continue;
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      const entry = await parseEnrichmentFile(fs.path.join(typePath, file));
+      if (entry)
+        map.set(entry[0], entry[1]);
+    }
+  }
+  return map;
+}
+async function readProjectName(projectDir) {
+  const fs = getFileSystem();
+  const [err, content] = await catchError(fs.readFile(fs.path.join(projectDir, "project.uiproj"), "utf-8"));
+  if (!err && content) {
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (!parseErr && parsed.Name)
+      return parsed.Name;
+  }
+  return fs.path.basename(projectDir);
+}
+async function readEntryPointIO(projectDir) {
+  const fs = getFileSystem();
+  const candidates = [
+    fs.path.join(projectDir, "entry-points.json"),
+    fs.path.join(projectDir, "content", "entry-points.json")
+  ];
+  for (const filePath of candidates) {
+    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    if (err || !content)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (parseErr || !parsed.entryPoints?.length)
+      continue;
+    const ep = parsed.entryPoints[0];
+    return {
+      inputs: ep.input ?? ep.InputArguments,
+      outputs: ep.output ?? ep.OutputArguments
+    };
+  }
+  return {};
+}
+async function readLocalResourcesForType(ctx, resourceType, enrichment) {
+  if (!LOCAL_RESOURCE_TYPES.has(resourceType))
+    return [];
+  const fs = getFileSystem();
+  const enrichmentMap = enrichment ?? await loadResourceEnrichmentMap(ctx.solutionDir);
+  const entries = [];
+  for (const project of ctx.projects) {
+    if (!project.Id || !project.Type)
+      continue;
+    if (ctx.currentProjectId && project.Id === ctx.currentProjectId)
+      continue;
+    if (PROJECT_TYPE_TO_RESOURCE_LC[project.Type.toLowerCase()] !== resourceType)
+      continue;
+    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath ?? ""));
+    if (!isUnder(ctx.solutionDir, projectDir))
+      continue;
+    const enriched = enrichmentMap.get(project.Id);
+    const [name, io] = await Promise.all([
+      enriched?.name ? Promise.resolve(enriched.name) : readProjectName(projectDir),
+      readEntryPointIO(projectDir)
+    ]);
+    entries.push({
+      entityKey: enriched?.key ?? project.Id,
+      name,
+      category: resourceType,
+      folders: enriched?.folders ?? [
+        { fullyQualifiedName: "solution_folder" }
+      ],
+      packageName: enriched?.packageName,
+      projectKey: project.Id,
+      inputs: io.inputs,
+      outputs: io.outputs,
+      source: "local"
+    });
+  }
+  return entries;
+}
+
+// src/services/process-entity-api.ts
+var PROCESS_ENTITY_BATCH_SIZE = 500;
+async function listProcessEntities(params) {
+  const loginStatus = await getLoginStatusAsync();
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.organizationId || !loginStatus.tenantId || !loginStatus.accessToken) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  const all = [];
+  const MAX_PAGES = 20;
+  let pageNumber = 0;
+  while (pageNumber < MAX_PAGES) {
+    if (pageNumber === MAX_PAGES - 1) {
+      logger.warn(`Fetching the last allowed page (${MAX_PAGES}). Results may be truncated.`);
+    }
+    const query = new URLSearchParams({
+      entitySubType: params.entitySubType,
+      take: String(PROCESS_ENTITY_BATCH_SIZE),
+      skip: String(pageNumber * PROCESS_ENTITY_BATCH_SIZE)
+    });
+    const url = `${loginStatus.baseUrl}/${loginStatus.organizationId}/${loginStatus.tenantId}/resourcecatalog_/Entities/Process?${query}`;
+    logger.debug(`Listing process entities with URL: ${url}`);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${loginStatus.accessToken}`,
+        "Content-Type": "application/json",
+        "X-Uipath-Tenantid": loginStatus.tenantId,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error(`Error response body: ${errorText}`);
+      throw new Error(`Process entity list failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    const page = data.value ?? [];
+    all.push(...page);
+    if (page.length < PROCESS_ENTITY_BATCH_SIZE)
+      break;
+    pageNumber += 1;
+  }
+  return all;
+}
+
+// src/services/solution-entities-api.ts
+async function listSolutionEntities(solutionId) {
+  const loginStatus = await getLoginStatusAsync();
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.organizationId || !loginStatus.tenantId || !loginStatus.accessToken) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  const url = `${loginStatus.baseUrl}/${loginStatus.organizationId}/studio_/backend/api/resourcebuilder/solutions/${solutionId}/entities`;
+  logger.debug(`Listing resource builder entities with URL: ${url}`);
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${loginStatus.accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.error(`Error response body: ${errorText}`);
+    throw new Error(`Resource builder entities list failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const data = await response.json();
+  return data.resources ?? [];
+}
+
+// src/services/studio-typecache-api.ts
+var catalogPromises = new Map;
+async function fetchSearchCatalog(projectType) {
+  const loginStatus = await getLoginStatusAsync();
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.organizationId || !loginStatus.accessToken || !loginStatus.tenantId) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  const query = new URLSearchParams({
+    useLucene: "false",
+    useElastic: "true",
+    projectType
+  });
+  const url = `${loginStatus.baseUrl}/${loginStatus.organizationId}/studio_/typecache/api/Search/Catalog?${query}`;
+  logger.debug(`Fetching Studio search catalog with URL: ${url}`);
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${loginStatus.accessToken}`,
+      "Content-Type": "application/json",
+      "X-Uipath-Tenantid": loginStatus.tenantId,
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.debug(`Error response body: ${errorText}`);
+    throw new Error(`catalog search failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const data = await response.json();
+  if (!Array.isArray(data.activities) || !Array.isArray(data.triggers)) {
+    throw new Error(`catalog search returned unexpected shape: ${JSON.stringify(data).slice(0, 200)}`);
+  }
+  const packages = Array.isArray(data.packages) ? data.packages : [];
+  const activities = data.activities;
+  const triggers = data.triggers;
+  logger.debug(`Received ${projectType} catalog: ${activities.length} activities, ${triggers.length} triggers, ${packages.length} packages`);
+  return {
+    packages,
+    activities,
+    triggers
+  };
+}
+async function searchCatalog(projectType) {
+  let promise = catalogPromises.get(projectType);
+  if (!promise) {
+    promise = fetchSearchCatalog(projectType);
+    catalogPromises.set(projectType, promise);
+    promise.catch(() => {
+      catalogPromises.delete(projectType);
+    });
+  }
+  return promise;
+}
+async function searchActivities(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).activities;
+}
+async function searchTriggers(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).triggers;
+}
+async function searchPackages(projectType = "ProcessOrchestration") {
+  return (await searchCatalog(projectType)).packages;
+}
+
+// src/services/resourcesSyncService.ts
+var CACHE_EXPIRATION = 24 * 60 * 60 * 1000;
+var SLICE_FETCHERS = {
+  activities: searchActivities,
+  triggers: searchTriggers,
+  packages: searchPackages
+};
+var TYPECACHE_PREFIXES = [
+  ["typecache", "ProcessOrchestration"],
+  ["typecache-external-automation", "IntsvcExternalAutomation"],
+  ["typecache-external-agent", "IntsvcExternalAgent"]
+];
+var TYPECACHE_SOURCES = Object.fromEntries(TYPECACHE_PREFIXES.flatMap(([prefix, projectType]) => Object.keys(SLICE_FETCHERS).map((slice) => [
+  `${prefix}-${slice}`,
+  { projectType, slice }
+])));
+async function pullResources(options = {}, resourceType) {
+  const { force = false, solutionId = undefined } = options;
+  if (force) {
+    const refreshResult2 = await refreshResources(resourceType, solutionId);
+    const meta2 = await loadIndexMetadata(resourceType);
+    return {
+      syncedCount: refreshResult2.count || meta2?.count || 0,
+      fromCache: false,
+      cacheWritten: refreshResult2.cacheWritten,
+      info: refreshResult2.info
+    };
+  }
+  const meta = await loadIndexMetadata(resourceType);
+  if (meta) {
+    const ageMs = Date.now() - meta.lastSync;
+    if (ageMs < CACHE_EXPIRATION) {
+      return {
+        syncedCount: meta.count,
+        fromCache: true,
+        ageMinutes: Math.round(ageMs / 60000)
+      };
+    }
+  }
+  const refreshResult = await refreshResources(resourceType, solutionId);
+  const refreshedMeta = await loadIndexMetadata(resourceType);
+  return {
+    syncedCount: refreshResult.count || refreshedMeta?.count || 0,
+    fromCache: false,
+    cacheWritten: refreshResult.cacheWritten,
+    info: refreshResult.info
+  };
+}
+async function refreshResources(resourceType, solutionId) {
+  const oldMeta = await loadIndexMetadata(resourceType);
+  const pullResult = await pullRemoteResources(resourceType, solutionId);
+  const resources = pullResult.resources;
+  if (!pullResult.cacheable) {
+    return {
+      cacheWritten: false,
+      count: resources.length,
+      info: pullResult.info
+    };
+  }
+  const content = JSON.stringify(resources, null, 2);
+  const newHash = await hashContent(content);
+  if (oldMeta && oldMeta.hash === newHash) {
+    await saveIndexMetadata({
+      lastSync: Date.now(),
+      count: oldMeta.count,
+      hash: oldMeta.hash
+    }, resourceType);
+    return {
+      cacheWritten: true,
+      count: oldMeta.count
+    };
+  }
+  await saveResourceIndex(resources, resourceType);
+  return {
+    cacheWritten: true,
+    count: resources.length
+  };
+}
+async function pullRemoteResources(resourceType, solutionId) {
+  const typecacheSource = TYPECACHE_SOURCES[resourceType];
+  if (typecacheSource) {
+    return {
+      resources: await SLICE_FETCHERS[typecacheSource.slice](typecacheSource.projectType),
+      cacheable: true
+    };
+  }
+  switch (resourceType) {
+    case "action-apps":
+      return {
+        resources: await listActionApps(),
+        cacheable: true
+      };
+    case "agent":
+    case "process":
+    case "api":
+    case "processOrchestration":
+    case "caseManagement":
+      return {
+        resources: await listProcessEntities({
+          entitySubType: resourceType
+        }),
+        cacheable: true
+      };
+    case "flow":
+      return {
+        resources: await listProcessEntities({
+          entitySubType: "Flow"
+        }),
+        cacheable: true
+      };
+    case "solution":
+      if (!solutionId) {
+        return {
+          resources: [],
+          cacheable: false,
+          info: "Solution ID not provided. Skipping solution entities pull."
+        };
+      }
+      return {
+        resources: await listSolutionEntities(solutionId),
+        cacheable: true
+      };
+    default: {
+      return {
+        resources: [],
+        cacheable: false,
+        info: `Unknown resource type: ${resourceType}`
+      };
+    }
+  }
+}
+async function getResourcesWithCacheFallback(resourceType) {
+  const [error, resources] = await catchError(loadResourceIndex(resourceType));
+  if (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!errorMessage.includes("No resource index found")) {
+      throw error;
+    }
+    const pullResult = await pullRemoteResources(resourceType);
+    if (pullResult.cacheable) {
+      await saveResourceIndex(pullResult.resources, resourceType);
+    }
+    return pullResult.resources;
+  }
+  return resources;
+}
+async function requireSolution() {
+  const ctx = await findSolutionFromCwd();
+  if (!ctx) {
+    throw new Error("No .uipx solution file found in the current directory, its parent, or its grandparent. Run this command from inside a solution project directory.");
+  }
+  return ctx;
+}
+async function listResources(resourceType) {
+  return getResourcesWithCacheFallback(resourceType);
+}
+async function listLocalResources() {
+  const ctx = await requireSolution();
+  const enrichment = await loadResourceEnrichmentMap(ctx.solutionDir);
+  const grouped = [];
+  for (const type of RESOURCE_TYPES) {
+    grouped.push({
+      type,
+      resources: await readLocalResourcesForType(ctx, type, enrichment)
+    });
+  }
+  return grouped;
+}
+async function searchResources(keyword, resourceType, options) {
+  return searchResourcesWithFilters(keyword, undefined, resourceType, options);
+}
+async function searchResourcesWithFilters(keyword, filters, resourceType, options) {
+  const types = resourceType ? [resourceType] : [...RESOURCE_TYPES];
+  const localCtx = options?.local ? await requireSolution() : null;
+  const enrichment = localCtx ? await loadResourceEnrichmentMap(localCtx.solutionDir) : null;
+  const settled = await Promise.allSettled(types.map((type) => (localCtx ? readLocalResourcesForType(localCtx, type, enrichment ?? undefined) : getResourcesWithCacheFallback(type)).then((resources) => ({
+    type,
+    resources
+  }))));
+  const results = [];
+  const failedTypes = [];
+  for (let i = 0;i < settled.length; i++) {
+    const result = settled[i];
+    if (result.status !== "fulfilled") {
+      const reason = result.reason;
+      failedTypes.push({
+        type: types[i],
+        error: reason instanceof Error ? reason.message : String(reason)
+      });
+      continue;
+    }
+    const { type, resources } = result.value;
+    const matched = searchWithFilters(resources, keyword, filters);
+    for (const resource of matched) {
+      results.push({ resourceType: type, resource });
+    }
+  }
+  if (failedTypes.length === types.length) {
+    throw new Error(`Failed to load resources for all types: ${failedTypes.map((f) => f.type).join(", ")}`);
+  }
+  return { results, failedTypes };
+}
+async function getLocalResources(identifier, resourceType) {
+  const ctx = await requireSolution();
+  const enrichment = await loadResourceEnrichmentMap(ctx.solutionDir);
+  const localTypes = resourceType ? GET_SEARCHABLE_TYPES.filter((t) => t.type === resourceType) : GET_SEARCHABLE_TYPES;
+  const matches = [];
+  for (const { type } of localTypes) {
+    const locals = await readLocalResourcesForType(ctx, type, enrichment);
+    for (const resource of locals) {
+      if (resource.entityKey === identifier) {
+        matches.push({ resourceType: type, resource });
+      }
+    }
+  }
+  return matches;
+}
+async function getResources(identifier, resourceType, options) {
+  if (options?.local) {
+    return getLocalResources(identifier, resourceType);
+  }
+  const typesToSearch = resourceType ? GET_SEARCHABLE_TYPES.filter((t) => t.type === resourceType) : GET_SEARCHABLE_TYPES;
+  const settled = await Promise.allSettled(typesToSearch.map(({ type, idField }) => getResourcesWithCacheFallback(type).then((resources) => ({
+    type,
+    idField,
+    resources
+  }))));
+  const matches = [];
+  for (const result of settled) {
+    if (result.status !== "fulfilled")
+      continue;
+    const { type, idField, resources } = result.value;
+    for (const resource of resources) {
+      if (resource[idField] === identifier) {
+        matches.push({ resourceType: type, resource });
+      }
+    }
+  }
+  return matches;
+}
+export {
+  getResources,
+  listLocalResources,
+  listResources,
+  pullRemoteResources,
+  pullResources,
+  searchResources,
+  searchResourcesWithFilters
+};
+
+//# debugId=E111735BC7C7645664756E2164756E21