fix(scripts): resolve i18n check script path and logic issues (#23069)

web/i18n-config/auto-gen-i18n.js

 const fs = require('node:fs')
 const path = require('node:path')
+const vm = require('node:vm')
 const transpile = require('typescript').transpile
 const magicast = require('magicast')
 const { parseModule, generateCode, loadFile } = magicast
 }, {})
 
 async function translateMissingKeyDeeply(sourceObj, targetObject, toLanguage) {
+  const skippedKeys = []
+  const translatedKeys = []
+
   await Promise.all(Object.keys(sourceObj).map(async (key) => {
     if (targetObject[key] === undefined) {
       if (typeof sourceObj[key] === 'object') {
         targetObject[key] = {}
-        await translateMissingKeyDeeply(sourceObj[key], targetObject[key], toLanguage)
+        const result = await translateMissingKeyDeeply(sourceObj[key], targetObject[key], toLanguage)
+        skippedKeys.push(...result.skipped)
+        translatedKeys.push(...result.translated)
       }
       else {
         try {
             targetObject[key] = ''
             return
           }
-          // not support translate with '(' or ')'
-          if (source.includes('(') || source.includes(')'))
+
+          // Only skip obvious code patterns, not normal text with parentheses
+          const codePatterns = [
+            /\{\{.*\}\}/, // Template variables like {{key}}
+            /\$\{.*\}/, // Template literals ${...}
+            /<[^>]+>/, // HTML/XML tags
+            /function\s*\(/, // Function definitions
+            /=\s*\(/, // Assignment with function calls
+          ]
+
+          const isCodeLike = codePatterns.some(pattern => pattern.test(source))
+          if (isCodeLike) {
+            console.log(`⏭️  Skipping code-like content: "${source.substring(0, 50)}..."`)
+            skippedKeys.push(`${key}: ${source}`)
             return
+          }
 
+          console.log(`🔄 Translating: "${source}" to ${toLanguage}`)
           const { translation } = await translate(sourceObj[key], null, languageKeyMap[toLanguage])
           targetObject[key] = translation
+          translatedKeys.push(`${key}: ${translation}`)
+          console.log(`✅ Translated: "${translation}"`)
         }
-        catch {
-          console.error(`Error translating "${sourceObj[key]}" to ${toLanguage}. Key: ${key}`)
+        catch (error) {
+          console.error(`❌ Error translating "${sourceObj[key]}" to ${toLanguage}. Key: ${key}`, error.message)
+          skippedKeys.push(`${key}: ${sourceObj[key]} (Error: ${error.message})`)
+
+          // Add retry mechanism for network errors
+          if (error.message.includes('network') || error.message.includes('timeout')) {
+            console.log(`🔄 Retrying translation for key: ${key}`)
+            try {
+              await new Promise(resolve => setTimeout(resolve, 1000)) // Wait 1 second
+              const { translation } = await translate(sourceObj[key], null, languageKeyMap[toLanguage])
+              targetObject[key] = translation
+              translatedKeys.push(`${key}: ${translation}`)
+              console.log(`✅ Retry successful: "${translation}"`)
+            }
+ catch (retryError) {
+              console.error(`❌ Retry failed for key ${key}:`, retryError.message)
+            }
+          }
         }
       }
     }
     else if (typeof sourceObj[key] === 'object') {
       targetObject[key] = targetObject[key] || {}
-      await translateMissingKeyDeeply(sourceObj[key], targetObject[key], toLanguage)
+      const result = await translateMissingKeyDeeply(sourceObj[key], targetObject[key], toLanguage)
+      skippedKeys.push(...result.skipped)
+      translatedKeys.push(...result.translated)
     }
   }))
+
+  return { skipped: skippedKeys, translated: translatedKeys }
 }
-async function autoGenTrans(fileName, toGenLanguage) {
-  const fullKeyFilePath = path.join(__dirname, i18nFolder, targetLanguage, `${fileName}.ts`)
-  const toGenLanguageFilePath = path.join(__dirname, i18nFolder, toGenLanguage, `${fileName}.ts`)
-  // eslint-disable-next-line sonarjs/code-eval
-  const fullKeyContent = eval(transpile(fs.readFileSync(fullKeyFilePath, 'utf8')))
-  // if toGenLanguageFilePath is not exist, create it
-  if (!fs.existsSync(toGenLanguageFilePath)) {
-    fs.writeFileSync(toGenLanguageFilePath, `const translation = {
+async function autoGenTrans(fileName, toGenLanguage, isDryRun = false) {
+  const fullKeyFilePath = path.resolve(__dirname, i18nFolder, targetLanguage, `${fileName}.ts`)
+  const toGenLanguageFilePath = path.resolve(__dirname, i18nFolder, toGenLanguage, `${fileName}.ts`)
+
+  try {
+    const content = fs.readFileSync(fullKeyFilePath, 'utf8')
+
+    // Create a safer module environment for vm
+    const moduleExports = {}
+    const context = {
+      exports: moduleExports,
+      module: { exports: moduleExports },
+      require,
+      console,
+      __filename: fullKeyFilePath,
+      __dirname: path.dirname(fullKeyFilePath),
+    }
+
+    // Use vm.runInNewContext instead of eval for better security
+    vm.runInNewContext(transpile(content), context)
+
+    const fullKeyContent = moduleExports.default || moduleExports
+
+    if (!fullKeyContent || typeof fullKeyContent !== 'object')
+      throw new Error(`Failed to extract translation object from ${fullKeyFilePath}`)
+
+    // if toGenLanguageFilePath is not exist, create it
+    if (!fs.existsSync(toGenLanguageFilePath)) {
+      fs.writeFileSync(toGenLanguageFilePath, `const translation = {
 }
 
 export default translation
 `)
-  }
-  // To keep object format and format it for magicast to work: const translation = { ... } => export default {...}
-  const readContent = await loadFile(toGenLanguageFilePath)
-  const { code: toGenContent } = generateCode(readContent)
-  const mod = await parseModule(`export default ${toGenContent.replace('export default translation', '').replace('const translation = ', '')}`)
-  const toGenOutPut = mod.exports.default
+    }
+    // To keep object format and format it for magicast to work: const translation = { ... } => export default {...}
+    const readContent = await loadFile(toGenLanguageFilePath)
+    const { code: toGenContent } = generateCode(readContent)
+    const mod = await parseModule(`export default ${toGenContent.replace('export default translation', '').replace('const translation = ', '')}`)
+    const toGenOutPut = mod.exports.default
+
+    console.log(`\n🌍 Processing ${fileName} for ${toGenLanguage}...`)
+    const result = await translateMissingKeyDeeply(fullKeyContent, toGenOutPut, toGenLanguage)
+
+    // Generate summary report
+    console.log(`\n📊 Translation Summary for ${fileName} -> ${toGenLanguage}:`)
+    console.log(`  ✅ Translated: ${result.translated.length} keys`)
+    console.log(`  ⏭️  Skipped: ${result.skipped.length} keys`)
+
+    if (result.skipped.length > 0) {
+      console.log(`\n⚠️  Skipped keys in ${fileName} (${toGenLanguage}):`)
+      result.skipped.slice(0, 5).forEach(item => console.log(`    - ${item}`))
+      if (result.skipped.length > 5)
+        console.log(`    ... and ${result.skipped.length - 5} more`)
+    }
 
-  await translateMissingKeyDeeply(fullKeyContent, toGenOutPut, toGenLanguage)
-  const { code } = generateCode(mod)
-  const res = `const translation =${code.replace('export default', '')}
+    const { code } = generateCode(mod)
+    const res = `const translation =${code.replace('export default', '')}
 
 export default translation
 `.replace(/,\n\n/g, ',\n').replace('};', '}')
 
-  fs.writeFileSync(toGenLanguageFilePath, res)
+    if (!isDryRun) {
+      fs.writeFileSync(toGenLanguageFilePath, res)
+      console.log(`💾 Saved translations to ${toGenLanguageFilePath}`)
+    }
+ else {
+      console.log(`🔍 [DRY RUN] Would save translations to ${toGenLanguageFilePath}`)
+    }
+
+    return result
+  }
+ catch (error) {
+    console.error(`Error processing file ${fullKeyFilePath}:`, error.message)
+    throw error
+  }
+}
+
+// Add command line argument support
+const isDryRun = process.argv.includes('--dry-run')
+const targetFile = process.argv.find(arg => arg.startsWith('--file='))?.split('=')[1]
+const targetLang = process.argv.find(arg => arg.startsWith('--lang='))?.split('=')[1]
+
+// Rate limiting helper
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
 }
 
 async function main() {
-  // const fileName = 'workflow'
-  // Promise.all(Object.keys(languageKeyMap).map(async (toLanguage) => {
-  //   await autoGenTrans(fileName, toLanguage)
-  // }))
+  console.log('🚀 Starting auto-gen-i18n script...')
+  console.log(`📋 Mode: ${isDryRun ? 'DRY RUN (no files will be modified)' : 'LIVE MODE'}`)
+
   const files = fs
-    .readdirSync(path.join(__dirname, i18nFolder, targetLanguage))
-    .map(file => file.replace(/\.ts/, ''))
+    .readdirSync(path.resolve(__dirname, i18nFolder, targetLanguage))
+    .filter(file => /\.ts$/.test(file)) // Only process .ts files
+    .map(file => file.replace(/\.ts$/, ''))
     .filter(f => f !== 'app-debug') // ast parse error in app-debug
 
-  await Promise.all(files.map(async (file) => {
-    await Promise.all(Object.keys(languageKeyMap).map(async (language) => {
+  // Filter by target file if specified
+  const filesToProcess = targetFile ? files.filter(f => f === targetFile) : files
+  const languagesToProcess = targetLang ? [targetLang] : Object.keys(languageKeyMap)
+
+  console.log(`📁 Files to process: ${filesToProcess.join(', ')}`)
+  console.log(`🌍 Languages to process: ${languagesToProcess.join(', ')}`)
+
+  let totalTranslated = 0
+  let totalSkipped = 0
+  let totalErrors = 0
+
+  // Process files sequentially to avoid API rate limits
+  for (const file of filesToProcess) {
+    console.log(`\n📄 Processing file: ${file}`)
+
+    // Process languages with rate limiting
+    for (const language of languagesToProcess) {
       try {
-        await autoGenTrans(file, language)
+        const result = await autoGenTrans(file, language, isDryRun)
+        totalTranslated += result.translated.length
+        totalSkipped += result.skipped.length
+
+        // Rate limiting: wait 500ms between language processing
+        await delay(500)
       }
       catch (e) {
-        console.error(`Error translating ${file} to ${language}`, e)
+        console.error(`❌ Error translating ${file} to ${language}:`, e.message)
+        totalErrors++
       }
-    }))
-  }))
+    }
+  }
+
+  // Final summary
+  console.log('\n🎉 Auto-translation completed!')
+  console.log('📊 Final Summary:')
+  console.log(`  ✅ Total keys translated: ${totalTranslated}`)
+  console.log(`  ⏭️  Total keys skipped: ${totalSkipped}`)
+  console.log(`  ❌ Total errors: ${totalErrors}`)
+
+  if (isDryRun)
+    console.log('\n💡 This was a dry run. To actually translate, run without --dry-run flag.')
 }
 
 main()

web/i18n-config/check-i18n.js

 const fs = require('node:fs')
 const path = require('node:path')
+const vm = require('node:vm')
 const transpile = require('typescript').transpile
 
 const targetLanguage = 'en-US'
 const data = require('./languages.json')
 const languages = data.languages.filter(language => language.supported).map(language => language.value)
 
-async function getKeysFromLanuage(language) {
+async function getKeysFromLanguage(language) {
   return new Promise((resolve, reject) => {
-    const folderPath = path.join(__dirname, '../i18n', language)
-    let allKeys = []
+    const folderPath = path.resolve(__dirname, '../i18n', language)
+    const allKeys = []
     fs.readdir(folderPath, (err, files) => {
       if (err) {
         console.error('Error reading folder:', err)
         return
       }
 
-      files.forEach((file) => {
+      // Filter only .ts and .js files
+      const translationFiles = files.filter(file => /\.(ts|js)$/.test(file))
+
+      translationFiles.forEach((file) => {
         const filePath = path.join(folderPath, file)
         const fileName = file.replace(/\.[^/.]+$/, '') // Remove file extension
         const camelCaseFileName = fileName.replace(/[-_](.)/g, (_, c) =>
           c.toUpperCase(),
         ) // Convert to camel case
-        // console.log(camelCaseFileName)
-        const content = fs.readFileSync(filePath, 'utf8')
-        // eslint-disable-next-line sonarjs/code-eval
-        const translationObj = eval(transpile(content))
-        // console.log(translation)
-        if(!translationObj || typeof translationObj !== 'object') {
-          console.error(`Error parsing file: ${filePath}`)
-          reject(new Error(`Error parsing file: ${filePath}`))
-          return
-        }
-        const keys = Object.keys(translationObj)
-        const nestedKeys = []
-        const iterateKeys = (obj, prefix = '') => {
-          for (const key in obj) {
-            const nestedKey = prefix ? `${prefix}.${key}` : key
-            nestedKeys.push(nestedKey)
-            if (typeof obj[key] === 'object')
-              iterateKeys(obj[key], nestedKey)
+
+        try {
+          const content = fs.readFileSync(filePath, 'utf8')
+
+          // Create a safer module environment for vm
+          const moduleExports = {}
+          const context = {
+            exports: moduleExports,
+            module: { exports: moduleExports },
+            require,
+            console,
+            __filename: filePath,
+            __dirname: folderPath,
           }
-        }
-        iterateKeys(translationObj)
 
-        allKeys = [...keys, ...nestedKeys].map(
-          key => `${camelCaseFileName}.${key}`,
-        )
+          // Use vm.runInNewContext instead of eval for better security
+          vm.runInNewContext(transpile(content), context)
+
+          // Extract the translation object
+          const translationObj = moduleExports.default || moduleExports
+
+          if(!translationObj || typeof translationObj !== 'object') {
+            console.error(`Error parsing file: ${filePath}`)
+            reject(new Error(`Error parsing file: ${filePath}`))
+            return
+          }
+
+          const nestedKeys = []
+          const iterateKeys = (obj, prefix = '') => {
+            for (const key in obj) {
+              const nestedKey = prefix ? `${prefix}.${key}` : key
+              nestedKeys.push(nestedKey)
+              if (typeof obj[key] === 'object' && obj[key] !== null)
+                iterateKeys(obj[key], nestedKey)
+            }
+          }
+          iterateKeys(translationObj)
+
+          // Fixed: accumulate keys instead of overwriting
+          const fileKeys = nestedKeys.map(key => `${camelCaseFileName}.${key}`)
+          allKeys.push(...fileKeys)
+        }
+ catch (error) {
+          console.error(`Error processing file ${filePath}:`, error.message)
+          reject(error)
+        }
       })
       resolve(allKeys)
     })
 
 async function main() {
   const compareKeysCount = async () => {
-    const targetKeys = await getKeysFromLanuage(targetLanguage)
-    const languagesKeys = await Promise.all(languages.map(language => getKeysFromLanuage(language)))
+    const targetKeys = await getKeysFromLanguage(targetLanguage)
+    const languagesKeys = await Promise.all(languages.map(language => getKeysFromLanguage(language)))
 
     const keysCount = languagesKeys.map(keys => keys.length)
     const targetKeysCount = targetKeys.length

web/i18n/de-DE/app-annotation.ts

       bulkImport: 'Massenimport',
       bulkExport: 'Massenexport',
       clearAll: 'Alle Anmerkungen löschen',
+      clearAllConfirm: 'Alle Anmerkungen löschen?',
     },
   },
   editModal: {

web/i18n/de-DE/app.ts

   noAccessPermission: 'Keine Berechtigung zum Zugriff auf die Webanwendung',
   maxActiveRequests: 'Maximale gleichzeitige Anfragen',
   maxActiveRequestsPlaceholder: 'Geben Sie 0 für unbegrenzt ein',
+  maxActiveRequestsTip: 'Maximale Anzahl gleichzeitiger aktiver Anfragen pro App (0 für unbegrenzt)',
 }
 
 export default translation

web/i18n/de-DE/plugin.ts

       fixOnly: {
         name: 'Nur fixieren',
         selectedDescription: 'Auto-Update nur für Patch-Versionen',
+        description: 'Automatische Aktualisierung nur für Patchversionen (z. B. 1.0.1 → 1.0.2). Kleinere Versionsänderungen lösen keine Aktualisierungen aus.',
       },
       latest: {
         description: 'Immer auf die neueste Version aktualisieren',

web/i18n/de-DE/workflow.ts

           search: 'Suchmetadaten',
         },
         title: 'Metadatenfilterung',
+        tip: 'Metadatenfilterung ist der Prozess, Metadatenattribute (wie Tags, Kategorien oder Zugriffsberechtigungen) zu verwenden, um die Abfrage und Kontrolle der relevanten Informationen innerhalb eines Systems zu verfeinern.',
       },
     },
     http: {

web/i18n/es-ES/app-annotation.ts

       bulkImport: 'Importar en Masa',
       bulkExport: 'Exportar en Masa',
       clearAll: 'Borrar Todas las Anotaciones',
+      clearAllConfirm: '¿Eliminar todas las anotaciones?',
     },
   },
   editModal: {

web/i18n/es-ES/app.ts

   noAccessPermission: 'No se permite el acceso a la aplicación web',
   maxActiveRequestsPlaceholder: 'Introduce 0 para ilimitado',
   maxActiveRequests: 'Máximas solicitudes concurrentes',
+  maxActiveRequestsTip: 'Número máximo de solicitudes activas concurrentes por aplicación (0 para ilimitado)',
 }
 
 export default translation

web/i18n/es-ES/plugin.ts

       fixOnly: {
         name: 'Arreglar Solo',
         selectedDescription: 'Actualización automática solo para versiones de parches',
+        description: 'Actualización automática solo para versiones de parche (por ejemplo, 1.0.1 → 1.0.2). Los cambios de versión menor no activarán actualizaciones.',
       },
       latest: {
         selectedDescription: 'Siempre actualiza a la última versión',

web/i18n/es-ES/workflow.ts

           search: 'Buscar metadatos',
         },
         title: 'Filtrado de Metadatos',
+        tip: 'El filtrado de metadatos es el proceso de utilizar atributos de metadatos (como etiquetas, categorías o permisos de acceso) para refinar y controlar la recuperación de información relevante dentro de un sistema.',
       },
     },
     http: {

web/i18n/fa-IR/app-annotation.ts

       bulkImport: 'واردات انبوه',
       bulkExport: 'صادرات انبوه',
       clearAll: 'پاک کردن همه یادداشت‌ها',
+      clearAllConfirm: 'آیا همه حاشیه‌نویسی‌ها را حذف کنیم؟',
     },
   },
   editModal: {

web/i18n/fa-IR/app.ts

   noAccessPermission: 'دسترسی به برنامه وب مجاز نیست',
   maxActiveRequests: 'بیشترین درخواست‌های همزمان',
   maxActiveRequestsPlaceholder: 'برای نامحدود، 0 را وارد کنید',
+  maxActiveRequestsTip: 'حداکثر تعداد درخواست‌های فعال همزمان در هر برنامه (0 برای نامحدود)',
 }
 
 export default translation

web/i18n/fa-IR/plugin.ts

       fixOnly: {
         name: 'فقط تعمیر کنید',
         selectedDescription: 'به‌روزرسانی خودکار تنها برای نسخه‌های وصله',
+        description: 'به‌روزرسانی خودکار فقط برای نسخه‌های پچ (مانند ۱.۰.۱ → ۱.۰.۲). تغییرات جزئی نسخه باعث راه‌اندازی به‌روزرسانی‌ها نمی‌شود.',
       },
       latest: {
         name: 'جدیدترین',

web/i18n/fa-IR/workflow.ts

           conditions: 'شرایط',
         },
         title: 'فیلتر کردن فراداده',
+        tip: 'فیلتر کردن متاداده فرایند استفاده از ویژگی‌های متاداده (مانند برچسب‌ها، دسته‌ها یا مجوزهای دسترسی) برای تصفیه و کنترل بازیابی اطلاعات مرتبط در یک سیستم است.',
       },
     },
     http: {

web/i18n/fr-FR/app-annotation.ts

       bulkImport: 'Importation en Vrac',
       bulkExport: 'Exportation en Vrac',
       clearAll: 'Effacer toutes les annotations',
+      clearAllConfirm: 'Supprimer toutes les annotations ?',
     },
   },
   editModal: {

web/i18n/fr-FR/app.ts

   noAccessPermission: 'Pas de permission d\'accéder à l\'application web',
   maxActiveRequestsPlaceholder: 'Entrez 0 pour illimité',
   maxActiveRequests: 'Nombre maximal de requêtes simultanées',
+  maxActiveRequestsTip: 'Nombre maximum de requêtes actives concurrentes par application (0 pour illimité)',
 }
 
 export default translation

web/i18n/fr-FR/plugin.ts

       fixOnly: {
         selectedDescription: 'Mise à jour automatique uniquement pour les versions de correctif',
         name: 'Réparer seulement',
+        description: 'Mise à jour automatique uniquement pour les versions de correctif (par exemple, 1.0.1 → 1.0.2). Les changements de version mineure ne déclencheront pas de mises à jour.',
       },
       latest: {
         name: 'Dernier',

web/i18n/fr-FR/workflow.ts

           title: 'Conditions de filtrage des métadonnées',
         },
         title: 'Filtrage des métadonnées',
+        tip: 'Le filtrage des métadonnées est le processus d\'utilisation des attributs de métadonnées (tels que les étiquettes, les catégories ou les autorisations d\'accès) pour affiner et contrôler la récupération d\'informations pertinentes au sein d\'un système.',
       },
     },
     http: {

web/i18n/hi-IN/app-annotation.ts

       bulkImport: 'बल्क आयात',
       bulkExport: 'बल्क निर्यात',
       clearAll: 'सभी एनोटेशन साफ करें',
+      clearAllConfirm: 'क्या सभी टिप्पणियाँ हटानी हैं?',
     },
   },
   editModal: {

web/i18n/hi-IN/app.ts

   noAccessPermission: 'वेब एप्लिकेशन तक पहुँचने की अनुमति नहीं है',
   maxActiveRequests: 'अधिकतम समवर्ती अनुरोध',
   maxActiveRequestsPlaceholder: 'असीमित के लिए 0 दर्ज करें',
+  maxActiveRequestsTip: 'प्रति ऐप अधिकतम सक्रिय अनुरोधों की अधिकतम संख्या (असीमित के लिए 0)',
 }
 
 export default translation

web/i18n/hi-IN/plugin.ts

       fixOnly: {
         name: 'केवल ठीक करें',
         selectedDescription: 'केवल पैच संस्करणों के लिए स्वचालित अपडेट',
+        description: 'केवल पैच संस्करणों के लिए स्वचालित अद्यतन (जैसे, 1.0.1 → 1.0.2)। छोटा संस्करण परिवर्तन अद्यतन को ट्रिगर नहीं करेगा।',
       },
       latest: {
         name: 'नवीनतम',

web/i18n/hi-IN/workflow.ts

           search: 'खोज मेटाडेटा',
         },
         title: 'मेटाडेटा फ़िल्टरिंग',
+        tip: 'मेटाडेटा छानने की प्रक्रिया है जिसमें मेटाडेटा विशेषताओं (जैसे टैग, श्रेणियाँ, या पहुंच अनुमतियाँ) का उपयोग करके एक प्रणाली के भीतर प्रासंगिक जानकारी की पुनर्प्राप्ति को सुधारने और नियंत्रित करने के लिए किया जाता है।',
       },
     },
     http: {

web/i18n/it-IT/app-annotation.ts

       bulkImport: 'Importazione Bulk',
       bulkExport: 'Esportazione Bulk',
       clearAll: 'Cancella Tutte le Annotazioni',
+      clearAllConfirm: 'Eliminare tutte le annotazioni?',
     },
   },
   editModal: {

web/i18n/it-IT/app.ts

   noAccessPermission: 'Nessun permesso per accedere all\'app web',
   maxActiveRequestsPlaceholder: 'Inserisci 0 per illimitato',
   maxActiveRequests: 'Massimo numero di richieste concorrenti',
+  maxActiveRequestsTip: 'Numero massimo di richieste attive concorrenti per app (0 per illimitato)',
 }
 
 export default translation

web/i18n/it-IT/plugin.ts

       fixOnly: {
         name: 'Ripara solo',
         selectedDescription: 'Aggiornamento automatico solo per versioni patch',
+        description: 'Aggiornamento automatico solo per le versioni patch (ad es., 1.0.1 → 1.0.2). Le modifiche delle versioni minori non attiveranno aggiornamenti.',
       },
       latest: {
         selectedDescription: 'Aggiorna sempre all\'ultima versione',

web/i18n/it-IT/workflow.ts

           search: 'Cerca metadati',
         },
         title: 'Filtraggio dei metadati',
+        tip: 'Il filtraggio dei metadati è il processo di utilizzo degli attributi dei metadati (come tag, categorie o permessi di accesso) per affinare e controllare il recupero di informazioni pertinenti all\'interno di un sistema.',
       },
     },
     http: {

web/i18n/ja-JP/app.ts

   noAccessPermission: 'Web アプリにアクセス権限がありません',
   maxActiveRequestsPlaceholder: '無制限のために0を入力してください',
   maxActiveRequests: '最大同時リクエスト数',
+  maxActiveRequestsTip: 'アプリごとの同時アクティブリクエストの最大数（無制限の場合は0）',
 }
 
 export default translation

web/i18n/ja-JP/plugin.ts

       fixOnly: {
         name: '修正のみ',
         selectedDescription: 'パッチバージョンのみの自動更新',
+        description: 'パッチバージョンのみ自動更新 (例: 1.0.1 → 1.0.2)。マイナーバージョンの変更は更新をトリガーしません。',
       },
       latest: {
         name: '最新',

web/i18n/ko-KR/app-annotation.ts

       bulkImport: '일괄 가져오기',
       bulkExport: '일괄 내보내기',
       clearAll: '모든 어노테이션 지우기',
+      clearAllConfirm: '모든 주석을 삭제하시겠습니까?',
     },
   },
   editModal: {

web/i18n/ko-KR/app.ts

   noAccessPermission: '웹 앱에 대한 접근 권한이 없습니다.',
   maxActiveRequests: '동시 최대 요청 수',
   maxActiveRequestsPlaceholder: '무제한 사용을 원하시면 0을 입력하세요.',
+  maxActiveRequestsTip: '앱당 최대 동시 활성 요청 수(무제한은 0)',
 }
 
 export default translation

web/i18n/ko-KR/plugin.ts

       fixOnly: {
         name: '수정만 하기',
         selectedDescription: '패치 버전만 자동 업데이트',
+        description: '패치 버전만 자동 업데이트 (예: 1.0.1 → 1.0.2). 마이너 버전 변경은 업데이트를 유발하지 않습니다.',
       },
       latest: {
         name: '최신',

web/i18n/ko-KR/workflow.ts

           conditions: '조건',
         },
         title: '메타데이터 필터링',
+        tip: '메타데이터 필터링은 시스템 내에서 관련 정보를 검색하는 과정을 정제하고 제어하기 위해 메타데이터 속성(예: 태그, 카테고리 또는 접근 권한)을 사용하는 과정입니다.',
       },
     },
     http: {

web/i18n/pl-PL/app-annotation.ts

       bulkImport: 'Masowy import',
       bulkExport: 'Masowy eksport',
       clearAll: 'Wyczyść wszystkie adnotacje',
+      clearAllConfirm: 'Usunąć wszystkie adnotacje?',
     },
   },
   editModal: {

web/i18n/pl-PL/app.ts

   noAccessPermission: 'Brak uprawnień do dostępu do aplikacji internetowej',
   maxActiveRequests: 'Maksymalne równoczesne żądania',
   maxActiveRequestsPlaceholder: 'Wprowadź 0, aby uzyskać nielimitowane',
+  maxActiveRequestsTip: 'Maksymalna liczba jednoczesnych aktywnych żądań na aplikację (0 dla nieograniczonej)',
 }
 
 export default translation

web/i18n/pl-PL/plugin.ts

       fixOnly: {
         selectedDescription: 'Automatyczna aktualizacja tylko dla wersji poprawek',
         name: 'Napraw tylko',
+        description: 'Automatyczna aktualizacja tylko dla wersji łatkowych (np. 1.0.1 → 1.0.2). Zmiany w wersjach mniejszych nie będą wywoływać aktualizacji.',
       },
       latest: {
         name: 'Najświeższy',

web/i18n/pl-PL/workflow.ts

           select: 'Wybierz zmienną...',
         },
         title: 'Filtrowanie metadanych',
+        tip: 'Filtracja metadanych to proces wykorzystania atrybutów metadanych (takich jak tagi, kategorie lub uprawnienia dostępu) do precyzowania i kontrolowania pozyskiwania istotnych informacji w systemie.',
       },
     },
     http: {

web/i18n/pt-BR/app-annotation.ts

       bulkImport: 'Importação em Massa',
       bulkExport: 'Exportação em Massa',
       clearAll: 'Limpar Todas as Anotações',
+      clearAllConfirm: 'Excluir todas as anotações?',
     },
   },
   editModal: {

web/i18n/pt-BR/app.ts

   noAccessPermission: 'Sem permissão para acessar o aplicativo web',
   maxActiveRequestsPlaceholder: 'Digite 0 para ilimitado',
   maxActiveRequests: 'Máximo de solicitações simultâneas',
+  maxActiveRequestsTip: 'Número máximo de solicitações ativas simultâneas por aplicativo (0 para ilimitado)',
 }
 
 export default translation

web/i18n/pt-BR/plugin.ts

       fixOnly: {
         selectedDescription: 'Atualização automática apenas para versões de patch',
         name: 'Reparar Apenas',
+        description: 'Atualização automática apenas para versões de patch (por exemplo, 1.0.1 → 1.0.2). Mudanças de versão menor não ativarão atualizações.',
       },
       latest: {
         description: 'Sempre atualize para a versão mais recente',

web/i18n/pt-BR/workflow.ts

           placeholder: 'Insira o valor',
         },
         title: 'Filtragem de Metadados',
+        tip: 'A filtragem de metadados é o processo de usar atributos de metadados (como etiquetas, categorias ou permissões de acesso) para refinar e controlar a recuperação de informações relevantes dentro de um sistema.',
       },
     },
     http: {

web/i18n/ro-RO/app-annotation.ts

       bulkImport: 'Import în Masă',
       bulkExport: 'Export în Masă',
       clearAll: 'Șterge Toate Anotațiile',
+      clearAllConfirm: 'Șterge toate anotările?',
     },
   },
   editModal: {

web/i18n/ro-RO/app.ts

   noAccessPermission: 'Nici o permisiune pentru a accesa aplicația web',
   maxActiveRequestsPlaceholder: 'Introduceți 0 pentru nelimitat',
   maxActiveRequests: 'Maxime cereri simultane',
+  maxActiveRequestsTip: 'Numărul maxim de cereri active concurente pe aplicație (0 pentru nelimitat)',
 }
 
 export default translation

web/i18n/ro-RO/plugin.ts

       fixOnly: {
         selectedDescription: 'Actualizare automată doar pentru versiuni patch',
         name: 'Fix doar',
+        description: 'Actualizare automată doar pentru versiunile de patch (de exemplu, 1.0.1 → 1.0.2). Schimbările de versiune minore nu vor declanșa actualizări.',
       },
       latest: {
         name: 'Ultimul',

web/i18n/ro-RO/workflow.ts

           search: 'Căutare metadate',
         },
         title: 'Filtrarea metadatelor',
+        tip: 'Filtrarea metadatelor este procesul de utilizare a atributelor metadatelor (cum ar fi etichetele, categoriile sau permisiunile de acces) pentru a rafina și controla recuperarea informațiilor relevante într-un sistem.',
       },
     },
     http: {

web/i18n/ru-RU/app-annotation.ts

       bulkImport: 'Массовый импорт',
       bulkExport: 'Массовый экспорт',
       clearAll: 'Очистить все аннотации',
+      clearAllConfirm: 'Удалить все аннотации?',
     },
   },
   editModal: {

web/i18n/ru-RU/app.ts

   noAccessPermission: 'Нет разрешения на доступ к веб-приложению',
   maxActiveRequests: 'Максимальное количество параллельных запросов',
   maxActiveRequestsPlaceholder: 'Введите 0 для неограниченного количества',
+  maxActiveRequestsTip: 'Максимальное количество одновременно активных запросов на одно приложение (0 для неограниченного количества)',
 }
 
 export default translation

web/i18n/ru-RU/plugin.ts

       fixOnly: {
         name: 'Только исправить',
         selectedDescription: 'Автообновление только для версий патчей',
+        description: 'Автообновление только для патч-версий (например, 1.0.1 → 1.0.2). Изменения в минорных версиях не вызовут обновления.',
       },
       latest: {
         name: 'Новости',

web/i18n/ru-RU/workflow.ts

           search: 'Поиск метаданных',
         },
         title: 'Фильтрация метаданных',
+        tip: 'Фильтрация метаданных — это процесс использования атрибутов метаданных (таких как теги, категории или права доступа) для уточнения и контроля извлечения соответствующей информации внутри системы.',
       },
     },
     http: {

web/i18n/sl-SI/app-annotation.ts

       bulkImport: 'Množični uvoz',
       bulkExport: 'Množični izvoz',
       clearAll: 'Počisti vse opombe',
+      clearAllConfirm: 'Izbrišite vse opombe?',
     },
   },
   editModal: {

web/i18n/sl-SI/app.ts

   noAccessPermission: 'Brez dovoljenja za dostop do spletne aplikacije',
   maxActiveRequestsPlaceholder: 'Vnesite 0 za neomejeno',
   maxActiveRequests: 'Maksimalno število hkratnih zahtevkov',
+  maxActiveRequestsTip: 'Največje število hkrati aktivnih zahtevkov na aplikacijo (0 za neomejeno)',
 }
 
 export default translation

web/i18n/sl-SI/plugin.ts

       fixOnly: {
         name: 'Popravi samo',
         selectedDescription: 'Samodejno posodabljanje samo za različice popravkov',
+        description: 'Samodejno posodabljanje samo za različice popravkov (npr. 1.0.1 → 1.0.2). Spremembe manjših različic ne bodo povzročile posodobitev.',
       },
       latest: {
         selectedDescription: 'Vedno posodobite na najnovejšo različico',

web/i18n/sl-SI/workflow.ts

     'start': 'Določite začetne parametre za zagon delovnega toka',
     'variable-assigner': 'Združite večpodružinske spremenljivke v eno samo spremenljivko za enotno konfiguracijo spodnjih vozlišč.',
     'variable-aggregator': 'Združite večpodružnične spremenljivke v eno samo spremenljivko za enotno konfiguracijo spodnjih vozlišč.',
+    'assigner': 'Vožnji vozlišča za dodelitev spremenljivk se uporablja za dodeljevanje vrednosti spremenljivkam, ki jih je mogoče zapisati (kot so spremenljivke za pogovor).',
   },
   operator: {
     zoomOut: 'Zoomirati ven',
     organizeBlocks: 'Organizirajte vozlišča',
     minimize: 'Izhod iz celotnega zaslona',
     maximize: 'Maksimiziraj platno',
+    optional: '(neobvezno)',
   },
   nodes: {
     common: {
           add: 'Dodaj pogoj',
         },
         title: 'Filtriranje metapodatkov',
+        tip: 'Filtriranje metapodatkov je postopek uporabe metapodatkovnih atributov (kot so oznake, kategorije ali dovoljenja za dostop) za natančnejše določanje in nadzorovanje pridobivanja relevantnih informacij znotraj sistema.',
       },
       queryVariable: 'Vprašanje spremenljivka',
       knowledge: 'Znanje',

web/i18n/th-TH/app-annotation.ts

       bulkImport: 'นําเข้าจํานวนมาก',
       bulkExport: 'ส่งออกจํานวนมาก',
       clearAll: 'ล้างคําอธิบายประกอบทั้งหมด',
+      clearAllConfirm: 'ลบหมายเหตุต่างๆ ทั้งหมดหรือไม่?',
     },
   },
   editModal: {

web/i18n/th-TH/app.ts

   noAccessPermission: 'ไม่มีสิทธิ์เข้าถึงเว็บแอป',
   maxActiveRequestsPlaceholder: 'ใส่ 0 สำหรับไม่จำกัด',
   maxActiveRequests: 'จำนวนคำขอพร้อมกันสูงสุด',
+  maxActiveRequestsTip: 'จำนวนการร้องขอที่ใช้งานพร้อมกันสูงสุดต่อแอป (0 หมายถึงไม่จำกัด)',
 }
 
 export default translation

web/i18n/th-TH/plugin.ts

       fixOnly: {
         name: 'ซ่อมเฉพาะ',
         selectedDescription: 'อัปเดตอัตโนมัติเฉพาะเวอร์ชันแพตช์เท่านั้น',
+        description: 'การอัปเดตอัตโนมัติสำหรับเฉพาะเวอร์ชันแพทช์ (เช่น 1.0.1 → 1.0.2) การเปลี่ยนแปลงเวอร์ชันย่อยจะไม่ทำให้เกิดการอัปเดต',
       },
       latest: {
         name: 'ล่าสุด',

web/i18n/th-TH/workflow.ts

           placeholder: 'ใส่ค่า',
         },
         title: 'การกรองข้อมูลเมตา',
+        tip: 'การกรองข้อมูลเมตาดาต้าเป็นกระบวนการที่ใช้คุณลักษณะของเมตาดาต้า (เช่น แท็ก หมวดหมู่ หรือสิทธิการเข้าถึง) เพื่อปรับแต่งและควบคุมการดึงข้อมูลที่เกี่ยวข้องภายในระบบ.',
       },
     },
     http: {

web/i18n/tr-TR/app-annotation.ts

       bulkImport: 'Toplu İçe Aktarma',
       bulkExport: 'Toplu Dışa Aktarma',
       clearAll: 'Tüm Ek Açıklamaları Temizle',
+      clearAllConfirm: 'Tüm açıklamaları silinsin mi?',
     },
   },
   editModal: {

web/i18n/tr-TR/app.ts

   noAccessPermission: 'Web uygulamasına erişim izni yok',
   maxActiveRequestsPlaceholder: 'Sınırsız için 0 girin',
   maxActiveRequests: 'Maksimum eş zamanlı istekler',
+  maxActiveRequestsTip: 'Her uygulama için maksimum eşzamanlı aktif istek sayısı (sınırsız için 0)',
 }
 
 export default translation

web/i18n/tr-TR/plugin.ts

       fixOnly: {
         selectedDescription: 'Sadece yamanın versiyonları için otomatik güncelleme',
         name: 'Sadece Düzelt',
+        description: 'Yalnızca yamanın sürüm güncellemeleri için otomatik güncelleme (örneğin, 1.0.1 → 1.0.2). Küçük sürüm değişiklikleri güncellemeleri tetiklemez.',
       },
       latest: {
         name: 'Son',

web/i18n/tr-TR/workflow.ts

           datePlaceholder: 'Bir zaman seçin...',
         },
         title: 'Meta Verileri Filtreleme',
+        tip: 'Metadata filtreleme, bir sistem içinde ilgili bilgilerin alınmasını ince ayar ve kontrol etmek için metadata özniteliklerini (etiketler, kategoriler veya erişim izinleri gibi) kullanma sürecidir.',
       },
     },
     http: {

web/i18n/uk-UA/app-annotation.ts

       bulkImport: 'Масовий імпорт',
       bulkExport: 'Масовий експорт',
       clearAll: 'Очистити всі анотації',
+      clearAllConfirm: 'Видалити всі анотації?',
     },
   },
   editModal: {

web/i18n/uk-UA/app.ts

   noAccessPermission: 'Немає дозволу на доступ до веб-додатку',
   maxActiveRequestsPlaceholder: 'Введіть 0 для необмеженого',
   maxActiveRequests: 'Максимальна кількість одночасних запитів',
+  maxActiveRequestsTip: 'Максимальна кількість одночасних активних запитів на додаток (0 для необмеженої кількості)',
 }
 
 export default translation

web/i18n/uk-UA/plugin.ts

       fixOnly: {
         name: 'Виправити тільки',
         selectedDescription: 'Автоматичне оновлення лише для версій патчів',
+        description: 'Автооновлення лише для патч-версій (наприклад, 1.0.1 → 1.0.2). Зміни в малих версіях не активують оновлення.',
       },
       latest: {
         name: 'Останні',

web/i18n/uk-UA/workflow.ts

           add: 'Додати умову',
         },
         title: 'Фільтрація метаданих',
+        tip: 'Фільтрація метаданих — це процес використання атрибутів метаданих (таких як теги, категорії або права доступу) для уточнення та контролю отримання відповідної інформації в системі.',
       },
     },
     http: {

web/i18n/vi-VN/app-annotation.ts

       bulkImport: 'Nhập hàng loạt',
       bulkExport: 'Xuất hàng loạt',
       clearAll: 'Xóa tất cả chú thích',
+      clearAllConfirm: 'Xóa tất cả các chú thích?',
     },
   },
   editModal: {

web/i18n/vi-VN/app.ts

   accessControl: 'Kiểm soát truy cập ứng dụng web',
   maxActiveRequestsPlaceholder: 'Nhập 0 để không giới hạn',
   maxActiveRequests: 'Số yêu cầu đồng thời tối đa',
+  maxActiveRequestsTip: 'Số yêu cầu hoạt động đồng thời tối đa cho mỗi ứng dụng (0 để không giới hạn)',
 }
 
 export default translation

web/i18n/vi-VN/plugin.ts

       fixOnly: {
         name: 'Chỉ sửa chữa',
         selectedDescription: 'Tự động cập nhật chỉ cho các phiên bản bản vá',
+        description: 'Tự động cập nhật chỉ cho các phiên bản vá (ví dụ: 1.0.1 → 1.0.2). Thay đổi phiên bản nhỏ sẽ không kích hoạt cập nhật.',
       },
       latest: {
         name: 'Mới nhất',

web/i18n/vi-VN/workflow.ts

           search: 'Tìm kiếm siêu dữ liệu',
         },
         title: 'Lọc siêu dữ liệu',
+        tip: 'Lọc siêu dữ liệu là quá trình sử dụng các thuộc tính siêu dữ liệu (chẳng hạn như thẻ, danh mục hoặc quyền truy cập) để tinh chỉnh và kiểm soát việc truy xuất thông tin liên quan trong một hệ thống.',
       },
     },
     http: {

web/i18n/zh-Hant/app-annotation.ts

       bulkImport: '批次匯入',
       bulkExport: '批次匯出',
       clearAll: '刪除所有標註',
+      clearAllConfirm: '要刪除所有標註嗎？',
     },
   },
   editModal: {

web/i18n/zh-Hant/app.ts

   noAccessPermission: '沒有權限訪問網絡應用程式',
   maxActiveRequestsPlaceholder: '輸入 0 以表示無限',
   maxActiveRequests: '同時最大請求數',
+  maxActiveRequestsTip: '每個應用程式可同時活躍請求的最大數量（0為無限制）',
 }
 
 export default translation

web/i18n/zh-Hant/plugin.ts

       fixOnly: {
         name: '僅修理',
         selectedDescription: '僅限於修補版本的自動更新',
+        description: '僅為補丁版本自動更新（例如：1.0.1 → 1.0.2）。次要版本變更不會觸發更新。',
       },
       latest: {
         description: '始終更新至最新版本',

web/i18n/zh-Hant/workflow.ts

           placeholder: '輸入數值',
         },
         title: '元數據過濾',
+        tip: '元數據過濾是使用元數據屬性（如標籤、類別或訪問權限）來精煉和控制在系統內檢索相關信息的過程。',
       },
     },
     http: {