@uipath/flow-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/packager-tool-tn5e7wnb.js

@@ -0,0 +1,384 @@
+import {
+  generateNodeVariables
+} from "./packager-tool-vpqyvh4c.js";
+import {
+  MINIMUM_SUPPORTED_SCHEMA_VERSION,
+  RESERVED_WORDS,
+  VALID_IDENTIFIER_PATTERN,
+  coerceInputsViaSchema,
+  createRefResolver,
+  executeWritePlan,
+  fileFormatToInMemoryWorkflow,
+  generateNextId,
+  inMemoryWorkflowToFileFormat,
+  planWriteThrough,
+  resolveAndConvertWorkflow,
+  workflowFileSchema,
+  workflowSchema
+} from "./packager-tool-m5qfverj.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-PYGLRILU.js
+function needsBinding(manifest) {
+  const model = manifest.model;
+  if (!model)
+    return false;
+  if (model.bindings !== undefined)
+    return true;
+  const context = model.context;
+  if (!context || typeof context !== "object")
+    return false;
+  const connectionKeys = ["connection", "folderKey", "connectionId"];
+  return Object.keys(context).some((k) => connectionKeys.includes(k));
+}
+function createBinding(options) {
+  return {
+    id: generateNextId("b", 8),
+    name: options.name,
+    type: "string",
+    resource: options.resource,
+    resourceKey: options.resourceKey ?? options.resource,
+    ...options.value && { default: options.value },
+    ...options.propertyAttribute && { propertyAttribute: options.propertyAttribute },
+    ...options.resourceSubType && { resourceSubType: options.resourceSubType }
+  };
+}
+function createConnectionBinding(connectionId, connectorName) {
+  return createBinding({
+    name: connectorName,
+    value: connectorName,
+    resource: "connection",
+    resourceKey: connectionId,
+    propertyAttribute: "connection"
+  });
+}
+function createFolderKeyBinding(connectionId, folderKey) {
+  return createBinding({
+    name: folderKey,
+    value: folderKey,
+    resource: "folderKey",
+    resourceKey: connectionId,
+    propertyAttribute: "folderKey"
+  });
+}
+function addBindingIfMissing(bindings, binding) {
+  const exists = bindings.some((b) => b.name === binding.name && b.resource === binding.resource && b.resourceKey === binding.resourceKey && b.propertyAttribute === binding.propertyAttribute);
+  if (exists)
+    return bindings;
+  return [...bindings, binding];
+}
+function createBindingsFromManifest(manifest) {
+  const model = manifest.model;
+  const bindingsTemplate = model?.bindings;
+  if (!bindingsTemplate?.values)
+    return [];
+  return bindingsTemplate.values.map((v) => createBinding({
+    name: v.name,
+    value: v.default ?? "",
+    resource: bindingsTemplate.resource,
+    resourceKey: bindingsTemplate.resourceKey,
+    propertyAttribute: v.propertyAttribute,
+    resourceSubType: bindingsTemplate.resourceSubType
+  }));
+}
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-GCUQRSSY.js
+var DEFAULT_TRIGGER_POSITION = { x: 256, y: 144 };
+var DEFAULT_LAYOUT_OPTIONS = {
+  algorithm: "layered",
+  direction: "RIGHT",
+  nodeSpacing: 96,
+  layerSpacing: 96,
+  minimizeCrossings: true,
+  straightenEdges: true,
+  compact: false,
+  animate: true,
+  animationDuration: 500
+};
+function resolveWidth(node) {
+  return node.measured?.width ?? node.width ?? 96;
+}
+function resolveHeight(node) {
+  return node.measured?.height ?? node.height ?? 96;
+}
+var GRID_SPACING = 16;
+function snapToGrid(value, gridSize = GRID_SPACING) {
+  return Math.round(value / gridSize) * gridSize;
+}
+
+// ../../node_modules/@uipath/flow-core/dist/index.js
+function sanitizeNodeLabel(label) {
+  const words = label.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (words.length === 0)
+    return "node";
+  return words.map((word, index) => {
+    const lower = word.toLowerCase();
+    if (index === 0)
+      return lower;
+    return lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+}
+function lowerCaseFirstLetter(str) {
+  if (!str)
+    return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function generateNodeId(label, existingIds) {
+  return generateNodeIdAndName(label, existingIds).id;
+}
+function generateNodeIdAndName(label, existingIds) {
+  const idSet = existingIds instanceof Set ? existingIds : new Set(existingIds);
+  const baseId = lowerCaseFirstLetter(sanitizeNodeLabel(label).replace("createNew", ""));
+  let index = 1;
+  let candidateId = `${baseId}${index}`;
+  while (idSet.has(candidateId)) {
+    index++;
+    candidateId = `${baseId}${index}`;
+  }
+  return {
+    id: candidateId,
+    displayName: label ? index > 1 ? `${label} ${index}` : label : `Node${index > 1 ? ` ${index}` : ""}`
+  };
+}
+function validateIdFormat(id) {
+  if (!id || !id.trim()) {
+    return "ID is required";
+  }
+  const trimmed = id.trim();
+  if (!VALID_IDENTIFIER_PATTERN.test(trimmed)) {
+    if (/^\d/.test(trimmed))
+      return "ID cannot start with a number";
+    if (/\s/.test(trimmed))
+      return "ID cannot contain spaces";
+    if (/[^a-zA-Z0-9_]/.test(trimmed))
+      return "ID can only contain letters, numbers, and underscores";
+    return "ID must start with a letter or underscore";
+  }
+  if (RESERVED_WORDS.includes(trimmed)) {
+    return `"${trimmed}" is a reserved word`;
+  }
+  return;
+}
+function validateIdentifier(id, existingIds, currentNodeId) {
+  const formatError = validateIdFormat(id);
+  if (formatError)
+    return formatError;
+  const idSet = existingIds instanceof Set ? existingIds : new Set(existingIds);
+  if (currentNodeId && id === currentNodeId) {
+    return;
+  }
+  if (idSet.has(id) && id !== currentNodeId) {
+    return `ID "${id}" is already in use by a node or variable`;
+  }
+  return;
+}
+function generateEdgeId(source, sourceHandle, target, targetHandle, existingIds) {
+  const baseId = `${source}-${sourceHandle ?? "default"}-${target}-${targetHandle ?? "default"}`;
+  if (!existingIds || !existingIds.has(baseId)) {
+    return baseId;
+  }
+  let index = 2;
+  let candidateId = `${baseId}-${index}`;
+  while (existingIds.has(candidateId)) {
+    index++;
+    candidateId = `${baseId}-${index}`;
+  }
+  return candidateId;
+}
+function getInputDefaults(manifest) {
+  const raw = manifest.inputDefaults ? structuredClone(manifest.inputDefaults) : manifest.inputDefinition ? structuredClone(manifest.inputDefinition) : {};
+  const inputDefinition = manifest.inputDefinition;
+  const inputProps = inputDefinition?.properties ?? {};
+  for (const [key, value] of Object.entries(raw)) {
+    raw[key] = coerceInputsViaSchema(value, inputProps[key]);
+  }
+  return raw;
+}
+function createNodeFromManifest(manifest, id, position = { x: 0, y: 0 }, label) {
+  const manifestModel = manifest.model;
+  const inputs = getInputDefaults(manifest);
+  if (manifestModel?.entryPointId) {
+    inputs.entryPointId = crypto.randomUUID();
+  }
+  if (manifestModel?.source) {
+    inputs.source = crypto.randomUUID();
+  }
+  return {
+    id,
+    type: manifest.nodeType,
+    typeVersion: manifest.version,
+    ui: { position },
+    display: { label: label ?? manifest.display?.label ?? id },
+    inputs
+  };
+}
+function createNode(options) {
+  if (!options.typeVersion) {
+    throw new Error("createNode requires an explicit typeVersion");
+  }
+  return {
+    id: options.id,
+    type: options.type,
+    typeVersion: options.typeVersion,
+    ui: { position: options.position ?? { x: 0, y: 0 } },
+    display: { label: options.label ?? options.id },
+    inputs: options.inputs ?? {}
+  };
+}
+function createEdge(options) {
+  const sourcePort = options.sourcePort ?? "default";
+  const targetPort = options.targetPort ?? "default";
+  const id = options.id ?? generateEdgeId(options.source, sourcePort, options.target, targetPort, options.existingIds);
+  return {
+    id,
+    sourceNodeId: options.source,
+    sourcePort,
+    targetNodeId: options.target,
+    targetPort
+  };
+}
+function addDefinition(workflow, manifest) {
+  const defs = workflow.definitions;
+  const already = defs.some((d) => d.nodeType === manifest.nodeType && d.version === manifest.version);
+  if (!already) {
+    defs.push(manifest);
+  }
+}
+function addNode(workflow, manifest, id, position, label) {
+  const node = createNodeFromManifest(manifest, id, position, label);
+  if (node.inputs?.entryPointId) {
+    const hasDefault = workflow.nodes.some((n) => n.inputs?.isDefaultEntryPoint === true);
+    if (!hasDefault) {
+      node.inputs.isDefaultEntryPoint = true;
+    }
+  }
+  workflow.nodes.push(node);
+  addDefinition(workflow, manifest);
+  const manifestBindings = createBindingsFromManifest(manifest);
+  if (manifestBindings.length > 0) {
+    let bindings = workflow.bindings ?? [];
+    for (const b of manifestBindings)
+      bindings = addBindingIfMissing(bindings, b);
+    workflow.bindings = bindings;
+  }
+  workflow.variables = {
+    ...workflow.variables,
+    nodes: generateNodeVariables(workflow.nodes, workflow.definitions)
+  };
+  return node;
+}
+function createWorkflow(options) {
+  const id = options?.id ?? crypto.randomUUID();
+  const name = options?.name ?? "Untitled Workflow";
+  const nodes = [];
+  const definitions = [];
+  if (options?.triggerManifest) {
+    const triggerNode = createNodeFromManifest(options.triggerManifest, "start", { ...DEFAULT_TRIGGER_POSITION });
+    if (triggerNode.inputs?.entryPointId) {
+      triggerNode.inputs.isDefaultEntryPoint = true;
+    }
+    nodes.push(triggerNode);
+    definitions.push(options.triggerManifest);
+  }
+  return {
+    id,
+    version: MINIMUM_SUPPORTED_SCHEMA_VERSION,
+    name,
+    nodes,
+    edges: [],
+    definitions
+  };
+}
+function addEdge(workflow, options) {
+  const existingIds = new Set(workflow.edges.map((e) => e.id));
+  const edge = createEdge({ ...options, existingIds });
+  workflow.edges.push(edge);
+  return edge;
+}
+function addBinding(workflow, binding) {
+  const current = workflow.bindings ?? [];
+  const updated = addBindingIfMissing(current, binding);
+  workflow.bindings = updated;
+}
+function addVariable(workflow, variable) {
+  if (!workflow.variables) {
+    workflow.variables = { globals: [], nodes: [] };
+  }
+  if (!workflow.variables.globals) {
+    workflow.variables.globals = [];
+  }
+  workflow.variables.globals.push(variable);
+}
+var cachedNodeFs;
+async function getNodeFs() {
+  if (cachedNodeFs)
+    return cachedNodeFs;
+  const nodeFs = await import("fs");
+  cachedNodeFs = {
+    readFile: (p, enc) => nodeFs.promises.readFile(p, enc),
+    writeFile: (p, c, enc) => nodeFs.promises.writeFile(p, c, enc)
+  };
+  return cachedNodeFs;
+}
+async function readWorkflow(filePath, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const refResolver = createRefResolver((resolvedPath) => filesystem.readFile(resolvedPath, "utf-8"));
+  const content = await filesystem.readFile(filePath, "utf-8");
+  const raw = JSON.parse(content);
+  const { workflow } = await resolveAndConvertWorkflow(raw, refResolver, { baseUri: filePath });
+  return workflowSchema.parse(workflow);
+}
+async function writeWorkflow(filePath, workflow, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+  await filesystem.writeFile(filePath, JSON.stringify(fileFormat, null, 2), "utf-8");
+}
+async function writeWorkflowWithRefs(filePath, workflow, refMap, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+  const plan = planWriteThrough(fileFormat, refMap);
+  await executeWritePlan(plan, {
+    writeMainFile: async (content) => {
+      await filesystem.writeFile(filePath, content, "utf-8");
+    },
+    writeRefFile: async (refPath, content) => {
+      const path = await import("path");
+      const absPath = path.resolve(path.dirname(filePath), refPath);
+      await filesystem.writeFile(absPath, content, "utf-8");
+    }
+  });
+}
+function validateWorkflow(workflow) {
+  const file = workflowFileSchema.parse(workflow);
+  return fileFormatToInMemoryWorkflow(file);
+}
+function summarizeWorkflow(workflow) {
+  const nodes = workflow.nodes;
+  const edges = workflow.edges;
+  return {
+    id: workflow.id,
+    name: workflow.name,
+    version: workflow.version,
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    nodes: nodes.map((n) => ({
+      id: n.id,
+      type: n.type,
+      label: n.display?.label
+    })),
+    edges: edges.map((e) => ({
+      source: e.sourceNodeId,
+      target: e.targetNodeId
+    })),
+    variableCount: {
+      globals: workflow.variables?.globals?.length ?? 0,
+      nodes: workflow.variables?.nodes?.length ?? 0
+    },
+    hasBindings: (workflow.bindings?.length ?? 0) > 0
+  };
+}
+export { needsBinding, createBinding, createConnectionBinding, createFolderKeyBinding, addBindingIfMissing, createBindingsFromManifest, DEFAULT_LAYOUT_OPTIONS, resolveWidth, resolveHeight, GRID_SPACING, snapToGrid, generateNodeId, generateNodeIdAndName, validateIdentifier, generateEdgeId, createNodeFromManifest, createNode, createEdge, addDefinition, addNode, createWorkflow, addEdge, addBinding, addVariable, readWorkflow, writeWorkflow, writeWorkflowWithRefs, validateWorkflow, summarizeWorkflow };
+
+//# debugId=B91CF0AAF9DF6B2D64756E2164756E21

package/dist/packager-tool-vpqyvh4c.js

@@ -0,0 +1,304 @@
+import {
+  en_default
+} from "./packager-tool-58q3tvh7.js";
+import {
+  __glob
+} from "./packager-tool-sc961w0q.js";
+import {
+  CONNECTOR_NODE_PREFIX
+} from "./packager-tool-m5qfverj.js";
+import {
+  createI18nRegistrar
+} from "./packager-tool-e0p2zsyc.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-LBMWRHN4.js
+var ARRAY_WILDCARD_RE = /\[\*\]/g;
+function stripWildcard(name) {
+  return name.replace(ARRAY_WILDCARD_RE, "");
+}
+function hasWildcardKey(record) {
+  return record ? Object.keys(record).some((key) => key.includes("[*]")) : false;
+}
+function hasWildcard(schema) {
+  return hasWildcardKey(schema.properties) || hasWildcardKey(schema.definitions) || hasWildcardKey(schema.$defs);
+}
+function rewriteKeyedSchemas(record) {
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[stripWildcard(key)] = sanitizeNode(value);
+  }
+  return result;
+}
+function sanitizeNode(node) {
+  const result = { ...node };
+  if (typeof result.$ref === "string" && result.$ref.includes("[*]")) {
+    result.$ref = stripWildcard(result.$ref);
+  }
+  if (node.properties) {
+    result.properties = rewriteKeyedSchemas(node.properties);
+  }
+  if (node.items && !Array.isArray(node.items)) {
+    result.items = sanitizeNode(node.items);
+  }
+  for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+    if (node[combinator]) {
+      result[combinator] = node[combinator].map(sanitizeNode);
+    }
+  }
+  return result;
+}
+function sanitizeConnectorSchema(schema) {
+  if (!schema || !hasWildcard(schema))
+    return schema;
+  const result = sanitizeNode(schema);
+  if (schema.definitions)
+    result.definitions = rewriteKeyedSchemas(schema.definitions);
+  if (schema.$defs)
+    result.$defs = rewriteKeyedSchemas(schema.$defs);
+  return result;
+}
+var JSON_STRING_PREFIX = "=jsonString:";
+var JIT_OBJECT_INPUT_MODE = "jitObject";
+function flattenSplitConfiguration(config) {
+  if ("essentialConfiguration" in config || "optionalConfiguration" in config) {
+    return {
+      ...config.optionalConfiguration,
+      ...config.essentialConfiguration
+    };
+  }
+  return config;
+}
+function normalizeTransientProperties(config) {
+  const result = { ...config };
+  const fc = result.fieldsContainer;
+  const inputMode = result.savedInputMode ?? fc?.inputMode;
+  const jitFieldName = result.savedJitInputFieldId ?? fc?.jitInputField?.name;
+  if (inputMode === JIT_OBJECT_INPUT_MODE || jitFieldName === "body") {
+    result.isJitObjectInputMode = true;
+  }
+  return result;
+}
+function parseConfigurationJson(configuration) {
+  if (!configuration)
+    return null;
+  try {
+    if (typeof configuration === "object") {
+      return normalizeTransientProperties(flattenSplitConfiguration(configuration));
+    }
+    let str = configuration;
+    if (str.startsWith(JSON_STRING_PREFIX))
+      str = str.substring(JSON_STRING_PREFIX.length);
+    const parsed = JSON.parse(str);
+    return typeof parsed === "object" && parsed !== null ? normalizeTransientProperties(flattenSplitConfiguration(parsed)) : null;
+  } catch {
+    return null;
+  }
+}
+function resolveJsonSchema(schema, options = {}) {
+  const { maxDepth = 25 } = options;
+  const definitions = schema.definitions || schema.$defs || {};
+  function resolveRef(ref) {
+    const match = ref.match(/^#\/(?:definitions|\$defs)\/(.+)$/);
+    if (!match)
+      return {};
+    return definitions[match[1]] || {};
+  }
+  function resolve(node, visited, depth) {
+    if (depth > maxDepth)
+      return node;
+    if (node.$ref) {
+      if (visited.has(node.$ref))
+        return { type: "any" };
+      visited.add(node.$ref);
+      return resolve(resolveRef(node.$ref), visited, depth + 1);
+    }
+    const result = { ...node };
+    if (node.properties) {
+      result.properties = {};
+      for (const [key, prop] of Object.entries(node.properties)) {
+        result.properties[key] = resolve(prop, new Set(visited), depth + 1);
+      }
+    }
+    if (node.items && !Array.isArray(node.items)) {
+      result.items = resolve(node.items, new Set(visited), depth + 1);
+    }
+    for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+      if (node[combinator]) {
+        result[combinator] = node[combinator].map((s) => resolve(s, new Set(visited), depth + 1));
+      }
+    }
+    return result;
+  }
+  const isArray = schema.type === "array";
+  let rootSchema = schema;
+  if (isArray && schema.items && !Array.isArray(schema.items)) {
+    rootSchema = schema.items;
+  }
+  return {
+    schema: resolve(rootSchema, /* @__PURE__ */ new Set, 0),
+    isArray
+  };
+}
+function resolveLocalRef(root, node) {
+  if (!node || typeof node.$ref !== "string")
+    return node;
+  const match = node.$ref.match(/^#\/(definitions|\$defs)\/(.+)$/);
+  if (!match)
+    return node;
+  const bucket = root[match[1]];
+  return bucket?.[match[2]] ?? node;
+}
+function resolveConnectorOutputSchema(rawOutputJsonSchema, fieldsContainer) {
+  if (!rawOutputJsonSchema || typeof rawOutputJsonSchema !== "object")
+    return;
+  const schema = sanitizeConnectorSchema(rawOutputJsonSchema);
+  if (!schema.type && !schema.properties && !schema.$ref && !schema.definitions && !schema.$defs)
+    return;
+  const jsonSchemaType = typeof schema.type === "string" ? schema.type : "object";
+  const formatFields = fieldsContainer ? collectResponseFieldFormats(fieldsContainer) : [];
+  if (formatFields.length > 0) {
+    const stamped = structuredClone(schema);
+    for (const field of formatFields) {
+      const target = findSchemaNodeByFieldPath(stamped, field.name.split("."));
+      if (target)
+        applyStringFormat(target, field.format);
+    }
+    return { jsonSchemaType, schema: stamped };
+  }
+  return { jsonSchemaType, schema };
+}
+function resolveConnectorOutputTypeSchema(inputsDetail) {
+  if (!inputsDetail || typeof inputsDetail !== "object")
+    return;
+  const configuration = parseConfigurationJson(inputsDetail.configuration);
+  const fieldsContainer = configuration?.fieldsContainer;
+  return resolveConnectorOutputSchema(fieldsContainer?.outputJsonSchema, fieldsContainer);
+}
+function collectResponseFieldFormats(fieldsContainer) {
+  const raw = [
+    ...Array.isArray(fieldsContainer.inputFields) ? fieldsContainer.inputFields : [],
+    ...Array.isArray(fieldsContainer.outputFields) ? fieldsContainer.outputFields : []
+  ];
+  const fields = [];
+  for (const field of raw) {
+    if (typeof field?.name !== "string" || !field.name)
+      continue;
+    if (typeof field.format !== "string" || !field.format)
+      continue;
+    if (field.response !== true)
+      continue;
+    fields.push({ name: field.name, format: field.format });
+  }
+  return fields;
+}
+function applyStringFormat(node, format) {
+  if (node.format)
+    return;
+  if (node.type === "string" || Array.isArray(node.type) && node.type.includes("string")) {
+    node.format = format;
+  } else if (node.type === "array" && node.items && !Array.isArray(node.items)) {
+    applyStringFormat(node.items, format);
+  }
+}
+function findSchemaNodeByFieldPath(root, segments) {
+  let node = root;
+  for (const segment of segments) {
+    node = resolveLocalRef(root, node);
+    const properties = node?.properties;
+    node = properties?.[segment];
+    if (!node)
+      return;
+  }
+  return resolveLocalRef(root, node);
+}
+function resolveNodeOutputTypeSchema(nodeType, inputsDetail, outputKey) {
+  if (outputKey !== "output")
+    return;
+  if (nodeType.startsWith(CONNECTOR_NODE_PREFIX)) {
+    return resolveConnectorOutputTypeSchema(inputsDetail);
+  }
+  return;
+}
+function createWorkflowVariable(options) {
+  return {
+    id: options.id,
+    direction: options.direction,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.schema && { schema: options.schema },
+    ...options.defaultValue !== undefined && { defaultValue: options.defaultValue },
+    ...options.description && { description: options.description }
+  };
+}
+function createNodeVariable(options) {
+  return {
+    id: `${options.nodeId}.${options.outputId}`,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.description && { description: options.description },
+    ...options.schema && { schema: options.schema },
+    binding: {
+      nodeId: options.nodeId,
+      outputId: options.outputId
+    }
+  };
+}
+function generateNodeVariables(nodes, definitions) {
+  const generatedVariables = [];
+  const definitionOutputs = /* @__PURE__ */ new Map;
+  for (const def of definitions) {
+    if (def.outputDefinition && Object.keys(def.outputDefinition).length > 0) {
+      definitionOutputs.set(def.nodeType, def.outputDefinition);
+    }
+  }
+  for (const node of nodes) {
+    const nodeOutputs = node.outputs ?? {};
+    const outputs = Object.keys(nodeOutputs).length > 0 ? nodeOutputs : definitionOutputs.get(node.type) ?? {};
+    for (const [outputKey, outputDef] of Object.entries(outputs)) {
+      if (outputDef && typeof outputDef === "object") {
+        const def = outputDef;
+        const resolved = resolveNodeOutputTypeSchema(node.type, node.inputs?.detail, outputKey);
+        generatedVariables.push(createNodeVariable({
+          nodeId: node.id,
+          outputId: outputKey,
+          type: resolved?.jsonSchemaType ?? def.type,
+          subType: def.subType,
+          description: def.description,
+          schema: def.schema
+        }));
+      }
+    }
+  }
+  return generatedVariables;
+}
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-BTLI3M56.js
+var globImport_locales_json = __glob({
+  "../../locales/de.json": () => import("./de-7XQXX2DK-tqdy5n2b.js"),
+  "../../locales/en.json": () => import("./en-5ZGC5VQ3-h581y30k.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-U2VN3SZW-anynsmd8.js"),
+  "../../locales/es.json": () => import("./es-ZGCPPOME-8gazspjj.js"),
+  "../../locales/fr.json": () => import("./fr-T3G5GZCT-y3f7xb1q.js"),
+  "../../locales/ja.json": () => import("./ja-BI5K3JDZ-77zat4z2.js"),
+  "../../locales/ko.json": () => import("./ko-JOBF5V7N-4bv0mjje.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-7DYX2YPT-fqxqzqtf.js"),
+  "../../locales/pt.json": () => import("./pt-HTXGGX6Y-97t21dty.js"),
+  "../../locales/ro.json": () => import("./ro-KTNQ3MNU-y08n1x5g.js"),
+  "../../locales/ru.json": () => import("./ru-GSCT4ARZ-1sa9wbr8.js"),
+  "../../locales/tr.json": () => import("./tr-XHSSPNK7-cmqyc4wd.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-2EHQT23P-mr63c4xz.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-MGZCE5BT-c4ekmrz9.js")
+});
+var MANIFEST_NAMESPACE = "manifest";
+var registerFlowCoreI18n = createI18nRegistrar({
+  namespace: MANIFEST_NAMESPACE,
+  englishBundle: en_default,
+  loadCatalog: (lng) => globImport_locales_json(`../../locales/${lng}.json`)
+});
+
+export { parseConfigurationJson, resolveJsonSchema, resolveConnectorOutputSchema, createWorkflowVariable, createNodeVariable, generateNodeVariables, MANIFEST_NAMESPACE, registerFlowCoreI18n };
+
+//# debugId=F276D2300BE3F86B64756E2164756E21