@uipath/case-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/packager-tool-k0ar6cn7.js

@@ -0,0 +1,295 @@
+import {
+  catchError2,
+  logger
+} from "./packager-tool-psmb758n.js";
+import {
+  ConnectionsApi,
+  ElementsApi,
+  createApiClient,
+  isV4ActivityConfiguration,
+  getConnectorActivityMetadataV4
+} from "./packager-tool-ccejfs0r.js";
+
+// ../maestro-sdk/src/registry/integration-service-fetcher.ts
+function parseContext(node) {
+  const context = node.model?.context;
+  if (!Array.isArray(context))
+    return null;
+  const connectorKey = context.find((c) => c.name === "connectorKey")?.value;
+  const objectName = context.find((c) => c.name === "objectName")?.value;
+  const method = context.find((c) => c.name === "method")?.value ?? "POST";
+  const operation = context.find((c) => c.name === "operation")?.value;
+  if (!connectorKey || !objectName)
+    return null;
+  return { connectorKey, objectName, method, operation };
+}
+function applyOptionalFieldProps(compact, field) {
+  if (field.enum?.length)
+    compact.enum = field.enum;
+  if (field.reference) {
+    compact.reference = {
+      objectName: field.reference.objectName,
+      lookupValue: field.reference.lookupValue,
+      lookupNames: field.reference.lookupNames,
+      path: field.reference.path,
+      childPath: field.reference.childPath,
+      scriptRef: field.reference.scriptRef
+    };
+  }
+}
+function extractFields(metadata, method, requestOnly) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => {
+    const methodInfo = field.method?.[method];
+    if (!methodInfo)
+      return false;
+    return requestOnly ? methodInfo.request === true || methodInfo.requestCurated === true : methodInfo.response === true || methodInfo.responseCurated === true;
+  }).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: requestOnly ? field.method?.[method]?.required === true : false,
+      description: field.description
+    };
+    if (!requestOnly)
+      compact.responseOnly = true;
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function isConnectorNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector") || false;
+}
+function isConnectorTriggerNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector.trigger") || false;
+}
+function toCompactField(field, required) {
+  const compact = {
+    name: field.name,
+    displayName: field.displayName,
+    type: field.type,
+    dataType: field.type,
+    required,
+    description: field.description
+  };
+  applyOptionalFieldProps(compact, field);
+  return compact;
+}
+function extractTriggerEventParameters(metadata, operationName) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => !!field.events?.[operationName]).map((field) => toCompactField(field, field.events?.[operationName]?.required === true));
+}
+function extractTriggerFilterFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => field.order === 1).map((field) => toCompactField(field, false));
+}
+function extractActivityFilterFields(metadata, _method) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => field.searchable === true).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: false,
+      description: field.description
+    };
+    if (field.searchableOperators?.length) {
+      compact.searchableOperators = [...field.searchableOperators];
+    }
+    if (field.searchableNames?.length) {
+      compact.searchableNames = [...field.searchableNames];
+    }
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function extractTriggerOutputFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.map((field) => {
+    const compact = toCompactField(field, false);
+    compact.responseOnly = true;
+    return compact;
+  });
+}
+async function fetchConnectorTriggerMetadata(connectorKey, operationName, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  const triggerMetadata = await api.getInstanceEventObjectMetadata({
+    connectionOrInstanceId: connectionId,
+    elementKey: connectorKey,
+    operationName,
+    objectName,
+    allFields: true
+  });
+  return triggerMetadata;
+}
+function getConfigurationString(node) {
+  const modelConfig = node.model?.configuration;
+  if (modelConfig)
+    return modelConfig;
+  const form = node.form;
+  for (const section of form?.sections ?? []) {
+    for (const field of section.fields ?? []) {
+      const config = field.componentProps?.connectorDetail?.configuration;
+      if (config)
+        return config;
+    }
+  }
+  return;
+}
+function getConnectorConfiguration(node) {
+  const configStr = getConfigurationString(node);
+  if (!configStr)
+    return null;
+  const [err, parsed] = catchError2(() => JSON.parse(configStr));
+  return err ? null : parsed;
+}
+class ConnectionConnectorMismatchError2 extends Error {
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "ConnectionConnectorMismatchError";
+  }
+}
+function assertConnectionConnector(connectionId, info, connectorKey, subject) {
+  if (!info.connectorKey || !connectorKey || info.connectorKey.toLowerCase() === connectorKey.toLowerCase()) {
+    return;
+  }
+  throw new ConnectionConnectorMismatchError2(`Connection "${connectionId}" is a ${info.connectorKey} connection, but ${subject} runs on ${connectorKey}.`, `Pass a ${connectorKey} connection: 'uip is connections list ${connectorKey} --all-folders'.`);
+}
+async function fetchConnectionInfo(connectionId) {
+  const api = await createApiClient(ConnectionsApi);
+  const response = await api.apiV1ConnectionsConnectionIdGet({
+    connectionId
+  });
+  const connector = response.connector;
+  return {
+    id: response.id ?? connectionId,
+    name: response.name ?? connectionId,
+    connectorKey: connector?.key ?? "",
+    connectorName: connector?.name ?? "",
+    connectorVersion: response.elementVersion ?? null,
+    pollingInterval: response.pollingIntervalInMinutes ?? null,
+    byoaConnection: response.byoaConnection === true,
+    elementInstanceId: response.elementInstanceId ?? null,
+    folderKey: response.folder?.key ?? null
+  };
+}
+async function fetchConnectorMetadata2(connectorKey, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  if (connectionId) {
+    const response = await api.getInstanceObjectMetadataRaw({
+      connectionOrInstanceId: connectionId,
+      elementKey: connectorKey,
+      objectName,
+      includeParentArray: true
+    });
+    return await response.raw.json();
+  }
+  const response = await api.getObjectMetadataRaw({
+    elementKey: connectorKey,
+    objectName,
+    includeParentArray: true
+  });
+  return await response.raw.json();
+}
+async function fetchConnectorActivityMetadataV4(connectorKey, objectName) {
+  return await getConnectorActivityMetadataV4(undefined, connectorKey, objectName);
+}
+function buildEnrichedActivityNode(node, metadata, method) {
+  const connectorMethodInfo = metadata?.metadata?.method?.[method];
+  const inputFields = extractFields(metadata, method, true);
+  const outputFields = extractFields(metadata, method, false);
+  const filterFields = extractActivityFilterFields(metadata, method);
+  return {
+    ...node,
+    ...connectorMethodInfo && { connectorMethodInfo },
+    inputDefinition: node.inputDefinition && Object.keys(node.inputDefinition).length > 0 ? node.inputDefinition : { fields: inputFields },
+    outputResponseDefinition: { fields: outputFields },
+    ...filterFields.length > 0 && {
+      filterFields: { fields: filterFields }
+    }
+  };
+}
+async function enrichConnectorActivityNode(node, connectionId) {
+  const parsed = parseContext(node);
+  const config = getConnectorConfiguration(node);
+  if (isV4ActivityConfiguration(config)) {
+    return enrichV4ConnectorActivityNode(node, connectionId, config);
+  }
+  if (!parsed)
+    return node;
+  const { connectorKey, objectName, method } = parsed;
+  const [error, metadata] = await catchError2(fetchConnectorMetadata2(connectorKey, objectName, connectionId));
+  if (error) {
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichV4ConnectorActivityNode(node, connectionId, config) {
+  const connectorKey = config?.connectorKey;
+  const objectName = config?.objectName;
+  const method = config?.httpMethod;
+  if (!connectorKey || !objectName || !method) {
+    logger.warn("v4 IS enrichment skipped: node configuration carries no connectorKey/objectName/httpMethod.");
+    return node;
+  }
+  if (connectionId) {
+    logger.warn("v4 metadata endpoints are not connection-scoped — --connection-id is ignored for 4.0.0 enrichment.");
+  }
+  const [error, metadata] = await catchError2(fetchConnectorActivityMetadataV4(connectorKey, objectName));
+  if (error) {
+    logger.warn(`IS v4 enrichment failed: ${error.message}`);
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichConnectorNode(node, connectionId) {
+  if (!isConnectorNode(node))
+    return node;
+  return isConnectorTriggerNode(node) ? enrichConnectorTriggerNode(node, connectionId) : enrichConnectorActivityNode(node, connectionId);
+}
+async function enrichConnectorTriggerNode(node, connectionId) {
+  if (!connectionId) {
+    throw new Error("Trigger nodes require --connection-id for IS enrichment. Provide it with --connection-id <id>.");
+  }
+  const parsed = parseContext(node);
+  if (!parsed?.operation)
+    return node;
+  const { connectorKey, objectName, operation } = parsed;
+  const metadata = await fetchConnectorTriggerMetadata(connectorKey, operation, objectName, connectionId);
+  const eventParameters = extractTriggerEventParameters(metadata, operation);
+  const filterFields = extractTriggerFilterFields(metadata);
+  const outputFields = extractTriggerOutputFields(metadata);
+  let byoaConnection = false;
+  let elementInstanceId = null;
+  if (connectionId) {
+    const [connErr, connInfo] = await catchError2(fetchConnectionInfo(connectionId));
+    if (!connErr) {
+      byoaConnection = connInfo.byoaConnection;
+      elementInstanceId = connInfo.elementInstanceId;
+    } else {
+      logger.warn(`Failed to fetch connection info for ${connectionId}: ${connErr.message}`);
+    }
+  }
+  return {
+    ...node,
+    eventMode: metadata.eventMode,
+    byoaConnection,
+    elementInstanceId,
+    eventParameters: { fields: eventParameters },
+    filterFields: { fields: filterFields },
+    outputResponseDefinition: { fields: outputFields }
+  };
+}
+
+export { extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, ConnectionConnectorMismatchError2, assertConnectionConnector, fetchConnectionInfo, fetchConnectorMetadata2, enrichConnectorNode };
+
+//# debugId=1F5E5EEBDAE1651764756E2164756E21

package/dist/packager-tool-kz7zz79p.js

@@ -0,0 +1,71 @@
+import {
+  catchError2
+} from "./packager-tool-psmb758n.js";
+import {
+  byCodeUnit
+} from "./packager-tool-1c30ttpm.js";
+
+// src/services/bindings-v2.ts
+var BINDINGS_V2_FILE_NAME2 = "bindings_v2.json";
+var BINDINGS_V2_VERSION = "2.0";
+var CONNECTION_ID_PROPERTY2 = "ConnectionId";
+var FOLDER_KEY_PROPERTY2 = "folderKey";
+var sortBindingsV2Resources = (resources) => [...resources].sort((a, b) => byCodeUnit(a.resource, b.resource) || byCodeUnit(a.key, b.key));
+var serializeBindingsV2File2 = (resources) => {
+  const file = {
+    version: BINDINGS_V2_VERSION,
+    resources: sortBindingsV2Resources(resources)
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+};
+var readBindingsV2Resources2 = (raw) => {
+  const [error, parsed] = catchError2(() => JSON.parse(raw));
+  if (error)
+    return;
+  if (parsed === null || typeof parsed !== "object")
+    return;
+  const resources = parsed.resources;
+  if (!Array.isArray(resources))
+    return;
+  return resources.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.key === "string");
+};
+var identity = (entry) => `${entry.resource}:${entry.key}`;
+var asSaved = (entry, found) => {
+  let saved = entry;
+  if (entry.resource === "Connection" && entry.value[FOLDER_KEY_PROPERTY2] !== undefined && found.value?.[FOLDER_KEY_PROPERTY2] === undefined) {
+    const { [FOLDER_KEY_PROPERTY2]: _dropped, ...value } = entry.value;
+    saved = { ...saved, value };
+  }
+  if (saved.metadata?.ActivityName !== undefined && found.metadata?.ActivityName === undefined) {
+    const { ActivityName: _label, ...metadata } = saved.metadata;
+    saved = { ...saved, metadata };
+  }
+  return saved;
+};
+var diffBindingsV22 = (expected, actual) => {
+  const expectedByKey = new Map(expected.map((e) => [identity(e), e]));
+  const actualByKey = new Map(actual.map((e) => [identity(e), e]));
+  const missing = [];
+  const changed = [];
+  for (const [key, entry] of expectedByKey) {
+    const found = actualByKey.get(key);
+    if (found === undefined) {
+      missing.push(entry.key);
+    } else if (JSON.stringify(found) !== JSON.stringify(asSaved(entry, found))) {
+      changed.push(entry.key);
+    }
+  }
+  const extra = [...actualByKey.values()].filter((entry) => !expectedByKey.has(identity(entry))).map((entry) => entry.key);
+  const alphabetically = (left, right) => left.localeCompare(right);
+  return {
+    missing: missing.sort(alphabetically),
+    extra: extra.sort(alphabetically),
+    changed: changed.sort(alphabetically)
+  };
+};
+var hasBindingsV2Difference2 = (difference) => difference.missing.length > 0 || difference.extra.length > 0 || difference.changed.length > 0;
+
+export { BINDINGS_V2_FILE_NAME2, CONNECTION_ID_PROPERTY2, FOLDER_KEY_PROPERTY2, serializeBindingsV2File2, readBindingsV2Resources2, diffBindingsV22, hasBindingsV2Difference2 };
+
+//# debugId=A1ABBB615ABF984E64756E2164756E21

package/dist/{packager-tool-1gwbq864.js → packager-tool-m5384a1s.js}

@@ -1,31 +1,37 @@
 import {
-  fetchConnectorConnections,
-  lookupTypeCacheEntry
-} from "./packager-tool-qn3zkrrc.js";
-import {
-  addVarIdsToInputsOutputs,
-  buildErrorOutput
-} from "./packager-tool-ydyvtknp.js";
-import {
-  fetchConnectorMetadata
-} from "./packager-tool-b1nw50ev.js";
+  catchError2
+} from "./packager-tool-psmb758n.js";
 import {
   ElementsApi,
-  assertActivityMetadataResolved,
-  buildInputMetadata,
   createApiClient,
   createConfiguredActivityClient,
-  extractMultipartParameters
-} from "./packager-tool-wr12ndwk.js";
+  assertActivityMetadataResolved,
+  extractMultipartParameters,
+  buildInputMetadata
+} from "./packager-tool-ccejfs0r.js";
+import {
+  guardJsonString
+} from "./packager-tool-h2ar8xf8.js";
+import {
+  lookupTypeCacheEntry2,
+  fetchConnectorConnections2
+} from "./packager-tool-ehjw672b.js";
+import {
+  buildErrorOutput,
+  addVarIdsToInputsOutputs
+} from "./packager-tool-0w4fsdzv.js";
+import {
+  fetchConnectorMetadata2
+} from "./packager-tool-k0ar6cn7.js";
 import {
   createConnectorBindings
-} from "./packager-tool-sq931c23.js";
+} from "./packager-tool-e1tx5mqg.js";
 import {
-  catchError
-} from "./packager-tool-83v804p7.js";
+  v2ConfigurationVersionEntry
+} from "./packager-tool-68648y3j.js";
 
 // src/services/connector-enrichment-service.ts
-function parseEntryConfiguration(entry) {
+function parseEntryConfiguration2(entry) {
   if (!entry.configuration)
     return {};
   try {
@@ -35,15 +41,15 @@ function parseEntryConfiguration(entry) {
   }
 }
 async function fetchMetadataSafe(connectorKey, objectName, connectionId) {
-  const [err, result] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
+  const [err, result] = await catchError2(fetchConnectorMetadata2(connectorKey, objectName, connectionId));
   return err ? undefined : result;
 }
-async function resolveActivityOperation(connectorKey, displayName, operation) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function resolveActivityOperation2(connectorKey, displayName, operation) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return operation;
   }
-  const [fetchError, activities] = await catchError(api.getActivities({ elementKey: connectorKey }));
+  const [fetchError, activities] = await catchError2(api.getActivities({ elementKey: connectorKey }));
   if (fetchError) {
     return operation;
   }
@@ -52,9 +58,9 @@ async function resolveActivityOperation(connectorKey, displayName, operation) {
   }
   const list = activities;
   if (operation) {
-    const match2 = list.find((a) => a.operation === operation && !a.isTrigger);
-    if (match2) {
-      return match2.name;
+    const match = list.find((a) => a.operation === operation && !a.isTrigger);
+    if (match) {
+      return match.name;
     }
   }
   const match = list.find((a) => a.displayName === displayName && !a.isTrigger);
@@ -63,31 +69,31 @@ async function resolveActivityOperation(connectorKey, displayName, operation) {
   }
   return operation;
 }
-async function fetchObjectSwaggerPath(connectorKey, objectName) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function fetchObjectSwaggerPath2(connectorKey, objectName) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return;
   }
-  const [fetchError, swagger] = await catchError(api.getObjectSwagger({
+  const [fetchError, swagger] = await catchError2(api.getObjectSwagger({
     elementKey: connectorKey,
     objectName
   }));
   if (fetchError) {
     return;
   }
-  const [parseError, parsed] = catchError(() => typeof swagger === "string" ? JSON.parse(swagger) : swagger);
+  const [parseError, parsed] = catchError2(() => typeof swagger === "string" ? JSON.parse(swagger) : swagger);
   if (parseError || !parsed?.paths) {
     return;
   }
   const pathKeys = Object.keys(parsed.paths).filter((k) => k.startsWith("/"));
   return pathKeys[0];
 }
-async function fetchObjectMethodConfig(connectorKey, objectName, httpMethod) {
-  const [apiError, api] = await catchError(createApiClient(ElementsApi));
+async function fetchObjectMethodConfig2(connectorKey, objectName, httpMethod) {
+  const [apiError, api] = await catchError2(createApiClient(ElementsApi));
   if (apiError) {
     return;
   }
-  const [fetchError, objects] = await catchError(api.getObjects({ elementKey: connectorKey }));
+  const [fetchError, objects] = await catchError2(api.getObjects({ elementKey: connectorKey }));
   if (fetchError) {
     return;
   }
@@ -104,7 +110,7 @@ async function fetchObjectMethodConfig(connectorKey, objectName, httpMethod) {
 }
 async function buildActivityPropertyConfig(params) {
   const { entry, uiPathActivityTypeId, connectionId } = params;
-  const instanceParameters = parseEntryConfiguration(entry);
+  const instanceParameters = parseEntryConfiguration2(entry);
   const activityClient = await createConfiguredActivityClient({
     instanceParameters,
     connectionId
@@ -115,7 +121,7 @@ async function buildActivityPropertyConfig(params) {
   const multipartParams = extractMultipartParameters(params.objectMethodConfig?.parameters ?? []);
   return {
     ...multipartParams.length > 0 ? { multipartParameters: multipartParams } : {},
-    configuration: `=jsonString:${JSON.stringify(essentialConfig)}`,
+    configuration: guardJsonString(JSON.stringify(essentialConfig)),
     uiPathActivityTypeId,
     errorState: { issues: [] }
   };
@@ -125,7 +131,7 @@ function buildInputMetadataFromParams(objectMethodConfig, resolvedOperation) {
   const multipartParams = extractMultipartParameters(params);
   return buildInputMetadata(multipartParams, resolvedOperation ?? "list") ?? undefined;
 }
-function extractFields(metadata) {
+function extractFields2(metadata) {
   if (metadata.fields) {
     return metadata.fields;
   }
@@ -135,36 +141,18 @@ function extractFields(metadata) {
   }
   return;
 }
-function normalizeFields(raw) {
+function normalizeFields2(raw) {
   if (Array.isArray(raw)) {
     return raw;
   }
   return Object.values(raw);
 }
-var UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-function nestDottedKeys(flat) {
-  const result = {};
-  for (const [key, value] of Object.entries(flat)) {
-    const parts = key.split(".");
-    if (parts.some((p) => UNSAFE_KEYS.has(p)))
-      continue;
-    let current = result;
-    for (let i = 0;i < parts.length - 1; i++) {
-      if (!Object.hasOwn(current, parts[i]) || typeof current[parts[i]] !== "object" || current[parts[i]] === null) {
-        current[parts[i]] = {};
-      }
-      current = current[parts[i]];
-    }
-    current[parts[parts.length - 1]] = value;
-  }
-  return result;
-}
-function mapISFieldsToInputOutputs(metadata, httpMethod) {
-  const rawFields = extractFields(metadata);
+function mapISFieldsToInputOutputs2(metadata, httpMethod) {
+  const rawFields = extractFields2(metadata);
   if (!rawFields) {
     return { inputs: [], outputs: [] };
   }
-  const fields = normalizeFields(rawFields);
+  const fields = normalizeFields2(rawFields);
   const method = httpMethod ?? "POST";
   const requestFields = [];
   const responseFields = [];
@@ -214,7 +202,7 @@ function mapISFieldsToInputOutputs(metadata, httpMethod) {
   outputs.push(buildErrorOutput());
   return { inputs, outputs };
 }
-function buildParameterInputs(objectMethodConfig, activityPropertyConfig) {
+function buildParameterInputs2(objectMethodConfig, activityPropertyConfig) {
   const inputs = [];
   inputs.push({
     name: "pathParameters",
@@ -269,7 +257,7 @@ function httpMethodToOperationType(method) {
       return "";
   }
 }
-function buildConnectorContext(params) {
+function buildConnectorContext2(params) {
   const {
     config,
     entry,
@@ -339,26 +327,22 @@ function buildConnectorContext(params) {
       primaryKeyName: ""
     }
   };
-  context.push({
-    name: "metadata",
-    type: "json",
-    body: metadataBody
-  });
+  context.push({ name: "metadata", type: "json", body: metadataBody }, v2ConfigurationVersionEntry());
   return context;
 }
-async function extractFieldDefinitions(connectorKey, objectName, httpMethod, prefetched) {
+async function extractFieldDefinitions2(connectorKey, objectName, httpMethod, prefetched) {
   const result = {};
   if (!objectName)
     return result;
   const method = httpMethod ?? "POST";
   const [metadata, methodConfig] = prefetched ? [prefetched.metadata, prefetched.methodConfig] : await Promise.all([
     fetchMetadataSafe(connectorKey, objectName),
-    fetchObjectMethodConfig(connectorKey, objectName, method)
+    fetchObjectMethodConfig2(connectorKey, objectName, method)
   ]);
   if (metadata) {
-    const rawFields = extractFields(metadata);
+    const rawFields = extractFields2(metadata);
     if (rawFields) {
-      const fields = normalizeFields(rawFields);
+      const fields = normalizeFields2(rawFields);
       const bodyDefs = {};
       for (const field of fields) {
         const mc = field.method?.[method];
@@ -414,7 +398,7 @@ async function extractFieldDefinitions(connectorKey, objectName, httpMethod, pre
   }
   return result;
 }
-async function enrichConnectorRegistryEntry(config, connectionId) {
+async function enrichConnectorRegistryEntry2(config, connectionId) {
   if (!config.objectName || !config.httpMethod) {
     return null;
   }
@@ -422,11 +406,11 @@ async function enrichConnectorRegistryEntry(config, connectionId) {
   if (!metadata) {
     return null;
   }
-  const rawFields = extractFields(metadata);
+  const rawFields = extractFields2(metadata);
   if (!rawFields) {
     return null;
   }
-  const fields = normalizeFields(rawFields);
+  const fields = normalizeFields2(rawFields);
   const method = config.httpMethod;
   const inputFields = [];
   const outputFields = [];
@@ -460,9 +444,9 @@ async function enrichConnectorRegistryEntry(config, connectionId) {
     outputDefinition: { fields: outputFields }
   };
 }
-async function enrichConnectorActivity(activityTypeId, connectionId, indexType = "typecache-activities") {
-  const { entry, config } = await lookupTypeCacheEntry(activityTypeId, indexType);
-  const resolvedOperation = await resolveActivityOperation(config.connectorKey, entry.displayName, config.operation);
+async function enrichConnectorActivity2(activityTypeId, connectionId, indexType = "typecache-activities") {
+  const { entry, config } = await lookupTypeCacheEntry2(activityTypeId, indexType);
+  const resolvedOperation = await resolveActivityOperation2(config.connectorKey, entry.displayName, config.operation);
   let inputs = [];
   let outputs = [];
   let objectSwaggerPath;
@@ -472,13 +456,13 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (config.objectName) {
     const [md, swaggerPath, mc] = await Promise.all([
       fetchMetadataSafe(config.connectorKey, config.objectName),
-      fetchObjectSwaggerPath(config.connectorKey, config.objectName),
-      fetchObjectMethodConfig(config.connectorKey, config.objectName, config.httpMethod)
+      fetchObjectSwaggerPath2(config.connectorKey, config.objectName),
+      fetchObjectMethodConfig2(config.connectorKey, config.objectName, config.httpMethod)
     ]);
     metadata = md ?? undefined;
     objectMethodConfig = mc ?? undefined;
     if (metadata) {
-      const io = mapISFieldsToInputOutputs(metadata, config.httpMethod);
+      const io = mapISFieldsToInputOutputs2(metadata, config.httpMethod);
       inputs = io.inputs;
       outputs = io.outputs;
       inputMetadata = buildInputMetadataFromParams(objectMethodConfig, resolvedOperation ?? config.operation);
@@ -496,10 +480,10 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (config.objectName) {
     inputs = [
       ...inputs,
-      ...buildParameterInputs(objectMethodConfig, activityPropertyConfig)
+      ...buildParameterInputs2(objectMethodConfig, activityPropertyConfig)
     ];
   }
-  const connections = await fetchConnectorConnections(config.connectorKey);
+  const connections = await fetchConnectorConnections2(config.connectorKey);
   const connection = connections.find((c) => c.id === connectionId);
   if (!connection) {
     throw new Error(`Connection "${connectionId}" not found for connector "${config.connectorKey}"`);
@@ -511,7 +495,7 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   if (folderKeyBinding) {
     bindings.push(folderKeyBinding);
   }
-  const context = buildConnectorContext({
+  const context = buildConnectorContext2({
     config,
     entry,
     connectionBindingId: connectionBinding.id,
@@ -541,6 +525,6 @@ async function enrichConnectorActivity(activityTypeId, connectionId, indexType =
   };
 }
 
-export { parseEntryConfiguration, resolveActivityOperation, fetchObjectSwaggerPath, fetchObjectMethodConfig, extractFields, normalizeFields, UNSAFE_KEYS, nestDottedKeys, mapISFieldsToInputOutputs, buildParameterInputs, buildConnectorContext, extractFieldDefinitions, enrichConnectorRegistryEntry, enrichConnectorActivity };
+export { parseEntryConfiguration2, resolveActivityOperation2, fetchObjectSwaggerPath2, fetchObjectMethodConfig2, extractFields2, normalizeFields2, mapISFieldsToInputOutputs2, buildParameterInputs2, buildConnectorContext2, extractFieldDefinitions2, enrichConnectorRegistryEntry2, enrichConnectorActivity2 };
 
-//# debugId=3B7A9B9E859645AF64756E2164756E21
+//# debugId=E98C74933F9F2C6D64756E2164756E21