@boomi/embedkit-sdk 1.1.2 → 1.1.3

package/dist/index.js

@@ -4279,6 +4279,25 @@ var EnvironmentExtensionsService = class {
       }
     });
   }
+  /**
+   * Queries for an EnvironmentExtensions object(s)
+   * For general information about the structure of QUERY filters, their sample payloads, and how to handle the paged results, refer to [Query filters](#section/Introduction/Query-filters) and [Query paging](#section/Introduction/Query-paging).
+   * @param requestBody  Possible properties include: environmentId, extensionGroupId
+   * @returns EnvironmentExtensionsQueryResponse Successful request and response.
+   * @throws ApiError
+   */
+  queryOauth2Url(requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/EnvironmentOAuth2AccessTokenExtensionGenerationRequest/execute",
+      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/EnvironmentMapExtensionService.ts
@@ -11872,6 +11891,45 @@ var MergeRequestSimpleExpression;
   })(operator = MergeRequestSimpleExpression2.operator || (MergeRequestSimpleExpression2.operator = {}));
 })(MergeRequestSimpleExpression || (MergeRequestSimpleExpression = {}));
 
+// lib/models/Oauth2UrlGroupingExpression.ts
+var Oauth2UrlGroupingExpression;
+((Oauth2UrlGroupingExpression2) => {
+  let operator;
+  ((operator2) => {
+    operator2["AND"] = "and";
+    operator2["OR"] = "or";
+  })(operator = Oauth2UrlGroupingExpression2.operator || (Oauth2UrlGroupingExpression2.operator = {}));
+})(Oauth2UrlGroupingExpression || (Oauth2UrlGroupingExpression = {}));
+
+// lib/models/Oauth2UrlSimpleExpression.ts
+var Oauth2UrlSimpleExpression;
+((Oauth2UrlSimpleExpression2) => {
+  let operator;
+  ((operator2) => {
+    operator2["EQUALS"] = "EQUALS";
+    operator2["LIKE"] = "LIKE";
+    operator2["NOT_EQUALS"] = "NOT_EQUALS";
+    operator2["IS_NULL"] = "IS_NULL";
+    operator2["IS_NOT_NULL"] = "IS_NOT_NULL";
+    operator2["BETWEEN"] = "BETWEEN";
+    operator2["GREATER_THAN"] = "GREATER_THAN";
+    operator2["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+    operator2["LESS_THAN"] = "LESS_THAN";
+    operator2["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+    operator2["CONTAINS"] = "CONTAINS";
+    operator2["NOT_CONTAINS"] = "NOT_CONTAINS";
+  })(operator = Oauth2UrlSimpleExpression2.operator || (Oauth2UrlSimpleExpression2.operator = {}));
+  let property;
+  ((property2) => {
+    property2["ENVIRONMENT_ID"] = "environmentId";
+    property2["EXTENSION_GROUP_ID"] = "extensionGroupId";
+    property2["CONNECTION_ID"] = "connectionId";
+    property2["OAUTH_FIELD_ID"] = "oAuthFieldId";
+    property2["CLIENT_ID"] = "clientId";
+    property2["CLIENT_SECRET"] = "clientSecret";
+  })(property = Oauth2UrlSimpleExpression2.property || (Oauth2UrlSimpleExpression2.property = {}));
+})(Oauth2UrlSimpleExpression || (Oauth2UrlSimpleExpression = {}));
+
 // lib/models/ODETTEConnectorRecordGroupingExpression.ts
 var ODETTEConnectorRecordGroupingExpression;
 ((ODETTEConnectorRecordGroupingExpression2) => {
@@ -13570,700 +13628,6 @@ var X12Options;
     outboundValidationOption2["FAIL_ALL"] = "failAll";
   })(outboundValidationOption = X12Options2.outboundValidationOption || (X12Options2.outboundValidationOption = {}));
 })(X12Options || (X12Options = {}));
-
-// lib/automation/graph/builder.ts
-var nid = 0;
-var eid = 0;
-var nextN = (p = "n") => `${p}_${++nid}`;
-var nextE = () => `e_${++eid}`;
-var GraphBuilder = class {
-  constructor(name, gid = nextN("g")) {
-    this.name = name;
-    this.gid = gid;
-    this.nodes = [];
-    this.edges = [];
-  }
-  /** Add a new node to the graph */
-  add(spec) {
-    const node = { id: this._nextId(), ...spec };
-    this.nodes.push(node);
-    const handle = {
-      id: node.id,
-      node,
-      in: (p) => ({ node: node.id, port: p }),
-      out: (p) => ({ node: node.id, port: p })
-    };
-    return handle;
-  }
-  /** Flow helpers (flow.ts) call this; accept edge without id and assign one */
-  addEdge(edge) {
-    this.edges.push({ id: nextE(), ...edge });
-  }
-  /** Optional explicit connector that also assigns an id */
-  connect(from, to, meta) {
-    this.edges.push({ id: nextE(), from, to, meta });
-  }
-  /** Finalize to a JSON BPG object */
-  toJSON() {
-    return {
-      id: this.gid,
-      name: this.name,
-      nodes: this.nodes,
-      edges: this.edges
-    };
-  }
-  /** Internal node id generator */
-  _nextId() {
-    return nextN("n");
-  }
-};
-
-// lib/automation/automation.ts
-function defineAutomation(fn2) {
-  const components = [];
-  let graph = null;
-  const api = {
-    component: (c) => {
-      components.push(c);
-    },
-    process: (name, build) => {
-      const g = new GraphBuilder(name);
-      build(g);
-      graph = g.toJSON();
-    }
-  };
-  fn2(api);
-  if (!graph) throw new Error("No process graph defined. Call b.process(...)");
-  const catalog = { components };
-  return { graph, catalog };
-}
-
-// lib/automation/graph/flow.ts
-function metaFor(port4) {
-  if (port4 === "true") return { label: "True", branchIdentifier: "true" };
-  if (port4 === "false") return { label: "False", branchIdentifier: "false" };
-  if (/^\d+$/.test(port4)) return { label: port4, branchIdentifier: port4 };
-  return void 0;
-}
-function add(g, from, fromPort, to, toPort) {
-  g.addEdge({
-    from: { node: from.id, port: fromPort },
-    to: { node: to.id, port: toPort },
-    meta: metaFor(fromPort)
-  });
-}
-function makeChain(g, current, outPort = "main") {
-  return {
-    to(next) {
-      add(g, current, outPort, next, "main");
-      return makeChain(g, next, "main");
-    },
-    if(decisionNode, routes) {
-      add(g, current, outPort, decisionNode, "main");
-      const trueChain = {
-        to(next) {
-          add(g, decisionNode, "true", next, "main");
-          return makeChain(g, next, "main");
-        },
-        if: (dn, nested) => {
-          add(g, decisionNode, "true", dn, "main");
-          const tTrue = { to(n) {
-            add(g, dn, "true", n, "main");
-            return makeChain(g, n, "main");
-          }, if: this.if, branch: this.branch };
-          const tFalse = { to(n) {
-            add(g, dn, "false", n, "main");
-            return makeChain(g, n, "main");
-          }, if: this.if, branch: this.branch };
-          nested({ onTrue: tTrue, onFalse: tFalse });
-          return makeChain(g, dn, "main");
-        },
-        branch: (brNode, table) => {
-          add(g, decisionNode, "true", brNode, "main");
-          for (const [exitKey, go] of Object.entries(table)) {
-            const exit = exitKey;
-            const exitChain = {
-              to(n) {
-                add(g, brNode, exit, n, "main");
-                return makeChain(g, n, "main");
-              },
-              if: (dn, cb) => this.if(dn, cb),
-              branch: (bn, tb) => this.branch(bn, tb)
-            };
-            go(exitChain);
-          }
-          return makeChain(g, brNode, "main");
-        }
-      };
-      const falseChain = {
-        to(next) {
-          add(g, decisionNode, "false", next, "main");
-          return makeChain(g, next, "main");
-        },
-        if: (dn, nested) => {
-          add(g, decisionNode, "false", dn, "main");
-          const fTrue = { to(n) {
-            add(g, dn, "true", n, "main");
-            return makeChain(g, n, "main");
-          }, if: this.if, branch: this.branch };
-          const fFalse = { to(n) {
-            add(g, dn, "false", n, "main");
-            return makeChain(g, n, "main");
-          }, if: this.if, branch: this.branch };
-          nested({ onTrue: fTrue, onFalse: fFalse });
-          return makeChain(g, dn, "main");
-        },
-        branch: (brNode, table) => {
-          add(g, decisionNode, "false", brNode, "main");
-          for (const [exitKey, go] of Object.entries(table)) {
-            const exit = exitKey;
-            const exitChain = {
-              to(n) {
-                add(g, brNode, exit, n, "main");
-                return makeChain(g, n, "main");
-              },
-              if: (dn, cb) => this.if(dn, cb),
-              branch: (bn, tb) => this.branch(bn, tb)
-            };
-            go(exitChain);
-          }
-          return makeChain(g, brNode, "main");
-        }
-      };
-      routes({ onTrue: trueChain, onFalse: falseChain });
-      return makeChain(g, decisionNode, "main");
-    },
-    branch(branchNode, table) {
-      add(g, current, outPort, branchNode, "main");
-      for (const [exitKey, go] of Object.entries(table)) {
-        const exit = exitKey;
-        const exitChain = {
-          to(n) {
-            add(g, branchNode, exit, n, "main");
-            return makeChain(g, n, "main");
-          },
-          if: (dn, cb) => {
-            add(g, branchNode, exit, dn, "main");
-            const t = {
-              to(n) {
-                add(g, dn, "true", n, "main");
-                return makeChain(g, n, "main");
-              },
-              if: (inner, cb2) => this.if(inner, cb2),
-              branch: (bn, tb) => this.branch(bn, tb)
-            };
-            const f = {
-              to(n) {
-                add(g, dn, "false", n, "main");
-                return makeChain(g, n, "main");
-              },
-              if: (inner, cb2) => this.if(inner, cb2),
-              branch: (bn, tb) => this.branch(bn, tb)
-            };
-            cb({ onTrue: t, onFalse: f });
-            return makeChain(g, dn, "main");
-          },
-          branch: (bn, tb) => {
-            add(g, branchNode, exit, bn, "main");
-            for (const [exKey, go2] of Object.entries(tb)) {
-              const ex = exKey;
-              const exChain = {
-                to(n) {
-                  add(g, bn, ex, n, "main");
-                  return makeChain(g, n, "main");
-                },
-                if: (dn, cb2) => this.if(dn, cb2),
-                branch: (bn2, tb2) => this.branch(bn2, tb2)
-              };
-              go2(exChain);
-            }
-            return makeChain(g, bn, "main");
-          }
-        };
-        go(exitChain);
-      }
-      return makeChain(g, branchNode, "main");
-    }
-  };
-}
-function seq(g, start2) {
-  return makeChain(g, start2, "main");
-}
-
-// lib/automation/stdlib/index.ts
-var port = (id, direction, label) => ({ id, name: id, direction, label });
-var start = (name = "Start") => ({
-  name,
-  kind: { family: "start", type: "passthrough" },
-  ports: [port("main", "out")]
-});
-var docProps = (name, cfg) => ({
-  name,
-  kind: { family: "doc", type: "properties" },
-  ports: [port("main", "in"), port("main", "out")],
-  config: cfg
-});
-var decision = (name = "Decision", cfg) => ({
-  name,
-  kind: { family: "decision", type: "compare" },
-  ports: [port("main", "in"), port("true", "out", "True"), port("false", "out", "False")],
-  config: cfg
-});
-var branch = (name = "Branch", n = 2) => ({
-  name,
-  kind: { family: "control", type: "branch" },
-  ports: [port("main", "in"), ...Array.from({ length: n }, (_, i) => port(String(i + 1), "out", String(i + 1)))]
-});
-var mapNode = (name = "Map", cfg) => ({
-  name,
-  kind: { family: "transform", type: "map" },
-  ports: [port("main", "in"), port("main", "out")],
-  config: cfg
-});
-var notify = (name = "Notify", cfg) => ({
-  name,
-  kind: { family: "notify", type: "message" },
-  ports: [port("main", "in"), port("main", "out")],
-  config: cfg
-});
-var returnDocs = (name = "Return") => ({
-  name,
-  kind: { family: "return", type: "returndocuments" },
-  ports: [port("main", "in")]
-});
-var stop = (name = "Stop", cfg = { continue: true }) => ({
-  name,
-  kind: { family: "stop", type: "stop" },
-  ports: [port("main", "in")],
-  config: cfg
-});
-
-// lib/automation/stdlib/map.ts
-var port2 = (id, direction, label) => ({ id, name: id, direction, label });
-function mapNodeByAlias(name, cfg) {
-  return {
-    name,
-    kind: { family: "transform", type: "map" },
-    ports: [port2("main", "in"), port2("main", "out")],
-    config: cfg
-  };
-}
-
-// lib/automation/stdlib/connector.ts
-var port3 = (id, direction, label) => ({
-  id,
-  name: id,
-  // keep a human-friendly port name
-  direction,
-  // must match type definition
-  label
-  // optional display label
-});
-function connectorNode(name, connectorType, cfg) {
-  return {
-    name,
-    kind: { family: "connector", type: connectorType },
-    ports: [
-      port3("main", "in"),
-      port3("main", "out")
-    ],
-    config: cfg
-  };
-}
-
-// lib/automation/catalog/map.helpers.ts
-var fn = {
-  propertyGet(key, name, position, opts, xy) {
-    return {
-      key,
-      name,
-      category: "ProcessProperty",
-      type: "PropertyGet",
-      position,
-      x: xy?.x,
-      y: xy?.y,
-      inputs: [
-        { key: "1", name: "Property Name", default: opts.propertyName },
-        { key: "2", name: "Default Value", default: opts.defaultValue ?? "" }
-      ],
-      outputs: [{ key: "3", name: "Result" }],
-      configurationXml: "<Configuration/>",
-      cacheEnabled: true,
-      cacheOption: "none",
-      sumEnabled: false
-    };
-  },
-  documentPropertyGet(key, outputName, position, propertyId, propertyName, xy) {
-    return {
-      key,
-      name: "Get Document Property",
-      category: "ProcessProperty",
-      type: "DocumentPropertyGet",
-      position,
-      x: xy?.x,
-      y: xy?.y,
-      inputs: [],
-      outputs: [{ key: "3", name: outputName }],
-      configurationXml: `
-        <Configuration>
-          <DocumentProperty defaultValue="" persist="false" propertyId="${propertyId}" propertyName="${propertyName}"/>
-        </Configuration>`.trim(),
-      cacheEnabled: true,
-      sumEnabled: false
-    };
-  }
-};
-var m = {
-  fromFnToProfile(fromFunction, fromKey, toKey, toKeyPath, toNamePath) {
-    return {
-      fromFunction,
-      fromKey,
-      fromType: "function",
-      toKey,
-      toKeyPath,
-      toNamePath,
-      toType: "profile"
-    };
-  }
-};
-
-// lib/automation/catalog/profiles/flatfile.helpers.ts
-function ffElement(params) {
-  return {
-    dataType: "character",
-    isMappable: true,
-    isNode: true,
-    enforceUnique: false,
-    identityValue: "",
-    justification: "left",
-    mandatory: false,
-    minLength: 0,
-    maxLength: 0,
-    useToIdentifyFormat: false,
-    validateData: false,
-    ...params
-  };
-}
-function ffElementsGroup(params) {
-  return {
-    isNode: true,
-    ...params
-  };
-}
-function ffRecord(params) {
-  return {
-    isNode: true,
-    detectFormat: "numberofcolumns",
-    ...params
-  };
-}
-
-// lib/automation/compiler/compile.ts
-function esc(s) {
-  return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-var typeMap = (k) => k === "connector-operation" ? "connector-action" : k;
-function attrs(r) {
-  return Object.entries(r).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}="${String(v)}"`).join(" ");
-}
-function emitMapping(mp) {
-  return `                <Mapping fromFunction="${mp.fromFunction}" fromKey="${mp.fromKey}" fromType="${mp.fromType}" toKey="${mp.toKey}" toKeyPath="${mp.toKeyPath}" toNamePath="${mp.toNamePath}" toType="${mp.toType}"/>`;
-}
-function componentToXml(c) {
-  const xmlType = typeMap(c.kind);
-  const a = attrs({ type: xmlType, subType: c.subType, name: c.name });
-  if (c.kind === "connector-settings" && c.subType === "http") {
-    const s = c.config;
-    return `<?xml version="1.0"?>
-<bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" ${a}>
-  <bns:object>
-    <HttpSettings authenticationType="${s.authenticationType}" url="${s.url}">
-      <AuthSettings${s.AuthSettings?.user ? ` user="${s.AuthSettings.user}"` : ""}/>
-      <OAuth2Settings${s.OAuth2Settings?.grantType ? ` grantType="${s.OAuth2Settings.grantType}"` : ""}/>
-      <SSLOptions${s.SSLOptions?.clientauth !== void 0 ? ` clientauth="${s.SSLOptions.clientauth}"` : ""}${s.SSLOptions?.trustServerCert !== void 0 ? ` trustServerCert="${s.SSLOptions.trustServerCert}"` : ""}/>
-    </HttpSettings>
-  </bns:object>
-</bns:ApiComponent>`;
-  }
-  if (c.kind === "connector-operation" && c.subType === "http") {
-    const o = c.config;
-    return `<?xml version="1.0"?>
-<bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" ${a}>
-  <bns:object>
-    <Operation>
-      <Configuration>
-        <HttpSendAction methodType="${o.method}" dataContentType="${o.dataContentType}" followRedirects="${o.followRedirects}"
-          returnErrors="${o.returnErrors}" returnResponses="${o.returnResponses}"
-          requestProfileType="${o.requestProfileType}" responseProfileType="${o.responseProfileType}">
-          <requestHeaders/>
-          <pathElements>${(o.pathElements || []).map((e) => `<element isVariable="${e.isVariable}" key="${e.key}" name="${e.name}"/>`).join("")}</pathElements>
-          <responseHeaderMapping/>
-        </HttpSendAction>
-      </Configuration>
-    </Operation>
-  </bns:object>
-</bns:ApiComponent>`;
-  }
-  if (c.kind === "transform.map") {
-    const cfg = c.config;
-    const mappingsXml = (cfg.mappings ?? []).map(emitMapping).join("\n");
-    const functionsXml = (cfg.functions ?? []).map((f) => {
-      const inputsXml = (f.inputs ?? []).map((i) => `<Input key="${i.key}" name="${i.name}"${i.default !== void 0 ? ` default="${i.default}"` : ""}/>`).join("");
-      const outputsXml = (f.outputs ?? []).map((o) => `<Output key="${o.key}" name="${o.name}"/>`).join("");
-      const pos = f.position !== void 0 ? ` position="${f.position}"` : "";
-      const xy = f.x !== void 0 && f.y !== void 0 ? ` x="${f.x}" y="${f.y}"` : "";
-      const cache = (f.cacheEnabled !== void 0 ? ` cacheEnabled="${f.cacheEnabled}"` : "") + (f.cacheOption ? ` cacheOption="${f.cacheOption}"` : "") + (f.sumEnabled !== void 0 ? ` sumEnabled="${f.sumEnabled}"` : "");
-      return `                <FunctionStep category="${f.category}" key="${f.key}" name="${f.name}" type="${f.type}"${pos}${xy}${cache}>
-                  <Inputs>${inputsXml}</Inputs>
-                  <Outputs>${outputsXml}</Outputs>
-                  ${f.configurationXml ?? "<Configuration/>"}
-                </FunctionStep>`;
-    }).join("\n");
-    const optimize = cfg.optimizeExecutionOrder ?? true;
-    return `<?xml version="1.0"?>
-<bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" ${a}>
-  <bns:object>
-    <Map fromProfile="ALIAS:${cfg.fromProfile.alias}" toProfile="ALIAS:${cfg.toProfile.alias}">
-      <Mappings>
-${mappingsXml}
-      </Mappings>
-      <Functions optimizeExecutionOrder="${optimize}">
-${functionsXml}
-      </Functions>
-      <Defaults/>
-      <DocumentCacheJoins/>
-    </Map>
-  </bns:object>
-</bns:ApiComponent>`;
-  }
-  if (c.kind === "profile.flatfile") {
-    const p = c.config;
-    if (p.raw) return p.raw;
-    const modelVersion = p.modelVersion ?? "2";
-    const strict = p.strict ?? true;
-    const gi = p.properties.generalInfo;
-    const opts = p.properties.options?.delimited;
-    const record = p.dataElements.record;
-    const group = record.elementsGroup;
-    const elementsXml = group.elements.map((el) => `
-                          <FlatFileElement dataType="${el.dataType ?? "character"}"
-                                          enforceUnique="${!!el.enforceUnique}"
-                                          identityValue="${el.identityValue ?? ""}"
-                                          isMappable="${el.isMappable ?? true}"
-                                          isNode="${el.isNode ?? true}"
-                                          justification="${el.justification ?? "left"}"
-                                          key="${el.key}"
-                                          mandatory="${!!el.mandatory}"
-                                          maxLength="${el.maxLength ?? 0}"
-                                          minLength="${el.minLength ?? 0}"
-                                          name="${esc(el.name)}"
-                                          useToIdentifyFormat="${!!el.useToIdentifyFormat}"
-                                          validateData="${!!el.validateData}">
-                              <DataFormat>
-                                  <ProfileCharacterFormat/>
-                              </DataFormat>
-                          </FlatFileElement>`).join("\n");
-    return `<?xml version="1.0"?>
-  <bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" ${attrs({ type: "profile.flatfile", name: c.name })}>
-    <bns:object>
-      <FlatFileProfile xmlns="" modelVersion="${modelVersion}" strict="${strict}">
-        <ProfileProperties>
-          <GeneralInfo fileType="${gi.fileType}" useColumnHeaders="${!!gi.useColumnHeaders}"/>
-          <Options>
-            <DataOptions/>
-            ${opts ? `<DelimitedOptions fileDelimiter="${opts.fileDelimiter}" removeEscape="${!!opts.removeEscape}" textQualifier="${opts.textQualifier ?? "na"}"/>` : "<DelimitedOptions/>"}
-          </Options>
-        </ProfileProperties>
-        <DataElements>
-          <FlatFileRecord detectFormat="${record.detectFormat ?? "numberofcolumns"}" isNode="${record.isNode ?? true}" key="${record.key}" name="${esc(record.name)}">
-            <FlatFileElements isNode="${group.isNode ?? true}" key="${group.key}" name="${esc(group.name)}">
-  ${elementsXml}
-            </FlatFileElements>
-          </FlatFileRecord>
-        </DataElements>
-      </FlatFileProfile>
-    </bns:object>
-  </bns:ApiComponent>`;
-  }
-  if (c.kind === "profile.json") {
-    const cfg = c.config;
-    if (!cfg.raw) {
-      const inner = renderJsonProfileXML(cfg).replace(/<bns:ApiComponent[^>]*name=""/, `<bns:ApiComponent ${a}`);
-      return inner;
-    }
-    return cfg.raw;
-  }
-  return `<?xml version="1.0"?><bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" ${a}/>`;
-}
-function compileAutomation(pkg) {
-  const componentXmls = pkg.catalog.components.map((c) => ({
-    alias: c.alias,
-    kind: c.kind,
-    subType: c.subType,
-    xml: componentToXml(c)
-  }));
-  const shapes = pkg.graph.nodes.map((n, i) => {
-    const isConnector = n.kind.family === "connector";
-    const isMap = n.kind.family === "transform" && n.kind.type === "map";
-    const cfg = n.config ?? {};
-    return `    <shape name="${n.name ?? `shape${i + 1}`}" shapetype="${n.kind.family}">
-      <configuration>${isConnector ? `
-        <connectoraction connectorType="${n.kind.type}" connectionAlias="${cfg.connection?.alias}" operationAlias="${cfg.operation?.alias}">
-          <parameters/>
-        </connectoraction>` : isMap ? `
-        <map action="transform" mapAlias="${cfg.map?.alias}"/>` : ""}
-      </configuration>
-    </shape>`;
-  }).join("\n");
-  const edges = pkg.graph.edges.map(
-    (e) => `    <edge from="${e.from.node}:${e.from.port}" to="${e.to.node}:${e.to.port}" label="${e.meta?.label ?? ""}" identifier="${e.meta?.branchIdentifier ?? ""}"/>`
-  ).join("\n");
-  const processXml = `<?xml version="1.0"?>
-<bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" type="process" name="${pkg.graph.name}">
-  <bns:object>
-    <process>
-      <shapes>
-${shapes}
-      </shapes>
-      <edges>
-${edges}
-      </edges>
-    </process>
-  </bns:object>
-</bns:ApiComponent>`;
-  return { processXml, componentXmls };
-}
-function renderJsonProfileXML(p) {
-  if (p.raw) return p.raw;
-  const rootKey = p.root?.key ?? "1";
-  const rootName = p.root?.name ?? "Root";
-  const rootDataType = p.root?.dataType ?? "character";
-  const rootIsMappable = p.root?.isMappable ?? false;
-  const rootIsNode = p.root?.isNode ?? true;
-  const objKey = p.object?.key ?? "2";
-  const objName = p.object?.name ?? "Object";
-  const objIsMappable = p.object?.isMappable ?? false;
-  const objIsNode = p.object?.isNode ?? true;
-  const entries = (p.object?.entries ?? []).map((e) => {
-    const k = esc(e.key);
-    const nm = esc(e.name);
-    const dt = esc(e.dataType ?? "character");
-    const mappable = e.isMappable ?? true;
-    const isNode = e.isNode ?? true;
-    return `                        <JSONObjectEntry dataType="${dt}" isMappable="${mappable}" isNode="${isNode}" key="${k}" name="${nm}">
-                            <DataFormat>
-                                <ProfileCharacterFormat/>
-                            </DataFormat>
-                            <Qualifiers>
-                                <QualifierList/>
-                            </Qualifiers>
-                        </JSONObjectEntry>`;
-  }).join("\n");
-  return `<?xml version="1.0"?>
-<bns:ApiComponent xmlns:bns="http://api.platform.boomi.com/" type="profile.json" name="">
-  <bns:object>
-    <JSONProfile xmlns="">
-      <DataElements>
-        <JSONRootValue dataType="${rootDataType}" isMappable="${rootIsMappable}" isNode="${rootIsNode}" key="${esc(rootKey)}" name="${esc(rootName)}">
-          <DataFormat>
-            <ProfileCharacterFormat/>
-          </DataFormat>
-          <JSONObject isMappable="${objIsMappable}" isNode="${objIsNode}" key="${esc(objKey)}" name="${esc(objName)}">
-${entries}
-          </JSONObject>
-          <Qualifiers>
-            <QualifierList/>
-          </Qualifiers>
-        </JSONRootValue>
-      </DataElements>
-      <tagLists/>
-    </JSONProfile>
-  </bns:object>
-</bns:ApiComponent>`;
-}
-
-// lib/services/helpers.ts
-function extractIdAndVersion(xml) {
-  const id = xml.match(/\bcomponentId="([^"]+)"/)?.[1];
-  if (!id) throw new Error("createComponent: componentId not found in response XML");
-  const version = xml.match(/\bversion="([^"]+)"/)?.[1] ?? "";
-  return { componentId: id, version };
-}
-function resolveMapXmlAliases(xml, idByAlias) {
-  return xml.replace(
-    /\b(fromProfile|toProfile)="ALIAS:([^"]+)"/g,
-    (_, attr, alias) => `${attr}="${idByAlias[alias] ?? (() => {
-      throw new Error(`Missing ID for alias ${alias} used in Map`);
-    })()}"`
-  );
-}
-function resolveProcessXmlAliases(xml, idByAlias) {
-  let out = xml;
-  out = out.replace(
-    /\bconnectionAlias="([^"]+)"/g,
-    (_, alias) => `connectionId="${idByAlias[alias] ?? (() => {
-      throw new Error(`Missing ID for connection alias ${alias}`);
-    })()}"`
-  ).replace(
-    /\boperationAlias="([^"]+)"/g,
-    (_, alias) => `operationId="${idByAlias[alias] ?? (() => {
-      throw new Error(`Missing ID for operation alias ${alias}`);
-    })()}"`
-  );
-  out = out.replace(
-    /\bmapAlias="([^"]+)"/g,
-    (_, alias) => `mapId="${idByAlias[alias] ?? (() => {
-      throw new Error(`Missing ID for map alias ${alias}`);
-    })()}"`
-  );
-  return out;
-}
-function asXmlString(resp) {
-  if (typeof resp === "string") return resp;
-  const maybe = resp?.xml ?? resp?.data ?? resp?.body;
-  return typeof maybe === "string" ? maybe : String(resp);
-}
-
-// lib/core/XmlClient.ts
-function makeEmbedKitClient(services) {
-  return {
-    async createComponent(xml) {
-      const resp = await services.component.createComponent(xml);
-      const xmlText = asXmlString(resp);
-      return extractIdAndVersion(xmlText);
-    }
-  };
-}
-
-// lib/services/AutomationService.ts
-function postOrder(components) {
-  const weight = (c) => {
-    if (c.kind?.startsWith("profile.")) return 10;
-    if (c.kind === "transform.map") return 20;
-    if (c.kind === "connector-settings") return 30;
-    if (c.kind === "connector-operation") return 40;
-    return 50;
-  };
-  return [...components].sort((a, b) => weight(a) - weight(b));
-}
-async function createInBoomiFromAutomation(pkg, boomi) {
-  const { componentXmls, processXml } = compileAutomation(pkg);
-  const idByAlias = {};
-  const created = {};
-  const ordered = postOrder(componentXmls);
-  for (const c of ordered) {
-    let xmlToSend = c.xml;
-    if (c.kind === "transform.map") {
-      xmlToSend = resolveMapXmlAliases(xmlToSend, idByAlias);
-    }
-    const { componentId, version } = await boomi.createComponent(xmlToSend);
-    idByAlias[c.alias] = componentId;
-    created[c.alias] = { id: componentId, version, kind: c.kind, subType: c.subType };
-  }
-  const processXmlResolved = resolveProcessXmlAliases(processXml, idByAlias);
-  const { componentId: processId, version: processVersion } = await boomi.createComponent(processXmlResolved);
-  return { processId, processVersion, componentIds: created };
-}
 export {
   AS2CommunicationOptions,
   AS2ConnectorRecordGroupingExpression,
@@ -14535,6 +13899,8 @@ export {
   OFTP2ConnectorRecordGroupingExpression,
   OFTP2ConnectorRecordSimpleExpression,
   OFTPCommunicationOptions,
+  Oauth2UrlGroupingExpression,
+  Oauth2UrlSimpleExpression,
   OdetteConnectorRecordService,
   OdetteOptions,
   OdetteUNBControlInfo,
@@ -14643,26 +14009,6 @@ export {
   X12ConnectorRecordGroupingExpression,
   X12ConnectorRecordService,
   X12ConnectorRecordSimpleExpression,
-  X12Options,
-  branch,
-  compileAutomation,
-  connectorNode,
-  createInBoomiFromAutomation,
-  decision,
-  defineAutomation,
-  docProps,
-  ffElement,
-  ffElementsGroup,
-  ffRecord,
-  fn,
-  m,
-  makeEmbedKitClient,
-  mapNode,
-  mapNodeByAlias,
-  notify,
-  returnDocs,
-  seq,
-  start,
-  stop
+  X12Options
 };
 //# sourceMappingURL=index.js.map