@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/services/expression-validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Expression type checking for `flow validate` (MST-12984).
+ *
+ * Delegates to @uipath/flow-expression-model — the same rule and inference
+ * cascade the Flow canvas runs, over its headless ts.LanguageService backend.
+ * The shared core assembles the compilation unit, so both surfaces check
+ * byte-identical content on the TypeScript version Monaco bundles.
+ *
+ * Findings are warnings by default (canvas severity parity) and are promoted
+ * to errors under `--strict-expressions`. The check always runs; the headless
+ * module carries the pinned compiler, so it is imported lazily.
+ */
+import type { CheckWorkflowExpressionsInput } from "@uipath/flow-expression-model";
+import type { ValidationIssue } from "./node-validators/index.js";
+/**
+ * The graph the checker consumes. Owned by the package — a `.flow` file is
+ * already this shape — so the CLI does not restate node/edge/definition
+ * fields that would drift from it.
+ */
+export type ExpressionCheckGraph = CheckWorkflowExpressionsInput;
+/**
+ * Type-check every expression and script body in one graph level
+ * (root or a single subflow — mirrors how the structural rules run per
+ * level). `pathPrefix` matches the service's subflow prefixing
+ * (`subflows[<id>].`); `strict` promotes findings from warning to error,
+ * which is what makes them fail validation.
+ */
+export declare function validateExpressions(graph: ExpressionCheckGraph, pathPrefix: string, strict?: boolean): Promise<ValidationIssue[]>;

package/dist/services/flow-eval-schema/types.d.ts

@@ -50,6 +50,7 @@ export interface Simulation {
     simulationInstruction?: string;
     mockValue?: unknown;
     outputSchema?: unknown;
+    childSimulations?: Simulation[];
 }
 export interface Evaluation {
     id: string;
@@ -61,8 +62,22 @@ export interface Evaluation {
     createdAt?: string | Date;
     updatedAt?: string | Date;
 }
+export type EvaluationSetTarget = {
+    kind: "agentNode";
+    nodeId: string;
+} | {
+    kind: "documentClassification";
+    nodeId: string;
+} | {
+    kind: "documentExtraction";
+    nodeId: string;
+} | {
+    kind: "flow";
+    entrypoint?: string;
+};
 export interface EvaluationSet {
     version: string;
+    schemaVersion?: number;
     id: string;
     name: string;
     description?: string;
@@ -71,8 +86,10 @@ export interface EvaluationSet {
     batchSize?: number;
     timeoutMinutes?: number;
     fileName?: string;
+    target?: EvaluationSetTarget;
     selectedEntrypoint?: string;
     nodeEval?: boolean;
+    targetKind?: string;
     createdAt?: string | Date;
     updatedAt?: string | Date;
 }

package/dist/services/flow-validate-service.d.ts

@@ -59,6 +59,16 @@ export interface FlowValidateOptions {
      * opt in via `--strict-bindings` to fail the build instead.
      */
     strictBindings?: boolean;
+    /**
+     * Promote expression and script type errors from warning to error, which
+     * is what makes them fail validation. The check itself always runs — it
+     * uses the shared Flow expression checker (@uipath/flow-expression-model,
+     * the same rule and inference the canvas runs, on a headless TypeScript
+     * language service pinned to the canvas worker's TS version) and reports
+     * warnings by default. Mirrors `strictBindings`: advisory unless a CI gate
+     * opts in, here via `--strict-expressions` (MST-12984).
+     */
+    strictExpressions?: boolean;
     /**
      * Test/host override for the connector catalog used by the binding-shape
      * validator. Supplying this skips the `loadRegistry()` cache lookup.
@@ -74,6 +84,7 @@ export declare class FlowValidateService {
     private readonly validateCurrentManifests;
     private readonly currentManifestOverrides?;
     private readonly strictBindings;
+    private readonly strictExpressions;
     private readonly connectorCatalogOverride?;
     private currentManifestCache?;
     private connectorCatalogCache?;
@@ -259,6 +270,21 @@ export declare class FlowValidateService {
      */
     private enrichInlineAgentPromptIssues;
     private validateGraph;
+    /**
+     * A Merge (`core.logic.merge` → `bpmn:ParallelGateway`) waits for a token on
+     * EVERY incoming edge; a Decision/Switch emits exactly one. So a Merge whose
+     * incoming paths all come from different ports of the same Decision/Switch
+     * can never complete — the run hangs at the gateway with no incident and
+     * `flow debug` polls until `--timeout`. The format allows it and the runtime
+     * cannot recover, so validate refuses it.
+     *
+     * Exact, not heuristic: each incoming edge is walked upstream through
+     * single-predecessor nodes; the Merge is flagged only when every walk ends
+     * at the SAME Decision/Switch and at least two left it through DIFFERENT
+     * ports. A join after a parallel fork (several edges out of one port) or
+     * with an unrelated extra input is left alone.
+     */
+    private validateExclusiveBranchJoins;
     private validateEdgeReferences;
     private validateNodeTypeDefinitions;
     private validateUniqueIds;

package/dist/services/node-validators/js-expression-syntax-validator.d.ts

@@ -14,9 +14,12 @@ import type { FlowNodeValidator } from "./types.js";
  *    one issue at `inputs.script`.
  * 2. **Connector / HTTP nodes** — every canvas-authored `jsExpression` or
  *    legacy `=js:`-prefixed string under
- *    `inputs.detail.{body,query,path}Parameters` is an expression. Parse its
- *    body as an expression; a `SyntaxError` becomes one issue at the field's
- *    path. Plain literals and `=jsonString:` values are skipped.
+ *    `inputs.detail.{body,query,path}Parameters`, and under
+ *    `inputs.detail.filterVariables` (the `=js:` operands a compiled
+ *    `--detail.filter` moves out of the CEQL text as `{var_…}` placeholders),
+ *    is an expression. Parse its body as an expression; a `SyntaxError`
+ *    becomes one issue at the field's path. Plain literals and `=jsonString:`
+ *    values are skipped.
  *
  * Scope mirrors `expression-prefix-validator` exactly: connector activity nodes
  * (`uipath.connector.*`, excluding triggers / wait-for-event), managed and

package/dist/services/tidy-service.d.ts

@@ -0,0 +1,26 @@
+interface TidyResult {
+    nodeCount: number;
+    edgeCount: number;
+    nodesRepositioned: number;
+    nodesResized: number;
+    subflowsTidied: number;
+    /** Total `variables.nodes` entries (top-level + every subflow) after regeneration. */
+    variableCount: number;
+}
+export declare const UI_ONLY_NODE_TYPES: Set<string>;
+/**
+ * Tidy up node positions in a .flow file using the ELK layout engine.
+ * Reads the file, computes optimal positions for the top-level workflow
+ * AND every subflow, and writes the result back.
+ *
+ * Also regenerates `variables.nodes` from current nodes + definitions
+ * (top-level and per subflow), matching what `uip maestro flow node add`
+ * and the canvas / Studio Web save path do. Without this regeneration,
+ * direct-authored `.flow` files that skip the `variables.nodes` block
+ * silently produce BPMN with no process-level `<uipath:inputOutput>`
+ * declarations — downstream `$vars.<sourceNodeId>.output` references then
+ * resolve to `undefined` at runtime even though `flow validate` passes
+ * (MST-9972).
+ */
+export declare function tidyFlow(filePath: string): Promise<TidyResult>;
+export {};

package/dist/services/vars-reference-rule.d.ts

@@ -0,0 +1,156 @@
+/**
+ * `$vars` reference resolution — a structural rule for `uip maestro flow validate`.
+ *
+ * Root cause (2026-09-02 v1-arm batch RCA: skill-flow-move-node,
+ * skill-flow-wiki-pageviews, skill-flow-ipe-jira-search-triage,
+ * skill-flow-devcon-billing-dispute-resolution): agents shipped flows whose
+ * expressions named things the runtime never had — a node id with a typo
+ * (`$vars.fetchWikimediaPageviews` for `fetchWikimediaPageviews1`), a node that
+ * runs AFTER the reader (a Decision moved before the Script its `expression`
+ * still read), an output variable the producer does not declare
+ * (`$vars.<decision>.output.matchedCaseId`; a Decision exposes `matchedCaseId`
+ * directly), a property read on an array-typed output, and an inline-agent
+ * input bound to a node on another Switch arm. Every one of them passed
+ * `validate` (the 09-02 move-node and wiki-pageviews artifacts validated
+ * `Valid` with zero warnings) and faulted at `flow debug` — `[400302]`,
+ * `[300501]`, `[400300]`, or a silent empty value.
+ *
+ * `@uipath/flow-schema`'s `expression-ref` rule used to cover part of this
+ * class, for `=js:` strings and expression objects under `inputs`, dot access
+ * only, with its unknown-root check off unless the caller supplied
+ * `workflowVariableIds` (the CLI never did). `flow validate` no longer runs it:
+ * it read a producer's declared output `type` and called anything but
+ * `object`/`array` a closed primitive, so it refused deep reads of the `any`
+ * that script, transform and loop `currentItem` outputs declare, and no edit to
+ * the `.flow` could suppress it. This rule owns that structural class outright
+ * now, including the graph question the schema could not ask: does the
+ * referenced node RUN before the reader?
+ *
+ * For every `$vars` reference in a node's `inputs` (plain strings such as a
+ * Script body, a Decision/Switch condition or a Transform `collection`, and
+ * `=js:` values), in `outputs.*.source`, and in the node's `variableUpdates` —
+ * dot form, bracket form (`$vars['a']['b']`, `$vars["a.b"]`) and optional
+ * chaining alike:
+ *
+ *  1. the root segment is a workflow variable or a node in this scope
+ *     (otherwise: unresolved, with the nearest node id as a hint);
+ *  2. a node root is an ancestor of the reader — on some path from a trigger
+ *     to the reader (otherwise the value is never set when the expression is
+ *     evaluated);
+ *  3. the second segment is an output the producer declares (its instance
+ *     `outputs` or its definition's `outputDefinition`), in every reference
+ *     form — dot-form `=js:` inputs were left to the schema rule until it
+ *     stopped running;
+ *  4. an identifier read on an output the definition types as `array` — or
+ *     a connector `output` whose `inputs.detail.inputMetadata.operation` is
+ *     `list` (every configured list node carries it; the `definitions[]`
+ *     type is only rewritten by a fresh `node configure`) — is an Array
+ *     member (`.output.issues` on a list result is undefined). An error only
+ *     where the reference IS the value (`collection: "=js:$vars.x.output.issues"`
+ *     faults the Loop, [400008]); embedded in a larger expression it is a
+ *     warning — `array.items` is undefined without a throw, and archived
+ *     passes branch on the shape (`Array.isArray(o) ? o : o.issues`; one
+ *     2026-07 Drive list even returned an `items` envelope);
+ *  5. an inline-agent input binding (`agentInputVariables[].binding`) names a
+ *     node that runs on EVERY path to the agent — a parallel branch counts, an
+ *     exclusive branch does not (`[400300]` is certain on the other arm).
+ *     On agent bindings only this check and (4) run: their existence, ancestry
+ *     and output-name checks are `validateAgentInputScopeRefs`'s (which also
+ *     reads the agent.json schema keys), so one defect is reported once.
+ *
+ * Severity: a node INPUT that cannot resolve faults the node, so (1)–(5) are
+ * errors there (`validateAgentInputScopeRefs`'s no-edge-path finding on an
+ * agent binding is an error for the same reason — the same fact, the same
+ * `[400300]`); a read the author guarded with optional chaining right after
+ * the segment that is undefined (`$vars.x?.output.y` for (1), (2) and (5),
+ * `$vars.x.output?.y` for (3), `$vars.x.output.items?.y` for (4)) short-circuits
+ * to undefined instead of faulting, so it is reported as a warning — an
+ * earlier `?.` does not help (`a?.b.c` throws at `.c` when `a` exists and
+ * `a.b` does not), and a `?.` with nothing read after it changes nothing
+ * (`$vars.x?.output` is `$vars.x.output`); an End's
+ * `outputs.*.source` and variable updates evaluate leniently (an undefined
+ * intermediate yields null — archived debug-graded passes carry such reads),
+ * so every finding there is a warning.
+ *
+ * JavaScript texts (a Script node's `inputs.script`, `=js:` strings and
+ * `jsExpression` objects) are scanned with their `//` and `/* *\/` comments
+ * removed, so a commented-out reference left behind by an edit is not a
+ * finding. String and template literals are kept: `${$vars.x.y}` is evaluated,
+ * and a plain string mentioning `$vars` is rare enough to accept.
+ *
+ * Overlap with the expression type checker (`expression-validator.ts`, the
+ * canvas's `@uipath/flow-expression-model`): it also reports an unresolved
+ * `$vars` root in a Script body, as `[EXPRESSION_DIAGNOSTIC]`. It is not
+ * deduplicated here on purpose: that checker is a warning unless
+ * `--strict-expressions` (canvas severity parity), so on its own it does not
+ * fail a build; it models only nodes that expose an `output` (a Decision, whose
+ * outputs are all primitives, is absent from its `$vars` type altogether);
+ * and its diagnostic is a TypeScript property error on the `$vars` type
+ * (`Property 'checkTemperature' does not exist on type {...}`) — it cannot say
+ * WHICH of (1)–(4) failed or what to write instead. This rule is the
+ * structural answer and the one that fails the build.
+ *
+ * A reader with no incoming edge at all has no run order yet, so (2) and (5)
+ * are skipped for it (the connection rules report the unwired node).
+ *
+ * Self-references are allowed everywhere (an HTTP `branches[].conditionExpression`
+ * and a `variableUpdates` entry legitimately read their own node). Loop bodies
+ * read `$vars.<loopId>.currentItem`; the loop node is their ancestor through its
+ * inner `start` port, so nothing special is needed. Cycles (a loop body's edge
+ * back into the loop's `loopBack` port) are fine for ancestry and are cut for
+ * the every-path analysis.
+ *
+ * Archive scan before shipping (9,016 archived eval `.flow` files, 2026-05 →
+ * 2026-09-02, re-run 2026-09-03 after the review changes): one error on a
+ * debug-graded run that passed — a billing run whose agent binding names a
+ * node behind a Decision arm (5) and whose graded debug took the arm where it
+ * ran; the other arm faults, so it stays an error. Every other finding on such
+ * runs is a warning by the rules above ((4) embedded in guarded JavaScript,
+ * `outputs.*.source` reads, `?.`-guarded roots).
+ */
+import type { ValidationIssue } from "./node-validators/index.js";
+export interface VarsRefFlow {
+    nodes: Array<{
+        id: string;
+        type: string;
+        typeVersion?: string;
+        display?: {
+            label?: string;
+        } & Record<string, unknown>;
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
+        model?: Record<string, unknown>;
+    }>;
+    edges: Array<{
+        sourceNodeId: string;
+        sourcePort: string;
+        targetNodeId: string;
+        targetPort: string;
+    }>;
+    definitions: Array<{
+        nodeType: string;
+        version: string;
+        outputDefinition?: Record<string, unknown>;
+        model?: {
+            type?: string;
+        } & Record<string, unknown>;
+    }>;
+    variables?: unknown;
+}
+export interface VarsRefOptions {
+    /**
+     * Roots known outside this scope's own `variables.globals` — the parent
+     * flow's globals when validating a subflow body. Never a node id.
+     */
+    extraKnownRoots?: Iterable<string>;
+}
+/**
+ * Remove `//` and `/* *\/` comments from JavaScript source, keeping string and
+ * template literals verbatim (a `//` inside `'https://x'` is not a comment).
+ * Regex literals are NOT tracked: a `//` inside one (`split(/\/\//)`) opens a
+ * line comment and drops the rest of that line — a missed reference at worst,
+ * never a false finding. Output length may differ from the input; only the
+ * presence of references matters downstream.
+ */
+export declare function stripJsComments(source: string): string;
+export declare function validateVarsReferences(flow: VarsRefFlow, options?: VarsRefOptions): ValidationIssue[];

package/dist/shared-utils-8xdq6f04.js

@@ -0,0 +1,20 @@
+import {
+  VALID_PACKAGE_NAME_REGEX,
+  VALID_PROJECT_NAME_REGEX,
+  formatTraceLine,
+  formatTraceStatus
+} from "./packager-tool-eypvc2kv.js";
+import {
+  readStdin
+} from "./packager-tool-5qaxht3k.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  VALID_PACKAGE_NAME_REGEX,
+  VALID_PROJECT_NAME_REGEX,
+  formatTraceLine,
+  formatTraceStatus,
+  readStdin
+};
+
+//# debugId=5DDAF54C1A74EC3564756E2164756E21

package/dist/tidy-service-ashgyfwj.js

@@ -0,0 +1,34 @@
+import {
+  UI_ONLY_NODE_TYPES,
+  tidyFlow
+} from "./packager-tool-4fhgws0x.js";
+import"./packager-tool-nq4rcqqg.js";
+import"./packager-tool-94w17vf8.js";
+import"./packager-tool-6m078z5s.js";
+import"./packager-tool-tn5e7wnb.js";
+import"./packager-tool-xhzfwa5p.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-rs6jm14d.js";
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-em5r6g6j.js";
+import"./packager-tool-9bec251q.js";
+import"./packager-tool-z9bfhmm5.js";
+import"./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-5qaxht3k.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  UI_ONLY_NODE_TYPES,
+  tidyFlow
+};
+
+//# debugId=4D181BAF29BCAEC864756E2164756E21

package/dist/tool.js

@@ -1,42 +1,39 @@
 import {
   metadata,
   registerCommands
-} from "./packager-tool-8mqydhz8.js";
-import"./packager-tool-pbsghbmj.js";
-import"./packager-tool-hr0xg6q8.js";
-import"./packager-tool-3vdpx9ng.js";
-import"./packager-tool-7yjpwj92.js";
-import"./packager-tool-3y0k15sv.js";
-import"./packager-tool-0sz8se22.js";
-import"./packager-tool-pkq70dec.js";
-import"./packager-tool-cvwr40ax.js";
-import"./packager-tool-9qecd4wb.js";
+} from "./packager-tool-nxx8naxv.js";
+import"./packager-tool-tf3d2y8z.js";
+import"./packager-tool-7b6tpg7y.js";
+import"./packager-tool-27avrkyk.js";
+import"./packager-tool-a1hbfmws.js";
+import"./packager-tool-cdwpc9fh.js";
+import"./packager-tool-g9y14b10.js";
+import"./packager-tool-5z1eg3ea.js";
+import"./packager-tool-v9rrz038.js";
+import"./packager-tool-fjaa8d3v.js";
+import"./packager-tool-v9psxdy5.js";
+import"./packager-tool-ywqc9rtf.js";
+import"./packager-tool-f0kd5kq4.js";
+import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
-import"./packager-tool-1cb0d5e0.js";
-import"./packager-tool-5arsyj36.js";
-import"./packager-tool-17cn3xb7.js";
-import"./packager-tool-1gt6js73.js";
-import"./packager-tool-nkrmjr3a.js";
-import"./packager-tool-y3dezh8k.js";
-import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-v74yk918.js";
-import"./packager-tool-xj0agqpk.js";
-import"./packager-tool-3wygxefb.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-7exrv6w7.js";
+import"./packager-tool-eypvc2kv.js";
+import"./packager-tool-5qaxht3k.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-p9stswjj.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-m6x5sczh.js";
-import"./packager-tool-vdd02vns.js";
-import"./packager-tool-p9j43p8h.js";
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-78a3szsp.js";
-import"./packager-tool-0567pxpm.js";
-import"./packager-tool-6ejqwbw9.js";
-import"./packager-tool-mcaf4ewf.js";
-import"./packager-tool-tq9q9m77.js";
+import"./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
 import"./packager-tool-c23zrhj8.js";
-import"./packager-tool-wckvcay0.js";
+import"./packager-tool-1yh8g550.js";
 export {
-  registerCommands,
-  metadata
+  metadata,
+  registerCommands
 };
 
-//# debugId=DB8CA9AE7108C55164756E2164756E21
+//# debugId=A619C849012DC6F164756E2164756E21

package/dist/{tr-AA6O2WSR-ga1xnymp.js → tr-AA6O2WSR-86ba4bdf.js}

@@ -1,5 +1,5 @@
 import"./packager-tool-c23zrhj8.js";
-import"./packager-tool-wckvcay0.js";
+import"./packager-tool-1yh8g550.js";
 
 // ../../node_modules/@uipath/flow-schema/dist/tr-AA6O2WSR.js
 var agentDuplicateToolNames_duplicateName_message = 'Araç adı "{{name}}" bu aracıda birden çok araç tarafından kullanılıyor. Her aracın benzersiz bir adı olmalıdır.';
@@ -105,57 +105,57 @@ var tr_default = {
   triggerRequired_message
 };
 export {
-  triggerRequired_message,
-  singleConversationTrigger_message,
-  scriptBody_mustache_message,
-  schemaValidator_validation_genericError,
-  schemaValidator_typeMismatch_message,
-  schemaValidator_required_message,
-  schemaValidator_outOfRange_message,
-  schemaValidator_invalidPattern_message,
-  schemaValidator_invalidField_message,
-  schemaValidator_invalidEnum_message,
-  schemaValidator_genericKeyword_message,
-  outputMapping_missing_message,
-  ixpSchemaDraft_invalid_message,
-  ixpSchemaDraft_invalidWithDetail_message,
-  hitlQuickForm_fieldLabelRequired_message,
-  hitlQuickForm_emptySchema_message,
-  governance_temperatureExceeded_message,
-  governance_noAllowedModel_message,
-  governance_modelNotAvailable_message,
-  governance_maxTokensExceeded_message,
-  governance_maxIterationsExceeded_message,
-  governance_hitlRequired_message,
-  escalation_recipientRequired_message,
-  escalation_quickFormDuplicateFieldLabel_message,
-  escalation_nameRequired_message,
-  escalation_appRequired_message,
-  doWhile_limitOutOfRange_message,
-  tr_default as default,
-  dataTransform_noOperations_message,
-  dataTransform_missingCollection_message,
-  dataTransform_mapNoMappings_message,
-  dataTransform_mapMissingField_message,
-  dataTransform_groupByMissingField_message,
-  dataTransform_groupByAggMissingOutputName_message,
-  dataTransform_groupByAggMissingField_message,
-  dataTransform_filterNoConditions_message,
-  dataTransform_filterMissingField_message,
-  dataTransform_customScriptMissing_message,
-  conversationalVoice_callContextRequired_message,
-  conversationalVoice_callContextInvalid_message,
-  conversationalVoiceEndCall_callContextInvalid_message,
-  conditionExpression_required_message,
-  conditionExpression_invalid_message,
-  conditionExpression_incomplete_message,
-  conditionExpression_decisionWrapped_message,
-  agentInputRefs_unresolvedRef_message,
-  agentInputRefs_reservedNamespace_message,
-  agentInputRefs_reservedMetadataRoot_message,
-  agentInputRefs_ambiguousUnderscoreRoot_message,
+  agentDuplicateToolNames_duplicateName_message,
   agentEmptyVar_unwrittenVariable_message,
-  agentDuplicateToolNames_duplicateName_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,
+  tr_default as default,
+  doWhile_limitOutOfRange_message,
+  escalation_appRequired_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=C2862495F148A43D64756E2164756E21
+//# debugId=E6C2DC498B428E2364756E2164756E21

package/dist/tr-GSQQ6SOT-hv1gyeaa.js

@@ -0,0 +1,35 @@
+import"./packager-tool-m3wkcxf5.js";
+import"./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-expression-model/dist/tr-GSQQ6SOT.js
+var expressionDiagnostic_dollarHint_replacement = ". `$vars.<name>`, `$kendi.<field>` veya tanımlanmış başka bir değişken.";
+var schemaPanel_arrayItemType_description = "Dizi öğesi türü";
+var scopeService_outputDescription_fallback = "{{nodeLabel}} kaynaklı çıkış";
+var scopeService_variableName_containsDotsError = "Değişken adı nokta içeremez";
+var scopeService_variableName_containsSpacesError = "Değişken adı boşluk içeremez";
+var scopeService_variableName_invalidCharactersError = "Değişken adı yalnızca harf, sayı ve alt çizgi içermelidir";
+var scopeService_variableName_reservedWordError = '"{{name}}" ayrılmış bir sözcük';
+var scopeService_variableName_startsWithNumberError = "Değişken adı bir sayıyla başlayamaz";
+var tr_default = {
+  expressionDiagnostic_dollarHint_replacement,
+  schemaPanel_arrayItemType_description,
+  scopeService_outputDescription_fallback,
+  scopeService_variableName_containsDotsError,
+  scopeService_variableName_containsSpacesError,
+  scopeService_variableName_invalidCharactersError,
+  scopeService_variableName_reservedWordError,
+  scopeService_variableName_startsWithNumberError
+};
+export {
+  tr_default as default,
+  expressionDiagnostic_dollarHint_replacement,
+  schemaPanel_arrayItemType_description,
+  scopeService_outputDescription_fallback,
+  scopeService_variableName_containsDotsError,
+  scopeService_variableName_containsSpacesError,
+  scopeService_variableName_invalidCharactersError,
+  scopeService_variableName_reservedWordError,
+  scopeService_variableName_startsWithNumberError
+};
+
+//# debugId=807168016D0709C264756E2164756E21