@boomi/embedkit-sdk 1.1.6 → 1.2.1

package/dist/index.cjs

@@ -417,7 +417,9 @@ __export(lib_exports, {
   X12ConnectorRecordGroupingExpression: () => X12ConnectorRecordGroupingExpression,
   X12ConnectorRecordService: () => X12ConnectorRecordService,
   X12ConnectorRecordSimpleExpression: () => X12ConnectorRecordSimpleExpression,
-  X12Options: () => X12Options
+  X12Options: () => X12Options,
+  redactBody: () => redactBody,
+  redactHeaders: () => redactHeaders
 });
 module.exports = __toCommonJS(lib_exports);
 
@@ -545,6 +547,35 @@ _promise = new WeakMap();
 _resolve = new WeakMap();
 _reject = new WeakMap();
 
+// lib/utils/redact.ts
+function redactHeaders(h) {
+  if (!h) return h;
+  const lower = {};
+  for (const [k, v] of Object.entries(h)) lower[k.toLowerCase()] = String(v);
+  if (lower["authorization"]) lower["authorization"] = "[REDACTED]";
+  if (lower["cookie"]) lower["cookie"] = "[REDACTED]";
+  if (lower["set-cookie"]) lower["set-cookie"] = "[REDACTED]";
+  return lower;
+}
+function redactBody(body) {
+  if (!body || typeof body !== "object") return body;
+  try {
+    const clone = JSON.parse(JSON.stringify(body));
+    const scrubKeys = ["password", "token", "accessToken", "refreshToken", "clientSecret", "secret"];
+    const walk = (o) => {
+      if (!o || typeof o !== "object") return;
+      for (const k of Object.keys(o)) {
+        if (scrubKeys.includes(k)) o[k] = "[REDACTED]";
+        else walk(o[k]);
+      }
+    };
+    walk(clone);
+    return clone;
+  } catch {
+    return "[Unserializable body]";
+  }
+}
+
 // lib/core/request.ts
 var isDefined = (value) => {
   return value !== void 0 && value !== null;
@@ -599,23 +630,6 @@ var getQueryString = (params) => {
   }
   return "";
 };
-var getUrl = (config, options) => {
-  const encoder = config.ENCODE_PATH || encodeURI;
-  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
-    if (options.path?.hasOwnProperty(group)) {
-      return encoder(String(options.path[group]));
-    }
-    return substring;
-  });
-  const url = `${config.BASE}${path}`;
-  if (options.query) {
-    return `${url}${getQueryString(options.query)}`;
-  }
-  if (config.OVERRIDE_ACCOUNT) {
-    return `${url}?overrideAccount=${config.OVERRIDE_ACCOUNT_ID}`;
-  }
-  return url;
-};
 var getFormData = (options) => {
   if (options.formData) {
     const formData = new FormData();
@@ -650,7 +664,7 @@ var getHeaders = async (config, options, formData) => {
     resolve(options, config.PASSWORD),
     resolve(options, config.HEADERS)
   ]);
-  const formHeaders = typeof formData?.getHeaders === "function" && formData?.getHeaders() || {};
+  const formHeaders = formData && typeof formData.getHeaders === "function" ? formData.getHeaders() : {};
   const headers = Object.entries({
     Accept: "application/json",
     ...additionalHeaders,
@@ -755,15 +769,79 @@ var catchErrorCodes = (options, result) => {
     );
   }
 };
+var mergeQuery = (base, extra) => ({ ...base ?? {}, ...extra });
+async function resolveChildOverrideId(config, options) {
+  if (options.overrideAccountId) return options.overrideAccountId;
+  if (config.OVERRIDE_ACCOUNT) {
+    const maybeId = await resolve(options, config.OVERRIDE_ACCOUNT_ID);
+    return isStringWithValue(maybeId) ? maybeId : void 0;
+  }
+  return void 0;
+}
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const base = `${config.BASE}${path}`;
+  return options.query ? `${base}${getQueryString(options.query)}` : base;
+};
+function getLogger(config) {
+  return config.LOGGER;
+}
+function reqId() {
+  return Math.random().toString(36).slice(2, 10);
+}
 var request = (config, options, axiosClient = import_axios.default) => {
-  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+  return new CancelablePromise(async (resolvePromise, reject, onCancel) => {
+    const logger = getLogger(config);
+    const id = options.requestId ?? reqId();
     try {
-      const url = getUrl(config, options);
       const formData = getFormData(options);
       const body = getRequestBody(options);
       const headers = await getHeaders(config, options, formData);
+      const mode = options.overrideMode ?? "auto";
+      let effectiveOverrideId;
+      switch (mode) {
+        case "force-parent":
+        case "suppress":
+          effectiveOverrideId = void 0;
+          break;
+        case "force-child":
+        case "auto":
+        default:
+          effectiveOverrideId = await resolveChildOverrideId(config, options);
+          break;
+      }
+      const urlOptions = effectiveOverrideId ? { ...options, query: mergeQuery(options.query, { overrideAccount: effectiveOverrideId }) } : options;
+      const url = getUrl(config, urlOptions);
+      const child = logger?.child?.({
+        component: "embedkit-sdk",
+        reqId: id,
+        overrideAccount: effectiveOverrideId
+      }) ?? logger;
+      const start = Date.now();
+      child?.info?.({
+        req: {
+          method: (options.method || "GET").toUpperCase(),
+          url,
+          headers: redactHeaders(headers),
+          body: redactBody(body ?? formData)
+        }
+      }, "http.request");
       if (!onCancel.isCancelled) {
         const response = await sendRequest(config, options, url, body, formData, headers, onCancel, axiosClient);
+        const ms = Date.now() - start;
+        child?.info?.({
+          res: {
+            statusCode: response.status,
+            headers: redactHeaders(response.headers)
+          },
+          responseTime: ms
+        }, "http.response");
         const responseBody = getResponseBody(response);
         const responseHeader = getResponseHeader(response, options.responseHeader);
         const result = {
@@ -774,9 +852,16 @@ var request = (config, options, axiosClient = import_axios.default) => {
           body: responseHeader ?? responseBody
         };
         catchErrorCodes(options, result);
-        resolve2(result.body);
+        resolvePromise(result.body);
       }
     } catch (error) {
+      const ms = typeof error?.config === "object" && error.config?._start ? Date.now() - error.config._start : void 0;
+      const errObj = {
+        err: error,
+        responseTime: ms
+      };
+      const logger2 = getLogger(config);
+      logger2?.error?.(errObj, "http.error");
       reject(error);
     }
   });
@@ -4269,6 +4354,50 @@ var EdifactConnectorRecordService = class {
   }
 };
 
+// lib/helpers/queryFilter.ts
+function queryFilter(property, operator, values) {
+  if (values.length === 0) {
+    throw new Error("Values array cannot be empty.");
+  }
+  for (const value of values) {
+    if (typeof value !== "string") {
+      throw new Error("All values must be strings.");
+    }
+  }
+  const expression = {
+    operator,
+    property,
+    argument: values
+  };
+  return {
+    QueryFilter: { expression }
+  };
+}
+function nestedQueryFilter(filters, logicalOperator = "and") {
+  const nestedExpression = filters.map((f) => ({
+    operator: f.operator,
+    property: f.property,
+    argument: Array.isArray(f.value) ? f.value : [f.value]
+  }));
+  return {
+    QueryFilter: {
+      expression: {
+        operator: logicalOperator,
+        nestedExpression
+      }
+    }
+  };
+}
+function bulkFilter(type, requestValues) {
+  if (requestValues.length === 0) {
+    throw new Error("Request values array cannot be empty.");
+  }
+  return {
+    type,
+    request: requestValues.map((id) => ({ id }))
+  };
+}
+
 // lib/services/EnvironmentService.ts
 var EnvironmentService = class {
   constructor(httpRequest) {
@@ -4436,6 +4565,69 @@ var EnvironmentService = class {
       }
     });
   }
+  /**
+   * Browse Environments with runtime/attachment enrichment.
+   * - classification: 'ALL' | 'PROD' | 'TEST'
+   * - environmentId: optional direct lookup
+   * Returns each environment with:
+   *   - installed: boolean (true if any runtime attachment exists)
+   *   - isActive: boolean (true if any attached atom is ONLINE; set to false if attachments exist but none online)
+   */
+  async fetchEnvironments(params) {
+    const { classification, environmentId } = params ?? {};
+    let filter;
+    if (classification === "ALL") {
+      filter = nestedQueryFilter(
+        [
+          { property: "classification", operator: "EQUALS", value: "PROD" },
+          { property: "classification", operator: "EQUALS", value: "TEST" }
+        ],
+        "or"
+      );
+    } else if (classification === "PROD" || classification === "TEST") {
+      filter = queryFilter("classification", "EQUALS", [classification]);
+    } else if (environmentId) {
+      filter = queryFilter("id", "EQUALS", [environmentId]);
+    }
+    const envResp = await this.queryEnvironment(filter);
+    const baseItems = envResp?.result ?? [];
+    if (!baseItems.length) {
+      return { numberOfResults: 0, result: [] };
+    }
+    const enriched = await Promise.all(
+      baseItems.map(async (env) => {
+        env.installed = false;
+        env.isActive = false;
+        try {
+          const aFilter = queryFilter("environmentId", "EQUALS", [env.id]);
+          const attachResp = await this.httpRequest.request({
+            method: "POST",
+            url: "/EnvironmentAtomAttachment/query",
+            mediaType: "application/json",
+            body: aFilter
+          });
+          const attachments = attachResp?.result ?? [];
+          if (!attachments.length) return env;
+          env.installed = true;
+          const atomIds = attachments.map((att) => att?.atomId).filter(Boolean);
+          if (!atomIds.length) return env;
+          const atoms = await Promise.all(
+            atomIds.map(
+              (atomId) => this.httpRequest.request({ method: "GET", url: "/Atom/{id}", path: { id: atomId } }).catch(() => null)
+            )
+          );
+          const anyOnline = atoms.filter(Boolean).some((a) => a?.status === "ONLINE");
+          env.isActive = anyOnline;
+        } catch {
+        }
+        return env;
+      })
+    );
+    return {
+      numberOfResults: enriched.length,
+      result: enriched
+    };
+  }
 };
 
 // lib/services/EnvironmentAtomAttachmentService.ts
@@ -4569,6 +4761,393 @@ var EnvironmentConnectionFieldExtensionSummaryService = class {
   }
 };
 
+// lib/helpers/fetchProcesses.ts
+async function fetchProcesses(httpRequest, integrationPackInstanceId) {
+  return await httpRequest.request({
+    method: "POST",
+    url: "/Process/query",
+    mediaType: "application/json",
+    body: queryFilter("integrationPackInstanceId", "EQUALS", [integrationPackInstanceId]),
+    overrideMode: "force-child"
+  });
+}
+
+// lib/helpers/fetchEnvironmentExtensions.ts
+async function fetchEnvironmentExtensions(httpRequest, requestBody) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentExtensions/query",
+    body: requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
+// lib/helpers/fetchExtensionsForPair.ts
+async function fetchExtensionsForPair(httpRequest, processId, envId) {
+  const extensionFilter = nestedQueryFilter(
+    [
+      { property: "environmentId", operator: "EQUALS", value: envId },
+      { property: "extensionGroupId", operator: "EQUALS", value: processId }
+    ],
+    "and"
+  );
+  const extResponse = await fetchEnvironmentExtensions(httpRequest, extensionFilter);
+  return extResponse?.result || [];
+}
+
+// lib/helpers/fetchExtensions.ts
+async function fetchExtensions(httpRequest, integrationPackInstanceId, environmentId, environments) {
+  const resp = await fetchProcesses(httpRequest, integrationPackInstanceId);
+  if (!resp?.result) {
+    throw new Error(
+      `No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`
+    );
+  }
+  const processes = resp.result;
+  const allExtensions = [];
+  const targetEnvs = resolveTargetEnvironments(environments, environmentId);
+  for (const process of processes) {
+    if (!process.id) {
+      throw new Error(
+        `Missing process ID for integrationPackInstanceId: ${integrationPackInstanceId}`
+      );
+    }
+    if (!targetEnvs?.length) {
+      const exts = await fetchExtensionsForPair(httpRequest, process.id, environmentId);
+      allExtensions.push(...exts);
+    } else {
+      for (const env of targetEnvs) {
+        const envId = env.id || "";
+        const exts = await fetchExtensionsForPair(httpRequest, process.id, envId);
+        allExtensions.push(...exts);
+      }
+    }
+  }
+  return allExtensions;
+}
+function resolveTargetEnvironments(environments, environmentId) {
+  return environmentId ? [{ id: environmentId }] : environments;
+}
+
+// lib/helpers/combineEnvironmentExtensions.ts
+function combineEnvironmentExtensions(exts) {
+  const hasId = (x) => typeof x.id === "string" && x.id.length > 0;
+  const hasKey = (x) => typeof x.key === "string" && x.key.length > 0;
+  const byEnv = /* @__PURE__ */ new Map();
+  const conflicts = { connections: [], processProperties: [] };
+  const ensureEnv = (envId) => {
+    if (!byEnv.has(envId)) {
+      byEnv.set(envId, {
+        env: {
+          environmentId: envId,
+          extensionGroupId: "combined",
+          id: `combined:${envId}`,
+          connections: { connection: [] },
+          processProperties: {
+            ProcessProperty: [{
+              id: "combined",
+              name: "Process Properties",
+              ProcessPropertyValue: []
+            }]
+          }
+        },
+        connMap: /* @__PURE__ */ new Map(),
+        propMap: /* @__PURE__ */ new Map()
+      });
+    }
+    return byEnv.get(envId);
+  };
+  const coalesceField = (envId, connId, existing, incoming) => {
+    const a = existing?.value ?? "";
+    const b = incoming?.value ?? "";
+    if (a && !b) return existing;
+    if (!a && b) return incoming;
+    if (a && b && a !== b) {
+      conflicts.connections.push({
+        environmentId: envId,
+        connectionId: connId,
+        fieldId: String(existing.id ?? incoming.id ?? ""),
+        values: [a, b]
+      });
+      return incoming;
+    }
+    if (!a && !b && (existing.encryptedValueSet || incoming.encryptedValueSet)) {
+      return {
+        ...existing,
+        encryptedValueSet: !!((existing.encryptedValueSet ?? false) || (incoming.encryptedValueSet ?? false))
+      };
+    }
+    return existing || incoming;
+  };
+  for (const ext of exts) {
+    const envId = ext.environmentId;
+    if (!envId) continue;
+    const target = ensureEnv(envId);
+    const conns = ext.connections?.connection ?? [];
+    for (const conn of conns) {
+      const connKey = conn.id ?? `name:${conn.name}`;
+      if (!target.connMap.has(connKey)) {
+        target.connMap.set(connKey, {
+          ...conn,
+          field: Array.isArray(conn.field) ? [...conn.field] : []
+        });
+      } else {
+        const merged = { ...target.connMap.get(connKey) };
+        const fieldMap = /* @__PURE__ */ new Map();
+        for (const f of merged.field ?? []) if (hasId(f)) fieldMap.set(f.id, { ...f });
+        for (const f of conn.field ?? []) {
+          if (!hasId(f)) continue;
+          const prev = fieldMap.get(f.id);
+          fieldMap.set(f.id, prev ? coalesceField(envId, connKey, prev, f) : { ...f });
+        }
+        merged.field = Array.from(fieldMap.values());
+        target.connMap.set(connKey, merged);
+      }
+    }
+    const ppGroups = ext.processProperties?.ProcessProperty ?? [];
+    for (const group of ppGroups) {
+      for (const v of group.ProcessPropertyValue ?? []) {
+        if (!hasKey(v)) continue;
+        const existing = target.propMap.get(v.key);
+        if (!existing) {
+          target.propMap.set(v.key, { ...v });
+        } else {
+          const a = existing.value ?? "";
+          const b = v.value ?? "";
+          if (a && b && a !== b) {
+            conflicts.processProperties.push({
+              environmentId: envId,
+              key: v.key,
+              ...v.label !== void 0 ? { label: v.label } : {},
+              values: [a, b]
+            });
+            target.propMap.set(v.key, { ...v });
+          } else if (!a && b) {
+            target.propMap.set(v.key, { ...v });
+          }
+        }
+      }
+    }
+  }
+  const combined = [];
+  for (const { env, connMap, propMap } of byEnv.values()) {
+    env.connections = { connection: Array.from(connMap.values()) };
+    env.processProperties = {
+      ProcessProperty: [{
+        id: "combined",
+        name: "Process Properties",
+        ProcessPropertyValue: Array.from(propMap.values())
+      }]
+    };
+    combined.push(env);
+  }
+  return { combined, conflicts };
+}
+
+// lib/helpers/normalizeConnections.ts
+function normalizeConnections(c) {
+  const list = c?.connection ?? [];
+  return { connection: [...list] };
+}
+
+// lib/helpers/normalizeProcessProperties.ts
+function normalizeProcessProperties(p) {
+  const src = p?.ProcessProperty;
+  const groups = Array.isArray(src) ? src : [];
+  return {
+    ProcessProperty: groups.map((g) => ({
+      ...g,
+      ProcessPropertyValue: [...g?.ProcessPropertyValue ?? []]
+    }))
+  };
+}
+
+// lib/helpers/indexCombined.ts
+function indexCombined(combined) {
+  const connKeyOf = (c, i) => c.id || (c.name ? `name:${c.name}` : `__conn_${i}`);
+  const hasId = (x) => typeof x.id === "string" && x.id.length > 0;
+  const hasKey = (x) => typeof x.key === "string" && x.key.length > 0;
+  const byEnvConnField = /* @__PURE__ */ new Map();
+  const byEnvPropKey = /* @__PURE__ */ new Map();
+  for (const envExt of combined) {
+    const envId = envExt.environmentId;
+    if (!envId) continue;
+    const connIndex = byEnvConnField.get(envId) ?? /* @__PURE__ */ new Map();
+    (envExt.connections?.connection ?? []).forEach((c, i) => {
+      const k = connKeyOf(c, i);
+      const fieldIndex = connIndex.get(k) ?? /* @__PURE__ */ new Map();
+      (c.field ?? []).forEach((f) => {
+        if (hasId(f)) fieldIndex.set(f.id, f);
+      });
+      connIndex.set(k, fieldIndex);
+    });
+    byEnvConnField.set(envId, connIndex);
+    const propIndex = byEnvPropKey.get(envId) ?? /* @__PURE__ */ new Map();
+    (envExt.processProperties?.ProcessProperty ?? []).forEach((grp) => {
+      (grp.ProcessPropertyValue ?? []).forEach((v) => {
+        if (hasKey(v)) propIndex.set(v.key, v);
+      });
+    });
+    byEnvPropKey.set(envId, propIndex);
+  }
+  return { byEnvConnField, byEnvPropKey };
+}
+
+// lib/helpers/applyFieldEdit.ts
+function applyFieldEdit(orig, edited) {
+  const sameStr = (a, b) => (a ?? "") === (b ?? "");
+  if (!edited) return orig;
+  const out = { ...orig };
+  if (orig.usesEncryption) {
+    const newVal = edited.value ?? "";
+    if (newVal.trim().length) {
+      out.value = newVal;
+      out.encryptedValueSet = true;
+      out.useDefault = false;
+    }
+    return out;
+  }
+  if (!sameStr(orig.value, edited.value)) {
+    out.value = edited.value ?? "";
+    out.useDefault = false;
+  }
+  return out;
+}
+
+// lib/helpers/planBackport.ts
+function planBackport(originals, combinedEdited) {
+  const sameStr = (a, b) => (a ?? "") === (b ?? "");
+  const connKeyOf = (c, i) => c.id || (c.name ? `name:${c.name}` : `__conn_${i}`);
+  const hasId = (x) => typeof x.id === "string" && x.id.length > 0;
+  const hasKey = (x) => typeof x.key === "string" && x.key.length > 0;
+  const idx = indexCombined(combinedEdited);
+  const plans = [];
+  for (const ext of originals) {
+    const envId = ext.environmentId;
+    if (!envId) continue;
+    const editedConnIndex = idx.byEnvConnField.get(envId) ?? /* @__PURE__ */ new Map();
+    const editedPropIndex = idx.byEnvPropKey.get(envId) ?? /* @__PURE__ */ new Map();
+    let connChanges = 0;
+    let propChanges = 0;
+    const next = {
+      ...ext,
+      connections: normalizeConnections(ext.connections),
+      processProperties: normalizeProcessProperties(ext.processProperties)
+    };
+    const connsArr = next.connections.connection ?? [];
+    connsArr.forEach((c, ci) => {
+      const k = connKeyOf(c, ci);
+      const editedFields = editedConnIndex.get(k);
+      if (!editedFields) return;
+      const fields = c.field ?? [];
+      const updatedFields = fields.map((f) => {
+        if (!hasId(f)) return f;
+        const edited = editedFields.get(f.id);
+        if (!edited) return f;
+        const after = applyFieldEdit(f, edited);
+        if (after !== f && !sameStr(f.value, after.value)) connChanges++;
+        return after;
+      });
+      c.field = updatedFields;
+    });
+    const groups = next.processProperties.ProcessProperty ?? [];
+    groups.forEach((grp) => {
+      const vals = grp.ProcessPropertyValue ?? [];
+      const updatedVals = vals.map((v) => {
+        if (!hasKey(v)) return v;
+        const edited = editedPropIndex.get(v.key);
+        if (!edited) return v;
+        const a = v.value ?? "";
+        const b = edited.value ?? "";
+        if (!sameStr(a, b)) {
+          propChanges++;
+          return { ...v, value: b, useDefault: false };
+        }
+        return v;
+      });
+      grp.ProcessPropertyValue = updatedVals;
+    });
+    const changed = connChanges + propChanges > 0;
+    plans.push({
+      original: ext,
+      payload: changed ? { ...next, partial: true } : null,
+      changes: { connections: connChanges, properties: propChanges }
+    });
+  }
+  return plans;
+}
+
+// lib/helpers/updateEnvironmentExtensionsPartial.ts
+async function updateEnvironmentExtensionsPartial(httpRequest, extension) {
+  const extensionId = extension?.id ?? "";
+  if (!extensionId) {
+    throw Object.assign(new Error("Code [3004] - extension.id is required for update"), { status: 400 });
+  }
+  const payload = { ...extension, partial: true };
+  return updateEnvironmentExtensions(httpRequest, extensionId, payload);
+}
+async function updateEnvironmentExtensions(httpRequest, id, requestBody) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentExtensions/{id}",
+    path: {
+      "id": id
+    },
+    body: requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
+// lib/helpers/updateEnvironmentExtensionsBatch.ts
+async function updateEnvironmentExtensionsBatch(httpRequest, plans) {
+  let updated = 0;
+  let skipped = 0;
+  let result = {};
+  const failures = [];
+  for (const plan of plans) {
+    const { payload, original } = plan;
+    if (!payload) {
+      skipped++;
+      continue;
+    }
+    try {
+      result = await updateEnvironmentExtensionsPartial(httpRequest, payload);
+      updated++;
+    } catch (e) {
+      failures.push({
+        id: original?.id,
+        groupId: original?.extensionGroupId,
+        error: e?.message ?? "Unknown update error"
+      });
+    }
+  }
+  return { updated, skipped, failed: failures.length, failures, updatedExtensions: result };
+}
+
+// lib/helpers/generateOauth2UrlRequestSoap.ts
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function generateOauth2UrlSoapXml(environmentId, connectionId, extensionGroupId, oAuthFieldId, clientId, clientSecret) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<bns:EnvironmentOAuth2AccessTokenExtensionGenerationRequest
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:bns="http://api.platform.boomi.com/"
+  environmentId="${esc(environmentId)}"
+  connectionId="${esc(connectionId)}"
+  extensionGroupId="${esc(extensionGroupId)}"
+  oAuthFieldId="${esc(oAuthFieldId)}"
+  clientId="${esc(clientId)}"
+  clientSecret="${esc(clientSecret)}"
+/>`;
+}
+
 // lib/services/EnvironmentExtensionsService.ts
 var EnvironmentExtensionsService = class {
   constructor(httpRequest) {
@@ -4701,20 +5280,454 @@ var EnvironmentExtensionsService = class {
    * @returns EnvironmentExtensionsQueryResponse Successful request and response.
    * @throws ApiError
    */
-  queryOauth2Url(requestBody) {
-    return this.httpRequest.request({
+  async fetchOauth2Url(integrationPackInstanceId, environmentId, connectionId, oAuthFieldId, clientId, clientSecret) {
+    const procResp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+    const firstProcessId = procResp.result?.[0]?.id;
+    if (!firstProcessId) {
+      throw new Error(`No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`);
+    }
+    const requestXml = generateOauth2UrlSoapXml(
+      environmentId,
+      connectionId,
+      firstProcessId,
+      oAuthFieldId,
+      clientId,
+      clientSecret
+    );
+    const resp = await this.httpRequest.request({
       method: "POST",
       url: "/EnvironmentOAuth2AccessTokenExtensionGenerationRequest/execute",
-      body: requestBody,
-      mediaType: "application/json",
+      body: requestXml,
+      mediaType: "application/soap+xml",
       errors: {
         403: `Missing or incorrect authentication credentials.
                 To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
       }
     });
+    if (!resp || !resp.authorizationCodeRequestUrl) {
+      throw new Error(`No authorization URL found in SOAP response for integrationPackInstanceId: ${integrationPackInstanceId}`);
+    }
+    return {
+      numberOfResults: 1,
+      result: {
+        authorizationCodeRequestUrl: resp.authorizationCodeRequestUrl
+      }
+    };
+  }
+  /**
+   * High-level: create plans from combined edits and apply them ---
+   * Uses the SDK’s own planBackport() already in this class.
+   */
+  async updateEnvironmentExtensionsFromCombined(originals, combinedEdited) {
+    const plans = planBackport(originals, combinedEdited);
+    return updateEnvironmentExtensionsBatch(this.httpRequest, plans);
+  }
+  /**
+   * Browse environment extensions for given environments
+   * @param requestBody Possible properties include: environmentId, environmentIds, integrationPackInstanceId
+   * @returns EnvironmentExtensionQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  async fetchEnvironmentExtensions(params) {
+    const { integrationPackInstanceId, environmentId, environmentIds } = params;
+    if (!integrationPackInstanceId) {
+      throw Object.assign(new Error("integrationPackInstanceId is required"), { status: 400 });
+    }
+    const targets = environmentId ? [environmentId] : Array.isArray(environmentIds) && environmentIds.length ? environmentIds : [];
+    if (!targets.length) {
+      throw Object.assign(
+        new Error("environmentId or environmentIds must be provided"),
+        { status: 400 }
+      );
+    }
+    const chunks = [];
+    for (const envId of targets) {
+      const list = await fetchExtensions(this.httpRequest, integrationPackInstanceId, envId);
+      chunks.push(list ?? []);
+    }
+    const items = [].concat(...chunks);
+    const { combined } = combineEnvironmentExtensions(items);
+    return {
+      numberOfResults: items?.length || 0,
+      result: items || [],
+      combined: combined || []
+    };
+  }
+  /** Fetch EnvironmentExtensionConnectionStatus for a given connection and fieldId. */
+  async fetchExtensionConnectionStatus(integrationPackInstanceId, environmentId, connectionId, fieldId) {
+    let connected = false;
+    const resp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+    if (!resp?.result) {
+      throw new Error(
+        `No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`
+      );
+    }
+    for (const process of resp.result) {
+      if (!process.id) {
+        throw new Error(
+          `Missing process ID for integrationPackInstanceId: ${integrationPackInstanceId}`
+        );
+      }
+      const exts = await fetchExtensionsForPair(this.httpRequest, process.id, environmentId);
+      for (const ext of exts) {
+        const conns = ext.connections?.connection ?? [];
+        for (const conn of conns) {
+          if (conn.id === connectionId) {
+            const fields = conn.field ?? [];
+            for (const field of fields) {
+              if (field.id === fieldId) {
+                if (field.encryptedValueSet) {
+                  connected = true;
+                }
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+    return connected;
   }
 };
 
+// lib/helpers/buildOnePayload.ts
+function buildOnePayload(mapId, containerId, sourceFields, targetFields) {
+  const srcArray = Array.from(sourceFields.values());
+  const tgtArray = Array.from(targetFields.values());
+  const BrowseSettings = { containerId };
+  if (srcArray.length) {
+    BrowseSettings.SourceBrowse = { BrowseFields: srcArray };
+  }
+  if (tgtArray.length) {
+    BrowseSettings.DestinationBrowse = { BrowseFields: tgtArray };
+  }
+  return {
+    id: mapId,
+    Map: { BrowseSettings }
+  };
+}
+
+// lib/helpers/buildBrowseRequests.ts
+async function buildBrowseRequests(candidates, opts = {}) {
+  const { includeSessions = false, defaultValueForEmpty } = opts;
+  const groups = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const mapId = c.mapId;
+    const containerId = c.containerId;
+    if (!mapId || !containerId || !c.paramName) continue;
+    const key = `${mapId}|${containerId}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = {
+        candidate: c,
+        mapId,
+        containerId,
+        sourceFields: /* @__PURE__ */ new Map(),
+        targetFields: /* @__PURE__ */ new Map()
+      };
+      groups.set(key, g);
+    }
+    const value = c.paramValue ?? (defaultValueForEmpty ? defaultValueForEmpty(c) : void 0);
+    const field = { name: c.paramName, value };
+    if (c.candidateSource === "source") {
+      g.sourceFields.set(c.paramName, field);
+    } else {
+      g.targetFields.set(c.paramName, field);
+    }
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    out.push({
+      candidate: g.candidate,
+      request: buildOnePayload(
+        g.mapId,
+        g.containerId,
+        g.sourceFields,
+        g.targetFields
+      )
+    });
+  }
+  return out;
+}
+
+// lib/helpers/executeEnvironmentMapExtension.ts
+async function executeEnvironmentMapExtension(httpRequest, id, requestBody) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentMapExtension/execute/{id}",
+    path: {
+      "id": id
+    },
+    body: requestBody,
+    mediaType: "application/json",
+    overrideMode: "force-child",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
+// lib/helpers/extractBrowseSessionId.ts
+function extractBrowseSessionId(resp) {
+  const src = resp?.Map?.BrowseSettings?.SourceBrowse?.sessionId;
+  if (typeof src === "string" && src.length > 0) {
+    return { sessionId: src, kind: "source" };
+  }
+  const dest = resp?.Map?.BrowseSettings?.DestinationBrowse?.sessionId;
+  if (typeof dest === "string" && dest.length > 0) {
+    return { sessionId: dest, kind: "target" };
+  }
+  return { sessionId: "", kind: null };
+}
+
+// lib/helpers/executeMapExtension.ts
+async function executeMapExtension(httpRequest, request2) {
+  const response = await executeEnvironmentMapExtension(
+    httpRequest,
+    request2.id,
+    request2
+  );
+  console.log("Execute map extension response:", JSON.stringify(response, null, 2));
+  return extractBrowseSessionId(response);
+}
+
+// lib/helpers/fetchEnvironmentMapExtensionSummary.ts
+async function fetchEnvironmentMapExtensionsSummary(httpRequest, requestBody) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentMapExtensionsSummary/query",
+    body: requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
+// lib/helpers/fetchMapExtensionSummaries.ts
+async function fetchMapExtensionSummaries(httpRequest, processId, environmentId) {
+  const summaryMap = /* @__PURE__ */ new Map();
+  const summaryFilter = nestedQueryFilter(
+    [
+      { property: "environmentId", operator: "EQUALS", value: environmentId },
+      { property: "extensionGroupId", operator: "EQUALS", value: processId }
+    ],
+    "and"
+  );
+  const summaryResponse = await fetchEnvironmentMapExtensionsSummary(
+    httpRequest,
+    summaryFilter
+  );
+  let summaries = summaryResponse?.result || [];
+  return summaries;
+}
+
+// lib/helpers/fetchExtensionsSummariesByProcessAndEnvironment.ts
+async function fetchExtensionsSummariesByProcessAndEnvironment(httpRequest, processId, environmentId) {
+  const summaryMap = /* @__PURE__ */ new Map();
+  let summaries = await fetchMapExtensionSummaries(httpRequest, processId, environmentId);
+  for (const summary of summaries) {
+    if (summary.id && !summaryMap.has(summary.id)) {
+      summaryMap.set(summary.id, summary);
+    }
+  }
+  summaries = Array.from(summaryMap.values());
+  return summaries || [];
+}
+
+// lib/helpers/fetchAllSummaries.ts
+async function fetchAllSummaries(httpRequest, integrationPackInstanceId, environmentId) {
+  const resp = await fetchProcesses(httpRequest, integrationPackInstanceId);
+  const allSummaries = [];
+  if (!resp?.result) {
+    throw new Error(
+      `Code [2002] - No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`
+    );
+  }
+  const processes = resp.result;
+  for (const process of processes) {
+    if (!process.id) continue;
+    const mapSummaries = await fetchExtensionsSummariesByProcessAndEnvironment(httpRequest, process.id, environmentId);
+    allSummaries.push(...mapSummaries.filter(Boolean));
+  }
+  const deduped = Array.from(new Map(allSummaries.map((s) => [s.id, s])).values());
+  return deduped;
+}
+
+// lib/helpers/fetchContainerId.ts
+async function fetchContainerId(httpRequest, environmentId) {
+  const aFilter = queryFilter(
+    "environmentId",
+    "EQUALS",
+    [environmentId]
+  );
+  const resp = await httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentAtomAttachment/query",
+    mediaType: "application/json",
+    body: aFilter
+  });
+  return resp?.result?.[0]?.atomId ?? resp?.result?.[0]?.containerId ?? "";
+}
+
+// lib/helpers/findConnectionName.ts
+function findConnectionName(connectionId, exts) {
+  const list = Array.isArray(exts) ? exts : [exts];
+  for (const e of list) {
+    const match = e?.connections?.connection?.find((c) => c?.id === connectionId);
+    if (match?.name) return match.name;
+  }
+  return null;
+}
+
+// lib/helpers/findConnectionFieldValue.ts
+function findConnectionFieldValue(connectionId, paramName, exts) {
+  const list = Array.isArray(exts) ? exts : [exts];
+  for (const e of list) {
+    const conns = e?.connections?.connection ?? [];
+    for (const c of conns) {
+      if (!c || c.id !== connectionId) continue;
+      const fields = c.field ?? [];
+      const match = fields.find((f) => {
+        const fid = f?.id ?? f?.["@id"];
+        const fname = f?.name ?? f?.["@name"];
+        return fid === paramName || fname === paramName;
+      });
+      if (match) {
+        const raw = match.value ?? "";
+        return raw != null ? String(raw) : void 0;
+      }
+    }
+  }
+  return void 0;
+}
+
+// lib/helpers/sessionFromSet.ts
+function sessionsFromSet(sets, sourceName, summary, containerId, environmentId, processId, originalExtensions, exts) {
+  const asArray = (x) => x == null ? [] : Array.isArray(x) ? x : [x];
+  return asArray(sets).filter((s) => !!s?.connectionId).flatMap((s) => {
+    const connectionId = s.connectionId;
+    const connectionName = findConnectionName(connectionId, originalExtensions) ?? "";
+    const fieldNames = asArray(s?.BrowseField).map((bf) => bf?.name).filter((n) => !!n);
+    return fieldNames.map((paramName) => {
+      return {
+        containerId,
+        environmentId,
+        processId,
+        connectionId,
+        connectionName,
+        candidateSource: sourceName,
+        paramName,
+        mapId: summary.id ?? "",
+        paramValue: exts ? findConnectionFieldValue(connectionId, paramName, exts) ?? "" : ""
+      };
+    });
+  });
+}
+
+// lib/helpers/extractBrowseCandidateFromSummary.ts
+function extractBrowseCandidateFromSummary(s, containerId, environmentId, processId, originalExtensions, extensions) {
+  return [
+    ...sessionsFromSet(s.SourceFieldSet, "source", s, containerId, environmentId, processId, originalExtensions, extensions),
+    ...sessionsFromSet(s.DestinationFieldSet, "target", s, containerId, environmentId, processId, originalExtensions, extensions)
+  ];
+}
+
+// lib/helpers/buildBrowseCandidates.ts
+async function buildBrowseCandidates(httpRequest, summaries, originalExtensions, updatedExtensions, environmentId) {
+  const containerId = await fetchContainerId(httpRequest, environmentId);
+  if (!containerId) {
+    throw new Error(`Atom attachment not found for environment: ${environmentId}`);
+  }
+  const candidates = [];
+  for (const s of summaries) {
+    candidates.push(
+      ...extractBrowseCandidateFromSummary(
+        s,
+        containerId,
+        environmentId,
+        s.processId || "",
+        originalExtensions,
+        updatedExtensions
+      )
+    );
+  }
+  return candidates;
+}
+
+// lib/helpers/fetchBrowseCandidateForPair.ts
+async function fetchBrowseCandidatesForPair(httpRequest, summary, environmentId, integrationPackInstanceId) {
+  const candidates = [];
+  const extensions = await fetchExtensions(httpRequest, integrationPackInstanceId, environmentId);
+  const containerId = await fetchContainerId(httpRequest, environmentId);
+  if (!containerId) {
+    throw new Error(`Atom attachment not found for environment: ${environmentId}`);
+  }
+  candidates.push(
+    ...extractBrowseCandidateFromSummary(
+      summary,
+      containerId,
+      environmentId,
+      summary.processId || "",
+      extensions
+    )
+  );
+  return candidates;
+}
+
+// lib/helpers/fetchEnvironmentMapExtension.ts
+async function fetchEnvironmentMapExtension(httpRequest, id) {
+  return httpRequest.request({
+    method: "GET",
+    url: "/EnvironmentMapExtension/{id}",
+    path: {
+      "id": id
+    },
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
+// lib/helpers/fetchExtensionsByProcessAndEnvironment.ts
+async function fetchExtensionsByProcessAndEnvironment(httpRequest, processId, environmentId, integrationPackInstanceId) {
+  let summaries = await fetchExtensionsSummariesByProcessAndEnvironment(httpRequest, processId, environmentId);
+  const allMaps = [];
+  const missingCandidates = [];
+  let requiresBrowseSession = false;
+  const mapExtensions = await Promise.all(
+    summaries.map(async (summary) => {
+      const hasBrowse = !!summary?.SourceFieldSet?.BrowseField?.length || !!summary?.DestinationFieldSet?.BrowseField?.length;
+      const map = await fetchEnvironmentMapExtension(
+        httpRequest,
+        summary.id
+      );
+      if (hasBrowse) {
+        requiresBrowseSession = true;
+        const candidates = await fetchBrowseCandidatesForPair(
+          httpRequest,
+          summary,
+          environmentId,
+          integrationPackInstanceId
+        );
+        const missing = candidates.filter((c) => !c.sessionId);
+        if (missing.length) {
+          missingCandidates.push(...missing);
+        }
+      }
+      allMaps.push({
+        map,
+        requiresBrowseSession,
+        candidates: missingCandidates.length ? missingCandidates : []
+      });
+    })
+  );
+  return allMaps;
+}
+
 // lib/services/EnvironmentMapExtensionService.ts
 var EnvironmentMapExtensionService = class {
   constructor(httpRequest) {
@@ -4790,6 +5803,73 @@ var EnvironmentMapExtensionService = class {
       }
     });
   }
+  /** fetch all maps for an environment and integrationPackInstance */
+  async fetchAllMaps(integrationPackInstanceId, environmentId) {
+    const resp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+    const allMaps = [];
+    if (!resp?.result) {
+      throw new Error(
+        `No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`
+      );
+    }
+    const processes = resp.result;
+    for (const process of processes) {
+      if (!process.id) continue;
+      const mapExtensions = await fetchExtensionsByProcessAndEnvironment(this.httpRequest, process.id, environmentId, integrationPackInstanceId);
+      allMaps.push(...mapExtensions.filter(Boolean));
+    }
+    const deduped = Array.from(new Map(allMaps.map((s) => [s.map.id, s])).values());
+    return deduped;
+  }
+  /** fetch all maps for an environment and integrationPackInstance */
+  updateEnvironmentMapExtension(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: `/EnvironmentMapExtension/${requestBody.id}`,
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        403: `Missing or incorrect authentication credentials.
+                To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+      }
+    });
+  }
+  /** try to authenticate the maps for dynamic browsing 
+   * Todo: return both failed and succeeded candidates
+  */
+  async executeDynamicBrowse(candidates) {
+    const failedCandidates = [];
+    const successCandidates = [];
+    const filteredCandidates = candidates.filter((c) => c.paramValue?.trim());
+    const resp = await buildBrowseRequests(filteredCandidates, { includeSessions: true });
+    if (!resp) {
+      return { failedCandidates, successCandidates };
+    }
+    for (const r of resp) {
+      try {
+        const { sessionId } = await executeMapExtension(this.httpRequest, r.request);
+        if (!sessionId) {
+          failedCandidates.push(r.candidate);
+        }
+        r.candidate.sessionId = sessionId;
+        successCandidates.push(r.candidate);
+      } catch (e) {
+        failedCandidates.push(r.candidate);
+      }
+    }
+    return { failedCandidates, successCandidates };
+  }
+  /** call execute on each map extension that contains a source or target browse */
+  async executeMapFunctionBrowse(originals, updated, integrationPackInstanceId, environmentId) {
+    const allSummaries = await fetchAllSummaries(
+      this.httpRequest,
+      integrationPackInstanceId,
+      environmentId
+    );
+    const candidates = await buildBrowseCandidates(this.httpRequest, allSummaries, originals, updated, environmentId);
+    const response = await this.executeDynamicBrowse(candidates);
+    return response;
+  }
 };
 
 // lib/services/EnvironmentMapExtensionExternalComponentService.ts
@@ -5488,6 +6568,59 @@ var ExecutionRequestService = class {
   }
 };
 
+// lib/helpers/withBackOff.ts
+async function withBackoff(fn, opts = {}) {
+  const tries = opts.tries ?? 4;
+  const baseMs = opts.baseMs ?? 200;
+  const jitterMs = opts.jitterMs ?? 100;
+  let attempt = 0;
+  let lastError;
+  while (attempt < tries) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const delay = baseMs * Math.pow(2, attempt) + Math.floor(Math.random() * jitterMs);
+      await new Promise((r) => setTimeout(r, delay));
+      attempt++;
+    }
+  }
+  throw lastError;
+}
+
+// lib/helpers/runWithConcurrency.ts
+async function runWithConcurrency(tasks, maxConcurrent = 4) {
+  const results = [];
+  let i = 0;
+  async function worker() {
+    while (i < tasks.length) {
+      const idx = i++;
+      try {
+        results[idx] = await tasks[idx]();
+      } catch (err) {
+        results[idx] = void 0;
+      }
+    }
+  }
+  const n = Math.max(1, Math.min(maxConcurrent, tasks.length));
+  await Promise.all(new Array(n).fill(0).map(() => worker()));
+  return results;
+}
+
+// lib/helpers/fetchExecutionRecord.ts
+async function fetchExecutionRecord(httpRequest, requestBody) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/ExecutionRecord/query",
+    body: requestBody,
+    mediaType: "application/json",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+                To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
 // lib/services/ExecutionSummaryRecordService.ts
 var ExecutionSummaryRecordService = class {
   constructor(httpRequest) {
@@ -5531,6 +6664,55 @@ var ExecutionSummaryRecordService = class {
       }
     });
   }
+  async fetchExecutionRecordsByIntegrationPack(params) {
+    const {
+      integrationPackInstanceId,
+      search = "",
+      page = 1,
+      pageSize = 20,
+      maxRuns = 30,
+      maxConcurrent = 4,
+      backoff
+    } = params;
+    if (!integrationPackInstanceId) {
+      throw new Error("Code [2002] - integrationPackInstanceId is required.");
+    }
+    const pResp = await withBackoff(
+      () => fetchProcesses(this.httpRequest, integrationPackInstanceId),
+      backoff
+    );
+    const processes = pResp?.result ?? [];
+    if (!processes.length) {
+      return { result: [], page, pageSize, numberOfResults: 0, totalPages: 1 };
+    }
+    const tasks = processes.filter((p) => !!p?.id).map((p) => {
+      const rFilter = queryFilter("processId", "EQUALS", [String(p.id)]);
+      return () => withBackoff(
+        () => fetchExecutionRecord(this.httpRequest, rFilter).then((r) => r?.result ?? []),
+        backoff
+      ).catch(() => []);
+    });
+    const perProcessLists = await runWithConcurrency(tasks, maxConcurrent);
+    const all = perProcessLists.flat().filter(Boolean);
+    if (!all.length) {
+      return { result: [], page, pageSize, numberOfResults: 0, totalPages: 1 };
+    }
+    const needle = search.trim().toLowerCase();
+    const filtered = needle ? all.filter((r) => (r?.message ?? "").toLowerCase().includes(needle)) : all;
+    const toTs = (t) => t ? new Date(t).getTime() || 0 : 0;
+    filtered.sort((a, b) => toTs(b.executionTime) - toTs(a.executionTime));
+    const capped = filtered.slice(0, Math.max(1, maxRuns));
+    const pages = Math.max(1, Math.ceil(capped.length / Math.max(1, pageSize)));
+    const safePage = Math.min(Math.max(page, 1), pages);
+    const start = (safePage - 1) * pageSize;
+    const end = start + pageSize;
+    return {
+      result: capped.slice(start, end),
+      numberOfResults: capped.length,
+      page: safePage,
+      totalPages: pages
+    };
+  }
 };
 
 // lib/services/FolderService.ts
@@ -6255,6 +7437,241 @@ var IntegrationPackInstanceService = class {
       }
     });
   }
+  /**
+   * Browse Integration Pack Instances for an Account Group
+   * @param requestBody  Possible properties include: accountGroup (name), search (name/overrideName), page, pageSize
+   * @returns IntegrationPackInstanceQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  async fetchIntegrationPackInstances(params) {
+    const { accountGroup, search, page = 1, pageSize = 12 } = params;
+    const agResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroup/query",
+      mediaType: "application/json",
+      body: queryFilter("name", "EQUALS", [accountGroup]),
+      overrideMode: "force-parent"
+    });
+    const groupId = agResp?.result?.[0]?.id;
+    if (!groupId) throw new Error(`Code [1005] - AccountGroup '${accountGroup}' not found.`);
+    const agIpResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroupIntegrationPack/query",
+      mediaType: "application/json",
+      body: queryFilter("accountGroupId", "EQUALS", [groupId]),
+      overrideMode: "force-parent"
+    });
+    const agRows = agIpResp?.result ?? [];
+    const packIds = agRows.map((r) => r?.integrationPackId).filter(Boolean);
+    const installationTypeById = /* @__PURE__ */ new Map();
+    const packNameById = /* @__PURE__ */ new Map();
+    for (const r of agRows) {
+      if (r?.integrationPackId && r?.installationType) installationTypeById.set(r.integrationPackId, r.installationType);
+      if (r?.integrationPackId && r?.integrationPackName) packNameById.set(r.integrationPackId, r.integrationPackName);
+    }
+    if (packIds.length === 0) {
+      return { result: [], page, pageSize, numberOfResults: 0, totalPages: 0 };
+    }
+    const ipDetailsResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/IntegrationPack/query",
+      mediaType: "application/json",
+      body: nestedQueryFilter(
+        packIds.map((id) => ({ property: "id", operator: "EQUALS", value: id })),
+        "or"
+      )
+    });
+    const ipDetails = ipDetailsResp?.result ?? [];
+    const packDescById = /* @__PURE__ */ new Map();
+    for (const ip of ipDetails) {
+      if (ip?.id && ip?.Description) packDescById.set(ip.id, ip.Description);
+    }
+    const instResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/IntegrationPackInstance/query",
+      mediaType: "application/json",
+      body: nestedQueryFilter(
+        packIds.map((id) => ({ property: "integrationPackId", operator: "EQUALS", value: id })),
+        "or"
+      )
+    });
+    const allInstances = instResp?.result ?? [];
+    const searchLc = search?.toLowerCase();
+    const filtered = searchLc ? allInstances.filter(
+      (inst) => (inst?.integrationPackInstancName?.toLowerCase?.().includes(searchLc) ?? false) || (inst?.integrationPackOverrideName?.toLowerCase?.().includes(searchLc) ?? false)
+    ) : allInstances;
+    const total = filtered.length;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const clampedPage = Math.min(Math.max(1, page), totalPages);
+    const start = (clampedPage - 1) * pageSize;
+    const slice = filtered.slice(start, start + pageSize);
+    const enriched = await Promise.all(
+      slice.map(async (instance) => {
+        const inst = { ...instance };
+        inst.installed = true;
+        const ipId = inst.integrationPackId;
+        const rawType = installationTypeById.get(ipId);
+        inst.installationType = rawType === "SINGLE" || rawType === "MULTI" ? rawType : "SINGLE";
+        inst.integrationPackName = packNameById.get(ipId);
+        inst.integrationPackDescription = packDescById.get(ipId);
+        const ipeResp = await this.httpRequest.request({
+          method: "POST",
+          url: "/IntegrationPackEnvironmentAttachment/query",
+          mediaType: "application/json",
+          body: queryFilter("integrationPackInstanceId", "EQUALS", [inst.id])
+        });
+        const attachments = ipeResp?.result ?? [];
+        for (const att of attachments) {
+          if (att?.environmentId) inst.environmentId = att.environmentId;
+        }
+        return inst;
+      })
+    );
+    return {
+      numberOfResults: total,
+      result: enriched,
+      page: clampedPage,
+      pageSize,
+      totalPages
+    };
+  }
+  /**
+   * Create and attach an Integration Pack Instance
+   * @param requestBody Possible properties include: integrationPackId, isSingleInstall, environmentId, integrationPackOverrideName, accountGroupName (for AG-mapped display name)
+   * @returns IntegrationPackInstanceQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  async createAndAttachIntegrationPackInstance(params) {
+    const { integrationPackId, isSingleInstall, environmentId, integrationPackOverrideName, accountGroupName } = params;
+    if (!integrationPackId) throw new Error("Code [2001] - integrationPackId is required");
+    if (!environmentId) throw new Error("Code [2002] - environmentId is required");
+    const instance = await this.httpRequest.request({
+      method: "POST",
+      url: "/IntegrationPackInstance",
+      mediaType: "application/json",
+      body: {
+        integrationPackId,
+        ...isSingleInstall ? {} : { integrationPackOverrideName }
+      }
+    });
+    if (!instance?.id) throw new Error("Code [1011] - Integration Pack Instance missing ID after creation.");
+    const attachResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/IntegrationPackEnvironmentAttachment",
+      mediaType: "application/json",
+      body: {
+        environmentId,
+        integrationPackInstanceId: instance.id
+      }
+    });
+    if (!attachResp?.id) throw new Error("Code [1012] - Environment attachment failed, no ID returned.");
+    let integrationPackDescription;
+    let integrationPackName;
+    try {
+      const ipResp = await this.httpRequest.request({
+        method: "POST",
+        url: "/IntegrationPack/query",
+        mediaType: "application/json",
+        body: nestedQueryFilter(
+          [{ property: "id", operator: "EQUALS", value: integrationPackId }],
+          "or"
+        )
+      });
+      const pack = ipResp?.result?.[0];
+      if (pack?.Description) integrationPackDescription = pack.Description;
+      if (!integrationPackOverrideName && accountGroupName) {
+        integrationPackName = await this.resolvePackNameFromAccountGroup(accountGroupName, integrationPackId);
+        if (!integrationPackName) integrationPackName = pack?.name || "";
+      }
+    } catch {
+    }
+    return {
+      ...instance,
+      id: instance.id,
+      integrationPackId,
+      integrationPackOverrideName: instance.integrationPackOverrideName || integrationPackOverrideName || "",
+      integrationPackName: instance.integrationPackOverrideName || integrationPackOverrideName || integrationPackName || "",
+      integrationPackDescription: integrationPackDescription || "",
+      installationType: isSingleInstall ? "SINGLE" : "MULTI",
+      installed: true,
+      environmentId
+    };
+  }
+  /**
+   * List Account Group Publisher Packs
+   * @param requestBody Possible properties include: accountGroup (name)
+   * @returns IntegrationPackInstanceQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  async listAccountGroupPublisherPacks(params) {
+    const { accountGroup } = params;
+    const agResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroup/query",
+      mediaType: "application/json",
+      body: queryFilter("name", "EQUALS", [accountGroup]),
+      overrideMode: "force-parent"
+    });
+    const groupId = agResp?.result?.[0]?.id;
+    if (!groupId) throw Object.assign(new Error(`Code [1005] - AccountGroup '${accountGroup}' not found.`), { status: 404 });
+    const agIpResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroupIntegrationPack/query",
+      mediaType: "application/json",
+      body: queryFilter("accountGroupId", "EQUALS", [groupId]),
+      overrideMode: "force-parent"
+    });
+    const agRows = agIpResp?.result ?? [];
+    const packIds = agRows.map((r) => r.integrationPackId).filter(Boolean);
+    if (packIds.length === 0) {
+      throw Object.assign(new Error(`Code [1007] - No integration packs found for AccountGroupId[ ${groupId}]`), { status: 404 });
+    }
+    const typeById = /* @__PURE__ */ new Map();
+    for (const r of agRows) {
+      if (r?.integrationPackId && r?.installationType) typeById.set(r.integrationPackId, r.installationType);
+    }
+    const bulkResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/PublisherIntegrationPack/bulk",
+      mediaType: "application/json",
+      body: bulkFilter("GET", packIds),
+      overrideMode: "force-parent"
+    });
+    const fetched = bulkResp?.response?.filter((r) => r.statusCode === 200 && r.Result).map((r) => r.Result) ?? [];
+    const instResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/IntegrationPackInstance/query",
+      mediaType: "application/json",
+      body: nestedQueryFilter(
+        packIds.map((id) => ({ property: "integrationPackId", operator: "EQUALS", value: id })),
+        "or"
+      )
+    });
+    const existing = instResp?.result ?? [];
+    const existingIds = new Set(existing.map((i) => i.integrationPackId));
+    return fetched.filter((pack) => !(typeById.get(pack.id) === "SINGLE" && existingIds.has(pack.id)));
+  }
+  /* =============== private =============== */
+  async resolvePackNameFromAccountGroup(accountGroupName, integrationPackId) {
+    const agResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroup/query",
+      mediaType: "application/json",
+      body: queryFilter("name", "EQUALS", [accountGroupName]),
+      overrideMode: "force-parent"
+    });
+    const groupId = agResp?.result?.[0]?.id;
+    if (!groupId) return void 0;
+    const agIpResp = await this.httpRequest.request({
+      method: "POST",
+      url: "/AccountGroupIntegrationPack/query",
+      mediaType: "application/json",
+      body: queryFilter("accountGroupId", "EQUALS", [groupId]),
+      overrideMode: "force-parent"
+    });
+    const row = (agIpResp?.result ?? []).find((r) => r?.integrationPackId === integrationPackId);
+    return row?.integrationPackName;
+  }
 };
 
 // lib/services/JavaRollbackService.ts
@@ -7169,6 +8586,31 @@ var PersistedProcessPropertiesService = class {
   }
 };
 
+// lib/helpers/fetchEnvironmentAtomAttachments.ts
+async function fetchEnvironmentAtomAttachments(httpRequest, environmentId) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/EnvironmentAtomAttachment/query",
+    body: queryFilter("environmentId", "EQUALS", [environmentId]),
+    mediaType: "application/json",
+    overrideMode: "force-child"
+  });
+}
+
+// lib/helpers/createExecutionRequest.ts
+async function createExecutionRequest(httpRequest, request2) {
+  return httpRequest.request({
+    method: "POST",
+    url: "/ExecutionRequest",
+    body: request2,
+    mediaType: "application/json",
+    errors: {
+      403: `Missing or incorrect authentication credentials.
+            To know the action to be taken for this and the other error responses (410, 503, etc), refer to [API Errors](#section/Introduction/API-errors)`
+    }
+  });
+}
+
 // lib/services/ProcessService.ts
 var ProcessService = class {
   constructor(httpRequest) {
@@ -7253,6 +8695,50 @@ var ProcessService = class {
       }
     });
   }
+  /**
+   * Triggers execution of all processes for an Integration Pack Instance
+   * This operation triggers the execution of all processes associated with the specified Integration Pack Instance ID across all atoms in the specified environment.
+   * @param requestBody
+   * @returns ProcessQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  async runAllProcesses(integrationPackInstanceId, environmentId) {
+    const urls = [];
+    const { result: attachments = [] } = await fetchEnvironmentAtomAttachments(this.httpRequest, environmentId);
+    const atomIds = attachments.map((att) => att?.atomId).filter((id) => Boolean(id));
+    if (!atomIds.length) {
+      throw Object.assign(
+        new Error(`No atoms found for environmentId: ${environmentId}`),
+        { status: 404 }
+      );
+    }
+    const procResp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+    const processes = procResp?.result ?? [];
+    if (!processes.length) {
+      throw Object.assign(
+        new Error(`No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`),
+        { status: 404 }
+      );
+    }
+    for (const proc of processes) {
+      const processId = proc?.id;
+      if (!processId) continue;
+      for (const atomId of atomIds) {
+        const executionRequest = {
+          DynamicProcessProperties: { DynamicProcessProperty: [] },
+          ProcessProperties: { ProcessProperty: [] },
+          processId,
+          atomId
+        };
+        const result = await createExecutionRequest(this.httpRequest, executionRequest);
+        const recordUrl = result?.recordUrl;
+        if (recordUrl) {
+          urls.push(recordUrl);
+        }
+      }
+    }
+    return urls;
+  }
 };
 
 // lib/services/ProcessAtomAttachmentService.ts
@@ -7508,6 +8994,127 @@ var ProcessSchedulesService = class {
       }
     });
   }
+  /**
+   * Fetch the first ProcessSchedules that matches any process on any atom in the environment.
+   * Returns { numberOfResults, result: ProcessSchedules[] }.
+   */
+  async fetchProcessSchedules(integrationPackInstanceId, environmentId) {
+    try {
+      const { result: attachments = [] } = await fetchEnvironmentAtomAttachments(this.httpRequest, environmentId);
+      const atomIds = attachments.map((att) => att?.atomId).filter((id) => Boolean(id));
+      if (!atomIds.length) {
+        throw Object.assign(
+          new Error(`No atoms found for environmentId: ${environmentId}`),
+          { status: 404 }
+        );
+      }
+      const procResp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+      const processes = procResp?.result ?? [];
+      if (!processes.length) {
+        throw Object.assign(
+          new Error(`No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`),
+          { status: 404 }
+        );
+      }
+      for (const proc of processes) {
+        const processId = proc?.id;
+        if (!processId) continue;
+        for (const atomId of atomIds) {
+          const scheduleFilter = nestedQueryFilter(
+            [
+              { property: "atomId", operator: "EQUALS", value: atomId },
+              { property: "processId", operator: "EQUALS", value: processId }
+            ],
+            "and"
+          );
+          const qs = await this.queryProcessSchedules(scheduleFilter);
+          const row = Array.isArray(qs?.result) ? qs.result[0] : void 0;
+          if (row?.Schedule?.length) {
+            return {
+              numberOfResults: 1,
+              result: [row]
+            };
+          }
+        }
+      }
+      return {
+        numberOfResults: 0,
+        result: []
+      };
+    } catch (err) {
+      throw Object.assign(
+        new Error(
+          `Unable to fetch process schedules for env=${environmentId} ipi=${integrationPackInstanceId}: ${err?.message ?? err}`
+        ),
+        { status: err?.status ?? 400 }
+      );
+    }
+  }
+  /**
+   * Updates all ProcessSchedules for all processes on all atoms in the environment.
+   */
+  async updateAllProcessSchedules(integrationPackInstanceId, environmentId, schedules) {
+    try {
+      const { result: attachments = [] } = await fetchEnvironmentAtomAttachments(this.httpRequest, environmentId);
+      const atomIds = attachments.map((att) => att?.atomId).filter((id) => Boolean(id));
+      if (!atomIds.length) {
+        throw Object.assign(
+          new Error(`No atoms found for environmentId: ${environmentId}`),
+          { status: 404 }
+        );
+      }
+      const procResp = await fetchProcesses(this.httpRequest, integrationPackInstanceId);
+      const processes = procResp?.result ?? [];
+      if (!processes.length) {
+        throw Object.assign(
+          new Error(`No processes found for integrationPackInstanceId: ${integrationPackInstanceId}`),
+          { status: 404 }
+        );
+      }
+      const retry = {
+        Schedule: schedules,
+        maxRetry: 5
+      };
+      const updated = [];
+      for (const proc of processes) {
+        const processId = proc?.id;
+        if (!processId) continue;
+        for (const atomId of atomIds) {
+          if (!atomId) continue;
+          const conceptualId = `${processId}:${atomId}`;
+          const schedFilter = nestedQueryFilter(
+            [
+              { property: "atomId", operator: "EQUALS", value: atomId },
+              { property: "processId", operator: "EQUALS", value: processId }
+            ],
+            "and"
+          );
+          const { result: existingResults = [] } = await this.queryProcessSchedules(schedFilter);
+          const existing = existingResults[0];
+          const schedulePayload = {
+            id: conceptualId,
+            atomId,
+            processId,
+            Schedule: schedules,
+            Retry: retry
+          };
+          const result = await this.updateProcessSchedules(
+            conceptualId,
+            schedulePayload
+          );
+          updated.push(result);
+        }
+      }
+      return updated;
+    } catch (err) {
+      throw Object.assign(
+        new Error(
+          `Unable to fetch process schedules for env=${environmentId} ipi=${integrationPackInstanceId}: ${err?.message ?? err}`
+        ),
+        { status: err?.status ?? 400 }
+      );
+    }
+  }
 };
 
 // lib/services/ProcessScheduleStatusService.ts
@@ -9095,7 +10702,8 @@ var Boomi = class {
       USERNAME: config?.USERNAME,
       PASSWORD: config?.PASSWORD,
       HEADERS: config?.HEADERS,
-      ENCODE_PATH: config?.ENCODE_PATH
+      ENCODE_PATH: config?.ENCODE_PATH,
+      LOGGER: config?.LOGGER
     });
     this.account = new AccountService(this.request);
     this.accountCloudAttachmentProperties = new AccountCloudAttachmentPropertiesService(this.request);
@@ -9225,7 +10833,8 @@ var OpenAPI = {
   USERNAME: void 0,
   PASSWORD: void 0,
   HEADERS: void 0,
-  ENCODE_PATH: void 0
+  ENCODE_PATH: void 0,
+  LOGGER: void 0
 };
 
 // lib/models/Account.ts
@@ -14425,6 +16034,8 @@ var X12Options;
   X12ConnectorRecordGroupingExpression,
   X12ConnectorRecordService,
   X12ConnectorRecordSimpleExpression,
-  X12Options
+  X12Options,
+  redactBody,
+  redactHeaders
 });
 //# sourceMappingURL=index.cjs.map