@uipath/maestro-tool 1.202.2 → 1.203.0-preview.180

package/dist/packager-tool.js

@@ -1,9 +1,13 @@
+import {
+  CaseToolFactory,
+  registerCaseBpmnCompiler
+} from "./packager-tool-kj0qc4f4.js";
 import {
   FlowToolFactory
-} from "./packager-tool-54b4v7wp.js";
-import"./packager-tool-29eg86w6.js";
+} from "./packager-tool-te6rrpsz.js";
+import"./packager-tool-6rsegsby.js";
+import"./packager-tool-wd01egnx.js";
 import"./packager-tool-2513jrxr.js";
-import"./packager-tool-7rz102fw.js";
 import {
   NugetConstants,
   NugetPackager,
@@ -13,26 +17,30 @@ import {
   TemporaryStorageService,
   ToolErrorCodes,
   ToolResult,
+  ZipService,
   ensureContentOperateFile,
   toolsFactoryRepository
-} from "./packager-tool-k4x5yn3p.js";
+} from "./packager-tool-khm7zsm8.js";
 import {
   BpmnValidateService
-} from "./packager-tool-15bstxb6.js";
-import"./packager-tool-jjpc0yka.js";
+} from "./packager-tool-y59jhapb.js";
+import"./packager-tool-vcjq9xkc.js";
 import {
   toolsFactoryRepository as toolsFactoryRepository2
 } from "./packager-tool-b803sdfp.js";
 import"./packager-tool-nkrmjr3a.js";
 import"./packager-tool-rs6jm14d.js";
 import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-ejyeka5x.js";
-import"./packager-tool-nxw5yzs7.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-r87gxwqa.js";
+import"./packager-tool-7q6z6npd.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-e8td7b01.js";
+import"./packager-tool-gpwec9sp.js";
+import"./packager-tool-vqcnvaae.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-d88rqwk8.js";
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-fvm2dddf.js";
 import"./packager-tool-p79yh9ww.js";
+import"./packager-tool-vdc8r21p.js";
 import"./packager-tool-z83pga0z.js";
 import"./packager-tool-6ejqwbw9.js";
 import"./packager-tool-mcaf4ewf.js";
@@ -205,7 +213,7 @@ class BpmnTool extends ProjectTool {
       isJsonObject,
       parseBpmnProcesses,
       parseOptionalJson
-    } = await import("./index-938ee96p.js");
+    } = await import("./index-rtg24r4x.js");
     let processes;
     let entryPoints;
     try {
@@ -339,6 +347,8 @@ toolsFactoryRepository.registerProjectToolFactory(new BpmnToolFactory);
 
 // ../packager/packager-tool-businessrules/dist/index.js
 var DmnExtension = ".dmn";
+var RuleArchiveExtension = ".uirule";
+var EntryPointsFileName = "entry-points.json";
 var ReservedInFileName = /[<>:"/\\|?*]/;
 function isUsableInFileName(name) {
   return !ReservedInFileName.test(name) && ![...name].some((character) => character.charCodeAt(0) < 32);
@@ -363,22 +373,38 @@ class BusinessRulesTool extends ProjectTool {
       if (ruleFiles.length === 0) {
         return ToolResult.error(ToolErrorCodes.InternalError, `No ${DmnExtension} file found in ${options.projectPath}.`, "Add a decision to the project, then pack again.");
       }
-      if (ruleFiles.length > 1) {
-        return ToolResult.error(ToolErrorCodes.InternalError, `Found ${ruleFiles.length} ${DmnExtension} files in ${options.projectPath}, expected one.`, `Keep one decision per project and move the rest to their own projects.`);
-      }
-      const sourceFile = ruleFiles[0];
       const ruleName = await this.resolveRuleName(options);
       if (ruleName === undefined) {
         return ToolResult.error(ToolErrorCodes.InternalError, `The project name in project.uiproj cannot be used in a file name.`, `Rename the project so its name has no path separators and none of < > : " | ? * characters.`);
       }
-      const targetName = `${ruleName}-${options.package.version}${DmnExtension}`;
-      const targetFile = Path.join(options.outputPath, targetName);
-      this.logger.progress(`Copying ${targetName}...`);
-      const content = await this.fileSystem.readFile(sourceFile);
-      if (!content) {
-        return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${sourceFile}.`);
+      const manifest = await this.fileSystem.readFile(Path.join(options.projectPath, EntryPointsFileName));
+      if (!manifest || manifest.length === 0) {
+        this.logger.warn(`No ${EntryPointsFileName} in ${options.projectPath}, so the rule ships as a ${DmnExtension} and exposes no arguments. Open the project in Studio Web and save it to write its entry points.`);
+        return this.copyRuleDocumentAsync(options, ruleFiles, ruleName);
+      }
+      const declared = this.readDeclaredDocuments(manifest);
+      if (declared === null) {
+        return ToolResult.error(ToolErrorCodes.InternalError, `${EntryPointsFileName} in ${options.projectPath} is not valid JSON.`, `Open the project in Studio Web and save it to rewrite its entry points, then pack again.`);
+      }
+      const entries = {
+        [EntryPointsFileName]: manifest
+      };
+      for (const ruleFile of ruleFiles) {
+        const content = await this.fileSystem.readFile(ruleFile);
+        if (!content) {
+          return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${ruleFile}.`);
+        }
+        entries[Path.basename(ruleFile)] = content;
+      }
+      const missing = this.declaredDocumentsMissingFrom(declared, entries);
+      if (missing.length > 0) {
+        return ToolResult.error(ToolErrorCodes.InternalError, `${EntryPointsFileName} names ${missing.join(", ")}, which ${missing.length === 1 ? "is" : "are"} not in ${options.projectPath}.`, `Move every .dmn the rule uses to the top level of the project, then pack again.`);
       }
-      await this.fileSystem.writeFile(targetFile, content);
+      const targetName = `${ruleName}-${options.package.version}${RuleArchiveExtension}`;
+      const targetFile = Path.join(options.outputPath, targetName);
+      this.logger.progress(`Packing ${ruleFiles.length} ${DmnExtension} file(s) into ${targetName}...`);
+      const archive = new ZipService(this.fileSystem).compressEntries(entries);
+      await this.fileSystem.writeFile(targetFile, archive);
       return new ToolResult(ToolErrorCodes.Success, "done", []);
     } catch (error) {
       const message = error instanceof Error ? error.toString() : String(error);
@@ -386,6 +412,19 @@ class BusinessRulesTool extends ProjectTool {
       return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing the Business Rules project");
     }
   }
+  async copyRuleDocumentAsync(options, ruleFiles, ruleName) {
+    if (ruleFiles.length > 1) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Found ${ruleFiles.length} ${DmnExtension} files in ${options.projectPath}, expected one.`, `Keep one decision per project and move the rest to their own projects, or save the project in Studio Web so its entry points name the callable one.`);
+    }
+    const content = await this.fileSystem.readFile(ruleFiles[0]);
+    if (!content) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${ruleFiles[0]}.`);
+    }
+    const targetName = `${ruleName}-${options.package.version}${DmnExtension}`;
+    this.logger.progress(`Copying ${targetName}...`);
+    await this.fileSystem.writeFile(Path.join(options.outputPath, targetName), content);
+    return new ToolResult(ToolErrorCodes.Success, "done", []);
+  }
   async resolveRuleName(options) {
     const uiProject = await this.getUiProjectAsync(options.projectPath);
     const declared = uiProject?.Name?.trim();
@@ -394,6 +433,18 @@ class BusinessRulesTool extends ProjectTool {
     }
     return isUsableInFileName(declared) ? declared : undefined;
   }
+  readDeclaredDocuments(manifest) {
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(manifest));
+      return (parsed.entryPoints ?? []).map((entryPoint) => entryPoint.filePath).filter((filePath) => !!filePath).map((filePath) => Path.basename(filePath.split("#")[0]));
+    } catch {
+      return null;
+    }
+  }
+  declaredDocumentsMissingFrom(declared, entries) {
+    const packed = new Set(Object.keys(entries));
+    return [...new Set(declared)].filter((document) => !packed.has(document));
+  }
   async findRuleFiles(projectPath) {
     const entries = await this.fileSystem.readdir(projectPath);
     const ruleFiles = [];
@@ -421,200 +472,6 @@ class BusinessRulesToolFactory {
 }
 toolsFactoryRepository.registerProjectToolFactory(new BusinessRulesToolFactory);
 
-// ../packager/packager-tool-case/src/case-bpmn-compiler.ts
-var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
-var _global = globalThis;
-function registerCaseBpmnCompiler(caseBpmnCompiler) {
-  _global[COMPILER_KEY] = caseBpmnCompiler;
-}
-function getCaseBpmnCompiler() {
-  return _global[COMPILER_KEY];
-}
-
-// ../packager/packager-tool-case/src/case-tool.ts
-var CaseConstants = {
-  EntryPointsFileName: "entry-points.json",
-  BindingsV2FileName: "bindings_v2.json",
-  CasePlanFileName: "caseplan.json",
-  CompiledBpmnFileName: "caseplan.json.bpmn"
-};
-
-class CaseTool extends ProjectTool {
-  _temporaryStorage;
-  constructor(fileSystem, logger) {
-    super(fileSystem, logger);
-    this._temporaryStorage = new TemporaryStorageService(fileSystem);
-  }
-  async restoreAsync(_options, _cancellationToken) {
-    this.logger.info("Restore operation is not required for Case Management projects");
-    return ToolResult.success();
-  }
-  async validateAsync(_options, _cancellationToken) {
-    this.logger.info("Validate operation is not required for Case Management projects");
-    return ToolResult.success();
-  }
-  async buildAsync(options, _cancellationToken) {
-    const tempFolder = await this._temporaryStorage.getTempFolderPath();
-    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
-    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
-    try {
-      this.logger.progress("Copying files...");
-      await this.copyFiles(options.projectPath, contentFolder);
-      this.logger.progress("Compiling case plan to BPMN...");
-      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
-      if (!compileResult.isSuccess) {
-        return compileResult;
-      }
-      this.logger.progress("Creating operate.json file...");
-      await this.createOperateFile(options, contentFolder);
-      this.logger.progress("Creating package-descriptor.json file...");
-      await this.createPackageDescriptor(localBuildFolder, contentFolder);
-      return new ToolResult(ToolErrorCodes.Success, "done", [
-        localBuildFolder
-      ]);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.toString() : String(error);
-      this.logger.error(errorMessage);
-      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while building Case Management project files");
-    }
-  }
-  async packAsync(options, cancellationToken) {
-    const buildResult = await this.buildAsync(options, cancellationToken);
-    if (!buildResult.isSuccess) {
-      return buildResult;
-    }
-    const localBuildFolder = buildResult.packages[0];
-    try {
-      this.logger.progress("Creating NuGet package...");
-      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
-      const packager = new NugetPackager(this.fileSystem);
-      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
-      this.logger.progress("Package created successfully");
-      return new ToolResult(ToolErrorCodes.Success, "done", [
-        result.outputPath
-      ]);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.toString() : String(error);
-      this.logger.error(errorMessage);
-      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing Case Management project");
-    }
-  }
-  async dispose() {
-    this.logger.info("Disposing Case Management Tool");
-    try {
-      await this._temporaryStorage.cleanup();
-    } catch {}
-  }
-  async copyFiles(sourcePath, contentFolder) {
-    await this.fileSystem.mkdir(contentFolder);
-    const files = await this.fileSystem.readdir(sourcePath);
-    for (const file of files) {
-      const sourceFile = Path.join(sourcePath, file);
-      const stat = await this.fileSystem.stat(sourceFile);
-      if (stat?.isFile()) {
-        const content = await this.fileSystem.readFile(sourceFile);
-        if (content) {
-          const destinationFile = Path.join(contentFolder, file);
-          await this.fileSystem.writeFile(destinationFile, content);
-        }
-      }
-    }
-  }
-  async compileCasePlan(projectPath, contentFolder) {
-    const compile = getCaseBpmnCompiler();
-    const casePlanPath = Path.join(projectPath, CaseConstants.CasePlanFileName);
-    if (!compile || !await this.fileSystem.exists(casePlanPath)) {
-      return this.checkEntryPointBpmnPresent(contentFolder);
-    }
-    const casePlan = await this.fileSystem.readFile(casePlanPath);
-    if (!casePlan || casePlan.length === 0) {
-      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.CasePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${CaseConstants.CompiledBpmnFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
-    }
-    try {
-      const bpmnXml = await compile(new TextDecoder().decode(casePlan));
-      await this.fileSystem.writeFile(Path.join(contentFolder, CaseConstants.CompiledBpmnFileName), bpmnXml);
-      return await this.checkEntryPointBpmnPresent(contentFolder);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error(message);
-      return ToolResult.error(ToolErrorCodes.InternalError, `Failed to compile '${CaseConstants.CasePlanFileName}' into '${CaseConstants.CompiledBpmnFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
-    }
-  }
-  async checkEntryPointBpmnPresent(contentFolder) {
-    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
-    if (referenced === null) {
-      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
-    }
-    if (referenced.length === 0) {
-      return ToolResult.success();
-    }
-    const contentFiles = await this.fileSystem.readdir(contentFolder);
-    const missing = referenced.filter((file) => !contentFiles.includes(file));
-    if (missing.length === 0) {
-      return ToolResult.success();
-    }
-    const fix = missing.includes(CaseConstants.CompiledBpmnFileName) ? `Author '${CaseConstants.CasePlanFileName}' so pack can compile it (see 'uip maestro case init'), then pack again.` : `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.`;
-    return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at ${missing.map((f) => `'content/${f}'`).join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job. ${fix}`);
-  }
-  async readEntryPointBpmnFiles(contentFolder) {
-    const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
-    if (!await this.fileSystem.exists(entryPointsPath)) {
-      return [];
-    }
-    const raw = await this.fileSystem.readFile(entryPointsPath);
-    if (!raw || raw.length === 0) {
-      return null;
-    }
-    try {
-      const parsed = JSON.parse(new TextDecoder().decode(raw));
-      const names = (parsed.entryPoints ?? []).map((entry) => entry.filePath ?? "").map((filePath) => filePath.split("#")[0]).map((filePath) => filePath.split("/").pop() ?? "").filter((name) => name.endsWith(".bpmn"));
-      return [...new Set(names)];
-    } catch {
-      return null;
-    }
-  }
-  async createOperateFile(options, contentFolder) {
-    await ensureContentOperateFile(this.fileSystem, {
-      contentFolder,
-      projectPath: options.projectPath,
-      projectStorageId: options.projectStorageId,
-      contentType: ProjectTypes.CaseManagement
-    });
-  }
-  async createPackageDescriptor(localBuildFolder, contentFolder) {
-    const descriptorFiles = {};
-    descriptorFiles[NugetConstants.OperateFileName] = Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
-    descriptorFiles[CaseConstants.EntryPointsFileName] = Path.join(NugetConstants.ContentFolderName, CaseConstants.EntryPointsFileName);
-    descriptorFiles[NugetConstants.BindingsFileId] = Path.join(NugetConstants.ContentFolderName, CaseConstants.BindingsV2FileName);
-    const contentFiles = await this.fileSystem.readdir(contentFolder);
-    for (const file of contentFiles) {
-      if (file.endsWith(".bpmn")) {
-        descriptorFiles[file] = Path.join(NugetConstants.ContentFolderName, file);
-      }
-    }
-    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
-    const packageDescriptorJson = JSON.stringify({
-      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-      files: descriptorFiles
-    }, null, 2);
-    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
-  }
-}
-
-// ../packager/packager-tool-case/src/case-tool-factory.ts
-class CaseToolFactory {
-  supportedTypes = [
-    ProjectTypes.CaseManagement
-  ];
-  async createAsync(logger, fileSystem) {
-    return new CaseTool(fileSystem, logger);
-  }
-}
-
-// ../packager/packager-tool-case/src/index.ts
-toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
-
 // ../packager/packager-tool-case/src/node.ts
 var compileCasePlan = async (casePlanJson) => {
   const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import("./index-k4xz16db.js").then((m)=>__toESM(m.default,1));
@@ -637,4 +494,4 @@ export {
   registerPackagerFactories
 };
 
-//# debugId=D742A2908BE14D8964756E2164756E21
+//# debugId=0E75987D6A81F03064756E2164756E21

package/dist/{project-artifacts-9z7atbk7.js → project-artifacts-h5cydk2n.js}

@@ -4,7 +4,7 @@ import {
 
 // ../case-tool/src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-yqfqxh2r.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-gvwc29bb.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 export {

package/dist/{project-validator-0rkrfmj0.js → project-validator-ek97s27p.js}

@@ -1,7 +1,7 @@
 import {
   BpmnValidateService,
   isIntsvcActivityExecutionV1
-} from "./packager-tool-15bstxb6.js";
+} from "./packager-tool-y59jhapb.js";
 import"./packager-tool-1yh8g550.js";
 export {
   BpmnValidateService,

package/dist/pt-3DIO5QWG-59b3f4bc.js

@@ -0,0 +1,173 @@
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/pt-3DIO5QWG.js
+var agentDuplicateToolNames_duplicateName_message = 'O nome da ferramenta "{{name}}" é utilizado por várias ferramentas neste agente. Cada ferramenta tem de ter um nome único.';
+var agentEmptyVar_unwrittenVariable_message = 'O agente utiliza "$vars.{{root}}" mas nenhum nó atribui um valor a "{{root}}", pelo que estará vazio no runtime. Associe-o a uma saída de nó (por exemplo, "<node>.output") ou atribua-lhe uma origem de valor.';
+var agentInputRefs_ambiguousUnderscoreRoot_message = 'O pedido referencia "$vars.{{ref}}", mas o nome "{{rootSegment}}" contém "__", que está reservado como o separador de codificação de entrada de agente e não pode fazer a viagem de ida e volta. Mude o nome para remover os carateres de sublinhado duplo.';
+var agentInputRefs_reservedMetadataRoot_message = 'O pedido referencia "$vars.{{ref}}", mas uma variável ou um nó com o nome "metadados" entra em conflito com a ferramenta "$metadata" o espaço de nomes é serializado uma vez para o agente e não pode ser de ida e volta. Mude o nome para algo diferente de "metadados".';
+var agentInputRefs_reservedNamespace_message = '"$agent.{{ref}}" é um espaço de nomes de runtime de agente interno do Fluxo e não pode ser utilizado diretamente em pedidos. Referencie a variável de fluxo através de "$vars.{{ref}}" ou "$metadata.{{ref}}" no seu lugar.';
+var agentInputRefs_unresolvedRef_message = 'O pedido referencia "$vars.{{ref}}" mas não existe nenhuma variável de fluxo de trabalho ou nó "{{rootSegment}}". Adicione a variável/nó ao fluxo ou remova a referência.';
+var conditionExpression_decisionWrapped_message = 'Condição inválida em "{{nodeLabel}}": {{error}}';
+var conditionExpression_incomplete_message = "Expressão incompleta";
+var conditionExpression_invalid_message = "Expressão inválida";
+var conditionExpression_required_message = "Adicionar uma condição";
+var conversationalVoiceEndCall_callContextInvalid_message = "{{label}}: o contexto da chamada tem de estar vinculado a um objeto de contexto de chamada";
+var conversationalVoice_callContextInvalid_message = "{{label}}: o contexto da chamada tem de estar vinculado a um objeto de contexto de chamada";
+var conversationalVoice_callContextRequired_message = "{{label}}: O contexto de chamada é necessário quando a voz está ativada";
+var dataTransform_customScriptMissing_message = 'A operação de script personalizada "{{nodeLabel}}" não tem script';
+var dataTransform_filterMissingField_message = 'A condição de filtro "{{nodeLabel}}" tem um campo em falta';
+var dataTransform_filterNoConditions_message = 'A operação de filtro "{{nodeLabel}}" não tem condições';
+var dataTransform_groupByAggMissingField_message = 'O grupo "{{nodeLabel}}" por agregação tem um campo em falta';
+var dataTransform_groupByAggMissingOutputName_message = 'O grupo "{{nodeLabel}}" por agregação tem um nome de saída em falta';
+var dataTransform_groupByMissingField_message = 'O grupo "{{nodeLabel}}" por operação não tem o grupo por campo';
+var dataTransform_mapMissingField_message = 'O mapeamento de campo do mapa "{{nodeLabel}}" tem um campo em falta';
+var dataTransform_mapNoMappings_message = 'A operação de mapa "{{nodeLabel}}" necessita de, pelo menos, um mapeamento de campo quando os campos originais não são mantidos';
+var dataTransform_missingCollection_message = '"{{nodeLabel}}" tem uma variável de coleção em falta';
+var dataTransform_noOperations_message = '"{{nodeLabel}}" não tem operações configuradas';
+var doWhile_limitOutOfRange_message = "Definir máximo de iterações entre {{min}} e {{max}}";
+var entityQuery_emptyFilterExpression_message = "Escrever uma expressão para cada filtro ou remover o filtro";
+var entityQuery_emptyFilterValueList_message = "Adicione pelo menos um valor ao filtro ou remova o filtro";
+var entityQuery_uncarryableExpression_message = "Armazene esta expressão numa variável ou escreva-a sem espaços, aspas ou barras invertidas";
+var escalation_appRequired_message = "Selecionar uma aplicação de ação";
+var escalation_memoryArgumentRequired_message = "{{label}}: adicione pelo menos um argumento para a memória de agente ou desative a memória de agente";
+var escalation_nameRequired_message = "{{label}}: O nome do escalamento é necessário";
+var escalation_quickFormDuplicateFieldLabel_message = '{{label}}: Vários campos estão etiquetados como "{{fieldLabel}}" – a tarefa de escalamento iria manter apenas um deles. Tornar as etiquetas de campos únicas';
+var escalation_recipientRequired_message = "{{label}}: É necessários um destinatário de escalamento";
+var governance_hitlRequired_message = "O agente tem de ter, pelo menos, um recurso de escalamento ou uma barreira de proteção com ação HITL. Regra imposta pela política de governação: {{policyName}}";
+var governance_maxIterationsExceeded_message = "O máximo de iterações ultrapassa {{maxIterations}}. Regra imposta pela política de governação: {{policyName}}";
+var governance_maxTokensExceeded_message = "O máximo de tokens por resposta excede {{maxTokens}}. Regra imposta pela política de governação: {{policyName}}";
+var governance_modelNotAvailable_message = "O modelo {{model}} não é permitido, aplicado pela política de governação: {{policyName}}";
+var governance_noAllowedModel_message = "Não foi selecionado um modelo permitido, aplicado pela política de governação: {{policyName}}";
+var governance_temperatureExceeded_message = "A temperatura ultrapassa {{maxTemperature}}. Regra imposta pela política de governação: {{policyName}}";
+var hitlQuickForm_emptySchema_message = "Adicione, pelo menos, um campo";
+var hitlQuickForm_fieldLabelRequired_message = "A etiqueta de campo é obrigatória";
+var ixpSchemaDraft_invalidWithDetail_message = 'O esquema não é válido em "{{nodeLabel}}": {{detail}}';
+var ixpSchemaDraft_invalid_message = 'O esquema não é válido em "{{nodeLabel}}".';
+var outputMapping_missing_message = '"{{nodeLabel}}" tem um mapeamento de saída em falta para "{{varId}}"';
+var schemaValidator_genericKeyword_message = '"{{fieldName}}" em "{{nodeLabel}}": {{detail}}';
+var schemaValidator_invalidEnum_message = '"{{fieldName}}" em "{{nodeLabel}}" tem de ser um dos valores permitidos';
+var schemaValidator_invalidField_message = '"{{fieldName}}" em "{{nodeLabel}}" é inválido';
+var schemaValidator_invalidPattern_message = '"{{fieldName}}" em "{{nodeLabel}}" tem um formato inválido';
+var schemaValidator_outOfRange_message = '"{{fieldName}}" em "{{nodeLabel}}" {{detail}}';
+var schemaValidator_required_message = '"{{fieldName}}" é necessário em "{{nodeLabel}}"';
+var schemaValidator_typeMismatch_message = '"{{fieldName}}" em "{{nodeLabel}}" espera {{type}}';
+var schemaValidator_validation_genericError = "Erro de validação";
+var scriptBody_mustache_message = "Variáveis de referência diretamente sem chavetas duplas";
+var singleConversationTrigger_message = "Apenas é permitido um acionador de conversação por processo. Remova o acionador adicional.";
+var triggerRequired_message = "O processo tem de ter, pelo menos, um nó de acionador";
+var pt_default = {
+  agentDuplicateToolNames_duplicateName_message,
+  agentEmptyVar_unwrittenVariable_message,
+  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentInputRefs_reservedMetadataRoot_message,
+  agentInputRefs_reservedNamespace_message,
+  agentInputRefs_unresolvedRef_message,
+  conditionExpression_decisionWrapped_message,
+  conditionExpression_incomplete_message,
+  conditionExpression_invalid_message,
+  conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
+  dataTransform_customScriptMissing_message,
+  dataTransform_filterMissingField_message,
+  dataTransform_filterNoConditions_message,
+  dataTransform_groupByAggMissingField_message,
+  dataTransform_groupByAggMissingOutputName_message,
+  dataTransform_groupByMissingField_message,
+  dataTransform_mapMissingField_message,
+  dataTransform_mapNoMappings_message,
+  dataTransform_missingCollection_message,
+  dataTransform_noOperations_message,
+  doWhile_limitOutOfRange_message,
+  entityQuery_emptyFilterExpression_message,
+  entityQuery_emptyFilterValueList_message,
+  entityQuery_uncarryableExpression_message,
+  escalation_appRequired_message,
+  escalation_memoryArgumentRequired_message,
+  escalation_nameRequired_message,
+  escalation_quickFormDuplicateFieldLabel_message,
+  escalation_recipientRequired_message,
+  governance_hitlRequired_message,
+  governance_maxIterationsExceeded_message,
+  governance_maxTokensExceeded_message,
+  governance_modelNotAvailable_message,
+  governance_noAllowedModel_message,
+  governance_temperatureExceeded_message,
+  hitlQuickForm_emptySchema_message,
+  hitlQuickForm_fieldLabelRequired_message,
+  ixpSchemaDraft_invalidWithDetail_message,
+  ixpSchemaDraft_invalid_message,
+  outputMapping_missing_message,
+  schemaValidator_genericKeyword_message,
+  schemaValidator_invalidEnum_message,
+  schemaValidator_invalidField_message,
+  schemaValidator_invalidPattern_message,
+  schemaValidator_outOfRange_message,
+  schemaValidator_required_message,
+  schemaValidator_typeMismatch_message,
+  schemaValidator_validation_genericError,
+  scriptBody_mustache_message,
+  singleConversationTrigger_message,
+  triggerRequired_message
+};
+export {
+  agentDuplicateToolNames_duplicateName_message,
+  agentEmptyVar_unwrittenVariable_message,
+  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentInputRefs_reservedMetadataRoot_message,
+  agentInputRefs_reservedNamespace_message,
+  agentInputRefs_unresolvedRef_message,
+  conditionExpression_decisionWrapped_message,
+  conditionExpression_incomplete_message,
+  conditionExpression_invalid_message,
+  conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
+  dataTransform_customScriptMissing_message,
+  dataTransform_filterMissingField_message,
+  dataTransform_filterNoConditions_message,
+  dataTransform_groupByAggMissingField_message,
+  dataTransform_groupByAggMissingOutputName_message,
+  dataTransform_groupByMissingField_message,
+  dataTransform_mapMissingField_message,
+  dataTransform_mapNoMappings_message,
+  dataTransform_missingCollection_message,
+  dataTransform_noOperations_message,
+  pt_default as default,
+  doWhile_limitOutOfRange_message,
+  entityQuery_emptyFilterExpression_message,
+  entityQuery_emptyFilterValueList_message,
+  entityQuery_uncarryableExpression_message,
+  escalation_appRequired_message,
+  escalation_memoryArgumentRequired_message,
+  escalation_nameRequired_message,
+  escalation_quickFormDuplicateFieldLabel_message,
+  escalation_recipientRequired_message,
+  governance_hitlRequired_message,
+  governance_maxIterationsExceeded_message,
+  governance_maxTokensExceeded_message,
+  governance_modelNotAvailable_message,
+  governance_noAllowedModel_message,
+  governance_temperatureExceeded_message,
+  hitlQuickForm_emptySchema_message,
+  hitlQuickForm_fieldLabelRequired_message,
+  ixpSchemaDraft_invalidWithDetail_message,
+  ixpSchemaDraft_invalid_message,
+  outputMapping_missing_message,
+  schemaValidator_genericKeyword_message,
+  schemaValidator_invalidEnum_message,
+  schemaValidator_invalidField_message,
+  schemaValidator_invalidPattern_message,
+  schemaValidator_outOfRange_message,
+  schemaValidator_required_message,
+  schemaValidator_typeMismatch_message,
+  schemaValidator_validation_genericError,
+  scriptBody_mustache_message,
+  singleConversationTrigger_message,
+  triggerRequired_message
+};
+
+//# debugId=A9081A724343C5DC64756E2164756E21