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

package/dist/{packager-tool-w1b5pyj6.js → packager-tool-r6b5ktzb.js}

@@ -1,14 +1,17 @@
 import {
   getAuthContext
-} from "./packager-tool-v99ygh9f.js";
+} from "./packager-tool-yn33pw57.js";
 import {
   isBrowser
 } from "./packager-tool-0gctz400.js";
 import {
   addSdkUserAgentHeader,
+  catchError,
+  extractErrorMessage,
   getSdkUserAgentToken,
+  httpStatusOf,
   installSdkUserAgentHeader
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -6240,7 +6243,7 @@ var package_default = {
   name: "@uipath/integrationservice-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0",
+  version: "1.205.0-preview.258",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -6276,12 +6279,13 @@ var package_default = {
   devDependencies: {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
+    "@uipath/solution-sdk": "workspace:*",
     "@openapitools/openapi-generator-cli": "^2.31.1",
     "@types/node": "^25.5.2",
     typescript: "^7.0.2"
   },
   dependencies: {
-    "@uipath/integration-service-design-time": "1.41.2"
+    "@uipath/integration-service-design-time": "2.10.0"
   }
 };
 
@@ -6355,7 +6359,12 @@ async function createApiClient(ApiClass, options) {
   const config = domain === "connections" ? await createConnectionsConfig(options) : await createElementsConfig(options);
   return new ApiClass(config);
 }
+var ACTIVITY_VERSION_V1 = "1.0.0";
 var ACTIVITY_VERSION_V4 = "4.0.0";
+var SUPPORTED_ACTIVITY_VERSIONS = [
+  ACTIVITY_VERSION_V1,
+  ACTIVITY_VERSION_V4
+];
 function isV4ActivityConfiguration(instanceParameters) {
   if (!instanceParameters)
     return false;
@@ -6377,6 +6386,34 @@ async function getConnectorActivityMetadataV4(options, connectorKey, objectName)
   }
   return await response.json();
 }
+async function runInstanceDesignAction(options, connectionOrInstanceId, method, relativeUrl, body) {
+  const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
+  const url = `${baseUrl}/${organizationId}/${tenantName}/elements_/v3/element/instances/${encodeURIComponent(connectionOrInstanceId)}${relativeUrl}`;
+  const headers = addSdkUserAgentHeader({
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "x-uipath-source": "UiPath.CodingAgent"
+  }, SDK_USER_AGENT);
+  const init = { method, headers };
+  if (body && Object.keys(body).length > 0) {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  const response = await connectorApiFetch(url, init);
+  const text = await response.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = text;
+  }
+  return {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    body: parsed
+  };
+}
 async function getEventOperationObjects(options, elementInstanceId, connectorKey, eventOperation) {
   const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
   const url = `${baseUrl}/${organizationId}/${tenantName}/elements_/v3/element/instances/${encodeURIComponent(String(elementInstanceId))}/elements/${encodeURIComponent(connectorKey)}/events/operations/${encodeURIComponent(eventOperation)}/objects`;
@@ -6393,6 +6430,97 @@ async function getEventOperationObjects(options, elementInstanceId, connectorKey
   }
   return await response.json();
 }
+var CONNECTOR_REQUEST_TIMEOUT_MS = 60000;
+async function connectorApiFetch(url, init) {
+  try {
+    return await fetch(url, {
+      ...init,
+      redirect: "manual",
+      signal: AbortSignal.timeout(CONNECTOR_REQUEST_TIMEOUT_MS)
+    });
+  } catch (e) {
+    if (e instanceof Error && e.name === "TimeoutError") {
+      throw new Error(`Request timed out after ${CONNECTOR_REQUEST_TIMEOUT_MS / 1000}s: ${url}. Check connectivity to the tenant and retry.`);
+    }
+    throw e;
+  }
+}
+
+// ../integrationservice-sdk/src/dap/activity-bindings.ts
+var DROPPED_RESOURCES = ["connection", "eventtrigger"];
+var isResourceType = (resource, types) => types.includes((resource ?? "").toLowerCase());
+function storedActivityBindings(bindings) {
+  return bindings.filter((binding) => !isResourceType(binding.resource, DROPPED_RESOURCES));
+}
+function planResourceBindings(stored, resolved) {
+  const plans = [];
+  for (const { field, companion, selection } of resolved) {
+    const entry = stored.find((binding) => binding.key?.toLowerCase() === selection.key.toLowerCase() && !isResourceType(binding.resource, ["property"]));
+    if (entry === undefined)
+      continue;
+    const displayName = entry.value?.name?.displayName ?? field;
+    const rows = [
+      {
+        field,
+        propertyAttribute: "name",
+        name: displayName,
+        default: selection.name
+      }
+    ];
+    if (entry.value?.folderKey && selection.folderKey) {
+      rows.push({
+        field: companion,
+        propertyAttribute: "folderKey",
+        name: `${displayName} folder`,
+        default: selection.folderKey
+      });
+    }
+    plans.push({
+      resource: entry.resource,
+      resourceKey: selection.key,
+      rows
+    });
+  }
+  return plans;
+}
+
+// ../integrationservice-sdk/src/dap/solution-resource-configurations.ts
+var CATALOG_MISS = "was not found in the solution or in the resource catalog";
+function createSolutionResourceConfigurationsProvider(solutionDir, namesByKey = new Map, openedEngine) {
+  let engine = openedEngine ? Promise.resolve(openedEngine) : undefined;
+  const ensureEngine = () => {
+    engine ??= openEngine().catch((err) => {
+      engine = undefined;
+      throw err;
+    });
+    return engine;
+  };
+  const where = solutionDir ? `in ${solutionDir} or the resource catalog` : "in the resource catalog";
+  return {
+    async getAllConfigurations(resourceKey) {
+      const { resources, services } = await ensureEngine();
+      const builder = solutionDir ? await services.getSolutionBuilder(solutionDir, true) : undefined;
+      const [error, graph] = await catchError(resources.readResourceConfigurationsAsync(services, builder, resourceKey, { name: namesByKey.get(resourceKey) }));
+      await builder?.disposeAsync();
+      if (error) {
+        const status = httpStatusOf(error) ?? (error.message.endsWith(CATALOG_MISS) ? 404 : undefined);
+        throw Object.assign(new Error(`Failed to read configuration for solution resource '${resourceKey}' ${where}: ${await extractErrorMessage(error)}`, { cause: error }), { status });
+      }
+      return {
+        resources: graph.resources ?? []
+      };
+    }
+  };
+}
+async function openEngine() {
+  const { getSolutionAuthContext } = await import("./solution-auth-30yycqtv.js");
+  await getSolutionAuthContext({});
+  const resources = await import("./index-ekwtgx7y.js");
+  return {
+    resources,
+    services: await resources.createResourceBuilderServices()
+  };
+}
 
 // ../integrationservice-sdk/src/dap/filter-builder/index.ts
 class FilterNotSupportedError extends Error {
@@ -6453,7 +6581,142 @@ function createLiveConnectionsProvider() {
   };
 }
 
+// ../integrationservice-sdk/src/dap/resource-field-resolver.ts
+var FIELD_ARRAY_MARKER = "[*]";
+function resourceFolderKeyFieldName(fieldName) {
+  const base = fieldName.endsWith(FIELD_ARRAY_MARKER) ? fieldName.slice(0, -FIELD_ARRAY_MARKER.length) : fieldName;
+  return `${base}_folderKey`;
+}
+function isResourceSelection(value) {
+  return typeof value === "object" && value !== null && typeof value.key === "string" && typeof value.name === "string";
+}
+
+class ResourceFieldResolutionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceFieldResolutionError";
+  }
+}
+async function resolveResourceFieldValues(fieldValues, resourceFields, solutionDir) {
+  let solution;
+  const openOnce = async () => {
+    solution ??= await openSolution(solutionDir);
+    return solution;
+  };
+  const [resolveError, resolved] = await catchError(resolveEach(fieldValues, resourceFields, openOnce));
+  const saveError = solution ? await saveSolution(solution, solutionDir) : null;
+  if (resolveError) {
+    if (saveError) {
+      resolveError.message += ` The solution at '${solutionDir}' also failed to save: ${saveError.message}`;
+    }
+    throw resolveError;
+  }
+  if (saveError) {
+    throw new ResourceFieldResolutionError(`The resource was referenced but the solution at '${solutionDir}' could not be saved: ${saveError.message}`);
+  }
+  return resolved;
+}
+async function resolveEach(fieldValues, resourceFields, openOnce) {
+  const resolved = [];
+  for (const field of resourceFields) {
+    const value = fieldValues[field.name];
+    if (value == null || value === "" || isResourceSelection(value) || typeof value === "string" && value.startsWith("=")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      throw new ResourceFieldResolutionError(`'${field.name}' is a multi-select ${field.kind} picker, which the CLI cannot resolve yet — pick one ${field.kind} by name.`);
+    }
+    if (typeof value !== "string") {
+      throw new ResourceFieldResolutionError(`'${field.name}' is a ${field.kind} picker on this activity — pass the ${field.kind} name as a string.`);
+    }
+    const companion = resourceFolderKeyFieldName(field.name);
+    const folderHint = fieldValues[companion];
+    const selection = await referenceResource(await openOnce(), field, value, typeof folderHint === "string" && folderHint !== "" ? folderHint : undefined, companion);
+    fieldValues[field.name] = selection;
+    delete fieldValues[companion];
+    resolved.push({ field: field.name, companion, selection });
+  }
+  return resolved;
+}
+async function openSolution(solutionDir) {
+  const [error, solution] = await catchError((async () => {
+    const { getSolutionAuthContext } = await import("./solution-auth-30yycqtv.js");
+    await getSolutionAuthContext({});
+    const resources = await import("./index-ekwtgx7y.js");
+    await resources.normalizeResourceFileCasing(solutionDir);
+    const services = await resources.createResourceBuilderServices();
+    return {
+      resources,
+      builder: await services.getSolutionBuilder(solutionDir)
+    };
+  })());
+  if (error) {
+    throw new ResourceFieldResolutionError(`A resource picker needs the solution the resource is referenced into, and '${solutionDir}' could not be opened: ${error.message}. ` + "Check the project sits in a solution and you are logged in (run 'uip login').");
+  }
+  return solution;
+}
+async function saveSolution({ resources, builder }, solutionDir) {
+  const error = await resources.saveCasingNormalized(builder);
+  if (!error)
+    await resources.normalizeResourceFileCasing(solutionDir);
+  return error;
+}
+async function referenceResource({ resources, builder }, field, name, folderHint, companion) {
+  const matches = await resources.searchRcsResources(builder, field.kind, name);
+  const candidates = matches.filter((match2) => match2.name.toLowerCase() === name.toLowerCase() && (folderHint === undefined || matchesFolder(resources, match2, folderHint)));
+  if (candidates.length === 0) {
+    throw new ResourceFieldResolutionError(`No ${field.kind} named '${name}'${folderHint ? ` in folder '${folderHint}'` : ""} was found. ` + "If a failed resource catalog lookup was logged above, check your login and retry. " + `Otherwise run 'uip solution resources list --source remote --kind ${field.kind} --search "${name}"' to discover candidates.`);
+  }
+  if (candidates.length > 1) {
+    const folders = candidates.map((match2) => `  - ${match2.folder?.fullyQualifiedName ?? "<tenant>"} (folder key ${match2.folder?.folderKey ?? "<none>"})`).join(`
+`);
+    throw new ResourceFieldResolutionError(`${candidates.length} ${field.kind} resources are named '${name}'. Pass the folder key or path as '${companion}' to pick one:
+${folders}`);
+  }
+  const [match] = candidates;
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError) {
+    throw new ResourceFieldResolutionError(`Failed to read the solution before referencing ${field.kind} '${name}': ${loadError.message}`);
+  }
+  const existing = solution.resources.find((resource) => resource.key.toLowerCase() === match.key.toLowerCase());
+  if (existing) {
+    return {
+      key: existing.key,
+      name: match.name,
+      folderKey: match.folder?.folderKey,
+      folderPath: match.folder?.fullyQualifiedName
+    };
+  }
+  const [referenceError, response] = await catchError(builder.addOrUpdateResourceToSolutionAsync({
+    kind: field.kind,
+    type: match.type,
+    key: match.key,
+    name: match.name,
+    folder: match.folder
+  }, true));
+  if (referenceError) {
+    throw new ResourceFieldResolutionError(`Failed to reference ${field.kind} '${name}' into the solution: ${referenceError.message}`);
+  }
+  return {
+    key: response.resource.key,
+    name: match.name,
+    folderKey: match.folder?.folderKey,
+    folderPath: match.folder?.fullyQualifiedName
+  };
+}
+function matchesFolder({ normalizeFolderPath }, match, folderHint) {
+  const folder = match.folder;
+  if (!folder)
+    return false;
+  if (folder.folderKey.toLowerCase() === folderHint.toLowerCase())
+    return true;
+  const hint = normalizeFolderPath(folderHint);
+  return normalizeFolderPath(folder.fullyQualifiedName) === hint || folder.path !== undefined && normalizeFolderPath(folder.path) === hint;
+}
+
 // ../integrationservice-sdk/src/dap/essential-config.ts
+var MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
+var MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
 function buildActivityEssentialConfiguration(instanceParameters, methodInfo, savedFilterTrees = null, customFieldsRequestDetails = null) {
   const operation = methodInfo.operation.toLowerCase();
   const savedJitInputFieldId = computeSavedJitInputFieldId(operation, methodInfo.parameters, instanceParameters.objectName);
@@ -6485,26 +6748,44 @@ function computeSavedJitInputFieldId(operation, parameters, objectName) {
     return;
   return `in_${objectName}`;
 }
-async function createConfiguredActivityClient({
+async function createConfiguredActivityClient(options) {
+  return (await configureActivityClient(options)).client;
+}
+async function configureActivityClient({
   instanceParameters,
   connectionId,
   savedFilterTrees = null,
   customFieldsRequestDetails = null,
-  fieldValues = null
+  fieldValues = null,
+  solutionDir = null
 }) {
   if (savedFilterTrees) {
     for (const tree of Object.values(savedFilterTrees)) {
       assertFilterTreeSupported(tree);
     }
   }
-  const { DesignTimeActivityClient } = await import("./index-ng2f77my.js");
-  const client = await DesignTimeActivityClient.initiate({ instanceParameters, uiPathActivityTypeId: "" }, { connectionsProvider: createLiveConnectionsProvider() });
+  const { DesignTimeActivityClient } = await import("./index-fyc0k5dd.js");
+  const initiateOptions = {
+    connectionsProvider: createLiveConnectionsProvider(),
+    ...solutionDir ? {
+      solutionResourceConfigurationsProvider: createSolutionResourceConfigurationsProvider(solutionDir)
+    } : {}
+  };
+  const client = await DesignTimeActivityClient.initiate({ instanceParameters, uiPathActivityTypeId: "" }, initiateOptions);
   await client.updateConnection({ connectionId });
+  const resourceFields = fieldValues && (solutionDir || customFieldsRequestDetails) ? await client.getResourceFields() : [];
+  const pickerNames = new Set(resourceFields.map((field) => field.name));
+  const resolvedResources = solutionDir && fieldValues ? await resolveResourceFieldValues(fieldValues, resourceFields, solutionDir) : [];
   if (customFieldsRequestDetails) {
     for (const [
       fieldId,
       value
     ] of customFieldsRequestDetails.parameterValues) {
+      const selection = fieldValues?.[fieldId];
+      if (pickerNames.has(fieldId) && isResourceSelection(selection)) {
+        await client.setFieldValues({ [fieldId]: selection });
+        continue;
+      }
       await client.updateProperty({
         propertyName: fieldId,
         valueType: "widget",
@@ -6523,7 +6804,7 @@ async function createConfiguredActivityClient({
       await applySavedFilterTree(client, filterParam, tree);
     }
   }
-  return client;
+  return { client, resolvedResources };
 }
 async function applySavedFilterTree(client, propertyName, tree) {
   await client.updateProperty({
@@ -6537,6 +6818,28 @@ function assertActivityMetadataResolved(essentialConfiguration, connectionId) {
     throw new Error(`Connector activity metadata was not resolved for connection '${connectionId}' (no connectorVersion). Check the connection is enabled and you are logged in (run 'uip login').`);
   }
 }
+function buildManagedHttpEssentialConfiguration() {
+  const essentialConfiguration = {
+    connectorVersion: MANAGED_HTTP_CONNECTOR_VERSION,
+    executionType: null,
+    customFieldsRequestDetails: null,
+    instanceParameters: {
+      connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
+      objectName: "http-request",
+      httpMethod: "POST",
+      activityType: "Curated",
+      version: "1.0.0"
+    },
+    objectName: "http-request",
+    operation: "create",
+    packageVersion: "1.0.0",
+    httpMethod: "POST",
+    path: "/http-request",
+    unifiedTypesCompatible: true,
+    savedJitInputFieldId: "in_http-request"
+  };
+  return { essentialConfiguration };
+}
 
 // ../integrationservice-sdk/src/dap/input-metadata.ts
 function findMultipartBodyField(params) {
@@ -6545,6 +6848,25 @@ function findMultipartBodyField(params) {
 function extractMultipartParameters(params) {
   return params.filter((p) => p.type === "multipart").map((p) => ({ name: p.name, dataType: p.dataType }));
 }
+function inlineMultipartFileValues(multipartParams, bodyParameters) {
+  if (!bodyParameters || multipartParams.length === 0) {
+    return { multipartParams, bodyParameters };
+  }
+  const nextBody = { ...bodyParameters };
+  const nextParams = multipartParams.map((param) => {
+    if (param.dataType !== "file")
+      return param;
+    const value = nextBody[param.name];
+    if (typeof value !== "string")
+      return param;
+    delete nextBody[param.name];
+    return { ...param, value };
+  });
+  return {
+    multipartParams: nextParams,
+    bodyParameters: Object.keys(nextBody).length > 0 ? nextBody : undefined
+  };
+}
 var DEFAULT_MAX_PAGE_SIZE = 1000;
 function isListOperation(operation) {
   return typeof operation === "string" && operation.toLowerCase() === "list";
@@ -6605,6 +6927,14 @@ function validateFolderKey(context) {
   return [];
 }
 var VALID_HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var METHOD_TO_OPERATION = {
+  GET: "List",
+  GETBYID: "Retrieve",
+  POST: "Create",
+  PATCH: "Update",
+  DELETE: "Delete",
+  PUT: "Replace"
+};
 var OPERATION_TO_METHOD = {
   LIST: "GET",
   RETRIEVE: "GETBYID",
@@ -6714,7 +7044,7 @@ function validateEventType(context) {
 function validateConfiguration(context) {
   if (!context.configuration?.trim()) {
     return [
-      issue(context, "configuration", "Error", 'Configuration is missing or empty. Expected `=jsonString:` prefix wrapping a JSON string with shape `{"essentialConfiguration": {"objectName": "...", "connectionId": "...", ...}}`. Re-run `uip maestro flow node configure` to populate this field correctly.')
+      issue(context, "configuration", "Error", 'Configuration is missing or empty. Expected `=jsonString:` prefix wrapping a JSON string with shape `{"essentialConfiguration": {"objectName": "...", "connectionId": "...", ...}}`. Re-run `uip maestro flow nodes configure` to populate this field correctly.')
     ];
   }
   const jsonStr = context.configuration.startsWith("=jsonString:") ? context.configuration.slice("=jsonString:".length) : context.configuration;
@@ -6722,12 +7052,12 @@ function validateConfiguration(context) {
     const parsed = JSON.parse(jsonStr);
     if (!parsed.essentialConfiguration) {
       return [
-        issue(context, "configuration", "Error", "Configuration is missing the essentialConfiguration envelope. The decoded `=jsonString:` value must be an object whose only top-level key is `essentialConfiguration` (which itself carries `objectName`, `connectionId`, `instanceParameters`, etc.). Re-run `uip maestro flow node configure` rather than hand-editing.")
+        issue(context, "configuration", "Error", "Configuration is missing the essentialConfiguration envelope. The decoded `=jsonString:` value must be an object whose only top-level key is `essentialConfiguration` (which itself carries `objectName`, `connectionId`, `instanceParameters`, etc.). Re-run `uip maestro flow nodes configure` rather than hand-editing.")
       ];
     }
   } catch {
     return [
-      issue(context, "configuration", "Error", 'Configuration contains invalid JSON. The `=jsonString:` prefix must be followed by a single JSON-encoded string (one level of quoting), e.g. `"=jsonString:{\\"essentialConfiguration\\":{...}}"`. Re-run `uip maestro flow node configure` to regenerate.')
+      issue(context, "configuration", "Error", 'Configuration contains invalid JSON. The `=jsonString:` prefix must be followed by a single JSON-encoded string (one level of quoting), e.g. `"=jsonString:{\\"essentialConfiguration\\":{...}}"`. Re-run `uip maestro flow nodes configure` to regenerate.')
     ];
   }
   return [];
@@ -6852,6 +7182,177 @@ var DEFAULT_RULES = [
 function validateIntSvcNode(context, rules = DEFAULT_RULES) {
   return rules.flatMap((rule) => rule(context));
 }
+// ../integrationservice-sdk/src/metadata/design-actions.ts
+var DESIGN_ACTION_TYPE = "api";
+function matchApiAction(actions, fieldValues, actionName) {
+  let matched = null;
+  for (const candidate of actions) {
+    const type = candidate.actionType ?? candidate.ActionType;
+    if (typeof type !== "string" || type.toLowerCase() !== DESIGN_ACTION_TYPE) {
+      continue;
+    }
+    const name = candidate.name ?? candidate.Name;
+    if (actionName && name !== actionName)
+      continue;
+    const rules = candidate.rules ?? candidate.Rules ?? [];
+    if (!rules.every((rule) => ruleSatisfied(rule, fieldValues)))
+      continue;
+    matched = candidate;
+    break;
+  }
+  if (!matched)
+    return null;
+  return normalizeAction(matched);
+}
+function ruleSatisfied(rule, fieldValues) {
+  const fieldName = rule.refFieldName ?? rule.RefFieldName;
+  if (typeof fieldName !== "string")
+    return true;
+  const value = fieldValues[fieldName];
+  const isEmpty = value === undefined || value === "";
+  if ((rule.isCleared ?? rule.IsCleared) === true)
+    return isEmpty;
+  if (isEmpty)
+    return false;
+  const allowed = rule.refFieldValues ?? rule.RefFieldValues;
+  if (!Array.isArray(allowed) || allowed.length === 0)
+    return true;
+  return allowed.some((v) => v === "*" || String(v) === value);
+}
+function normalizeAction(action) {
+  const apiConfig = action.apiConfiguration ?? action.ApiConfiguration;
+  if (!apiConfig) {
+    throw new Error(`Action '${String(action.name ?? action.Name)}' has no apiConfiguration.`);
+  }
+  const method = apiConfig.method ?? apiConfig.Method ?? "GET";
+  const url = apiConfig.url ?? apiConfig.Url ?? "";
+  let body = null;
+  const rawBody = apiConfig.body ?? apiConfig.Body;
+  if (rawBody && typeof rawBody === "object") {
+    body = {};
+    for (const [k, v] of Object.entries(rawBody)) {
+      body[k] = String(v ?? "");
+    }
+  }
+  const onSuccessRaw = action.onSuccess ?? action.OnSuccess;
+  const remap = onSuccessRaw?.remapConfiguration ?? onSuccessRaw?.RemapConfiguration;
+  const onSuccess = {
+    input: remap?.input ?? remap?.Input ?? "replace",
+    output: remap?.output ?? remap?.Output ?? "noop"
+  };
+  const rules = action.rules ?? action.Rules ?? [];
+  const ruleFieldNames = rules.map((r) => r.refFieldName ?? r.RefFieldName).filter((n) => typeof n === "string");
+  return {
+    name: String(action.name ?? action.Name ?? ""),
+    method: method.toUpperCase(),
+    url,
+    body,
+    onSuccess,
+    rules: ruleFieldNames
+  };
+}
+var loadDesignTime = () => import("./index-fyc0k5dd.js");
+var RESOURCE_KEY_EXPRESSION = "resourceKey";
+var SAFE_RESOURCE_KEY = /^(?!\.+$)[A-Za-z0-9._:-]+$/;
+function sentRequest(designTime, action) {
+  return designTime.httpMethodSupportsRequestBody(action.method) ? action : { ...action, body: null };
+}
+function assertRequestTokensResolvable(designTime, action, fieldValues, solutionResources) {
+  for (const token of designTime.getCustomFieldsRequestTokens(action)) {
+    if (token.expression === undefined) {
+      const value = fieldValues[token.fieldName];
+      if (value === undefined || value === "") {
+        throw new Error(`Action '${action.name}' requires a value for field '${token.fieldName}'.`);
+      }
+    } else if (token.expression !== RESOURCE_KEY_EXPRESSION || !solutionResources[token.fieldName]) {
+      throw new Error(`Action '${action.name}' uses expression token '{${token.token}}' which cannot be resolved from literal field values.`);
+    }
+  }
+}
+function toResourceSelections(designTime, action, solutionResources) {
+  const keysInUrl = new Set(designTime.getCustomFieldsRequestTokens({ ...action, body: null }).filter((token) => token.expression === RESOURCE_KEY_EXPRESSION).map((token) => token.fieldName));
+  const resourceSelections = {};
+  for (const [field, resource] of Object.entries(solutionResources)) {
+    if (keysInUrl.has(field) && !SAFE_RESOURCE_KEY.test(resource.resourceKey)) {
+      throw new Error(`Solution resource key '${resource.resourceKey}' for '${field}' is not a plain identifier, so it cannot be sent in the design action's URL.`);
+    }
+    resourceSelections[field] = { key: resource.resourceKey };
+  }
+  return resourceSelections;
+}
+async function resourcePickersRequestNeeds(action, parameters) {
+  if (parameters.length === 0)
+    return [];
+  const designTime = await loadDesignTime();
+  const fields = designTime.getResourceFieldsFromMetadata(parameters);
+  if (fields.length === 0)
+    return [];
+  const tokens = designTime.getCustomFieldsRequestTokens(sentRequest(designTime, action));
+  const referenced = new Set(tokens.map((t) => t.fieldName));
+  const keyRead = new Set(tokens.filter((t) => t.expression === RESOURCE_KEY_EXPRESSION).map((t) => t.fieldName));
+  const sendsBody = designTime.httpMethodSupportsRequestBody(action.method);
+  return fields.filter((field) => referenced.has(field.name) && (sendsBody || keyRead.has(field.name))).map((field) => ({
+    field,
+    readsKey: keyRead.has(field.name),
+    folderKeyField: designTime.solutionResourceFolderKeyFieldName(field.name)
+  }));
+}
+async function runDesignAction(options, connectionId, action, fieldValues, solutionResources = {}, configurationsProvider) {
+  const designTime = await loadDesignTime();
+  const sent = sentRequest(designTime, action);
+  assertRequestTokensResolvable(designTime, sent, fieldValues, solutionResources);
+  const resourceSelections = toResourceSelections(designTime, sent, solutionResources);
+  const { url } = designTime.buildCustomFieldsRequest({
+    apiConfiguration: sent,
+    fieldValues: Object.fromEntries(Object.entries(fieldValues).map(([k, v]) => [
+      k,
+      encodeURIComponent(v)
+    ])),
+    resourceSelections
+  });
+  const request = await designTime.buildCustomFieldsRequestAsync({ apiConfiguration: sent, fieldValues, resourceSelections }, configurationsProvider);
+  const result = await runInstanceDesignAction(options, connectionId, request.method, url, request.body);
+  if (!result.ok) {
+    const detail = typeof result.body === "string" ? result.body : JSON.stringify(result.body);
+    throw Object.assign(new Error(`Design action '${action.name}' failed: ${result.status} ${result.statusText} — ${detail}`), { status: result.status });
+  }
+  if (result.body === null || typeof result.body !== "object" || Array.isArray(result.body)) {
+    throw new Error(`Design action '${action.name}' returned an unexpected payload shape.`);
+  }
+  return result.body;
+}
+
+// ../integrationservice-sdk/src/metadata/trigger-design-actions.ts
+async function findTriggerDesignAction(eventObject, fieldValues, target, actionName) {
+  const design = eventObject.design;
+  const declared = matchApiAction(design?.actions ?? [], fieldValues, actionName);
+  if (!declared)
+    return null;
+  const { routeTriggerObjectAction } = await loadDesignTime();
+  return { ...declared, ...routeTriggerObjectAction(declared, target) };
+}
+function triggerEventParameters(eventObject) {
+  return Array.isArray(eventObject.parameters) ? eventObject.parameters : [];
+}
+function applyTriggerDesignActionRemap(base, response, onSuccess) {
+  const mode = (onSuccess.input || "replace").toLowerCase();
+  if (mode === "noop")
+    return base;
+  const baseFields = base.fields ?? {};
+  const responseFields = response.fields ?? {};
+  let fields;
+  if (mode === "replace")
+    fields = responseFields;
+  else if (mode === "prepend")
+    fields = { ...responseFields, ...baseFields };
+  else
+    fields = { ...baseFields, ...responseFields };
+  return { ...base, fields };
+}
+async function runTriggerDesignAction(options, connectionId, baseMetadata, action, fieldValues, solutionResources = {}, configurationsProvider) {
+  const response = await runDesignAction(options, connectionId, action, fieldValues, solutionResources, configurationsProvider);
+  return applyTriggerDesignActionRemap(baseMetadata, response, action.onSuccess);
+}
 // ../integrationservice-sdk/src/connection-state.ts
 var CONNECTION_STATE_NAMES = new Map([
   [ConnectionState.Enabled, "Enabled"],
@@ -6859,8 +7360,223 @@ var CONNECTION_STATE_NAMES = new Map([
   [ConnectionState.Expired, "Expired"],
   [ConnectionState.Failed, "Failed"]
 ]);
+function normalizeConnectionStatus(status) {
+  if (typeof status === "number") {
+    return CONNECTION_STATE_NAMES.get(status) ?? String(status);
+  }
+  if (typeof status === "string") {
+    const numericStatus = Number(status);
+    if (Number.isInteger(numericStatus)) {
+      return CONNECTION_STATE_NAMES.get(numericStatus) ?? status;
+    }
+    const normalized = status.toLowerCase();
+    if (normalized === "enabled")
+      return "Enabled";
+    if (normalized === "disabled")
+      return "Disabled";
+    if (normalized === "expired")
+      return "Expired";
+    if (normalized === "failed")
+      return "Failed";
+    return status;
+  }
+  return "Unknown";
+}
 // ../integrationservice-sdk/src/metadata/resource-metadata.ts
+async function fetchRawMetadata(api, connectorKey, objectName, connectionId) {
+  if (connectionId) {
+    const response2 = await api.getInstanceObjectMetadataRaw({
+      connectionOrInstanceId: connectionId,
+      elementKey: connectorKey,
+      objectName,
+      includeParentArray: true
+    });
+    return await response2.raw.json();
+  }
+  const response = await api.getObjectMetadataRaw({
+    elementKey: connectorKey,
+    objectName,
+    includeParentArray: true
+  });
+  return await response.raw.json();
+}
+function buildResourceCompactSummary(metadata, operation) {
+  const metadataObj = metadata.metadata;
+  const methods = metadataObj?.method || {};
+  const fields = metadata.fields || {};
+  if (!operation) {
+    const availableOperations = Object.entries(methods).map(([methodKey, methodVal]) => {
+      const curated2 = methodVal.curated;
+      return {
+        method: methodKey,
+        name: METHOD_TO_OPERATION[methodKey] || methodKey,
+        description: methodVal.description,
+        path: methodVal.path,
+        curated: curated2?.displayName
+      };
+    });
+    return {
+      name: metadata.name,
+      displayName: metadata.displayName,
+      elementKey: metadata.elementKey,
+      availableOperations,
+      hint: "Use --operation <Create|List|Retrieve|Update|Delete|Replace> to see fields for a specific operation."
+    };
+  }
+  const httpMethod = OPERATION_TO_METHOD[operation.toUpperCase()] || operation.toUpperCase();
+  const methodInfo = methods[httpMethod];
+  if (!methodInfo) {
+    return {
+      name: metadata.name,
+      displayName: metadata.displayName,
+      elementKey: metadata.elementKey,
+      error: `Operation '${operation}' not found. Available: ${Object.keys(methods).map((k) => METHOD_TO_OPERATION[k] || k).join(", ")}`
+    };
+  }
+  const rawParams = methodInfo.parameters || [];
+  const parameters = rawParams.filter((p) => p.type === "path" || p.type === "query" || p.type === "multipart").map((p) => {
+    const param = {
+      name: p.name,
+      type: p.type,
+      dataType: p.dataType,
+      required: p.required === true,
+      displayName: p.displayName
+    };
+    if (p.description)
+      param.description = p.description;
+    if (p.defaultValue !== undefined)
+      param.defaultValue = p.defaultValue;
+    if (p.reference)
+      param.reference = p.reference;
+    return param;
+  });
+  const requestFields = [];
+  const responseFields = [];
+  for (const [, fieldDef] of Object.entries(fields)) {
+    const design = fieldDef.design;
+    const isHidden = design?.isHidden === true;
+    const fieldMethod = fieldDef.method?.[httpMethod];
+    if (!fieldMethod)
+      continue;
+    const compact = {
+      name: fieldDef.name,
+      type: fieldDef.type,
+      displayName: fieldDef.displayName
+    };
+    if (fieldDef.description)
+      compact.description = fieldDef.description;
+    if (fieldDef.reference)
+      compact.reference = fieldDef.reference;
+    if (Array.isArray(fieldDef.enum) && fieldDef.enum.length > 0) {
+      compact.enum = fieldDef.enum.map((e) => e.value ?? e);
+    }
+    if (fieldDef.primaryKey === true)
+      compact.primaryKey = true;
+    if (fieldDef.searchable === true)
+      compact.searchable = true;
+    if (fieldDef.searchableOperators !== undefined)
+      compact.searchableOperators = fieldDef.searchableOperators;
+    if (fieldDef.searchableNames !== undefined)
+      compact.searchableNames = fieldDef.searchableNames;
+    if (!isHidden && (fieldMethod.request === true || fieldMethod.requestCurated === true)) {
+      requestFields.push({
+        ...compact,
+        required: fieldMethod.required === true
+      });
+    }
+    if (fieldMethod.response === true || fieldMethod.responseCurated === true) {
+      responseFields.push(compact);
+    }
+  }
+  const curated = methodInfo.curated;
+  return {
+    name: metadata.name,
+    displayName: metadata.displayName,
+    elementKey: metadata.elementKey,
+    operation: {
+      method: httpMethod,
+      name: METHOD_TO_OPERATION[httpMethod] || httpMethod,
+      description: methodInfo.description,
+      path: methodInfo.path,
+      curated: curated?.displayName
+    },
+    parameters,
+    requestFields,
+    responseFields,
+    ...Object.keys(methods).length > 0 && {
+      method: JSON.stringify(methods)
+    }
+  };
+}
 var CRUD_OPERATIONS = new Set(["CREATED", "UPDATED", "DELETED"]);
-export { ConnectionOperationsApi, ConnectionsApi, ConnectorsApi, ElementsApi, createApiClient, isV4ActivityConfiguration, getConnectorActivityMetadataV4, getEventOperationObjects, buildActivityEssentialConfiguration, createConfiguredActivityClient, assertActivityMetadataResolved, extractMultipartParameters, buildInputMetadata, validateIntSvcNode };
+async function fetchTriggerMetadata(api, connectorKey, operationName, objectName, connectionId) {
+  if (connectionId) {
+    return catchError(api.getInstanceEventObjectMetadata({
+      connectionOrInstanceId: connectionId,
+      elementKey: connectorKey,
+      operationName,
+      objectName,
+      allFields: true
+    }));
+  }
+  return catchError(api.getEventObjectMetadata({
+    elementKey: connectorKey,
+    operationName,
+    objectName,
+    allFields: true
+  }));
+}
+function buildCompactField(fieldDef, fieldName) {
+  const compact = {
+    name: fieldDef.name ?? fieldName,
+    type: fieldDef.type ?? fieldDef.dataType,
+    displayName: fieldDef.displayName
+  };
+  if (fieldDef.description)
+    compact.description = fieldDef.description;
+  if (fieldDef.reference)
+    compact.reference = fieldDef.reference;
+  if (Array.isArray(fieldDef.enum) && fieldDef.enum.length > 0) {
+    compact.enum = fieldDef.enum.map((e) => e.value ?? e);
+  }
+  return compact;
+}
+function buildTriggerCompactSummary(metadata, operationName) {
+  const fields = metadata.fields ?? {};
+  const eventParameters = [];
+  const filterFields = [];
+  const outputFields = [];
+  for (const [fieldName, fieldDef] of Object.entries(fields)) {
+    const compact = buildCompactField(fieldDef, fieldName);
+    outputFields.push({ ...compact });
+    const events = fieldDef.events;
+    if (events?.[operationName]) {
+      const eventDef = events[operationName];
+      const overrides = eventDef.designOverrides;
+      eventParameters.push({
+        ...compact,
+        displayName: overrides?.displayName ?? compact.displayName,
+        description: overrides?.description ?? compact.description,
+        required: eventDef.required === true
+      });
+    }
+    if (fieldDef.order === 1 || fieldDef.isCuratedEventField === true) {
+      filterFields.push({ ...compact });
+    }
+  }
+  return {
+    name: metadata.name,
+    displayName: metadata.displayName,
+    elementKey: metadata.elementKey,
+    operation: operationName,
+    eventMode: metadata.eventMode,
+    byoaConnection: metadata.byoaConnection === true,
+    isWebhookUrlVisible: metadata.isWebhookUrlVisible === true,
+    eventParameters,
+    filterFields,
+    outputFields
+  };
+}
+export { ConnectionOperationsApi, ConnectionsApi, ConnectorsApi, ElementsApi, createApiClient, ACTIVITY_VERSION_V4, SUPPORTED_ACTIVITY_VERSIONS, isV4ActivityConfiguration, getConnectorActivityMetadataV4, getEventOperationObjects, normalizeConnectionStatus, storedActivityBindings, planResourceBindings, createSolutionResourceConfigurationsProvider, MANAGED_HTTP_CONNECTOR_KEY, buildActivityEssentialConfiguration, createConfiguredActivityClient, configureActivityClient, applySavedFilterTree, assertActivityMetadataResolved, buildManagedHttpEssentialConfiguration, extractMultipartParameters, inlineMultipartFileValues, buildInputMetadata, validateIntSvcNode, resourcePickersRequestNeeds, fetchRawMetadata, buildResourceCompactSummary, fetchTriggerMetadata, buildTriggerCompactSummary, findTriggerDesignAction, triggerEventParameters, runTriggerDesignAction };
 
-//# debugId=5C9109E05EAA875E64756E2164756E21
+//# debugId=A6C4EE71CA44755064756E2164756E21