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

package/dist/connector-task-spec-kdx5bv87.js

@@ -0,0 +1,1250 @@
+import {
+  nestDottedKeys
+} from "./packager-tool-hrr0efqc.js";
+import"./packager-tool-134mvmcm.js";
+import {
+  extractActivityFilterFields,
+  extractTriggerEventParameters,
+  extractTriggerFilterFields,
+  fetchConnectionInfo,
+  fetchConnectorMetadata,
+  fetchConnectorTriggerMetadata
+} from "./packager-tool-rqvr63x5.js";
+import"./packager-tool-885mmrvr.js";
+import {
+  lookupConnectorDisplayName,
+  lookupTypeCacheEntry
+} from "./packager-tool-njzcfve1.js";
+import {
+  assertActivityMetadataResolved,
+  buildActivityEssentialConfiguration,
+  buildInputMetadata,
+  createConfiguredActivityClient,
+  extractMultipartParameters,
+  getEventOperationObjects
+} from "./packager-tool-mp59jtpm.js";
+import"./packager-tool-ajvse9r3.js";
+import"./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-0mj06yen.js";
+import"./packager-tool-j9rfdrdm.js";
+import {
+  TYPECACHE_ACTIVITY_INDEX_TYPES,
+  TYPECACHE_TRIGGER_INDEX_TYPES
+} from "./packager-tool-r84ng21s.js";
+import"./packager-tool-9scn4b15.js";
+import"./packager-tool-3ze5vt52.js";
+import"./packager-tool-vepqrsse.js";
+import"./packager-tool-dqs5qy9s.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  catchError
+} from "./packager-tool-5ax2ywcg.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/case-spec-input-validator.ts
+class InvalidInputDetailsError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidInputDetailsError";
+  }
+}
+var ACTIVITY_VALID_KEYS = new Set([
+  "bodyParameters",
+  "queryParameters",
+  "pathParameters",
+  "filter"
+]);
+var TRIGGER_VALID_KEYS = new Set(["eventParameters", "filter"]);
+function validateActivityInputDetails(raw, isHttpRequest) {
+  if (raw === undefined || raw === null)
+    return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new InvalidInputDetailsError("--input-details must be a JSON object");
+  }
+  const config = raw;
+  const errors = [];
+  if ("ceqlExpression" in config) {
+    errors.push("ceqlExpression is derived from the filter tree and cannot be provided directly");
+  }
+  const unknownKeys = Object.keys(config).filter((k) => !ACTIVITY_VALID_KEYS.has(k) && k !== "ceqlExpression");
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys for activity: ${[...ACTIVITY_VALID_KEYS].join(", ")}`);
+  }
+  for (const key of [
+    "bodyParameters",
+    "queryParameters",
+    "pathParameters"
+  ]) {
+    const val = config[key];
+    if (val !== undefined && (typeof val !== "object" || val === null || Array.isArray(val))) {
+      errors.push(`${key} must be a JSON object`);
+    }
+  }
+  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
+    errors.push("filter must be a JSON object (FilterTree)");
+  }
+  if (config.filter !== undefined && typeof config.queryParameters === "object" && config.queryParameters !== null && !Array.isArray(config.queryParameters) && "where" in config.queryParameters) {
+    errors.push("queryParameters.where is derived from `filter` and cannot be set alongside it. " + 'Drop one of the two — prefer "filter" so Studio Web can re-render the filter widget.');
+  }
+  if (isHttpRequest) {
+    if (config.bodyParameters !== undefined) {
+      errors.push("bodyParameters is not supported for synthetic HTTP request activities. " + "Pass body via --input-details.queryParameters or omit.");
+    }
+    if (config.filter !== undefined) {
+      errors.push("filter is not supported for synthetic HTTP request activities " + "(no curated filterable fields).");
+    }
+  }
+  if (errors.length > 0) {
+    throw new InvalidInputDetailsError(`Invalid --input-details:
+  - ${errors.join(`
+  - `)}`);
+  }
+  return config;
+}
+function validateTriggerInputDetails(raw) {
+  if (raw === undefined || raw === null)
+    return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new InvalidInputDetailsError("--input-details must be a JSON object");
+  }
+  const config = raw;
+  const errors = [];
+  if ("filterExpression" in config) {
+    errors.push("filterExpression is derived from the filter tree and cannot be provided directly. " + 'Pass a structured "filter" (FilterTree) instead.');
+  }
+  const unknownKeys = Object.keys(config).filter((k) => !TRIGGER_VALID_KEYS.has(k) && k !== "filterExpression");
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys for trigger: ${[...TRIGGER_VALID_KEYS].join(", ")}`);
+  }
+  if (config.eventParameters !== undefined && (typeof config.eventParameters !== "object" || config.eventParameters === null || Array.isArray(config.eventParameters))) {
+    errors.push("eventParameters must be a JSON object");
+  }
+  if (config.filter !== undefined && (typeof config.filter !== "object" || config.filter === null || Array.isArray(config.filter))) {
+    errors.push("filter must be a JSON object (FilterTree)");
+  }
+  if (errors.length > 0) {
+    throw new InvalidInputDetailsError(`Invalid --input-details:
+  - ${errors.join(`
+  - `)}`);
+  }
+  return config;
+}
+function normalizeFilterTree(tree) {
+  if (!tree || typeof tree !== "object" || Array.isArray(tree))
+    return tree;
+  const t = tree;
+  const normalized = { ...t };
+  if (t.groupOperator !== undefined) {
+    normalized.groupOperator = normalizeGroupOperator(t.groupOperator);
+  }
+  if (Array.isArray(t.groups)) {
+    normalized.groups = t.groups.map(normalizeFilterTree);
+  }
+  return normalized;
+}
+function normalizeGroupOperator(value) {
+  if (value === "And")
+    return 0;
+  if (value === "Or")
+    return 1;
+  return value;
+}
+
+// src/services/connector-task-spec.types.ts
+var CONN_BINDING_ID_PLACEHOLDER = "{{CONN_BINDING_ID}}";
+var FOLDER_BINDING_ID_PLACEHOLDER = "{{FOLDER_BINDING_ID}}";
+
+// src/services/connector-task-spec.ts
+async function fetchConnectorTaskSpec(type, activityTypeId, connectionId, opts = {}) {
+  if (opts.inputDetails !== undefined && opts.skipCaseShape === true) {
+    throw new InvalidInputDetailsError("--input-details has no effect when --skip-case-shape is set; remove one of the two flags.");
+  }
+  const diagnostics = {
+    fetched: [],
+    fallbacks: [],
+    timestamp: new Date().toISOString()
+  };
+  const typecache = await resolveTypeCacheEntry(type, activityTypeId);
+  diagnostics.fetched.push(`TypeCache(${typecache.source})`);
+  const { connectorKey } = typecache.config;
+  const objectName = opts.objectNameOverride ?? typecache.config.objectName;
+  if (typecache.config.activityType === "Generic" && opts.objectNameOverride === undefined) {
+    throw new Error(`Generic ${type} (${activityTypeId}, "${typecache.entry.displayName}") requires --object-name. ` + `Discover available objects via:
+` + `  uip is resources list --connector-key ${connectorKey}
+` + `  uip is resources describe --connector-key ${connectorKey} --object-name <name>`);
+  }
+  const connection = await fetchConnectionContext(connectionId, diagnostics);
+  if (type === "activity") {
+    if (!typecache.config.httpMethod) {
+      throw new Error(`TypeCache entry ${activityTypeId} ("${typecache.entry.displayName}") has no httpMethod — not a connector activity. Verify the id is for a connector activity (Curated/Generic), not a non-connector activity (process/agent/etc.).`);
+    }
+    const validatedDetails = validateActivityInputDetails(opts.inputDetails, isHttpRequestObject(objectName));
+    const optsForActivity = {
+      ...opts,
+      inputDetails: validatedDetails
+    };
+    return buildActivitySpec(connectorKey, objectName, typecache.config.httpMethod, connection, diagnostics, optsForActivity, {
+      activityTypeId,
+      entry: typecache.entry,
+      parsedConfig: typecache.config
+    });
+  }
+  if (!typecache.config.eventOperation) {
+    throw new Error(`TypeCache entry ${activityTypeId} ("${typecache.entry.displayName}") has no eventOperation — not a connector trigger.`);
+  }
+  const validatedTriggerDetails = validateTriggerInputDetails(opts.inputDetails);
+  const optsForTrigger = {
+    ...opts,
+    inputDetails: validatedTriggerDetails
+  };
+  return buildTriggerSpec(connectorKey, objectName, typecache.config.eventOperation, connection, diagnostics, optsForTrigger, {
+    activityTypeId,
+    entry: typecache.entry,
+    parsedConfig: typecache.config
+  });
+}
+async function resolveTypeCacheEntry(type, activityTypeId) {
+  const sources = type === "activity" ? TYPECACHE_ACTIVITY_INDEX_TYPES : TYPECACHE_TRIGGER_INDEX_TYPES;
+  const [err, result] = await catchError(lookupTypeCacheEntry(activityTypeId, sources));
+  if (err) {
+    throw new Error(`No TypeCache entry found in ${sources.join(", ")} for uiPathActivityTypeId "${activityTypeId}". ` + `If the id is correct, run 'uip maestro case registry pull' to refresh the local cache. ` + `If you're looking up the other kind, pass --type ${type === "activity" ? "trigger" : "activity"}.`);
+  }
+  return {
+    source: result.source,
+    entry: result.entry,
+    config: result.config
+  };
+}
+var ERROR_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    code: { type: "string" },
+    message: { type: "string" },
+    detail: { type: "string" },
+    category: { type: "string" },
+    status: { type: "number" },
+    element: { type: "string" }
+  }
+};
+var RESPONSE_NAME = "response";
+var RESPONSE_SOURCE = "=response";
+var JOB_ATTACHMENT_PREFIX = "=orchestrator.JobAttachments";
+var FILE_TYPE_JSON_SCHEMA = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    ID: {
+      type: "string",
+      description: "Orchestrator attachment key"
+    },
+    FullName: {
+      type: "string",
+      description: "File name"
+    },
+    MimeType: {
+      type: "string",
+      description: "The MIME type of the content, such as application/json or image/png"
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary<string, string> of metadata",
+      additionalProperties: {
+        type: "string"
+      }
+    }
+  },
+  required: ["ID"],
+  "x-uipath-resource-kind": "JobAttachment"
+};
+function humanizeSegment(name) {
+  const clean = name.replace(/\[\*\]/g, "");
+  if (!clean)
+    return "";
+  const spaced = clean.replace(/([A-Z])/g, " $1").toLowerCase().trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+function buildResponseJsonSchema(fields) {
+  const properties = {};
+  const definitions = {};
+  for (const field of fields) {
+    insertResponseField(field, properties, definitions);
+  }
+  return {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    definitions
+  };
+}
+function insertResponseField(field, properties, definitions) {
+  const segments = field.name.split(".");
+  if (segments.length === 0)
+    return;
+  if (segments.length === 1) {
+    properties[segments[0]] = makeLeaf(segments[0], field);
+    return;
+  }
+  let currentProps = properties;
+  let defName = "";
+  for (let i = 0;i < segments.length - 1; i++) {
+    const seg = segments[i];
+    defName = i === 0 ? seg : defName + capitalizeForDefName(seg);
+    if (!definitions[defName]) {
+      definitions[defName] = { type: "object", properties: {} };
+      currentProps[seg] = makeRef(seg, defName);
+    }
+    currentProps = definitions[defName].properties;
+  }
+  const leaf = segments[segments.length - 1];
+  currentProps[leaf] = makeLeaf(leaf, field);
+}
+function makeLeaf(segmentName, field) {
+  if (segmentName.endsWith("[*]")) {
+    return {
+      title: field.displayName ?? humanizeSegment(segmentName),
+      type: "array",
+      items: { type: field.type }
+    };
+  }
+  return {
+    title: field.displayName ?? humanizeSegment(segmentName),
+    type: field.type
+  };
+}
+function makeRef(segmentName, defName) {
+  if (segmentName.endsWith("[*]")) {
+    return {
+      title: humanizeSegment(segmentName),
+      type: "array",
+      items: { $ref: `#/definitions/${defName}` }
+    };
+  }
+  return {
+    title: humanizeSegment(segmentName),
+    $ref: `#/definitions/${defName}`
+  };
+}
+function capitalizeForDefName(seg) {
+  if (!seg)
+    return seg;
+  return seg.charAt(0).toUpperCase() + seg.slice(1);
+}
+function isFileType(type) {
+  return type === "file" || type === "octet-stream";
+}
+function isHttpRequestObject(objectName) {
+  return objectName === "http-request" || objectName === "httpRequest";
+}
+var HTTP_OUTPUT_FIELDS = [
+  {
+    name: "code",
+    displayName: "Code",
+    type: "number",
+    responseCurated: true
+  },
+  {
+    name: "headers",
+    displayName: "Headers",
+    type: "object",
+    responseCurated: true
+  },
+  {
+    name: "body",
+    displayName: "Body",
+    type: "object",
+    responseCurated: true
+  }
+];
+function buildJsonSchemaResponseOutput(displayName, responseFields) {
+  return {
+    name: RESPONSE_NAME,
+    displayName,
+    type: "jsonSchema",
+    source: RESPONSE_SOURCE,
+    body: responseFields.length > 0 ? buildResponseJsonSchema(responseFields) : null
+  };
+}
+function buildFileResponseOutput(displayName) {
+  return {
+    name: RESPONSE_NAME,
+    displayName,
+    type: "file",
+    source: RESPONSE_SOURCE,
+    target: JOB_ATTACHMENT_PREFIX,
+    body: FILE_TYPE_JSON_SCHEMA
+  };
+}
+function buildCuratedOutputs(responseFields) {
+  return responseFields.filter((f) => (f.responseCurated === true || f.primaryKey === true) && f.name !== RESPONSE_NAME).map((f) => {
+    const out = {
+      name: f.name,
+      displayName: f.displayName,
+      type: f.type,
+      source: `${RESPONSE_SOURCE}.${f.name}`,
+      body: null
+    };
+    if (isFileType(f.type)) {
+      out.target = JOB_ATTACHMENT_PREFIX;
+    }
+    return out;
+  });
+}
+function buildErrorOutput() {
+  return {
+    name: "Error",
+    displayName: "Error",
+    type: "jsonSchema",
+    source: "=Error",
+    _jsonSchema: ERROR_OUTPUT_SCHEMA,
+    body: ERROR_OUTPUT_SCHEMA
+  };
+}
+function buildOutputs(objectName, responseDisplayName, responseFields) {
+  const outputs = [];
+  const fileField = responseFields.find((f) => isFileType(f.type));
+  if (fileField) {
+    outputs.push(buildFileResponseOutput(fileField.displayName ?? fileField.name));
+  } else if (isHttpRequestObject(objectName)) {
+    for (const f of HTTP_OUTPUT_FIELDS) {
+      outputs.push({
+        name: f.name,
+        displayName: f.displayName,
+        type: f.type,
+        source: `${RESPONSE_SOURCE}.${f.name}`,
+        body: null
+      });
+    }
+  } else {
+    outputs.push(buildJsonSchemaResponseOutput(responseDisplayName, responseFields));
+    outputs.push(...buildCuratedOutputs(responseFields));
+  }
+  outputs.push(buildErrorOutput());
+  return outputs;
+}
+function buildActivityCaseShape(objectName, _pathParameters, _queryParameters, bodyFields, responseFields, multipart) {
+  const inputs = [];
+  inputs.push({
+    name: "pathParameters",
+    type: "json",
+    target: "pathParameters",
+    body: {}
+  });
+  inputs.push({
+    name: "queryParameters",
+    type: "json",
+    target: "queryParameters",
+    body: {}
+  });
+  if (bodyFields.length > 0) {
+    inputs.push({
+      name: "body",
+      type: "json",
+      target: "body",
+      body: {}
+    });
+  }
+  if (multipart) {
+    for (const param of multipart.parameters) {
+      if (!param.isFile)
+        continue;
+      inputs.push({
+        name: param.name,
+        type: "file",
+        target: "file"
+      });
+    }
+  }
+  const outputs = buildOutputs(objectName, "Response", responseFields);
+  return { inputs, outputs };
+}
+function buildActivityContext(args) {
+  const entries = [
+    { name: "connectorKey", type: "string", value: args.connectorKey },
+    {
+      name: "connection",
+      type: "string",
+      value: `=bindings.${CONN_BINDING_ID_PLACEHOLDER}`
+    },
+    { name: "resourceKey", type: "string", value: args.connectionId }
+  ];
+  if (args.hasFolderKey) {
+    entries.push({
+      name: "folderKey",
+      type: "string",
+      value: `=bindings.${FOLDER_BINDING_ID_PLACEHOLDER}`
+    });
+  }
+  entries.push({ name: "objectName", type: "string", value: args.objectName }, { name: "method", type: "string", value: args.httpMethod }, { name: "path", type: "string", value: args.path });
+  const activityPropertyConfiguration = {};
+  if (args.multipart && args.multipart.parameters.length > 0) {
+    activityPropertyConfiguration.multipartParameters = args.multipart.parameters.map((p) => ({
+      name: p.name,
+      dataType: p.dataType
+    }));
+  }
+  activityPropertyConfiguration.configuration = `=jsonString:${JSON.stringify(args.essentialConfiguration)}`;
+  activityPropertyConfiguration.uiPathActivityTypeId = args.uiPathActivityTypeId;
+  activityPropertyConfiguration.errorState = { issues: [] };
+  const multipartParams = args.multipart?.parameters.map((p) => ({
+    name: p.name,
+    dataType: p.dataType
+  })) ?? [];
+  const inputMetadata = buildInputMetadata(multipartParams, args.verb, args.maxPageSize) ?? {};
+  const activity = args.connectorDisplayName !== null ? { ...args.typecacheEntry, category: args.connectorDisplayName } : args.typecacheEntry;
+  const metadataBody = {
+    activityPropertyConfiguration,
+    activityMetadata: { activity },
+    inputMetadata,
+    telemetryData: {
+      connectorKey: args.connectorKey,
+      connectorName: args.connectorName,
+      operationType: args.verb,
+      objectName: args.objectName,
+      objectDisplayName: args.objectDisplayName,
+      primaryKeyName: args.primaryKeyName
+    }
+  };
+  entries.push({ name: "metadata", type: "json", body: metadataBody });
+  return entries;
+}
+function buildTriggerContext(args) {
+  const entries = [
+    { name: "connectorKey", type: "string", value: args.connectorKey },
+    {
+      name: "connection",
+      type: "string",
+      value: `=bindings.${CONN_BINDING_ID_PLACEHOLDER}`
+    },
+    { name: "resourceKey", type: "string", value: args.connectionId }
+  ];
+  if (args.hasFolderKey) {
+    entries.push({
+      name: "folderKey",
+      type: "string",
+      value: `=bindings.${FOLDER_BINDING_ID_PLACEHOLDER}`
+    });
+  }
+  entries.push({ name: "method", type: "string" }, { name: "path", type: "string" }, { name: "objectName", type: "string", value: args.objectName }, { name: "operation", type: "string", value: args.eventOperation });
+  const activity = args.connectorDisplayName !== null ? { ...args.typecacheEntry, category: args.connectorDisplayName } : args.typecacheEntry;
+  const activityPropertyConfiguration = {
+    objectName: args.objectName,
+    eventType: args.eventOperation,
+    eventMode: args.eventMode,
+    configuration: `=jsonString:${JSON.stringify(args.essentialConfiguration)}`,
+    uiPathActivityTypeId: args.uiPathActivityTypeId,
+    errorState: { issues: [] },
+    ...args.filterExpression && args.filterExpression.length > 0 ? { filterExpression: args.filterExpression } : {}
+  };
+  const telemetryData = {
+    connectorKey: args.connectorKey,
+    connectorName: args.connectorName,
+    objectName: args.objectName,
+    objectDisplayName: args.objectDisplayName,
+    primaryKeyName: ""
+  };
+  const metadataBody = {
+    activityPropertyConfiguration,
+    activityMetadata: { activity },
+    inputMetadata: {},
+    telemetryData
+  };
+  entries.push({ name: "metadata", type: "json", body: metadataBody });
+  return entries;
+}
+function buildTriggerCaseShape(objectName, _eventParameters, responseFields, responseDisplayName) {
+  const inputs = [
+    {
+      name: "body",
+      type: "json",
+      target: "body",
+      body: {}
+    }
+  ];
+  const outputs = buildOutputs(objectName, responseDisplayName, responseFields);
+  return { inputs, outputs };
+}
+async function fetchConnectionContext(connectionId, diagnostics) {
+  const [err, info] = await catchError(fetchConnectionInfo(connectionId));
+  if (err) {
+    diagnostics.fallbacks.push({
+      endpoint: "fetchConnectionInfo",
+      reason: err.message
+    });
+    throw new Error(`Connection "${connectionId}" not found or inaccessible: ${err.message}`);
+  }
+  diagnostics.fetched.push("fetchConnectionInfo");
+  return {
+    context: {
+      id: info.id,
+      name: info.name,
+      folderKey: info.folderKey,
+      elementInstanceId: info.elementInstanceId,
+      byoaConnection: info.byoaConnection,
+      pollingIntervalMinutes: info.pollingInterval,
+      supportedAuths: []
+    },
+    connectorName: info.connectorName,
+    elementVersion: info.connectorVersion
+  };
+}
+function applyActivityInputDetails(caseShape, inputDetails, filter) {
+  if (inputDetails.bodyParameters !== undefined) {
+    const nested = nestDottedKeys(inputDetails.bodyParameters);
+    let bodyInput = caseShape.inputs.find((i) => i.name === "body");
+    if (!bodyInput) {
+      bodyInput = {
+        name: "body",
+        type: "json",
+        target: "body",
+        body: {}
+      };
+      caseShape.inputs.push(bodyInput);
+    }
+    bodyInput.body = mergeShallow(bodyInput.body ?? {}, nested);
+  }
+  if (inputDetails.queryParameters !== undefined) {
+    const queryInput = caseShape.inputs.find((i) => i.name === "queryParameters");
+    if (queryInput) {
+      queryInput.body = mergeShallow(queryInput.body ?? {}, inputDetails.queryParameters);
+    }
+  }
+  if (inputDetails.pathParameters !== undefined) {
+    const pathInput = caseShape.inputs.find((i) => i.name === "pathParameters");
+    if (pathInput) {
+      pathInput.body = mergeShallow(pathInput.body ?? {}, inputDetails.pathParameters);
+    }
+  }
+  if (filter.filterParamName !== null && filter.ceqlExpression !== null) {
+    const queryInput = caseShape.inputs.find((i) => i.name === "queryParameters");
+    if (queryInput) {
+      const existing = queryInput.body ?? {};
+      queryInput.body = {
+        ...existing,
+        [filter.filterParamName]: filter.ceqlExpression
+      };
+    }
+  }
+}
+function mergeShallow(base, overlay) {
+  return { ...base, ...overlay };
+}
+function applyTriggerInputDetails(caseShape, inputDetails, filterExpression) {
+  let bodyInput = caseShape.inputs.find((i) => i.name === "body");
+  if (!bodyInput) {
+    bodyInput = {
+      name: "body",
+      type: "json",
+      target: "body",
+      body: {}
+    };
+    caseShape.inputs.push(bodyInput);
+  }
+  const body = bodyInput.body ?? {};
+  const eventParameters = inputDetails.eventParameters;
+  const hasEventParams = eventParameters !== undefined && Object.keys(eventParameters).length > 0;
+  if (filterExpression.length > 0) {
+    const existingFilters = body.filters ?? {};
+    body.filters = { ...existingFilters, expression: filterExpression };
+  }
+  if (hasEventParams && eventParameters) {
+    body.queryParams = { ...eventParameters };
+  }
+  bodyInput.body = body;
+}
+function buildActivityPagination(verb, methodInfo) {
+  if (verb !== "list")
+    return null;
+  const declared = methodInfo.pagination?.maxPageSize;
+  return { maxPageSize: declared ? declared : 1000 };
+}
+async function buildActivitySpec(connectorKey, objectName, httpMethod, resolvedConnection, diagnostics, opts, typecacheCtx) {
+  if (isHttpRequestObject(objectName)) {
+    return buildHttpActivitySpec(connectorKey, objectName, httpMethod, resolvedConnection, diagnostics, opts, typecacheCtx);
+  }
+  const [metaErr, metadata] = await catchError(fetchActivityMetadata(connectorKey, objectName, resolvedConnection.context.id));
+  if (metaErr) {
+    diagnostics.fallbacks.push({
+      endpoint: "fetchConnectorMetadata",
+      reason: metaErr.message
+    });
+    throw new Error(`Failed to fetch metadata for ${connectorKey}/${objectName}: ${metaErr.message}`);
+  }
+  diagnostics.fetched.push("fetchConnectorMetadata");
+  const methodInfo = extractMethodInfo(metadata, httpMethod);
+  if (!methodInfo) {
+    throw new Error(`Object "${objectName}" does not expose method "${httpMethod}". Available: ${listMethods(metadata).join(", ")}`);
+  }
+  const verb = methodInfo.operation.toLowerCase();
+  const objectDisplayName = metadata.displayName ?? objectName;
+  const params = methodInfo.parameters ?? [];
+  const pathParameters = params.filter((p) => p.type === "path").map(parameterFromIS);
+  const queryParameters = params.filter((p) => p.type === "query").map(parameterFromIS);
+  const multipart = buildMultipartSpec(params);
+  const fields = collectFields(metadata);
+  const bodyFields = filterFieldsByMethod(fields, httpMethod, "request");
+  const responseFields = filterFieldsByMethod(fields, httpMethod, "response");
+  const filter = buildActivityFilter(metadata, httpMethod, verb);
+  const pagination = buildActivityPagination(verb, methodInfo);
+  const references = collectReferences(connectorKey, resolvedConnection.context.id, [
+    ...pathParameters.map((p) => ({ p, slot: "pathParameters" })),
+    ...queryParameters.map((p) => ({ p, slot: "queryParameters" })),
+    ...bodyFields.map((p) => ({ p, slot: "bodyFields" }))
+  ]);
+  const inputDetails = opts.inputDetails;
+  let savedFilterTrees = null;
+  let activityFilterParamName = null;
+  if (inputDetails?.filter !== undefined) {
+    const filterBuilderParam = (methodInfo.parameters ?? []).find((p) => p.design?.component === "FilterBuilder");
+    if (!filterBuilderParam) {
+      throw new InvalidInputDetailsError(`Activity "${connectorKey}/${objectName}" does not declare a FilterBuilder parameter — server-side filtering is not supported by this operation. Drop "filter" from --input-details.`);
+    }
+    activityFilterParamName = filterBuilderParam.name;
+    savedFilterTrees = {
+      [activityFilterParamName]: normalizeFilterTree(inputDetails.filter)
+    };
+  }
+  const instanceParameters = {
+    ...typecacheCtx.parsedConfig,
+    connectorKey,
+    objectName,
+    httpMethod
+  };
+  const activityClient = await createConfiguredActivityClient({
+    instanceParameters,
+    connectionId: resolvedConnection.context.id,
+    savedFilterTrees
+  });
+  const { essentialConfiguration: essentialConfig } = activityClient.getEssentialConfiguration();
+  assertActivityMetadataResolved(essentialConfig, resolvedConnection.context.id);
+  const activityCeqlExpression = activityFilterParamName ? activityClient.getCompiledFilter(activityFilterParamName) : null;
+  const essentialConfiguration = { essentialConfiguration: essentialConfig };
+  const primaryKeyName = responseFields.filter((f) => f.primaryKey === true).map((f) => f.name).join(",");
+  let caseShape;
+  if (!opts.skipCaseShape) {
+    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    caseShape = buildActivityCaseShape(objectName, pathParameters, queryParameters, bodyFields, responseFields, multipart);
+    if (inputDetails) {
+      applyActivityInputDetails(caseShape, inputDetails, {
+        filterParamName: activityFilterParamName,
+        ceqlExpression: activityCeqlExpression
+      });
+    }
+    caseShape.context = buildActivityContext({
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      objectName,
+      objectDisplayName,
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      httpMethod: methodInfo.method,
+      verb,
+      path: methodInfo.path,
+      connectionId: resolvedConnection.context.id,
+      hasFolderKey: resolvedConnection.context.folderKey !== null,
+      typecacheEntry: typecacheCtx.entry,
+      connectorDisplayName,
+      multipart,
+      maxPageSize: pagination?.maxPageSize,
+      primaryKeyName,
+      essentialConfiguration
+    });
+  }
+  return {
+    specVersion: 1,
+    identity: {
+      target: "activity",
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      connectorVersion: extractElementVersion(resolvedConnection),
+      objectName,
+      objectDisplayName,
+      typecacheEntry: typecacheCtx.entry
+    },
+    operation: {
+      name: httpMethod,
+      verb,
+      description: methodInfo.description ?? "",
+      httpMethod,
+      path: methodInfo.path
+    },
+    connection: resolvedConnection.context,
+    inputs: {
+      pathParameters,
+      queryParameters,
+      bodyFields,
+      multipart,
+      eventParameters: []
+    },
+    outputs: {
+      responseFields,
+      pagination
+    },
+    ...filter ? { filter } : {},
+    essentialConfiguration,
+    references,
+    diagnostics,
+    ...caseShape ? { caseShape } : {}
+  };
+}
+async function buildHttpActivitySpec(connectorKey, objectName, httpMethod, resolvedConnection, diagnostics, opts, typecacheCtx) {
+  diagnostics.fetched.push("synthetic.HttpRequest");
+  const verb = httpMethodToVerb(httpMethod);
+  const objectDisplayName = typecacheCtx.entry.displayName ?? objectName;
+  const instanceParameters = {
+    ...typecacheCtx.parsedConfig,
+    connectorKey,
+    objectName,
+    httpMethod
+  };
+  const essentialConfiguration = buildActivityEssentialConfiguration(instanceParameters, {
+    operation: verb,
+    description: "",
+    method: httpMethod,
+    parameters: [],
+    path: "",
+    operationId: ""
+  });
+  const httpInputDetails = opts.inputDetails;
+  let caseShape;
+  if (!opts.skipCaseShape) {
+    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    caseShape = buildActivityCaseShape(objectName, [], [], [], [], null);
+    if (httpInputDetails) {
+      applyActivityInputDetails(caseShape, httpInputDetails, {
+        filterParamName: null,
+        ceqlExpression: null
+      });
+    }
+    caseShape.context = buildActivityContext({
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      objectName,
+      objectDisplayName,
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      httpMethod,
+      verb,
+      path: "",
+      connectionId: resolvedConnection.context.id,
+      hasFolderKey: resolvedConnection.context.folderKey !== null,
+      typecacheEntry: typecacheCtx.entry,
+      connectorDisplayName,
+      multipart: null,
+      maxPageSize: undefined,
+      primaryKeyName: "",
+      essentialConfiguration
+    });
+  }
+  return {
+    specVersion: 1,
+    identity: {
+      target: "activity",
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      connectorVersion: extractElementVersion(resolvedConnection),
+      objectName,
+      objectDisplayName,
+      typecacheEntry: typecacheCtx.entry
+    },
+    operation: {
+      name: httpMethod,
+      verb,
+      description: "Generic HTTP request — outputs are synthetic (code, headers, body) per FE's getHttpOutputResponse",
+      httpMethod,
+      path: ""
+    },
+    connection: resolvedConnection.context,
+    inputs: {
+      pathParameters: [],
+      queryParameters: [],
+      bodyFields: [],
+      multipart: null,
+      eventParameters: []
+    },
+    outputs: {
+      responseFields: [],
+      pagination: null
+    },
+    essentialConfiguration,
+    references: [],
+    diagnostics,
+    ...caseShape ? { caseShape } : {}
+  };
+}
+async function fetchActivityMetadata(connectorKey, objectName, connectionId) {
+  return fetchConnectorMetadata(connectorKey, objectName, connectionId);
+}
+function extractMethodInfo(metadata, httpMethod) {
+  const methodMap = metadata.metadata;
+  const map = methodMap?.method ?? {};
+  return map[httpMethod] ?? Object.values(map).find((m) => m.method === httpMethod);
+}
+function listMethods(metadata) {
+  const methodMap = metadata.metadata;
+  return Object.keys(methodMap?.method ?? {});
+}
+async function buildTriggerSpec(connectorKey, objectName, eventOperation, resolvedConnection, diagnostics, opts, typecacheCtx) {
+  const [metaErr, triggerMeta] = await catchError(fetchTriggerMetadata(connectorKey, objectName, eventOperation, resolvedConnection.context.id));
+  if (metaErr) {
+    diagnostics.fallbacks.push({
+      endpoint: "fetchConnectorTriggerMetadata",
+      reason: metaErr.message
+    });
+    throw new Error(`Failed to fetch trigger metadata for ${connectorKey}/${eventOperation}/${objectName}: ${metaErr.message}`);
+  }
+  diagnostics.fetched.push("fetchConnectorTriggerMetadata");
+  const elementInstanceId = resolvedConnection.context.elementInstanceId;
+  let eventOpFlags = null;
+  if (elementInstanceId !== null) {
+    const [flagsErr, flags] = await catchError(getEventOperationObjects(undefined, elementInstanceId, connectorKey, eventOperation));
+    if (flagsErr) {
+      diagnostics.fallbacks.push({
+        endpoint: "client-factory.getEventOperationObjects",
+        reason: flagsErr.message
+      });
+    } else {
+      diagnostics.fetched.push("client-factory.getEventOperationObjects");
+      const match = flags.find((f) => f.name === objectName);
+      if (match) {
+        eventOpFlags = match;
+        if (Array.isArray(match.supportedAuths)) {
+          resolvedConnection.context.supportedAuths = [
+            ...match.supportedAuths
+          ];
+        }
+      }
+    }
+  }
+  const eventMode = triggerMeta.eventMode === "webhooks" ? "webhooks" : "polling";
+  const objectDisplayName = triggerMeta.displayName ?? objectName;
+  const fieldsMap = triggerMeta.fields ?? {};
+  const allFields = Object.values(fieldsMap);
+  const eventParamCompacts = extractTriggerEventParameters(triggerMeta, eventOperation);
+  const eventParameters = eventParamCompacts.map(compactToFieldSpec);
+  const filterFieldDefs = extractTriggerFilterFieldsLocal(triggerMeta);
+  const responseFields = allFields.map((f) => triggerFieldToFieldSpec(f, false));
+  const references = collectReferences(connectorKey, resolvedConnection.context.id, [
+    ...eventParameters.map((p) => ({ p, slot: "eventParameters" })),
+    ...responseFields.map((p) => ({ p, slot: "responseFields" }))
+  ]);
+  const triggerInputDetails = opts.inputDetails;
+  let triggerFilterTree = null;
+  if (triggerInputDetails?.filter !== undefined) {
+    triggerFilterTree = normalizeFilterTree(triggerInputDetails.filter);
+  }
+  const baseActivityType = typecacheCtx.parsedConfig.activityType ?? "CuratedTrigger";
+  const overriddenActivityType = baseActivityType.startsWith("Generic") ? "GenericWaitFor" : "CuratedWaitFor";
+  const instanceParameters = {
+    ...typecacheCtx.parsedConfig,
+    connectorKey,
+    objectName,
+    eventOperation,
+    eventMode,
+    activityType: overriddenActivityType
+  };
+  const triggerClient = await createConfiguredActivityClient({
+    instanceParameters,
+    connectionId: resolvedConnection.context.id,
+    savedFilterTrees: triggerFilterTree ? { filter: triggerFilterTree } : null,
+    fieldValues: triggerInputDetails?.eventParameters ?? {}
+  });
+  const { essentialConfiguration: triggerEssentialConfig } = triggerClient.getEssentialConfiguration();
+  assertActivityMetadataResolved(triggerEssentialConfig, resolvedConnection.context.id);
+  const combinedFilterExpression = triggerClient.getCompiledFilter("filter");
+  const essentialConfiguration = {
+    essentialConfiguration: triggerEssentialConfig
+  };
+  const filter = filterFieldDefs.length > 0 ? { builder: "jmes", fields: filterFieldDefs } : undefined;
+  const byoaConnection = eventOpFlags?.byoaConnection ?? resolvedConnection.context.byoaConnection;
+  resolvedConnection.context.byoaConnection = byoaConnection;
+  const responseDisplayName = typecacheCtx.entry.displayName ?? objectDisplayName ?? "Response";
+  let caseShape;
+  if (!opts.skipCaseShape) {
+    caseShape = buildTriggerCaseShape(objectName, eventParameters, responseFields, responseDisplayName);
+    if (triggerInputDetails) {
+      applyTriggerInputDetails(caseShape, triggerInputDetails, combinedFilterExpression);
+    }
+    const connectorDisplayName = await lookupConnectorDisplayName(typecacheCtx.entry.packageId);
+    caseShape.context = buildTriggerContext({
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      objectName,
+      objectDisplayName,
+      eventOperation,
+      eventMode,
+      connectionId: resolvedConnection.context.id,
+      hasFolderKey: resolvedConnection.context.folderKey !== null,
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      essentialConfiguration,
+      typecacheEntry: typecacheCtx.entry,
+      connectorDisplayName,
+      filterExpression: combinedFilterExpression
+    });
+  }
+  return {
+    specVersion: 1,
+    identity: {
+      target: "trigger",
+      uiPathActivityTypeId: typecacheCtx.activityTypeId,
+      connectorKey,
+      connectorName: resolvedConnection.connectorName,
+      connectorVersion: extractElementVersion(resolvedConnection),
+      objectName,
+      objectDisplayName,
+      typecacheEntry: typecacheCtx.entry
+    },
+    operation: {
+      name: eventOperation,
+      verb: eventOperation,
+      description: "",
+      eventMode
+    },
+    connection: resolvedConnection.context,
+    inputs: {
+      pathParameters: [],
+      queryParameters: [],
+      bodyFields: [],
+      multipart: null,
+      eventParameters
+    },
+    outputs: {
+      responseFields,
+      pagination: null
+    },
+    ...filter ? { filter } : {},
+    essentialConfiguration,
+    references,
+    diagnostics,
+    ...caseShape ? { caseShape } : {}
+  };
+}
+async function fetchTriggerMetadata(connectorKey, objectName, operationName, connectionId) {
+  return fetchConnectorTriggerMetadata(connectorKey, operationName, objectName, connectionId);
+}
+function collectFields(metadata) {
+  const direct = metadata.fields;
+  if (direct) {
+    return Array.isArray(direct) ? direct : Object.values(direct);
+  }
+  const nested = metadata.metadata;
+  if (nested?.fields) {
+    return Array.isArray(nested.fields) ? nested.fields : Object.values(nested.fields);
+  }
+  return [];
+}
+function filterFieldsByMethod(fields, httpMethod, direction) {
+  const out = [];
+  for (const f of fields) {
+    const mc = f.method?.[httpMethod];
+    const isResponsePrimaryKey = direction === "response" && f.primaryKey === true;
+    if (!mc && !isResponsePrimaryKey)
+      continue;
+    const include = direction === "request" ? mc?.request === true || mc?.requestCurated === true : mc?.response === true || mc?.responseCurated === true || isResponsePrimaryKey;
+    if (!include)
+      continue;
+    out.push(fieldToFieldSpec(f, mc, direction));
+  }
+  return out;
+}
+function fieldToFieldSpec(field, methodConfig, direction) {
+  const spec = {
+    name: field.name,
+    displayName: field.displayName,
+    description: field.description ?? "",
+    dataType: field.type,
+    type: field.type,
+    required: direction === "request" ? methodConfig?.required === true : false
+  };
+  if (Array.isArray(field.enum) && field.enum.length > 0) {
+    spec.enum = field.enum;
+  }
+  if (field.reference) {
+    spec.reference = referenceToPointer(field.reference);
+  }
+  if (field.searchable === true) {
+    spec.searchable = true;
+    if (field.searchableOperators?.length) {
+      spec.searchableOperators = [...field.searchableOperators];
+    }
+    if (field.searchableNames?.length) {
+      spec.searchableNames = [...field.searchableNames];
+    }
+  }
+  if (direction === "response") {
+    if (methodConfig?.responseCurated === true) {
+      spec.responseCurated = true;
+    }
+    if (field.primaryKey === true) {
+      spec.primaryKey = true;
+    }
+  }
+  return spec;
+}
+function triggerFieldToFieldSpec(field, required) {
+  const spec = {
+    name: field.name,
+    displayName: field.displayName,
+    description: field.description ?? "",
+    dataType: field.type,
+    type: field.type,
+    required
+  };
+  if (Array.isArray(field.enum) && field.enum.length > 0) {
+    spec.enum = field.enum;
+  }
+  if (field.reference) {
+    spec.reference = referenceToPointer(field.reference);
+  }
+  return spec;
+}
+function compactToFieldSpec(c) {
+  const spec = {
+    name: c.name,
+    displayName: c.displayName,
+    description: c.description ?? "",
+    dataType: c.dataType,
+    type: c.type,
+    required: c.required
+  };
+  if (c.enum && c.enum.length > 0)
+    spec.enum = c.enum;
+  if (c.reference) {
+    spec.reference = referenceToPointer(c.reference);
+  }
+  return spec;
+}
+function toFilterFieldSpec(cf) {
+  const ff = {
+    name: cf.name,
+    displayName: cf.displayName,
+    type: normalizeFilterType(cf.type)
+  };
+  if (cf.enum && cf.enum.length > 0)
+    ff.enum = cf.enum;
+  if (cf.searchableOperators?.length) {
+    ff.searchableOperators = [...cf.searchableOperators];
+  }
+  if (cf.searchableNames?.length) {
+    ff.searchableNames = [...cf.searchableNames];
+  }
+  return ff;
+}
+function extractTriggerFilterFieldsLocal(triggerMeta) {
+  return extractTriggerFilterFields(triggerMeta).map(toFilterFieldSpec);
+}
+function buildActivityFilter(metadata, method, verb) {
+  if (verb !== "list" && verb !== "read")
+    return;
+  const filterFields = extractActivityFilterFields(metadata, method).map(toFilterFieldSpec);
+  return filterFields.length > 0 ? { builder: "ceql", fields: filterFields } : undefined;
+}
+function normalizeFilterType(raw) {
+  switch ((raw ?? "").toLowerCase()) {
+    case "number":
+      return "number";
+    case "integer":
+      return "integer";
+    case "boolean":
+      return "boolean";
+    case "date-time":
+    case "datetime":
+    case "date":
+      return "date-time";
+    default:
+      return "string";
+  }
+}
+function parameterFromIS(p) {
+  const spec = {
+    name: p.name,
+    displayName: p.displayName,
+    description: p.description ?? "",
+    dataType: p.dataType,
+    required: p.required === true
+  };
+  if (p.defaultValue !== undefined)
+    spec.defaultValue = p.defaultValue;
+  if (p.reference) {
+    spec.reference = referenceToPointer(p.reference);
+  }
+  return spec;
+}
+function buildMultipartSpec(params) {
+  const multiparts = extractMultipartParameters(params);
+  if (multiparts.length === 0)
+    return null;
+  const inputMeta = buildInputMetadata(multiparts, "create");
+  return {
+    bodyFieldName: inputMeta?.multipart?.bodyFieldName ?? null,
+    parameters: multiparts.map((m) => ({
+      name: m.name,
+      dataType: m.dataType,
+      isFile: m.dataType === "file"
+    }))
+  };
+}
+function referenceToPointer(reference) {
+  return {
+    objectName: reference.objectName ?? "",
+    lookupValue: reference.lookupValue ?? "",
+    lookupNames: Array.isArray(reference.lookupNames) ? reference.lookupNames : [],
+    discoverCommand: ""
+  };
+}
+function collectReferences(connectorKey, connectionId, sources) {
+  const seen = new Set;
+  const out = [];
+  for (const { p, slot } of sources) {
+    if (!p.reference?.objectName)
+      continue;
+    const key = `${slot}:${p.name}:${p.reference.objectName}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const cmd = `uip is resources run list ${connectorKey} ${p.reference.objectName} --connection-id ${connectionId}`;
+    const ref = {
+      ...p.reference,
+      discoverCommand: cmd,
+      consumedBy: `${slot}.${p.name}`
+    };
+    out.push(ref);
+    p.reference.discoverCommand = cmd;
+  }
+  return out;
+}
+function httpMethodToVerb(method) {
+  switch (method) {
+    case "GET":
+      return "list";
+    case "POST":
+      return "create";
+    case "PUT":
+      return "replace";
+    case "PATCH":
+      return "update";
+    case "DELETE":
+      return "delete";
+  }
+}
+function extractElementVersion(rc) {
+  return rc.elementVersion;
+}
+export {
+  applyActivityInputDetails,
+  applyTriggerInputDetails,
+  buildActivityContext,
+  buildResponseJsonSchema,
+  buildTriggerContext,
+  fetchConnectorTaskSpec
+};
+
+//# debugId=ACFD551E64F8716264756E2164756E21