n8n 中文脚本

n8n汉化脚本
安裝腳本 ?
換行
// ==UserScript==
// @name         n8n 中文脚本
// @namespace    http://tampermonkey.net/
// @version      0.2.1
// @description  n8n汉化脚本
// @author       webcpy
// @license      GPLv3
// @match        http://localhost:5678/*
// @match        http://207.211.161.235:5678/*
// @match        https://n8n.dudoo.top/*
// @match        https://n8nt.dudoo.top/*
// @match        http://217.142.253.17:5678/*
// @match        http://127.0.0.1:5678/*
// @require https://unpkg.com/xhook@latest/dist/xhook.min.js
// @require https://unpkg.com/[email protected]/lodash.min.js
// @icon         https://www.google.com/s2/favicons?sz=64&domain=undefined.localhost
// @grant        none
// ==/UserScript==

(function () {
	'use strict';

	const scripts = document.querySelectorAll('link[href*="/assets/_MapCache"]');
    console.log(scripts,1234)

	scripts.forEach(script => {
		const fullUrl = script.href;
		console.log(fullUrl, '如脚本失效请打开此地址全局搜索‘i18n$1 as’ 后的变量替换 ')
		const url = new URL(fullUrl);
		window.indexScript = url.pathname; // 获取路径部分（如 "/assets/index-main.js"）
	});
	const script = document.createElement('script');
	script.type = 'module'; // 设置为 ES6 模块（如果需要）

	// 插入代码
	script.textContent = `
    import(window.indexScript).then((module) => {
		// 使用模块中的导出
    function getFieldsWithObjectContainingSetLocaleMessage(instance) {
      let result = '';

      // 获取实例的所有属性名
      const properties = Object.getOwnPropertyNames(instance);


      // 遍历属性
      for (const prop of properties) {
        const value = instance[prop];



        if (value !== null && typeof value === 'function' && value.name === 'useI18n') {
           if (value().setLocaleMessage) {
              result = value()
              break;
           }
           
        }

         // 检查是否是对象类型（排除 null 和数组）
        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
          // 检查对象中是否存在 setLocaleMessage 属性

          if ('i18n' in value) {
            result = prop;
            return instance[result].i18n
          }
        }
      }

      return result.i18n;
    }
    let i18nStr = ''
    if (!i18nStr) {
        console.log('脚本失效再此替换module.c_替换i18n$1 as后的变量', module)
    }

    const i18n = getFieldsWithObjectContainingSetLocaleMessage(module);


		i18n.setLocaleMessage('en', {
      ...i18n.messages.en,
      // 中文
      ...{
        "_reusableBaseText": {
          "cancel": "取消",
          "codeNodeEditor": {
            "linter": {
              "useJson": "通过\`.json\`访问项目属性，例如\`item.json\`"
            },
            "completer": {
              "all": "返回节点输出的所有项目数组",
              "first": "返回节点输出的第一个项目",
              "last": "返回节点输出的最后一个项目",
              "itemMatching": "返回匹配项目，即在指定索引处用于生成当前节点项目的项目"
            }
          },
          "name": "名称",
          "save": "保存",
          "dismiss": "忽略",
          "unlimited": "无限制",
          "activate": "激活",
          "error": "错误"
        },
        "_reusableDynamicText": {
          "readMore": "阅读更多",
          "learnMore": "了解更多",
          "moreInfo": "更多信息",
          "oauth2": {
            "clientId": "客户端ID",
            "clientSecret": "客户端密钥"
          }
        },
        "generic.annotations": "注释",
        "generic.annotationData": "高亮数据",
        "generic.any": "任意",
        "generic.cancel": "取消",
        "generic.open": "打开",
        "generic.close": "关闭",
        "generic.confirm": "确认",
        "generic.create": "创建",
        "generic.create.workflow": "创建工作流",
        "generic.deleteWorkflowError": "删除工作流时出现问题",
        "generic.filtersApplied": "当前已应用筛选器。",
        "generic.field": "字段",
        "generic.fields": "字段",
        "generic.folderCount": "文件夹 | {count} 文件夹 | {count} 个文件夹",
        "generic.folder": "文件夹",
        "generic.learnMore": "了解更多",
        "generic.reset": "重置",
        "generic.resetAllFilters": "重置所有筛选器",
        "generic.communityNode": "社区节点",
        "generic.communityNode.tooltip": "这是来自我们社区的一个节点。它是 {packageName} 包的一部分。<a href=\'{docURL}\' target=\'_blank\' title=\'阅读 n8n 文档\'>了解更多</a>",
        "generic.copy": "复制",
        "generic.delete": "删除",
        "generic.dontShowAgain": "不再显示",
        "generic.enterprise": "企业版",
        "generic.executions": "执行",
        "generic.tag_plural": "标签",
        "generic.tag": "标签 | {count} 标签",
        "generic.tests": "测试",
        "generic.optional": "可选",
        "generic.or": "或",
        "generic.clickToCopy": "点击复制",
        "generic.copiedToClipboard": "已复制到剪贴板",
        "generic.beta": "测试版",
        "generic.yes": "是",
        "generic.no": "否",
        "generic.rating": "评分",
        "generic.refresh": "刷新",
        "generic.retry": "重试",
        "generic.error": "出现了一些问题",
        "generic.settings": "设置",
        "generic.service": "服务",
        "generic.star": "星标",
        "generic.tryNow": "立即尝试",
        "generic.dismiss": "忽略",
        "generic.unsavedWork.confirmMessage.headline": "离开前保存更改吗？",
        "generic.unsavedWork.confirmMessage.message": "如果您不保存，所做的更改将会丢失。",
        "generic.unsavedWork.confirmMessage.confirmButtonText": "保存",
        "generic.unsavedWork.confirmMessage.cancelButtonText": "不保存而离开",
        "generic.upgrade": "升级",
        "generic.upgradeNow": "立即升级",
        "generic.credential": "凭据 | {count} 凭据 | {count} 凭据",
        "generic.workflow": "工作流 | {count} 工作流 | {count} 工作流",
        "generic.workflowSaved": "工作流更改已保存",
        "generic.editor": "编辑器",
        "generic.seePlans": "查看计划",
        "generic.loading": "加载中",
        "generic.and": "和",
        "generic.ownedByMe": "(您)",
        "generic.moreInfo": "更多信息",
        "generic.next": "下一步",
        "generic.pro": "专业版",
        "generic.variable_plural": "变量",
        "generic.folders_plural": "文件夹",
        "generic.variable": "变量 | {count} 变量",
        "generic.viewDocs": "查看文档",
        "generic.workflows": "工作流",
        "generic.rename": "重命名",
        "generic.missing.permissions": "缺少执行此操作的权限",
        "about.aboutN8n": "关于 n8n",
        "about.close": "关闭",
        "about.license": "许可证",
        "about.n8nLicense": "可持续使用许可证 + n8n 企业许可证",
        "about.n8nVersion": "n8n 版本",
        "about.sourceCode": "源代码",
        "about.instanceID": "实例 ID",
        "about.debug.title": "调试",
        "about.debug.message": "复制调试信息",
        "about.debug.toast.title": "调试信息",
        "about.debug.toast.message": "已将调试信息复制到剪贴板",
        "askAi.dialog.title": "'询问AI' 即将准备就绪",
        "askAi.dialog.body": "我们仍在进行最后的润色。很快，您就能从简单的文本提示中<strong>自动生成代码</strong>。加入等待列表以获取此功能的早期访问权限。",
        "askAi.dialog.signup": "加入等待列表",
        "activationModal.butYouCanSeeThem": "但你可以在",
        "activationModal.executionList": "执行列表",
        "activationModal.gotIt": "明白了",
        "activationModal.ifYouChooseTo": "如果你选择",
        "activationModal.saveExecutions": "保存执行。",
        "activationModal.theseExecutionsWillNotShowUp": "这些执行不会立即显示在编辑器中，",
        "activationModal.workflowActivated": "工作流已激活",
        "activationModal.yourTriggerWillNowFire": "您的触发器现在将自动启动生产执行。",
        "activationModal.yourTriggersWillNowFire": "您的触发器现在将自动启动生产执行。",
        "activationModal.yourWorkflowWillNowListenForEvents": "您的工作流现在将监听来自 {serviceName} 的事件并触发执行。",
        "activationModal.yourWorkflowWillNowRegularlyCheck": "您的工作流现在将定期检查 {serviceName} 的事件并为它们触发执行。",
        "annotationTagsManager.manageTags": "管理执行标签",
        "annotationTagsView.usage": "使用情况（所有工作流）",
        "annotationTagsView.inUse": "{count} 执行 | {count} 执行",
        "auth.changePassword": "更改密码",
        "auth.changePassword.currentPassword": "当前密码",
        "auth.changePassword.mfaCode": "双重验证代码",
        "auth.changePassword.error": "更改密码时出现问题",
        "auth.changePassword.missingTokenError": "缺少令牌",
        "auth.changePassword.missingUserIdError": "缺少用户ID",
        "auth.changePassword.passwordUpdated": "密码已更新",
        "auth.changePassword.passwordUpdatedMessage": "现在您可以使用新密码登录",
        "auth.changePassword.passwordsMustMatchError": "密码必须匹配",
        "auth.changePassword.reenterNewPassword": "重新输入新密码",
        "auth.changePassword.tokenValidationError": "无效的重置密码令牌",
        "auth.defaultPasswordRequirements": "8个以上字符，至少包含1个数字和1个大写字母",
        "auth.validation.missingParameters": "缺少令牌或用户ID",
        "auth.email": "电子邮件",
        "auth.firstName": "名字",
        "auth.lastName": "姓氏",
        "auth.newPassword": "新密码",
        "auth.password": "密码",
        "auth.role": "角色",
        "auth.roles.member": "成员",
        "auth.roles.admin": "管理员",
        "auth.roles.owner": "所有者",
        "auth.agreement.label": "我希望接收安全和产品更新",
        "auth.setup.next": "下一步",
        "auth.setup.settingUpOwnerError": "设置所有者时出现问题",
        "auth.setup.setupOwner": "设置所有者账户",
        "auth.signin": "登录",
        "auth.signin.error": "登录时出现问题",
        "auth.signout": "登出",
        "auth.signout.error": "无法登出",
        "auth.signup.finishAccountSetup": "完成账户设置",
        "auth.signup.missingTokenError": "缺少令牌",
        "auth.signup.setupYourAccount": "设置您的账户",
        "auth.signup.setupYourAccountError": "设置您的账户时出现问题",
        "auth.signup.tokenValidationError": "验证邀请令牌时出现问题",
        "aiAssistant.name": "助手",
        "aiAssistant.assistant": "AI助手",
        "aiAssistant.newSessionModal.title.part1": "开始新的",
        "aiAssistant.newSessionModal.title.part2": "会话",
        "aiAssistant.newSessionModal.message": "您已经有一个活跃的AI助手会话。开始一个新的会话将清除当前的对话历史。",
        "aiAssistant.newSessionModal.question": "您确定要开始一个新会话吗？",
        "aiAssistant.newSessionModal.confirm": "开始新会话",
        "aiAssistant.serviceError.message": "无法连接到n8n的AI服务（{message}）",
        "aiAssistant.payloadTooBig.message": "负载大小过大",
        "aiAssistant.codeUpdated.message.title": "助手修改了工作流",
        "aiAssistant.codeUpdated.message.body1": "打开",
        "aiAssistant.codeUpdated.message.body2": "节点以查看更改",
        "aiAssistant.thinkingSteps.analyzingError": "正在分析错误...",
        "aiAssistant.thinkingSteps.thinking": "思考中...",
        "aiAssistant.prompts.currentView.workflowList": "用户当前正在查看工作流列表。",
        "aiAssistant.prompts.currentView.credentialsList": "用户当前正在查看凭据列表。",
        "aiAssistant.prompts.currentView.executionsView": "用户当前正在查看当前打开的工作流的执行列表。",
        "aiAssistant.prompts.currentView.workflowEditor": "用户当前正在n8n编辑器中查看当前工作流，没有选择任何特定的节点。",
        "banners.confirmEmail.message.1": "为了保护您的账户并防止未来的访问问题，请确认您的",
        "banners.confirmEmail.message.2": "电子邮件地址。",
        "banners.confirmEmail.button": "确认电子邮件",
        "banners.confirmEmail.toast.success.heading": "确认邮件已发送",
        "banners.confirmEmail.toast.success.message": "请检查您的收件箱并点击确认链接。",
        "banners.confirmEmail.toast.error.heading": "发送确认邮件时出现问题",
        "banners.confirmEmail.toast.error.message": "请稍后再试。",
        "banners.nonProductionLicense.message": "此n8n实例未获得生产用途的许可。",
        "banners.trial.message": "{count}天后您的n8n试用期结束 | 您的n8n试用期还剩1天",
        "banners.trialOver.message": "您的试用期已结束。立即升级以继续自动化。",
        "banners.v1.message": "n8n已更新至版本1，引入了一些重大变更。有关更多信息，请参阅<a target=\'_blank\' href=\'https://docs.n8n.io/1-0-migration-checklist\'>迁移指南</a>。",
        "binaryDataDisplay.backToList": "返回列表",
        "binaryDataDisplay.backToOverviewPage": "返回概览页面",
        "binaryDataDisplay.noDataFoundToDisplay": "未找到要显示的数据",
        "binaryDataDisplay.yourBrowserDoesNotSupport": "您的浏览器不支持视频元素。请将其更新到最新版本。",
        "chat.hide": "隐藏聊天",
        "chat.open": "打开聊天",
        "chat.window.title": "聊天",
        "chat.window.logs": "最新日志",
        "chat.window.logsFromNode": "来自{nodeName}节点",
        "chat.window.noChatNode": "无聊天节点",
        "chat.window.noExecution": "尚未执行任何操作",
        "chat.window.chat.placeholder": "输入消息，或按‘向上’箭头获取上一条",
        "chat.window.chat.placeholderPristine": "输入消息",
        "chat.window.chat.sendButtonText": "发送",
        "chat.window.chat.provideMessage": "请提供一条消息",
        "chat.window.chat.emptyChatMessage": "聊天消息为空",
        "chat.window.chat.emptyChatMessage.v2": "在下方发送消息以触发聊天工作流",
        "chat.window.chat.chatMessageOptions.reuseMessage": "重用消息",
        "chat.window.chat.chatMessageOptions.repostMessage": "重新发布消息",
        "chat.window.chat.chatMessageOptions.executionId": "执行ID",
        "chat.window.chat.unpinAndExecute.description": "发送消息将覆盖固定聊天节点数据。",
        "chat.window.chat.unpinAndExecute.title": "取消固定聊天输出数据？",
        "chat.window.chat.unpinAndExecute.confirm": "取消固定并发送",
        "chat.window.chat.unpinAndExecute.cancel": "取消",
        "chat.window.chat.response.empty": "[无响应。确保最后执行的节点输出了要在此处显示的内容]",
        "chat.window.session.title": "会话",
        "chat.window.session.id": "会话：{id}",
        "chat.window.session.id.copy": "(单击复制)",
        "chat.window.session.reset": "重置",
        "chat.window.session.resetSession": "重置聊天会话",
        "chatEmbed.infoTip.description": "使用n8n聊天包将聊天添加到外部应用程序。",
        "chatEmbed.infoTip.link": "了解更多",
        "chatEmbed.title": "将聊天嵌入到您的网站",
        "chatEmbed.close": "关闭",
        "chatEmbed.install": "首先，安装n8n聊天包：",
        "chatEmbed.paste.cdn": "将以下代码粘贴到HTML文件的{code}标签中的任意位置。",
        "chatEmbed.paste.cdn.file": "<body>",
        "chatEmbed.paste.vue": "接下来，在您的{code}文件中粘贴以下代码。",
        "chatEmbed.paste.vue.file": "App.vue",
        "chatEmbed.paste.react": "接下来，在您的{code}文件中粘贴以下代码。",
        "chatEmbed.paste.react.file": "App.ts",
        "chatEmbed.paste.other": "接下来，将以下代码粘贴到您的{code}文件中。",
        "chatEmbed.paste.other.file": "main.ts",
        "chatEmbed.packageInfo.description": "n8n聊天小部件可以轻松自定义以满足您的需求。",
        "chatEmbed.packageInfo.link": "阅读完整文档",
        "chatEmbed.chatTriggerNode": "您可以使用聊天触发器节点将聊天小部件直接嵌入到n8n中。",
        "chatEmbed.url": "https://www.npmjs.com/package/{'@'}n8n/chat",
        "codeEdit.edit": "编辑",
        "codeNodeEditor.askAi": "✨ 询问AI",
        "codeNodeEditor.completer.$()": "{nodeName}节点的输出数据",
        "codeNodeEditor.completer.$execution": "获取或设置当前执行的元数据",
        "codeNodeEditor.completer.$execution.id": "当前工作流执行的ID",
        "codeNodeEditor.completer.$execution.mode": "返回<code>test</code>（表示执行是通过点击n8n中的按钮触发的）或<code>production</code>（表示执行是自动触发的）",
        "codeNodeEditor.completer.$execution.resumeUrl": "用于恢复在'等待'节点处暂停的工作流的webhook URL。",
        "codeNodeEditor.completer.$execution.resumeFormUrl": "访问由'等待'节点生成的表单的URL。",
        "codeNodeEditor.completer.$execution.customData": "设置和获取自定义执行数据（例如用于筛选执行）。您也可以使用'执行数据'节点来实现此功能。",
        "codeNodeEditor.completer.$execution.customData.set": "将自定义执行数据存储在指定的键下。使用此功能可以轻松按此数据筛选执行。",
        "codeNodeEditor.completer.$execution.customData.set.args.key": "存储数据的键（标识符）",
        "codeNodeEditor.completer.$execution.customData.set.args.value": "要存储的数据",
        "codeNodeEditor.completer.$execution.customData.set.examples.1": "存储用户的电子邮件，以便稍后轻松检索与该用户相关的所有执行",
        "codeNodeEditor.completer.$execution.customData.get": "返回存储在给定键下的自定义执行数据。",
        "codeNodeEditor.completer.$execution.customData.get.args.key": "存储数据的键（标识符）",
        "codeNodeEditor.completer.$execution.customData.get.examples.1": "获取用户的电子邮件（之前存储的）",
        "codeNodeEditor.completer.$execution.customData.setAll": "为执行设置多个键值对的自定义数据。使用此功能可以轻松按此数据筛选执行。",
        "codeNodeEditor.completer.$execution.customData.setAll.args.obj": "包含要设置的数据键值对的JavaScript对象",
        "codeNodeEditor.completer.$execution.customData.getAll": "返回当前执行中设置的所有自定义数据的键值对。",
        "codeNodeEditor.completer.$ifEmpty": "如果第一个参数不为空，则返回它，否则返回第二个参数。以下情况视为空：<code>\'</code>、<code>[]</code>、<code>{'{}'}</code>、<code>null</code>、<code>undefined</code>",
        "codeNodeEditor.completer.$ifEmpty.args.value": "要返回的值，前提是它不为空",
        "codeNodeEditor.completer.$ifEmpty.args.valueIfEmpty": "如果<code>value</code>为空，则返回此值",
        "codeNodeEditor.completer.$input": "当前节点的输入数据",
        "codeNodeEditor.completer.$input.all": "@:_reusableBaseText.codeNodeEditor.completer.all",
        "codeNodeEditor.completer.$input.first": "@:_reusableBaseText.codeNodeEditor.completer.first",
        "codeNodeEditor.completer.$input.item": "生成当前项目的原始项目",
        "codeNodeEditor.completer.$input.itemMatching": "@:_reusableBaseText.codeNodeEditor.completer.itemMatching",
        "codeNodeEditor.completer.$input.last": "@:_reusableBaseText.codeNodeEditor.completer.last",
        "codeNodeEditor.completer.$itemIndex": "当前正在处理的项在输入项列表中的位置",
        "codeNodeEditor.completer.$jmespath": "使用<a target=\'_blank\' href=\'https://docs.n8n.io/code/cookbook/jmespath/\'>JMESPath</a>表达式从对象（或对象数组）中提取数据。适用于查询复杂的嵌套对象。如果表达式无效，则返回<code>undefined</code>。",
        "codeNodeEditor.completer.$jmespath.args.obj": "要从中检索数据的对象或对象数组",
        "codeNodeEditor.completer.$jmespath.args.expression": "定义从对象中检索数据的<a target=\'_blank\' href=\'https://jmespath.org/examples.html\'>JMESPath表达式</a>",
        "codeNodeEditor.completer.$jmespath.examples.1": "获取所有名称，以数组形式",
        "codeNodeEditor.completer.$jmespath.examples.2": "获取所有20岁以下人员的姓名和年龄",
        "codeNodeEditor.completer.$jmespath.examples.3": "获取第一个20岁以下人员的姓名",
        "codeNodeEditor.completer.$jmespath.examples.4": "获取每个需要双人间的预订中所有客人的姓名",
        "codeNodeEditor.completer.$if": "根据<code>condition</code>返回两个值中的一个。类似于JavaScript中的<code>?</code>运算符。",
        "codeNodeEditor.completer.$if.args.condition": "要进行的检查。应评估为<code>true</code>或<code>false</code>",
        "codeNodeEditor.completer.$if.args.valueIfTrue": "如果条件为真，则返回此值",
        "codeNodeEditor.completer.$if.args.valueIfFalse": "如果条件为假，则返回此值",
        "codeNodeEditor.completer.$if.examples.1": "如果时间在下午5点之前，返回\'Good day\'，否则返回\'Good evening\'",
        "codeNodeEditor.completer.$if.examples.2": "可以组合$if()调用\\n如果时间在上午10点之前，返回\'Good morning\'，如果在下午5点之前，返回\'Good day\'，否则返回\'Good evening\'",
        "codeNodeEditor.completer.$max": "返回给定数字中的最大值，如果没有参数，则返回-Infinity。",
        "codeNodeEditor.completer.$max.args.numbers": "要比较的数字",
        "codeNodeEditor.completer.$min": "返回给定数字中的最小值，如果没有参数，则返回Infinity。",
        "codeNodeEditor.completer.$now": "表示当前时刻的DateTime。\\n\\n使用工作流的时区（可以在工作流设置中更改）。",
        "codeNodeEditor.completer.$parameter": "当前节点的配置设置。这些是您在节点UI中填写的参数（例如其操作）。",
        "codeNodeEditor.completer.$prevNode": "关于当前输入来源节点的信息。\\n\\n在'合并'节点中，始终使用第一个输入连接器。",
        "codeNodeEditor.completer.$prevNode.name": "当前输入来源节点的名称。\\n\\n如果有多个输入连接器（例如在'合并'节点中），始终使用当前节点的第一个输入连接器。",
        "codeNodeEditor.completer.$prevNode.outputIndex": "当前输入来源的输出连接器的索引。当上一个节点有多个输出（如'If'或'Switch'节点）时使用此功能。\\n\\n如果有多个输入连接器（例如在'合并'节点中），始终使用当前节点的第一个输入连接器。",
        "codeNodeEditor.completer.$prevNode.runIndex": "生成当前输入的上一个节点的运行索引。\\n\\n如果有多个输入连接器（例如在'合并'节点中），始终使用当前节点的第一个输入连接器。",
        "codeNodeEditor.completer.$runIndex": "当前节点执行的当前运行的索引。从0开始。",
        "codeNodeEditor.completer.$nodeVersion": "当前节点的版本（如节点设置面板底部所示）",
        "codeNodeEditor.completer.$today": "表示当天午夜时刻的DateTime。\\n\\n使用实例的时区（除非在工作流设置中覆盖）。",
        "codeNodeEditor.completer.$vars": "工作流可用的<a target=\'_blank\'  href=\'https://docs.n8n.io/code/variables/\'>变量</a>",
        "codeNodeEditor.completer.$vars.varName": "在此n8n实例上设置的变量。所有变量都评估为字符串。",
        "codeNodeEditor.completer.$secrets": "如果配置了<a target=\'_blank\' href=\'https://docs.n8n.io/external-secrets/\'>外部密钥库</a>，则来自其中的密钥。密钥值从不显示给用户。仅在凭据字段中可用。",
        "codeNodeEditor.completer.$secrets.provider": "连接到此n8n实例的外部密钥提供程序。",
        "codeNodeEditor.completer.$secrets.provider.varName": "连接到此n8n实例的外部密钥。所有密钥都评估为字符串。",
        "codeNodeEditor.completer.$workflow": "关于当前工作流的信息",
        "codeNodeEditor.completer.$workflow.active": "工作流是否处于活动状态",
        "codeNodeEditor.completer.$workflow.id": "工作流ID。也可以在工作流的URL中找到。",
        "codeNodeEditor.completer.$workflow.name": "工作流名称，显示在编辑器顶部",
        "codeNodeEditor.completer.$response": "最后一次HTTP调用返回的响应。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.$response.headers": "最后一次HTTP调用返回的头部信息。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.$response.statusCode": "最后一次HTTP调用返回的HTTP状态码。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.$response.statusMessage": "关于请求状态的可选消息。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.$response.body": "最后一次HTTP调用的响应对象主体。仅在'HTTP请求'节点中可用",
        "codeNodeEditor.completer.$request": "节点最后一次运行时发送的请求对象。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.$pageCount": "节点已获取的结果页数。仅在'HTTP请求'节点中可用。",
        "codeNodeEditor.completer.dateTime": "Luxon DateTime对象。用于解析、格式化和操作日期和时间。",
        "codeNodeEditor.completer.binary": "返回当前节点的当前项目的任何二进制输入数据。<code>$input.item.binary</code>的简写。",
        "codeNodeEditor.completer.binary.mimeType": "表示文件内容格式的字符串，例如<code>image/jpeg</code>",
        "codeNodeEditor.completer.binary.fileSize": "表示文件大小的字符串（例如<code>1 kB</code>）",
        "codeNodeEditor.completer.binary.fileName": "文件名，包括扩展名",
        "codeNodeEditor.completer.binary.fileExtension": "附加到文件名的后缀（例如<code>txt</code>）",
        "codeNodeEditor.completer.binary.fileType": "表示文件类型的字符串，例如<code>image</code>。对应于MIME类型的第一部分。",
        "codeNodeEditor.completer.binary.id": "文件的唯一ID。用于在磁盘或S3等存储服务中识别文件。",
        "codeNodeEditor.completer.binary.directory": "文件所在目录的路径。用于区分不同目录中同名的文件。如果n8n配置为将文件存储在数据库中，则未设置。",
        "codeNodeEditor.completer.item.binary": "返回项目包含的任何二进制数据。",
        "codeNodeEditor.completer.item.json": "返回项目包含的JSON数据。",
        "codeNodeEditor.completer.math": "数学实用方法",
        "codeNodeEditor.completer.globalObject": "操作JavaScript对象的方法",
        "codeNodeEditor.completer.globalObject.assign": "将所有可枚举对象属性合并到目标对象中。返回修改后的目标对象。",
        "codeNodeEditor.completer.globalObject.entries": "对象的键和值",
        "codeNodeEditor.completer.globalObject.keys": "对象的键",
        "codeNodeEditor.completer.globalObject.values": "对象的值",
        "codeNodeEditor.completer.json": "返回当前节点的当前项目的JSON输入数据。<code>$input.item.json</code>的简写。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.expandFormat": "为区域设置生成完全展开的格式标记。不引用字符，因此引用的标记无法正确往返。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromFormat": "从输入字符串和格式字符串创建DateTime。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromFormatExplain": "解释字符串将如何被fromFormat()解析。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromHTTP": "从HTTP头部日期创建DateTime",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromISO": "从ISO 8601字符串创建DateTime",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromISO.args.isoString": "要转换为DateTime的ISO 8601字符串",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromISO.args.opts": "配置选项。更多详情请参见<a target=\'blank\' href=\'https://moment.github.io/luxon/api-docs/index.html#datetimefromiso\'>Luxon文档</a>",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromJSDate": "从JavaScript Date对象创建一个DateTime。使用默认时区",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromMillis": "根据自纪元（即1970年1月1日00：00：00 UTC）以来的毫秒数创建一个DateTime。使用默认时区",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromMillis.args.milliseconds": "自纪元（即1970年1月1日00：00：00 UTC）以来的毫秒数",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromMillis.args.opts": "配置选项。更多详情请参见<a target=\'blank\' href=\'https://moment.github.io/luxon/api-docs/index.html#datetimefrommillis\'>Luxon文档</a>",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromObject": "从具有类似'year'和'hour'键的JavaScript对象创建一个DateTime，并提供合理的默认值",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromRFC2822": "从RFC 2822字符串创建一个DateTime",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromString": "已弃用：请改用\`fromFormat\`。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromStringExplain": "已弃用：请改用\`fromFormatExplain\`。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromSQL": "从SQL日期、时间或日期时间创建一个DateTime",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromSeconds": "根据自纪元（即1970年1月1日00：00：00 UTC）以来的秒数创建一个DateTime。使用默认时区",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromSeconds.args.seconds": "自纪元（即1970年1月1日00：00：00 UTC）以来的秒数",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.fromSeconds.args.opts": "配置选项。更多详情请参见<a target=\'blank\' href=\'https://moment.github.io/luxon/api-docs/index.html#datetimefromseconds\'>Luxon文档</a>",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.invalid": "创建一个无效的DateTime。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.isDateTime": "检查一个对象是否是DateTime。跨上下文边界工作",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.isDateTime.args.maybeDateTime": "潜在的DateTime进行检查。只有Luxon DateTime类的实例会返回<code>true</code>",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.local": "创建一个本地DateTime",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.max": "返回几个日期时间中的最大值。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.max.args.dateTimes": "要比较的DateTime对象",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.min": "返回几个日期时间中的最小值。",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.min.args.dateTimes": "要比较的DateTime对象",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.now": "为当前时刻创建一个DateTime，在工作流的本地时区内",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.parseFormatForOpts": "生成完全扩展的区域格式标记。不引用字符，因此引用的标记不会正确往返",
        "codeNodeEditor.completer.luxon.dateTimeStaticMethods.utc": "在UTC中创建一个DateTime",
        "codeNodeEditor.completer.luxon.instanceMethods.day": "月份中的某天（1-31）。",
        "codeNodeEditor.completer.luxon.instanceMethods.daysInMonth": "返回此DateTime所在月份的天数。",
        "codeNodeEditor.completer.luxon.instanceMethods.daysInYear": "返回此DateTime所在年份的天数。",
        "codeNodeEditor.completer.luxon.instanceMethods.diff": "以Duration形式返回两个DateTime之间的差异。",
        "codeNodeEditor.completer.luxon.instanceMethods.diffNow": "返回此DateTime与现在时刻之间的差异。",
        "codeNodeEditor.completer.luxon.instanceMethods.endOf": "将DateTime向上取整到其单位之一的末尾，例如月末",
        "codeNodeEditor.completer.luxon.instanceMethods.endOf.args.unit": "要取整到末尾的单位。可以是<code>year</code>、<code>quarter</code>、<code>month</code>、<code>week</code>、<code>day</code>、<code>hour</code>、<code>minute</code>、<code>second</code>或<code>millisecond</code>",
        "codeNodeEditor.completer.luxon.instanceMethods.endOf.args.opts": "带有影响输出选项的对象。可能的属性：<code>useLocaleWeeks</code>（布尔值）：计算周开始时是否使用区域设置。默认为false。",
        "codeNodeEditor.completer.luxon.instanceMethods.equals": "如果两个DateTime表示完全相同的时刻并且位于同一时区，则返回<code>true</code>。对于不太严格的比较，请使用<code>hasSame()</code>",
        "codeNodeEditor.completer.luxon.instanceMethods.equals.args.other": "要比较的另一个DateTime",
        "codeNodeEditor.completer.luxon.instanceMethods.hasSame": "如果两个DateTime相同，直到指定的单位，则返回<code>true</code>。忽略时区（仅比较本地时间），所以如果需要首先使用<code>toUTC()</code>",
        "codeNodeEditor.completer.luxon.instanceMethods.hasSame.args.other": "要比较的另一个DateTime",
        "codeNodeEditor.completer.luxon.instanceMethods.hasSame.args.unit": "要检查相同性的单位。可以是<code>year</code>、<code>quarter</code>、<code>month</code>、<code>week</code>、<code>day</code>、<code>hour</code>、<code>minute</code>、<code>second</code>或<code>millisecond</code>",
        "codeNodeEditor.completer.luxon.instanceMethods.hour": "一天中的小时（0-23）。",
        "codeNodeEditor.completer.luxon.instanceMethods.invalidExplanation": "返回此DateTime变为无效的原因说明，如果DateTime有效则返回null。",
        "codeNodeEditor.completer.luxon.instanceMethods.invalidReason": "如果此DateTime无效，则返回错误代码，如果DateTime有效则返回null。",
        "codeNodeEditor.completer.luxon.instanceMethods.isInDST": "DateTime是否处于夏令时期间。",
        "codeNodeEditor.completer.luxon.instanceMethods.isInLeapYear": "DateTime是否处于闰年。",
        "codeNodeEditor.completer.luxon.instanceMethods.isOffsetFixed": "获取此区域的偏移量是否发生变化，如DST期间。",
        "codeNodeEditor.completer.luxon.instanceMethods.isValid": "返回DateTime是否有效。无效的DateTime发生在从无效的日历信息创建DateTime时，例如第13个月或2月30日。或者通过另一个无效日期的操作创建了DateTime。",
        "codeNodeEditor.completer.luxon.instanceMethods.locale": "DateTime的区域设置，如'en-GB'。区域设置用于格式化DateTime。",
        "codeNodeEditor.completer.luxon.instanceMethods.max": "返回几个日期时间中的最大值。",
        "codeNodeEditor.completer.luxon.instanceMethods.millisecond": "一秒中的毫秒（0-999）。",
        "codeNodeEditor.completer.luxon.instanceMethods.min": "返回几个日期时间中的最小值",
        "codeNodeEditor.completer.luxon.instanceMethods.minus": "减去小时、分钟、秒或毫秒会增加相应数量的毫秒",
        "codeNodeEditor.completer.luxon.instanceMethods.minute": "当前小时中的分钟数（0-59）。",
        "codeNodeEditor.completer.luxon.instanceMethods.month": "当前月份（1-12）。",
        "codeNodeEditor.completer.luxon.instanceMethods.monthLong": "完整的月份名称文本，例如'October'。如果未指定，默认为系统区域设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.monthShort": "缩写的月份名称文本，例如'Oct'。如果未指定，默认为系统区域设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.numberingSystem": "获取DateTime的编号系统，例如'beng'。编号系统用于格式化DateTime。",
        "codeNodeEditor.completer.luxon.instanceMethods.offset": "获取此DateTime的UTC偏移量（以分钟为单位）",
        "codeNodeEditor.completer.luxon.instanceMethods.offsetNameLong": "获取当前时区偏移量的完整人类可读名称，例如\'Eastern Standard Time\'或\'Eastern Daylight Time\'。",
        "codeNodeEditor.completer.luxon.instanceMethods.offsetNameShort": "获取当前时区偏移量的缩写人类可读名称，例如\'EST\'或\'EDT\'。",
        "codeNodeEditor.completer.luxon.instanceMethods.offsetNumber": "获取当前时区偏移量的缩写人类可读名称，例如\'EST\'或\'EDT\'。",
        "codeNodeEditor.completer.luxon.instanceMethods.ordinal": "获取序数（表示一年中的第几天）。",
        "codeNodeEditor.completer.luxon.instanceMethods.outputCalendar": "获取DateTime的输出日历，例如'islamic'。输出日历用于格式化DateTime。",
        "codeNodeEditor.completer.luxon.instanceMethods.plus": "增加小时、分钟、秒或毫秒，将时间戳增加相应的毫秒数。",
        "codeNodeEditor.completer.luxon.instanceMethods.quarter": "当前季度（1-4）。",
        "codeNodeEditor.completer.luxon.instanceMethods.reconfigure": "设置区域设置、编号系统或输出日历。返回一个新构建的DateTime。",
        "codeNodeEditor.completer.luxon.instanceMethods.resolvedLocaleOptions": "返回此DateTime解析后的Intl选项。这对于理解格式化方法的行为很有用。",
        "codeNodeEditor.completer.luxon.instanceMethods.second": "当前分钟中的秒数（0-59）。",
        "codeNodeEditor.completer.luxon.instanceMethods.set": "为DateTime的指定单位分配新值。要舍入DateTime，另请参见<code>startOf()</code>和<code>endOf()</code>。",
        "codeNodeEditor.completer.luxon.instanceMethods.set.args.values": "包含要设置的单位和相应值的对象。可能的键包括<code>year</code>、<code>month</code>、<code>day</code>、<code>hour</code>、<code>minute</code>、<code>second</code>和<code>millsecond</code>。",
        "codeNodeEditor.completer.luxon.instanceMethods.setLocale": "设置区域设置，确定DateTime的语言和格式。在生成DateTime的文本表示时很有用，例如使用<code>format()</code>或<code>toLocaleString()</code>。",
        "codeNodeEditor.completer.luxon.instanceMethods.setLocale.args.locale": "要设置的区域设置，例如'en-GB'表示英式英语，'pt-BR'表示巴西葡萄牙语。<a target=\'blank\' href=\'https://www.localeplanet.com/icu/\'>列表</a>（非官方）",
        "codeNodeEditor.completer.luxon.instanceMethods.setZone": "将DateTime转换为指定的时区。除非在选项中指定，否则DateTime仍表示相同的时刻。另请参见<code>toLocal()</code>和<code>toUTC()</code>。",
        "codeNodeEditor.completer.luxon.instanceMethods.setZone.args.zone": "时区标识符，可以是<code>'America/New_York'</code>、<code>'UTC+3'</code>格式，或者是字符串<code>'local'</code>或<code>'utc'</code>。<code>'local'</code>是工作流的本地时区，可以在工作流设置中更改。",
        "codeNodeEditor.completer.luxon.instanceMethods.setZone.args.opts": "影响输出的选项。可能的属性：\\n<code>keepCalendarTime</code>（布尔值）：是否保持时间不变，仅更改偏移量。默认为false。",
        "codeNodeEditor.completer.luxon.instanceMethods.startOf": "将DateTime向下舍入到其某个单位的开始，例如月份的开始",
        "codeNodeEditor.completer.luxon.instanceMethods.startOf.args.unit": "要舍入到其开始的单位。可以是<code>year</code>、<code>quarter</code>、<code>month</code>、<code>week</code>、<code>day</code>、<code>hour</code>、<code>minute</code>、<code>second</code>或<code>millisecond</code>之一。",
        "codeNodeEditor.completer.luxon.instanceMethods.startOf.args.opts": "包含影响输出的选项的对象。可能的属性：\\n<code>useLocaleWeeks</code>（布尔值）：在计算周的开始是否使用区域设置。默认为false。",
        "codeNodeEditor.completer.luxon.instanceMethods.toBSON": "返回与此DateTime等效的BSON可序列化对象。",
        "codeNodeEditor.completer.luxon.instanceMethods.toFormat": "返回根据指定格式字符串格式化的此DateTime的字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toHTTP": "返回适合在HTTP标头中使用的此DateTime的字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toISO": "返回此DateTime的ISO 8601兼容字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toISO.args.opts": "配置选项。有关更多信息，请参见<a target=\'blank\' href=\'https://moment.github.io/luxon/api-docs/index.html#datetimetoiso\'>Luxon文档</a>。",
        "codeNodeEditor.completer.luxon.instanceMethods.toISODate": "返回此DateTime日期组件的ISO 8601兼容字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toISOTime": "返回此DateTime时间组件的ISO 8601兼容字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toISOWeekDate": "返回此DateTime周日期组件的ISO 8601兼容字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toJSON": "返回适合在JSON中使用的此DateTime的ISO 8601表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toJsDate": "返回与此DateTime等效的JavaScript Date对象。",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocal": "将DateTime转换为工作流的本地时区。除非在参数中指定，否则DateTime仍表示相同的时刻。工作流的时区可以在工作流设置中设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocal.example": "如果时区是Europe/Berlin",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocaleParts": "返回格式\'部分\'的数组，即包含元数据的单个标记。",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocaleString": "返回表示DateTime的本地化字符串，即与其区域设置对应的语言和格式。如果未指定，默认为系统的区域设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocaleString.args.opts": "渲染的配置选项。完整列表请参见<a href=\'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#parameters\'>Intl.DateTimeFormat</a>。默认为渲染短日期。",
        "codeNodeEditor.completer.luxon.instanceMethods.toLocaleString.example": "渲染的配置选项。完整列表请参见<a href=\'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat#parameters\'>Intl.DateTimeFormat</a>。默认为渲染短日期。",
        "codeNodeEditor.completer.luxon.instanceMethods.toMillis": "返回Unix时间戳（自1970年1月1日以来的毫秒数）",
        "codeNodeEditor.completer.luxon.instanceMethods.toObject": "返回包含此DateTime的年、月、日等的JavaScript对象。",
        "codeNodeEditor.completer.luxon.instanceMethods.toRFC2822": "返回此DateTime的RFC 2822兼容字符串表示形式，始终以UTC表示。",
        "codeNodeEditor.completer.luxon.instanceMethods.toRelative": "返回相对于当前时间的文本表示形式，例如'两天后'。默认向下舍入。",
        "codeNodeEditor.completer.luxon.instanceMethods.toRelative.args.opts": "影响输出的选项。可能的属性：\\n<code>unit</code> = 默认使用的单位（<code>years</code>、<code>months</code>、<code>days</code>等）。\\n<code>locale</code> = 使用的语言和格式（例如<code>de</code>、<code>fr</code>）",
        "codeNodeEditor.completer.luxon.instanceMethods.toRelativeCalendar": "返回相对于今天的日期字符串表示形式，例如'昨天'或'下个月'。",
        "codeNodeEditor.completer.luxon.instanceMethods.toSQL": "返回适合在SQL DateTime中使用的此DateTime的字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toSQLDate": "返回适合在SQL Date中使用的此DateTime的字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toSQLTime": "返回一个适合在SQL Time中使用的DateTime的字符串表示形式。",
        "codeNodeEditor.completer.luxon.instanceMethods.toSeconds": "返回自1970年1月1日以来经过的Unix时间戳（以秒为单位）。",
        "codeNodeEditor.completer.luxon.instanceMethods.toString": "返回DateTime的字符串表示形式。类似于<code>toISO()</code>。有关更多格式选项，请参见<code>format()</code>或<code>toLocaleString()</code>。",
        "codeNodeEditor.completer.luxon.instanceMethods.toUTC": "将DateTime转换到UTC时区。除非在参数中指定，否则DateTime仍然表示同一时刻。使用<code>setZone()</code>转换到其他时区。",
        "codeNodeEditor.completer.luxon.instanceMethods.toUTC.args.offset": "与UTC的偏移量（以分钟为单位）",
        "codeNodeEditor.completer.luxon.instanceMethods.toUTC.args.opts": "影响输出的选项。可能的属性：\\n<code>keepCalendarTime</code>（布尔值）：是否保持时间不变，仅更改偏移量。默认为false。",
        "codeNodeEditor.completer.luxon.instanceMethods.toUnixInteger": "返回此DateTime的纪元秒数（作为一个整数）。",
        "codeNodeEditor.completer.luxon.instanceMethods.until": "返回一个跨越此DateTime和另一个DateTime之间的间隔。",
        "codeNodeEditor.completer.luxon.instanceMethods.valueOf": "返回此DateTime的纪元毫秒数。",
        "codeNodeEditor.completer.luxon.instanceMethods.weekNumber": "一年中的周数（1-52左右）。",
        "codeNodeEditor.completer.luxon.instanceMethods.weekYear": "获取周年份。",
        "codeNodeEditor.completer.luxon.instanceMethods.weekday": "一周中的某天。1是星期一，7是星期日。",
        "codeNodeEditor.completer.luxon.instanceMethods.weekdayLong": "文本化的完整工作日名称，例如'Wednesday'。如果未指定，默认为系统的区域设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.weekdayShort": "文本化的缩写工作日名称，例如'Wed'。如果未指定，默认为系统的区域设置。",
        "codeNodeEditor.completer.luxon.instanceMethods.weeksInWeekYear": "返回此DateTime的年份中的周数。",
        "codeNodeEditor.completer.luxon.instanceMethods.year": "年份。",
        "codeNodeEditor.completer.luxon.instanceMethods.zone": "与此DateTime关联的时区",
        "codeNodeEditor.completer.luxon.instanceMethods.zoneName": "获取时区的名称。",
        "codeNodeEditor.completer.selector.all": "@:_reusableBaseText.codeNodeEditor.completer.all",
        "codeNodeEditor.completer.selector.context": "节点的额外数据",
        "codeNodeEditor.completer.selector.first": "@:_reusableBaseText.codeNodeEditor.completer.first",
        "codeNodeEditor.completer.selector.item": "返回匹配项，即用于生成当前节点中当前项的项。",
        "codeNodeEditor.completer.selector.args.branchIndex": "要使用的节点的输出分支。默认为第一个分支（索引0）",
        "codeNodeEditor.completer.selector.args.runIndex": "要使用的节点的运行次数。默认为第一次运行（索引0）",
        "codeNodeEditor.completer.selector.itemMatching": "@:_reusableBaseText.codeNodeEditor.completer.itemMatching",
        "codeNodeEditor.completer.selector.itemMatching.args.currentItemIndex": "当前节点中要匹配的项的索引。",
        "codeNodeEditor.completer.selector.last": "@:_reusableBaseText.codeNodeEditor.completer.last",
        "codeNodeEditor.completer.selector.params": "给定节点的配置设置。这些是在节点的UI内填写的参数（例如其操作）。",
        "codeNodeEditor.completer.selector.isExecuted": "如果节点已执行，则为<code>true</code>；否则为<code>false</code>",
        "codeNodeEditor.completer.section.input": "输入",
        "codeNodeEditor.completer.section.prevNodes": "前面的节点",
        "codeNodeEditor.completer.section.metadata": "元数据",
        "codeNodeEditor.completer.section.fields": "字段",
        "codeNodeEditor.completer.section.properties": "属性",
        "codeNodeEditor.completer.section.methods": "方法",
        "codeNodeEditor.completer.section.otherMethods": "其他方法",
        "codeNodeEditor.completer.section.recommended": "建议的",
        "codeNodeEditor.completer.section.recommendedMethods": "建议的方法",
        "codeNodeEditor.completer.section.other": "其他",
        "codeNodeEditor.completer.section.edit": "编辑",
        "codeNodeEditor.completer.section.query": "查询",
        "codeNodeEditor.completer.section.format": "格式",
        "codeNodeEditor.completer.section.component": "组件",
        "codeNodeEditor.completer.section.case": "情况",
        "codeNodeEditor.completer.section.cast": "类型转换",
        "codeNodeEditor.completer.section.compare": "比较",
        "codeNodeEditor.completer.section.validation": "验证",
        "codeNodeEditor.linter.allItems.firstOrLastCalledWithArg": "期望不带参数。",
        "codeNodeEditor.linter.allItems.emptyReturn": "代码没有正确返回项目。请返回一个对象数组，每个对象对应您想要输出的一个项目。",
        "codeNodeEditor.linter.allItems.itemCall": "\`item\`是一个需要访问的属性，而不是一个调用的方法。您的意思可能是不带括号的\`.item\`吗？",
        "codeNodeEditor.linter.allItems.itemMatchingNoArg": "\`.itemMatching()\` 需要传入一个项目索引作为其参数。",
        "codeNodeEditor.linter.allItems.unavailableItem": "旧版 \`item\` 仅在‘对每个项目运行一次’模式下可用。",
        "codeNodeEditor.linter.allItems.unavailableProperty": "\`.item\` 仅在‘对每个项目运行一次’模式下可用。请使用 \`.first()\` 替代。",
        "codeNodeEditor.linter.allItems.unavailableVar": "仅在‘对每个项目运行一次’模式下可用。",
        "codeNodeEditor.linter.bothModes.directAccess.firstOrLastCall": "@:_reusableBaseText.codeNodeEditor.linter.useJson",
        "codeNodeEditor.linter.bothModes.directAccess.itemProperty": "@:_reusableBaseText.codeNodeEditor.linter.useJson",
        "codeNodeEditor.linter.bothModes.varDeclaration.itemProperty": "@:_reusableBaseText.codeNodeEditor.linter.useJson",
        "codeNodeEditor.linter.bothModes.varDeclaration.itemSubproperty": "@:_reusableBaseText.codeNodeEditor.linter.useJson",
        "codeNodeEditor.linter.eachItem.emptyReturn": "代码未返回对象。请返回表示输出项目的对象",
        "codeNodeEditor.linter.eachItem.legacyItemAccess": "\`item\` 是一个遗留变量。考虑使用 \`$input.item\`",
        "codeNodeEditor.linter.eachItem.returnArray": "代码未返回对象。返回了数组。请返回表示输出项目的对象",
        "codeNodeEditor.linter.eachItem.unavailableItems": "旧版 \`items\` 仅在‘对所有项目运行一次’模式下可用。",
        "codeNodeEditor.linter.eachItem.unavailableMethod": "方法 \`$input.{method}()\` 仅在‘对所有项目运行一次’模式下可用。",
        "codeNodeEditor.linter.eachItem.preferFirst": "建议优先使用 \`.first()\` 而不是 \`.item\`，以便 n8n 可以优化执行",
        "codeNodeEditor.linter.bothModes.syntaxError": "语法错误",
        "codeNodeEditor.linter.bothModes.dollarSignVariable": "使用字符串字面量而不是变量，以便 n8n 可以优化执行。",
        "codeNodeEditor.askAi.placeholder": "告诉AI你希望代码实现什么。你可以使用点符号引用输入数据字段（例如 user.email）",
        "codeNodeEditor.askAi.intro": "嘿，AI，生成JavaScript代码，该代码可以...",
        "codeNodeEditor.askAi.help": "帮助",
        "codeNodeEditor.askAi.generateCode": "生成代码",
        "codeNodeEditor.askAi.noInputData": "一旦此节点有来自工作流中较早节点的输入数据，就可以生成代码",
        "codeNodeEditor.askAi.sureLeaveTab": "确定要切换选项卡吗？代码生成将停止",
        "codeNodeEditor.askAi.areYouSure": "你确定吗？",
        "codeNodeEditor.askAi.switchTab": "切换选项卡",
        "codeNodeEditor.askAi.noPrompt": "首先在上方输入提示，然后再生成代码",
        "codeNodeEditor.askAi.onlyAllItemsMode": "询问AI生成仅在‘对所有项目运行一次’模式下有效",
        "codeNodeEditor.askAi.promptTooShort": "输入至少 {minLength} 个字符后，再尝试生成代码",
        "codeNodeEditor.askAi.generateCodeAndReplace": "生成并替换代码",
        "codeNodeEditor.askAi.replaceCurrentCode": "替换当前代码？",
        "codeNodeEditor.askAi.areYouSureToReplace": "你确定要生成新代码吗？你的当前代码将被替换。",
        "codeNodeEditor.askAi.loadingPhrase0": "AI齿轮转动，马上就好…",
        "codeNodeEditor.askAi.loadingPhrase1": "上上下下左右BA开始…",
        "codeNodeEditor.askAi.loadingPhrase2": "咨询Jan Oberhauser…",
        "codeNodeEditor.askAi.loadingPhrase3": "收集字节和片段…",
        "codeNodeEditor.askAi.loadingPhrase4": "检查是否有另一个AI知道答案…",
        "codeNodeEditor.askAi.loadingPhrase5": "检查Stack Overflow…",
        "codeNodeEditor.askAi.loadingPhrase6": "以AI风格处理数据…",
        "codeNodeEditor.askAi.loadingPhrase7": "待命，AI魔法正在工作…",
        "codeNodeEditor.askAi.generationCompleted": "✨ 代码生成完成",
        "codeNodeEditor.askAi.generationFailed": "代码生成失败",
        "codeNodeEditor.askAi.generationFailedUnknown": "由于未知原因，代码生成失败。请几分钟后重试。",
        "codeNodeEditor.askAi.generationFailedDown": "很抱歉，我们的AI服务当前不可用。请稍后再试。如果问题持续，请联系支持。",
        "codeNodeEditor.askAi.generationFailedRate": "我们达到了与AI合作伙伴的速率限制（请求过多）。请等待一分钟后再试。",
        "codeNodeEditor.askAi.generationFailedTooLarge": "你的工作流数据太大，AI无法处理。简化发送到代码节点的数据，然后重试。",
        "codeNodeEditor.tabs.askAi": "✨ 询问AI",
        "codeNodeEditor.tabs.code": "代码",
        "codeNodeEditor.examples": "示例",
        "codeNodeEditor.parameters": "参数",
        "codeNodeEditor.optional": "可选",
        "codeNodeEditor.defaultsTo": "默认为 {default}.",
        "collectionParameter.choose": "选择...",
        "collectionParameter.noProperties": "无属性",
        "credentialEdit.credentialConfig.accountConnected": "账户已连接",
        "credentialEdit.credentialConfig.clickToCopy": "点击复制",
        "credentialEdit.credentialConfig.connectionTestedSuccessfully": "连接测试成功",
        "credentialEdit.credentialConfig.couldntConnectWithTheseSettings": "无法使用这些设置连接",
        "credentialEdit.credentialConfig.couldntConnectWithTheseSettings.sharee": "连接设置有问题。{owner} 可能能够解决这个问题",
        "credentialEdit.credentialConfig.needHelpFillingOutTheseFields": "需要帮助填写这些字段吗？",
        "credentialEdit.credentialConfig.oAuthRedirectUrl": "OAuth 重定向 URL",
        "credentialEdit.credentialConfig.openDocs": "打开文档",
        "credentialEdit.credentialConfig.pleaseCheckTheErrorsBelow": "请检查下面的错误",
        "credentialEdit.credentialConfig.pleaseCheckTheErrorsBelow.sharee": "连接设置有问题。{owner} 可能能够解决这个问题",
        "credentialEdit.credentialConfig.reconnect": "重新连接",
        "credentialEdit.credentialConfig.reconnectOAuth2Credential": "重新连接 OAuth2 凭据",
        "credentialEdit.credentialConfig.redirectUrlCopiedToClipboard": "重定向 URL 已复制到剪贴板",
        "credentialEdit.credentialConfig.retry": "重试",
        "credentialEdit.credentialConfig.retryCredentialTest": "重试凭据测试",
        "credentialEdit.credentialConfig.retrying": "正在重试",
        "credentialEdit.credentialConfig.subtitle": "在 {appName} 中，当提示输入 OAuth 回调或重定向 URL 时，请使用上面的 URL",
        "credentialEdit.credentialConfig.theServiceYouReConnectingTo": "您正在连接的服务",
        "credentialEdit.credentialConfig.missingCredentialType": "此凭据类型不可用。这通常发生在之前安装的社区或自定义节点被卸载时。",
        "credentialEdit.credentialConfig.authTypeSelectorLabel": "使用以下方式连接",
        "credentialEdit.credentialConfig.authTypeSelectorTooltip": "用于连接的身份验证方法",
        "credentialEdit.credentialConfig.recommendedAuthTypeSuffix": "(推荐)",
        "credentialEdit.credentialConfig.externalSecrets": "企业计划用户可以从外部保险库中提取凭据。",
        "credentialEdit.credentialConfig.externalSecrets.moreInfo": "更多信息",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose1.cancelButtonText": "关闭",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose1.confirmButtonText": "继续编辑",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose1.headline": "不保存就关闭？",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose1.message": "您确定要放弃对 {credentialDisplayName} 凭据所做的更改吗？",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose2.cancelButtonText": "关闭",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose2.confirmButtonText": "继续编辑",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose2.headline": "不连接就关闭？",
        "credentialEdit.credentialEdit.confirmMessage.beforeClose2.message": "您需要连接您的凭据才能使其工作",
        "credentialEdit.credentialEdit.confirmMessage.deleteCredential.cancelButtonText": "",
        "credentialEdit.credentialEdit.confirmMessage.deleteCredential.confirmButtonText": "是的，删除",
        "credentialEdit.credentialEdit.confirmMessage.deleteCredential.headline": "删除凭据？",
        "credentialEdit.credentialEdit.confirmMessage.deleteCredential.message": "您确定要删除 \'{savedCredentialName}\' 吗？这可能会破坏任何使用它的工作流。",
        "credentialEdit.credentialEdit.connection": "连接",
        "credentialEdit.credentialEdit.sharing": "共享",
        "credentialEdit.credentialEdit.couldNotFindCredentialOfType": "找不到类型的凭据",
        "credentialEdit.credentialEdit.couldNotFindCredentialWithId": "找不到 ID 的凭据",
        "credentialEdit.credentialEdit.delete": "删除",
        "credentialEdit.credentialEdit.details": "详情",
        "credentialEdit.credentialEdit.saving": "保存中",
        "credentialEdit.credentialEdit.showError.createCredential.title": "创建凭据时出错",
        "credentialEdit.credentialEdit.showError.deleteCredential.title": "删除凭据时出错",
        "credentialEdit.credentialEdit.showError.generateAuthorizationUrl.message": "生成授权 URL 时出现问题",
        "credentialEdit.credentialEdit.showError.generateAuthorizationUrl.title": "OAuth 授权错误",
        "credentialEdit.credentialEdit.showError.loadCredential.title": "加载凭据时出错",
        "credentialEdit.credentialEdit.showError.updateCredential.title": "更新凭据时出现问题",
        "credentialEdit.credentialEdit.showMessage.title": "凭据已删除",
        "credentialEdit.credentialEdit.testing": "测试中",
        "credentialEdit.credentialEdit.info.sharee": "只有{credentialOwnerName}可以编辑此连接",
        "credentialEdit.credentialInfo.allowUseBy": "允许使用人员",
        "credentialEdit.credentialInfo.created": "创建时间",
        "credentialEdit.credentialInfo.id": "ID",
        "credentialEdit.credentialInfo.lastModified": "最后修改时间",
        "credentialEdit.credentialEdit.setupGuide": "设置指南",
        "credentialEdit.credentialEdit.docs": "文档",
        "credentialEdit.oAuthButton.connectMyAccount": "连接我的账户",
        "credentialEdit.oAuthButton.signInWithGoogle": "使用Google登录",
        "credentialEdit.credentialSharing.info.owner": "共享凭据允许他人在工作流中使用。他们无法访问凭据详细信息。",
        "credentialEdit.credentialSharing.info.sharee.team": "只有具有凭据共享权限的用户可以更改此凭据的共享对象",
        "credentialEdit.credentialSharing.info.sharee.personal": "只有{credentialOwnerName}或具有凭据共享权限的用户可以更改此凭据的共享对象",
        "credentialEdit.credentialSharing.info.sharee.fallback": "所有者",
        "credentialEdit.credentialSharing.list.delete": "移除",
        "credentialEdit.credentialSharing.list.delete.confirm.title": "移除访问权限？",
        "credentialEdit.credentialSharing.list.delete.confirm.message": "这可能会破坏{name}使用此凭据的任何工作流",
        "credentialEdit.credentialSharing.list.delete.confirm.confirmButtonText": "移除",
        "credentialEdit.credentialSharing.list.delete.confirm.cancelButtonText": "取消",
        "credentialEdit.credentialSharing.role.user": "用户",
        "credentialEdit.docs.aws": "配置此凭据：\\n\\n- 选择您的AWS**区域**。\\n- 登录您的<a href=\'https://aws.amazon.com/\' target=\'_blank\'>AWS</a>账户。\\n- 生成访问密钥对：\\n  - 打开AWS<a href=\'https://console.aws.amazon.com/iam\' target=\'_blank\'>IAM控制台</a>并打开用户菜单。\\n  - 选择**安全凭证**。\\n  - 在**访问密钥**部分创建新的访问密钥对。\\n  - 显示**访问密钥ID**和**秘密访问密钥**并在n8n中输入。\\n- 要使用**临时安全凭证**，请启用此选项并添加**会话令牌**。\\n- 如果您使用Amazon虚拟私有云<a href=\'https://aws.amazon.com/vpc/\' target=\'_blank\'>VPC</a>托管n8n，可以在VPC和某些应用之间建立连接。使用**自定义端点**输入相关自定义端点。\\n\\n点击上方文档链接获取更详细说明。",
        "credentialEdit.docs.gmailOAuth2": "配置此凭据：\\n\\n- 登录您的<a href=\'https://cloud.google.com/\' target=\'_blank\'>Google Cloud</a>账户。\\n- 转到<a href=\'https://console.cloud.google.com/apis/credentials\' target=\'_blank\'>Google Cloud控制台/API和服务</a>，从左上角选择要使用的项目（或创建新项目并选择）。\\n- 如果尚未在此Google Cloud项目中配置OAuth，请<a href=\'https://developers.google.com/workspace/guides/configure-oauth-consent\' target=\'_blank\'>配置OAuth同意屏幕</a>。\\n- 在凭证中，选择**+创建凭证>OAuth客户端ID**。\\n- 在**应用类型**下拉列表中选择**Web应用**。\\n- 在**授权重定向URI**下，选择**+添加URI**。粘贴n8n中的OAuth重定向URL。\\n- 选择**创建**。\\n- 在启用的API和服务中，选择**+启用API和服务**。\\n- 选择并启用Gmail API。\\n- 返回凭证，点击OAuth 2.0客户端ID中的凭证，在凭证页面可以找到客户端ID和客户端密钥。\\n\\n点击上方文档链接获取更详细说明。",
        "credentialEdit.docs.openAiApi": "配置此凭据：\\n\\n- 登录您的<a href=\'https://platform.openai.com/login\' target=\'_blank\'>OpenAI</a>账户。\\n- 打开OpenAI<a href=\'https://platform.openai.com/api-keys\' target=\'_blank\'>API密钥</a>页面创建**API密钥**。\\n- 如果属于多个组织，请输入**组织ID**；否则留空。打开OpenAI<a href=\'https://platform.openai.com/account/organization\' target=\'_blank\'>组织设置</a>页面获取组织ID。\\n\\n点击上方文档链接获取更详细说明。",
        "credentialSelectModal.addNewCredential": "添加新凭据",
        "credentialSelectModal.continue": "继续",
        "credentialSelectModal.searchForApp": "搜索应用...",
        "credentialSelectModal.selectAnAppOrServiceToConnectTo": "选择要连接的应用或服务",
        "credentialsList.addNew": "新增",
        "credentialsList.confirmMessage.cancelButtonText": "",
        "credentialsList.confirmMessage.confirmButtonText": "是的，删除",
        "credentialsList.confirmMessage.headline": "删除凭据？",
        "credentialsList.confirmMessage.message": "确定要删除{credentialName}吗？",
        "credentialsList.created": "创建时间",
        "credentialsList.credentials": "凭据",
        "credentialsList.deleteCredential": "删除凭据",
        "credentialsList.editCredential": "编辑凭据",
        "credentialsList.errorLoadingCredentials": "加载凭据时出错",
        "credentialsList.name": "@:_reusableBaseText.name",
        "credentialsList.operations": "操作",
        "credentialsList.showError.deleteCredential.title": "删除凭据时出现问题",
        "credentialsList.showMessage.title": "凭据已删除",
        "credentialsList.type": "类型",
        "credentialsList.updated": "更新时间",
        "credentialsList.yourSavedCredentials": "您保存的凭据",
        "credentials.heading": "凭据",
        "credentials.add": "添加凭据",
        "credentials.project.add": "添加项目凭据",
        "credentials.empty.heading": "{name}，让我们设置一个凭据",
        "credentials.empty.heading.userNotSetup": "设置凭证",
        "credentials.empty.description": "凭证让工作流能够与您的应用程序和服务进行交互",
        "credentials.empty.button": "添加第一个凭证",
        "credentials.empty.button.disabled.tooltip": "您在项目中的当前角色不允许您创建凭证",
        "credentials.item.open": "打开",
        "credentials.item.delete": "删除",
        "credentials.item.move": "移动",
        "credentials.item.updated": "最后更新",
        "credentials.item.created": "创建时间",
        "credentials.item.owner": "所有者",
        "credentials.item.readonly": "只读",
        "credentials.item.needsSetup": "需要首次设置",
        "credentials.search.placeholder": "搜索凭证...",
        "credentials.filters.type": "类型",
        "credentials.filters.setup": "需要首次设置",
        "credentials.filters.status": "状态",
        "credentials.filters.active": "由于应用了过滤器，某些凭证可能被隐藏。",
        "credentials.filters.active.reset": "移除过滤器",
        "credentials.sort.lastUpdated": "按最后更新排序",
        "credentials.sort.lastCreated": "按创建日期排序",
        "credentials.sort.nameAsc": "按名称排序（A-Z）",
        "credentials.sort.nameDesc": "按名称排序（Z-A）",
        "credentials.noResults": "未找到凭证",
        "credentials.noResults.withSearch.switchToShared.preamble": "有些凭证可能是",
        "credentials.noResults.withSearch.switchToShared.link": "隐藏的",
        "credentials.create.personal.toast.title": "凭证创建成功",
        "credentials.create.personal.toast.text": "此凭证已在您的个人空间内创建。",
        "credentials.create.project.toast.title": "凭证在{projectName}中创建成功",
        "credentials.create.project.toast.text": "{projectName}的所有成员都将可以访问此凭证。",
        "dataDisplay.needHelp": "需要帮助吗？",
        "dataDisplay.nodeDocumentation": "节点文档",
        "dataDisplay.openDocumentationFor": "打开 {nodeTypeDisplayName} 文档",
        "dataMapping.dragColumnToFieldHint": "拖动到一个字段以将列映射到该字段",
        "dataMapping.dragFromPreviousHint": "通过首先点击此按钮从先前节点映射数据到 <b>{name}</b>",
        "dataMapping.success.title": "您刚刚映射了一些数据！",
        "dataMapping.success.moreInfo": "查阅我们的<a href=\'https://docs.n8n.io/data/data-mapping\' target=\'_blank\'>文档</a>了解关于n8n中数据映射的更多详情",
        "dataMapping.tableView.tableColumnsExceeded": "某些列被隐藏",
        "dataMapping.tableView.tableColumnsExceeded.tooltip": "您的数据包含超过{columnLimit}列，因此部分列被隐藏。切换到{link}以查看全部数据。",
        "dataMapping.tableView.tableColumnsExceeded.tooltip.link": "JSON视图",
        "dataMapping.schemaView.emptyData": "没有字段 - 存在项，但它们为空",
        "dataMapping.schemaView.emptyDataWithBinary": "仅存在二进制数据。使用'二进制'标签查看",
        "dataMapping.schemaView.disabled": "此节点已禁用，只会传递数据",
        "dataMapping.schemaView.noMatches": "对于'{search}'没有结果",
        "dataMapping.schemaView.preview": "通常输出以下字段。执行节点以查看实际字段。 {link}",
        "dataMapping.schemaView.previewExtraFields": "可能存在更多字段。执行节点以确认。",
        "dataMapping.schemaView.previewNode": "预览",
        "dataMapping.schemaView.variablesContextTitle": "变量和上下文",
        "dataMapping.schemaView.execution.resumeUrl": "'等待'节点恢复的URL",
        "dataMapping.schemaView.variablesUpgrade": "使用专业版或企业版计划设置全局变量并在整个工作流中使用它们。<a href=\'https://docs.n8n.io/environments/variables/\' target=\'_blank\'>详情</a>",
        "dataMapping.schemaView.variablesEmpty": "创建可跨工作流使用的变量<a href=\'/variables\' target=\'_blank\'>这里</a>",
        "displayWithChange.cancelEdit": "取消编辑",
        "displayWithChange.clickToChange": "点击修改",
        "displayWithChange.setValue": "设置值",
        "duplicateWorkflowDialog.cancel": "@:_reusableBaseText.cancel",
        "duplicateWorkflowDialog.chooseOrCreateATag": "选择或创建一个标签",
        "duplicateWorkflowDialog.duplicateWorkflow": "复制工作流",
        "duplicateWorkflowDialog.enterWorkflowName": "输入工作流名称",
        "duplicateWorkflowDialog.save": "复制",
        "duplicateWorkflowDialog.errors.missingName.title": "缺少名称",
        "duplicateWorkflowDialog.errors.missingName.message": "请输入名称。",
        "duplicateWorkflowDialog.errors.forbidden.title": "复制工作流失败",
        "duplicateWorkflowDialog.errors.forbidden.message": "此操作被禁止。您是否有正确的权限？",
        "duplicateWorkflowDialog.errors.generic.title": "复制工作流失败",
        "editor.mainHeader.githubButton.label": "在GitHub上为n8n-io/n8n点赞",
        "error": "错误",
        "error.goBack": "返回",
        "error.pageNotFound": "抱歉，找不到该页面",
        "executions.ExecutionStatus": "执行状态",
        "executions.concurrency.docsLink": "https://docs.n8n.io/hosting/scaling/concurrency-control/",
        "executionDetails.confirmMessage.confirmButtonText": "是的，删除",
        "executionDetails.confirmMessage.headline": "删除执行？",
        "executionDetails.confirmMessage.message": "您确定要删除当前执行吗？",
        "executionDetails.confirmMessage.annotationsNote": "通过删除此项，您也将移除相关的注释数据。",
        "executionDetails.deleteExecution": "删除此次执行",
        "executionDetails.executionFailed": "执行失败",
        "executionDetails.executionFailed.recoveredNodeTitle": "无法显示数据",
        "executionDetails.executionFailed.recoveredNodeMessage": "执行被中断，因此数据未保存。尝试修复工作流并重新执行。",
        "executionDetails.executionId": "执行ID",
        "executionDetails.executionWaiting": "等待执行",
        "executionDetails.executionWasSuccessful": "执行成功",
        "executionDetails.of": "的",
        "executionDetails.at": "在",
        "executionDetails.newMessage": "执行正在队列中等待。",
        "executionDetails.openWorkflow": "打开工作流",
        "executionDetails.readOnly.readOnly": "只读",
        "executionDetails.readOnly.youreViewingTheLogOf": "您正在查看上一次执行的日志。您无法<br />\\n\t\t进行更改，因为这次执行已经发生。要对此工作流进行更改，请单击左侧的工作流名称。",
        "executionDetails.retry": "重试执行",
        "executionDetails.runningTimeFinished": "在{time}内完成",
        "executionDetails.runningTimeRunning": "运行了",
        "executionDetails.runningMessage": "执行正在进行中。完成后将在此处显示。",
        "executionDetails.startingSoon": "即将开始",
        "executionDetails.workflow": "工作流",
        "executionsLandingPage.emptyState.noTrigger.heading": "设置第一步。然后执行您的工作流",
        "executionsLandingPage.emptyState.noTrigger.buttonText": "添加第一步...",
        "executionsLandingPage.clickExecutionMessage": "从列表中单击一个执行以查看它",
        "executionsLandingPage.emptyState.heading": "这里还没有内容",
        "executionsLandingPage.emptyState.message": "新的工作流执行将在此显示",
        "executionsLandingPage.emptyState.accordion.title": "这个工作流保存了哪些执行？",
        "executionsLandingPage.emptyState.accordion.titleWarning": "某些执行不会被保存",
        "executionsLandingPage.emptyState.accordion.productionExecutions": "生产执行",
        "executionsLandingPage.emptyState.accordion.testExecutions": "测试执行",
        "executionsLandingPage.emptyState.accordion.productionExecutionsWarningTooltip": "并非所有生产执行都被保存。在工作流的<a href=\'#\'>设置</a>中更改此选项",
        "executionsLandingPage.emptyState.accordion.footer": "您可以在",
        "executionsLandingPage.emptyState.accordion.footer.settingsLink": "工作流设置",
        "executionsLandingPage.emptyState.accordion.footer.tooltipLink": "保存您的工作流",
        "executionsLandingPage.emptyState.accordion.footer.tooltipText": "为了访问工作流设置",
        "executionsLandingPage.noResults": "未找到执行",
        "executionsList.activeExecutions.none": "没有活动执行",
        "executionsList.activeExecutions.header": "{running}/{cap} 活动执行",
        "executionsList.activeExecutions.tooltip": "当前活动执行：{running} 其中 {cap} 是此实例限制的并发生产执行数量。",
        "executionsList.activeExecutions.evaluationNote": "评估运行会出现在执行列表中，但不计入您的执行并发性。",
        "executionsList.allWorkflows": "所有工作流",
        "executionsList.anyStatus": "任意状态",
        "executionsList.autoRefresh": "自动刷新",
        "executionsList.canceled": "已取消",
        "executionsList.confirmMessage.cancelButtonText": "",
        "executionsList.confirmMessage.confirmButtonText": "是的，删除",
        "executionsList.confirmMessage.headline": "删除执行？",
        "executionsList.confirmMessage.message": "您确定要删除所选的 {count} 个执行吗？",
        "executionsList.confirmMessage.annotationsNote": "通过删除这些执行，您也将移除相关的注解数据。",
        "executionsList.confirmMessage.annotatedExecutionMessage": "通过删除此项，您还将移除相关的注解数据。您确定要删除所选的执行吗？",
        "executionsList.clearSelection": "清除选择",
        "executionsList.error": "错误",
        "executionsList.filters": "过滤器",
        "executionsList.loadMore": "加载更多",
        "executionsList.empty": "没有执行",
        "executionsList.loadedAll": "没有更多的执行可获取",
        "executionsList.modes.error": "错误",
        "executionsList.modes.integrated": "集成",
        "executionsList.modes.manual": "手动",
        "executionsList.modes.retry": "重试",
        "executionsList.modes.trigger": "触发器",
        "executionsList.modes.webhook": "Webhook",
        "executionsList.name": "@:_reusableBaseText.name",
        "executionsList.new": "排队",
        "executionsList.openPastExecution": "打开过去的执行",
        "executionsList.retryExecution": "重试执行",
        "executionsList.retryOf": "重试",
        "executionsList.retryWithCurrentlySavedWorkflow": "使用当前保存的工作流重试（从有错误的节点开始）",
        "executionsList.retryWithOriginalWorkflow": "使用原始工作流重试（从有错误的节点开始）",
        "executionsList.running": "运行中",
        "executionsList.succeeded": "成功",
        "executionsList.selectStatus": "选择状态",
        "executionsList.selectWorkflow": "选择工作流",
        "executionsList.selected": "{count} 个执行已选中: | {count} 个执行已选中:",
        "executionsList.selectAll": "选择 {count} 个已完成的执行 | 选择全部 {count} 个已完成的执行",
        "executionsList.test": "测试执行",
        "executionsList.evaluation": "评估执行",
        "executionsList.showError.handleDeleteSelected.title": "删除执行时出现问题",
        "executionsList.showError.loadMore.title": "加载执行时出现问题",
        "executionsList.showError.loadWorkflows.title": "加载工作流时出现问题",
        "executionsList.showError.refreshData.title": "加载数据时出现问题",
        "executionsList.showError.retryExecution.title": "重试时出现问题",
        "executionsList.showError.stopExecution.title": "停止执行时出现问题",
        "executionsList.showMessage.handleDeleteSelected.title": "执行记录已删除",
        "executionsList.showMessage.retrySuccessfulFalse.title": "重试未成功",
        "executionsList.showMessage.retrySuccessfulTrue.title": "重试成功",
        "executionsList.showMessage.stopExecution.message": "执行ID {activeExecutionId}",
        "executionsList.showMessage.stopExecution.title": "执行已停止",
        "executionsList.startedAt": "开始时间",
        "executionsList.trigger": "触发者",
        "executionsList.runTime": "运行时间",
        "executionsList.startingSoon": "即将开始",
        "executionsList.started": "{date}, {time}",
        "executionsList.id": "执行ID",
        "executionsList.status": "状态",
        "executionsList.statusCanceled": "已取消",
        "executionsList.statusText": "{status} 在 {time}",
        "executionsList.statusTextWithoutTime": "{status}",
        "executionsList.statusRunning": "{status} 达到 {time}",
        "executionsList.statusWaiting": "{status} 直到 {time}",
        "executionsList.statusUnknown": "无法完成",
        "executionsList.stopExecution": "停止执行",
        "executionsList.success": "成功",
        "executionsList.successRetry": "重试成功",
        "executionsList.unknown": "无法完成",
        "executionsList.unsavedWorkflow": "[未保存的工作流]",
        "executionsList.waiting": "等待中",
        "executionsList.workflowExecutions": "执行情况",
        "executionsList.view": "查看",
        "executionsList.stop": "停止",
        "executionsList.statusTooltipText.waitingForWebhook": "此工作流无限期等待传入的webhook调用。",
        "executionsList.statusTooltipText.waitingForConcurrencyCapacity": "一旦并发容量可用，此执行将开始。{instance}",
        "executionsList.statusTooltipText.waitingForConcurrencyCapacity.cloud": "您的计划限制为最多同时进行 {concurrencyCap} 个生产执行。{link}",
        "executionsList.statusTooltipText.waitingForConcurrencyCapacity.self": "此实例限制为最多同时进行 {concurrencyCap} 个生产执行。{link}",
        "executionsList.statusTooltipText.theWorkflowIsWaitingIndefinitely": "此工作流无限期等待传入的webhook调用。",
        "executionsList.debug.button.copyToEditor": "复制到编辑器",
        "executionsList.debug.button.debugInEditor": "在编辑器中调试",
        "executionsList.debug.paywall.content": "在编辑器中调试允许您使用实际固定的数据调试之前的执行，直接在您的编辑器中进行。",
        "executionsList.debug.paywall.link.text": "阅读更多文档",
        "executionsList.debug.paywall.link.url": "https://docs.n8n.io/workflows/executions/debug/",
        "workerList.pageTitle": "工作者",
        "workerList.empty": "没有工作者响应或可用",
        "workerList.item.lastUpdated": "最后更新",
        "workerList.item.jobList.empty": "当前没有作业",
        "workerList.item.jobListTitle": "当前作业",
        "workerList.item.netListTitle": "网络接口",
        "workerList.item.chartsTitle": "性能监控",
        "workerList.item.copyAddressToClipboard": "地址已复制到剪贴板",
        "workerList.actionBox.title": "企业版可用",
        "workerList.actionBox.description": "查看连接到您实例的工作线程的当前状态。",
        "workerList.actionBox.description.link": "更多信息",
        "workerList.actionBox.buttonText": "查看方案",
        "workerList.docs.url": "https://docs.n8n.io/hosting/scaling/queue-mode/#view-running-workers",
        "executionSidebar.executionName": "执行 {id}",
        "executionSidebar.searchPlaceholder": "搜索执行记录...",
        "executionView.onPaste.title": "无法在此粘贴",
        "executionView.onPaste.message": "此视图为只读模式。切换到<i>工作流</i>选项卡可编辑当前工作流",
        "executionView.notFound.message": "找不到ID为'{executionId}'的执行记录！",
        "executionAnnotationView.data.notFound": "通过在工作流中添加<a target=\'_blank\' href=\'https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.executiondata/\'>执行数据</a>节点来在此显示执行中的重要数据",
        "executionAnnotationView.vote.error": "无法保存标注评分",
        "executionAnnotationView.tag.error": "无法保存标注标签",
        "executionAnnotationView.addTag": "添加标签",
        "executionAnnotationView.chooseOrCreateATag": "选择或创建标签",
        "executionsFilter.annotation.tags": "执行标签",
        "executionsFilter.annotation.rating": "评分",
        "executionsFilter.annotation.rating.all": "所有评分",
        "executionsFilter.annotation.rating.good": "良好",
        "executionsFilter.annotation.rating.bad": "差评",
        "executionsFilter.annotation.selectVoteFilter": "选择评分",
        "executionsFilter.selectStatus": "选择状态",
        "executionsFilter.selectWorkflow": "选择工作流",
        "executionsFilter.start": "执行开始时间",
        "executionsFilter.startDate": "最早时间",
        "executionsFilter.endDate": "最晚时间",
        "executionsFilter.savedData": "高亮数据",
        "executionsFilter.savedDataKey": "键名",
        "executionsFilter.savedDataKeyPlaceholder": "ID",
        "executionsFilter.savedDataValue": "值(精确匹配)",
        "executionsFilter.savedDataValuePlaceholder": "123",
        "executionsFilter.reset": "重置所有",
        "executionsFilter.customData.inputTooltip": "升级方案以按运行时设置的自定义数据筛选执行记录。{link}",
        "executionsFilter.customData.inputTooltip.link": "查看方案",
        "executionsFilter.customData.docsTooltip": "使用'执行数据'节点筛选已保存数据的执行记录。{link}",
        "executionsFilter.customData.docsTooltip.link": "更多信息",
        "expressionEdit.anythingInside": "大括号内的内容 ",
        "expressionEdit.isJavaScript": " 是JavaScript代码。",
        "expressionEdit.learnMore": "了解更多",
        "expressionEdit.editExpression": "编辑表达式",
        "expressionEdit.expression": "表达式",
        "expressionEdit.resultOfItem1": "第1项的结果",
        "expressionEditor.uncalledFunction": "[这是一个函数，请添加()]",
        "expressionModalInput.empty": "[空]",
        "expressionModalInput.undefined": "[未定义]",
        "expressionModalInput.null": "null",
        "expressionTip.noExecutionData": "请先执行前置节点以使用输入数据",
        "expressionTip.typeDotPrimitive": "输入<code>.</code>获取数据转换选项。<a target=\'_blank\' href=\'https://docs.n8n.io/code/builtin/data-transformation-functions/\'>了解更多</a>",
        "expressionTip.typeDotObject": "输入<code>.</code>获取数据转换选项或访问字段。<a target=\'_blank\' href=\'https://docs.n8n.io/code/builtin/data-transformation-functions/\'>了解更多</a>",
        "expressionTip.javascript": "<code>{'{{ }}'}</code>内的所有内容都是JavaScript代码。<a target=\'_blank\' href=\'https://docs.n8n.io/code-examples/expressions/\'>了解更多</a>",
        "expressionModalInput.noExecutionData": "请先执行前置节点以预览",
        "expressionModalInput.noNodeExecutionData": "请先执行节点'{node}'以预览",
        "expressionModalInput.noInputConnection": "无输入连接",
        "expressionModalInput.pairedItemConnectionError": "无法回溯到节点",
        "expressionModalInput.pairedItemInvalidPinnedError": "请取消固定节点'{node}'后执行",
        "expressionModalInput.pairedItemError": "无法确定使用哪个项目",
        "expressionModalInput.pairedItemError.noRunData": "无法确定使用哪个项目-请执行节点获取更多信息",
        "fixedCollectionParameter.choose": "选择...",
        "fixedCollectionParameter.currentlyNoItemsExist": "当前没有项目存在",
        "fixedCollectionParameter.deleteItem": "删除项目",
        "fixedCollectionParameter.dragItem": "拖动项目",
        "fixedCollectionParameter.moveDown": "下移",
        "fixedCollectionParameter.moveUp": "上移",
        "forgotPassword": "忘记密码",
        "forgotPassword.emailSentIfExists": "我们已向{email}发送邮件(如果存在匹配账户)",
        "forgotPassword.getRecoveryLink": "发送密码重置链接",
        "forgotPassword.noSMTPToSendEmailWarning": "请联系管理员。n8n当前未配置邮件发送功能。",
        "forgotPassword.recoverPassword": "重置密码",
        "forgotPassword.recoveryEmailSent": "重置邮件已发送",
        "forgotPassword.returnToSignIn": "返回登录",
        "forgotPassword.sendingEmailError": "发送邮件时出现问题",
        "forgotPassword.ldapUserPasswordResetUnavailable": "请联系您的LDAP管理员重置密码",
        "forgotPassword.smtpErrorContactAdministrator": "请联系管理员（SMTP设置存在问题）",
        "forgotPassword.tooManyRequests": "您已达到密码重置限制，请几分钟后再试。",
        "forms.resourceFiltersDropdown.filters": "筛选器",
        "forms.resourceFiltersDropdown.owner": "所有者",
        "forms.resourceFiltersDropdown.owner.placeholder": "按所有者筛选",
        "forms.resourceFiltersDropdown.reset": "重置全部",
        "folders.actions.create": "在此创建文件夹",
        "folders.actions.create.workflow": "在此创建工作流",
        "folders.actions.moveToFolder": "移动到文件夹",
        "folders.add": "添加文件夹",
        "folders.add.here.message": "在此处创建新文件夹",
        "folders.add.to.parent.message": "在\'{parent}\'中创建文件夹",
        "folders.add.overview.community.message": "您的个人空间中可用的文件夹",
        "folders.add.overview.withProjects.message": "项目或个人空间中可用的文件夹",
        "folders.add.success.title": "文件夹已创建",
        "folders.add.success.message": "已创建新文件夹\'{folderName}\'<br><a href=\'{link}\'>打开文件夹</a>",
        "folders.invalidName.empty.message": "文件夹名称不能为空",
        "folders.invalidName.tooLong.message": "文件夹名称不能超过{maxLength}个字符",
        "folders.invalidName.invalidCharacters.message": "文件夹名称不能包含以下字符：{illegalChars}",
        "folders.invalidName.starts.with.dot..message": "文件夹名称不能以点开头",
        "folders.invalidName.only.dots.message": "文件夹名称不能只包含点",
        "folders.delete.confirm.title": "删除\'{folderName}\'",
        "folders.delete.typeToConfirm": "删除{folderName}",
        "folders.delete.confirm.message": "确定要删除此文件夹吗？",
        "folders.delete.success.message": "文件夹已删除",
        "folder.delete.modal.confirmation": "如何处理此文件夹中的{folders}{workflows}？",
        "folder.count": "{count}个文件夹",
        "workflow.count": "{count}个工作流",
        "folder.and.workflow.separator": "和",
        "folders.delete.action": "删除所有工作流和子文件夹",
        "folders.delete.error.message": "删除文件夹时出现问题",
        "folders.delete.confirmation.message": "输入\'delete {folderName}\'以确认",
        "folders.transfer.confirm.message": "数据已转移到 \'{folderName}\'",
        "folders.transfer.action": "将工作流和子文件夹转移到“{projectName}”中的另一个文件夹",
        "folders.transfer.action.noProject": "将工作流和子文件夹转移到另一个文件夹",
        "folders.transfer.selectFolder": "要转移至的文件夹",
        "folders.transfer.select.placeholder": "选择文件夹",
        "folders.rename.message": "重命名 \'{folderName}\'",
        "folders.rename.error.title": "重命名文件夹时出现问题",
        "folders.rename.success.message": "文件夹已重命名",
        "folders.not.found.message": "未找到文件夹",
        "folders.move.modal.title": "将 \'{folderName}\' 移动到另一个文件夹",
        "folders.move.modal.description": "注意：移动此文件夹也会移动其中的所有工作流和子文件夹。",
        "folders.move.modal.select.placeholder": "搜索文件夹",
        "folders.move.modal.confirm": "移动到文件夹",
        "folders.move.modal.no.data.label": "未找到文件夹",
        "folders.move.success.title": "成功移动文件夹",
        "folders.move.success.message": "<b>{folderName}</b> 已被移动到 <b>{newFolderName}</b>, 以及它的所有工作流和子文件夹。<br/><br/><a href=\'{link}\'>查看 {newFolderName}</a>",
        "folders.move.error.title": "移动文件夹时出现问题",
        "folders.move.workflow.error.title": "移动工作流时出现问题",
        "folders.move.workflow.success.title": "成功移动工作流",
        "folders.move.workflow.success.message": "<b>{workflowName}</b> 已被移动到 <b>{newFolderName}</b>.<br/><br/><a href=\'{link}\'>查看 {newFolderName}</a>",
        "folders.move.project.root.name": "{projectName} (项目根目录)",
        "folders.open.error.title": "打开文件夹时出现问题",
        "folders.create.error.title": "创建文件夹时出现问题",
        "folders.empty.actionbox.title": "文件夹 \'{folderName}\' 中还没有内容",
        "folders.registeredCommunity.cta.heading": "获取对注册社区的文件夹的访问权限",
        "folders.breadcrumbs.noTruncated.message": "路径中没有隐藏项",
        "generic.oauth1Api": "OAuth1 API",
        "generic.oauth2Api": "OAuth2 API",
        "genericHelpers.loading": "加载中",
        "genericHelpers.min": "分钟",
        "genericHelpers.minShort": "m",
        "genericHelpers.sec": "秒",
        "genericHelpers.secShort": "s",
        "genericHelpers.millis": "毫秒",
        "readOnly.showMessage.executions.message": "执行是只读的。请从<b>工作流</b>选项卡进行更改。",
        "readOnly.showMessage.executions.title": "无法编辑执行",
        "readOnlyEnv.showMessage.executions.message": "执行是只读的。",
        "readOnlyEnv.showMessage.executions.title": "无法编辑执行",
        "readOnlyEnv.showMessage.workflows.message": "在受保护的实例中，工作流是只读的。",
        "readOnlyEnv.showMessage.workflows.title": "无法编辑工作流",
        "readOnlyEnv.tooltip": "这是一个受保护的实例，修改受到限制。{link}",
        "readOnlyEnv.tooltip.link": "更多信息。",
        "readOnlyEnv.cantAdd.workflow": "您不能向受保护的n8n实例添加新工作流",
        "readOnlyEnv.cantAdd.credential": "您不能向受保护的n8n实例添加新凭证",
        "readOnlyEnv.cantAdd.project": "您不能向受保护的n8n实例添加新项目",
        "readOnlyEnv.cantAdd.any": "您不能在受保护的n8n实例上创建新的工作流或凭证",
        "readOnlyEnv.cantEditOrRun": "由于位于受保护的实例上，此工作流无法被编辑或手动运行",
        "logs.overview.header.title": "日志",
        "logs.overview.header.actions.clearExecution": "清除执行",
        "logs.overview.header.actions.clearExecution.tooltip": "清除执行数据",
        "logs.overview.header.switch.details": "详细信息",
        "logs.overview.header.switch.overview": "概览",
        "logs.overview.body.empty.message": "还没有内容可显示。执行工作流以查看执行日志。",
        "logs.overview.body.empty.action": "执行工作流",
        "logs.overview.body.summaryText": "{status} 在 {time}",
        "logs.overview.body.started": "开始于 {time}",
        "mainSidebar.aboutN8n": "关于 n8n",
        "mainSidebar.confirmMessage.workflowDelete.cancelButtonText": "",
        "mainSidebar.confirmMessage.workflowDelete.confirmButtonText": "是的，删除",
        "mainSidebar.confirmMessage.workflowDelete.headline": "删除工作流？",
        "mainSidebar.confirmMessage.workflowDelete.message": "您确定要删除 '{workflowName}' 吗？",
        "mainSidebar.credentials": "凭据",
        "mainSidebar.variables": "变量",
        "mainSidebar.help": "帮助",
        "mainSidebar.helpMenuItems.course": "课程",
        "mainSidebar.helpMenuItems.documentation": "文档",
        "mainSidebar.helpMenuItems.forum": "论坛",
        "mainSidebar.helpMenuItems.quickstart": "快速入门",
        "mainSidebar.helpMenuItems.reportBug": "报告错误",
        "mainSidebar.new": "新建",
        "mainSidebar.newTemplate": "从模板新建",
        "mainSidebar.open": "打开",
        "mainSidebar.prompt.cancel": "@:_reusableBaseText.cancel",
        "mainSidebar.prompt.import": "导入",
        "mainSidebar.prompt.importWorkflowFromUrl": "从URL导入工作流",
        "mainSidebar.prompt.invalidUrl": "无效的URL",
        "mainSidebar.prompt.workflowUrl": "工作流URL",
        "mainSidebar.save": "@:_reusableBaseText.save",
        "mainSidebar.showError.stopExecution.title": "停止执行时出现问题",
        "mainSidebar.showMessage.handleFileImport.message": "文件不包含有效的JSON数据",
        "mainSidebar.showMessage.handleFileImport.title": "无法导入文件",
        "mainSidebar.showMessage.handleSelect1.title": "工作流已删除",
        "mainSidebar.showMessage.handleSelect2.title": "工作流已创建",
        "mainSidebar.showMessage.handleSelect3.title": "工作流已创建",
        "mainSidebar.showMessage.stopExecution.title": "执行已停止",
        "mainSidebar.templates": "模板",
        "mainSidebar.workflows": "工作流",
        "mainSidebar.workflows.readOnlyEnv.tooltip": "受保护的实例阻止编辑工作流（建议用于生产环境）。{link}",
        "mainSidebar.workflows.readOnlyEnv.tooltip.link": "更多信息",
        "mainSidebar.executions": "执行",
        "mainSidebar.workersView": "工作者",
        "menuActions.duplicate": "复制",
        "menuActions.download": "下载",
        "menuActions.push": "推送到Git",
        "menuActions.importFromUrl": "从URL导入...",
        "menuActions.importFromFile": "从文件导入...",
        "menuActions.delete": "删除",
        "multipleParameter.addItem": "添加项目",
        "multipleParameter.currentlyNoItemsExist": "当前没有项目存在",
        "multipleParameter.deleteItem": "删除项目",
        "multipleParameter.moveDown": "向下移动",
        "multipleParameter.moveUp": "向上移动",
        "ndv.backToCanvas": "返回画布",
        "ndv.backToCanvas.waitingForTriggerWarning": "等待触发节点执行。关闭此视图以查看工作流画布。",
        "ndv.execute.testNode": "测试步骤",
        "ndv.execute.testNode.description": "运行当前节点。如果之前的节点尚未运行，也会运行它们",
        "ndv.execute.generateCodeAndTestNode.description": "生成代码然后运行当前节点",
        "ndv.execute.generateCode.message": "'{nodeName}'中的指令已更改",
        "ndv.execute.generateCode.title": "生成转换代码",
        "ndv.execute.executing": "执行中",
        "ndv.execute.fetchEvent": "获取测试事件",
        "ndv.execute.fixPrevious": "首先修复前一个节点",
        "ndv.execute.generatingCode": "根据指令生成代码",
        "ndv.execute.listenForTestEvent": "监听测试事件",
        "ndv.execute.testChat": "测试聊天",
        "ndv.execute.testStep": "测试步骤",
        "ndv.execute.stopListening": "停止监听",
        "ndv.execute.nodeIsDisabled": "启用节点以执行",
        "ndv.execute.requiredFieldsMissing": "首先完成必填字段",
        "ndv.execute.stopWaitingForWebhook.error": "删除测试webhook时出现问题",
        "ndv.execute.workflowAlreadyRunning": "工作流已经在运行",
        "ndv.execute.deactivated": "此节点已停用，无法运行",
        "ndv.featureRequest": "我希望这个节点能...",
        "ndv.input": "输入",
        "ndv.input.nodeDistance": "{count}个节点后 | {count}个节点后",
        "ndv.input.noNodesFound": "未找到节点",
        "ndv.input.mapping": "映射",
        "ndv.input.debugging": "调试",
        "ndv.input.parentNodes": "父节点",
        "ndv.input.tooMuchData.title": "显示数据？",
        "ndv.input.noOutputDataInBranch": "此分支中没有输入数据",
        "ndv.input.noOutputDataInNode": "节点未输出任何数据。如果节点没有输出数据，n8n会停止执行工作流。",
        "ndv.input.noOutputData": "无数据",
        "ndv.input.noOutputData.executePrevious": "执行前一个节点",
        "ndv.input.noOutputData.title": "还没有输入数据",
        "ndv.input.noOutputData.hint": "（从最早需要的节点 {info}）",
        "ndv.input.noOutputData.hint.tooltip": "从未执行的最早节点开始，或已经执行但之后被更改的节点",
        "ndv.input.noOutputData.schemaPreviewHint": "切换到{schema}使用架构预览",
        "ndv.input.noOutputData.or": "或者",
        "ndv.input.executingPrevious": "正在执行前面的节点...",
        "ndv.input.notConnected.title": "连接我",
        "ndv.input.notConnected.message": "只有将此节点连接到另一个节点，它才能接收输入数据。",
        "ndv.input.notConnected.learnMore": "了解更多",
        "ndv.input.disabled": "'{nodeName}'节点已禁用且不会执行。",
        "ndv.input.disabled.cta": "启用它",
        "ndv.input.rootNodeHasNotRun.title": "父节点尚未运行",
        "ndv.input.rootNodeHasNotRun.description": "父节点发送给此节点的输入将在此处显示。要从前一个节点映射数据，请使用{link}视图。",
        "ndv.input.rootNodeHasNotRun.description.link": "映射",
        "ndv.output": "输出",
        "ndv.output.ai.empty": "👈 使用这些日志查看{node}节点完成处理的信息。你可以点击一个节点来查看它接收的输入和输出的数据。",
        "ndv.output.ai.waiting": "等待消息",
        "ndv.output.outType.logs": "日志",
        "ndv.output.outType.regular": "输出",
        "ndv.output.edit": "编辑输出",
        "ndv.output.all": "全部",
        "ndv.output.branch": "分支",
        "ndv.output.executing": "执行节点...",
        "ndv.output.items": "{count} 项 | {count} 项",
        "ndv.output.andSubExecutions": ", {count} 子执行 | , {count} 子执行",
        "ndv.output.noOutputData.message": "当节点没有输出数据时，n8n会停止工作流的执行。你可以通过设置更改这种默认行为",
        "ndv.output.noOutputData.message.settings": "设置",
        "ndv.output.noOutputData.message.settingsOption": "> \'总是输出数据\'。",
        "ndv.output.noOutputData.title": "无输出数据返回",
        "ndv.output.noOutputDataInBranch": "此分支中无输出数据",
        "ndv.output.of": "{current} 共 {total}",
        "ndv.output.pageSize": "页面大小",
        "ndv.output.run": "运行",
        "ndv.output.runNodeHint": "执行此节点以查看数据",
        "ndv.output.runNodeHintSubNode": "一旦父节点运行，输出将显示在这里",
        "ndv.output.waitNodeWaitingForWebhook": "收到以下网址的webhook后执行将继续 ",
        "ndv.output.sendAndWaitWaitingApproval": "用户响应后执行将继续",
        "ndv.output.waitNodeWaitingForFormSubmission": "提交表单后执行将继续",
        "ndv.output.waitNodeWaiting": "等待时间结束后执行将继续",
        "ndv.output.insertTestData": "设置模拟数据",
        "ndv.output.staleDataWarning.regular": "节点参数已更改。<br>重新测试节点以刷新输出。",
        "ndv.output.staleDataWarning.pinData": "节点参数的变化不会影响固定的输出数据。",
        "ndv.output.tooMuchData.message": "该节点包含 {size} MB的数据。显示它们可能会暂时拖慢你的浏览器。",
        "ndv.output.tooMuchData.showDataAnyway": "显示数据",
        "ndv.output.tooMuchData.title": "显示数据？",
        "ndv.output.waitingToRun": "等待执行...",
        "ndv.output.noToolUsedInfo": "此次运行未使用任何工具。尝试给你的工具更清晰的名字和描述以帮助AI理解",
        "ndv.title.cancel": "取消",
        "ndv.title.rename": "重命名",
        "ndv.title.renameNode": "重命名节点",
        "ndv.pinData.pin.title": "固定数据",
        "ndv.pinData.pin.description": "节点将总是输出当前数据而不是执行。不适用于生产执行。",
        "ndv.pinData.pin.binary": "由于此节点的输出包含二进制数据，因此禁用了固定数据。",
        "ndv.pinData.pin.link": "更多信息",
        "ndv.pinData.unpin.title": "取消固定数据",
        "ndv.pinData.pin.multipleRuns.title": "第 #{index} 次运行被固定",
        "ndv.pinData.pin.multipleRuns.description": "每次节点运行时都将输出这次运行的结果。",
        "ndv.pinData.unpinAndExecute.title": "取消固定输出数据？",
        "ndv.pinData.unpinAndExecute.description": "测试节点覆盖固定的数据。",
        "ndv.pinData.unpinAndExecute.cancel": "取消",
        "ndv.pinData.unpinAndExecute.confirm": "取消固定并测试",
        "ndv.pinData.beforeClosing.title": "关闭前保存输出更改？",
        "ndv.pinData.beforeClosing.cancel": "放弃",
        "ndv.pinData.beforeClosing.confirm": "保存",
        "ndv.pinData.error.syntaxError.title": "由于无效的JSON无法保存",
        "ndv.pinData.error.tooLarge.title": "由于大小限制无法固定数据",
        "ndv.pinData.error.tooLarge.description": "工作流已达到允许的最大固定数据大小（{size} mb / {limit} mb）",
        "ndv.pinData.error.tooLargeWorkflow.title": "由于大小限制无法固定数据",
        "ndv.pinData.error.tooLargeWorkflow.description": "工作流已达到允许的最大大小（{size} mb / {limit} mb）",
        "ndv.httpRequest.credentialOnly.docsNotice": "使用<a target=\'_blank\' href=\'{docsUrl}\'>{nodeName} 文档</a>来构建您的请求。如果您在下方添加了{nodeName}凭证，我们将为您处理认证部分。",
        "noTagsView.readyToOrganizeYourWorkflows": "准备好组织您的工作流了吗？",
        "noTagsView.withWorkflowTagsYouReFree": "通过工作流标签，您可以自由创建完美的标签系统来管理您的流程",
        "noAnnotationTagsView.title": "组织您的执行情况",
        "noAnnotationTagsView.description": "执行标签帮助您标记和识别不同的执行类别。此外，一旦给执行打上标签，它就不会被删除",
        "node.thisIsATriggerNode": "这是一个触发器节点。<a target=\'_blank\' href=\'https://docs.n8n.io/workflows/components/nodes/\'>了解更多</a>",
        "node.activateDeactivateNode": "激活/停用节点",
        "node.changeColor": "更改颜色",
        "node.disabled": "已停用",
        "node.testStep": "测试步骤",
        "node.disable": "停用",
        "node.enable": "激活",
        "node.delete": "删除",
        "node.add": "添加",
        "node.issues": "问题",
        "node.dirty": "节点配置已更改。当再次运行此节点时，输出数据可能会改变",
        "node.subjectToChange": "由于工作流的变化，当再次运行此节点时，输出数据可能会改变",
        "node.nodeIsExecuting": "节点正在执行",
        "node.nodeIsWaitingTill": "节点正在等待直到{date} {time}",
        "node.theNodeIsWaitingIndefinitelyForAnIncomingWebhookCall": "节点正在无限期等待传入的webhook调用",
        "node.theNodeIsWaitingWebhookCall": "节点正在等待传入的webhook调用",
        "node.theNodeIsWaitingFormCall": "节点正在等待表单提交",
        "node.theNodeIsWaitingUserInput": "节点正在等待用户输入",
        "node.waitingForYouToCreateAnEventIn": "等待您在{nodeType}中创建一个事件",
        "node.discovery.pinData.canvas": "您可以固定此输出，而不是等待测试事件。打开节点以执行此操作。",
        "node.discovery.pinData.ndv": "您可以固定此输出，而不是等待测试事件。",
        "node.executionError.openNode": "打开节点",
        "nodeBase.clickToAddNodeOrDragToConnect": "点击添加节点\\n或拖动连接",
        "nodeCreator.actionsPlaceholderNode.scheduleTrigger": "按计划",
        "nodeCreator.actionsPlaceholderNode.webhook": "在webhook调用时",
        "nodeCreator.actionsCategory.actions": "动作",
        "nodeCreator.actionsCategory.onNewEvent": "在新的{event}事件上",
        "nodeCreator.actionsCategory.onEvent": "在{event}上",
        "nodeCreator.actionsCategory.triggers": "触发器",
        "nodeCreator.actionsCategory.triggerNodes": "触发器节点",
        "nodeCreator.actionsCategory.regularNodes": "常规节点",
        "nodeCreator.actionsCategory.regularAndTriggers": "常规与触发器节点",
        "nodeCreator.actionsCategory.searchActions": "搜索{node}动作...",
        "nodeCreator.actionsCategory.noMatchingActions": "没有匹配的动作。<i>重置搜索</i>",
        "nodeCreator.actionsCategory.noMatchingTriggers": "没有匹配的触发器。<i>重置搜索</i>",
        "nodeCreator.actionsList.apiCall": "没有找到合适的事件？进行<a data-action='addHttpNode'>自定义{node} API调用</a>",
        "nodeCreator.actionsCallout.noActionItems": "我们还没有<strong>{nodeName}</strong>动作。心中有想法吗？在我们的社区中提出<a target=\'_blank\' href=\'https://community.n8n.io/c/feature-requests/5\'>请求</a>",
        "nodeCreator.actionsCallout.triggersStartWorkflow": "动作需要由另一个节点触发，例如，可以使用<strong>计划</strong>节点定期触发。<a target=\'_blank\' href=\'https://docs.n8n.io/integrations/builtin/\'>了解更多</a>",
        "nodeCreator.actionsTooltip.triggersStartWorkflow": "触发器是启动您的工作流的步骤。<a target=\'_blank\' href=\'https://docs.n8n.io/integrations/builtin/\'>了解更多</a>",
        "nodeCreator.actionsTooltip.actionsPerformStep": "操作在您的工作流启动后执行一个步骤。<a target=\'_blank\' href=\'https://docs.n8n.io/integrations/builtin/\'>了解更多</a>",
        "nodeCreator.actionsCallout.noTriggerItems": "没有<strong>{nodeName}</strong>触发器可用。用户通常将以下触发器与<strong>{nodeName}</strong>操作结合使用。",
        "nodeCreator.categoryNames.otherCategories": "其他类别的结果",
        "nodeCreator.subnodes": "子节点",
        "nodeCreator.noResults.dontWorryYouCanProbablyDoItWithThe": "别担心，您可能可以用",
        "nodeCreator.noResults.httpRequest": "HTTP请求",
        "nodeCreator.noResults.node": "节点",
        "nodeCreator.noResults.or": "或",
        "nodeCreator.noResults.requestTheNode": "请求该节点",
        "nodeCreator.noResults.wantUsToMakeItFaster": "希望我们让它更快吗？",
        "nodeCreator.noResults.weDidntMakeThatYet": "我们还没做那个... 还没",
        "nodeCreator.noResults.webhook": "Webhook",
        "nodeCreator.searchBar.searchNodes": "搜索节点...",
        "nodeCreator.subcategoryDescriptions.appTriggerNodes": "当应用程序中发生某些事情时（如Telegram、Notion或Airtable），运行此流程",
        "nodeCreator.subcategoryDescriptions.appRegularNodes": "在某个应用程序或服务中执行某些操作，例如Google Sheets、Telegram或Notion",
        "nodeCreator.subcategoryDescriptions.dataTransformation": "操纵、过滤或转换数据",
        "nodeCreator.subcategoryDescriptions.files": "CSV、XLS、XML、文本、图像等",
        "nodeCreator.subcategoryDescriptions.flow": "分支、合并或循环流程等",
        "nodeCreator.subcategoryDescriptions.helpers": "运行代码、发起HTTP请求、设置webhook等",
        "nodeCreator.subcategoryDescriptions.otherTriggerNodes": "在工作流错误、文件更改等情况时运行流程",
        "nodeCreator.subcategoryDescriptions.agents": "交互并做出决策的自主实体。",
        "nodeCreator.subcategoryDescriptions.chains": "为特定任务设计的结构化组件。",
        "nodeCreator.subcategoryDescriptions.documentLoaders": "处理文档加载以便进行处理。",
        "nodeCreator.subcategoryDescriptions.embeddings": "将文本转化为向量表示。",
        "nodeCreator.subcategoryDescriptions.languageModels": "理解和生成语言的AI模型。",
        "nodeCreator.subcategoryDescriptions.memory": "管理执行期间信息的存储和检索。",
        "nodeCreator.subcategoryDescriptions.outputParsers": "确保输出遵循定义格式。",
        "nodeCreator.subcategoryDescriptions.retrievers": "从源获取相关信息。",
        "nodeCreator.subcategoryDescriptions.textSplitters": "将文本分解成更小的部分。",
        "nodeCreator.subcategoryDescriptions.tools": "提供各种功能的实用组件。",
        "nodeCreator.subcategoryDescriptions.vectorStores": "处理向量表示的存储和检索。",
        "nodeCreator.subcategoryDescriptions.miscellaneous": "其他与AI相关的节点。",
        "nodeCreator.subcategoryDescriptions.humanInTheLoop": "在继续之前等待批准或人工输入",
        "nodeCreator.subcategoryInfos.languageModels": "聊天模型旨在用于互动对话，并且很好地遵循指令，而文本补全模型专注于生成给定文本输入的延续部分",
        "nodeCreator.subcategoryInfos.memory": "内存允许AI模型记住和引用过去的交互",
        "nodeCreator.subcategoryInfos.vectorStores": "向量存储允许AI模型引用相关文档片段，对于问答和文档搜索很有用",
        "nodeCreator.subcategoryNames.appTriggerNodes": "应用程序事件",
        "nodeCreator.subcategoryNames.appRegularNodes": "应用程序中的操作",
        "nodeCreator.subcategoryNames.dataTransformation": "数据转换",
        "nodeCreator.subcategoryNames.files": "文件",
        "nodeCreator.subcategoryNames.flow": "流程",
        "nodeCreator.subcategoryNames.helpers": "核心",
        "nodeCreator.subcategoryNames.otherTriggerNodes": "其他方式...",
        "nodeCreator.subcategoryNames.agents": "代理",
        "nodeCreator.subcategoryNames.chains": "链",
        "nodeCreator.subcategoryNames.documentLoaders": "文档加载器",
        "nodeCreator.subcategoryNames.embeddings": "嵌入",
        "nodeCreator.subcategoryNames.languageModels": "语言模型",
        "nodeCreator.subcategoryNames.memory": "记忆",
        "nodeCreator.subcategoryNames.outputParsers": "输出解析器",
        "nodeCreator.subcategoryNames.retrievers": "检索器",
        "nodeCreator.subcategoryNames.textSplitters": "文本分割器",
        "nodeCreator.subcategoryNames.tools": "工具",
        "nodeCreator.subcategoryNames.vectorStores": "向量存储",
        "nodeCreator.subcategoryNames.miscellaneous": "杂项",
        "nodeCreator.subcategoryNames.humanInTheLoop": "人工介入",
        "nodeCreator.sectionNames.popular": "热门",
        "nodeCreator.sectionNames.other": "其他",
        "nodeCreator.sectionNames.sendAndWait": "发送并等待响应",
        "nodeCreator.sectionNames.transform.combine": "合并项目",
        "nodeCreator.sectionNames.transform.addOrRemove": "添加或移除项目",
        "nodeCreator.sectionNames.transform.convert": "转换数据",
        "nodeCreator.triggerHelperPanel.addAnotherTrigger": "添加另一个触发器",
        "nodeCreator.triggerHelperPanel.addAnotherTriggerDescription": "触发器启动您的工作流。工作流可以有多个触发器。",
        "nodeCreator.triggerHelperPanel.title": "此工作流应在何时运行？",
        "nodeCreator.triggerHelperPanel.scheduleTriggerDisplayName": "按计划",
        "nodeCreator.triggerHelperPanel.scheduleTriggerDescription": "每天、每小时或自定义间隔运行流程",
        "nodeCreator.triggerHelperPanel.webhookTriggerDisplayName": "在webhook调用时",
        "nodeCreator.triggerHelperPanel.webhookTriggerDescription": "在收到HTTP请求时运行流程",
        "nodeCreator.triggerHelperPanel.formTriggerDisplayName": "在表单提交时",
        "nodeCreator.triggerHelperPanel.formTriggerDescription": "在n8n中生成网络表单并将它们的响应传递给工作流",
        "nodeCreator.triggerHelperPanel.formDisplayName": "表单",
        "nodeCreator.triggerHelperPanel.formDescription": "添加下一个表单页面",
        "nodeCreator.triggerHelperPanel.manualTriggerDisplayName": "手动触发",
        "nodeCreator.triggerHelperPanel.manualTriggerDescription": "在n8n中点击按钮时运行流程。非常适合快速开始",
        "nodeCreator.triggerHelperPanel.manualChatTriggerDisplayName": "在聊天消息时",
        "nodeCreator.triggerHelperPanel.manualChatTriggerDescription": "当用户发送聊天消息时运行流程。用于与AI节点一起使用",
        "nodeCreator.triggerHelperPanel.manualTriggerTag": "推荐",
        "nodeCreator.triggerHelperPanel.chatTriggerDisplayName": "在聊天消息时",
        "nodeCreator.triggerHelperPanel.chatTriggerDescription": "当用户发送聊天消息时运行流程。用于与AI节点一起使用",
        "nodeCreator.triggerHelperPanel.whatHappensNext": "接下来会发生什么？",
        "nodeCreator.triggerHelperPanel.selectATrigger": "是什么触发了这个工作流？",
        "nodeCreator.triggerHelperPanel.selectATriggerDescription": "触发器是启动您工作流的一个步骤",
        "nodeCreator.triggerHelperPanel.workflowTriggerDisplayName": "当被另一个工作流执行时",
        "nodeCreator.triggerHelperPanel.workflowTriggerDescription": "当由不同工作流中的执行工作流节点调用时运行流程",
        "nodeCreator.aiPanel.aiNodes": "AI节点",
        "nodeCreator.aiPanel.aiOtherNodes": "其他AI节点",
        "nodeCreator.aiPanel.aiOtherNodesDescription": "嵌入、向量存储、LLM和其他AI节点",
        "nodeCreator.aiPanel.selectAiNode": "选择一个AI节点添加到您的工作流",
        "nodeCreator.aiPanel.nodesForAi": "构建自主代理、总结或搜索文档等",
        "nodeCreator.aiPanel.newTag": "新",
        "nodeCreator.aiPanel.langchainAiNodes": "高级AI",
        "nodeCreator.aiPanel.title": "此工作流应在何时运行？",
        "nodeCreator.aiPanel.linkItem.description": "看看有什么可能，并以5倍的速度开始",
        "nodeCreator.aiPanel.linkItem.title": "AI模板",
        "nodeCreator.aiPanel.scheduleTriggerDisplayName": "按计划",
        "nodeCreator.aiPanel.scheduleTriggerDescription": "每天、每小时或自定义间隔运行流程",
        "nodeCreator.aiPanel.webhookTriggerDisplayName": "在webhook调用时",
        "nodeCreator.aiPanel.webhookTriggerDescription": "当另一个应用程序发送webhook时运行流程",
        "nodeCreator.aiPanel.manualTriggerDisplayName": "手动",
        "nodeCreator.aiPanel.manualTriggerDescription": "点击n8n中的按钮运行流程",
        "nodeCreator.aiPanel.whatHappensNext": "接下来会发生什么？",
        "nodeCreator.aiPanel.selectATrigger": "选择一个AI组件",
        "nodeCreator.aiPanel.selectATriggerDescription": "触发器是启动工作流的步骤",
        "nodeCreator.aiPanel.workflowTriggerDisplayName": "当被另一个工作流执行时",
        "nodeCreator.aiPanel.workflowTriggerDescription": "当从不同的工作流中通过执行工作流节点调用时运行流程",
        "nodeCreator.nodeItem.triggerIconTitle": "触发节点",
        "nodeCreator.nodeItem.aiIconTitle": "LangChain AI节点",
        "nodeCredentials.createNew": "创建新凭证",
        "nodeCredentials.credentialFor": "{credentialType}的凭证",
        "nodeCredentials.credentialsLabel": "连接所用的凭证",
        "nodeCredentials.issues": "问题",
        "nodeCredentials.selectCredential": "选择凭证",
        "nodeCredentials.selectedCredentialUnavailable": "{name}（不可用）",
        "nodeCredentials.showMessage.message": "使用凭证“{oldCredentialName}”的节点已更新为使用“{newCredentialName}”",
        "nodeCredentials.showMessage.title": "节点凭证已更新",
        "nodeCredentials.updateCredential": "更新凭证",
        "nodeErrorView.cause": "原因",
        "nodeErrorView.copyToClipboard": "复制到剪贴板",
        "nodeErrorView.copyToClipboard.tooltip": "复制错误详情以供调试。复制的数据可能包含敏感信息。分享时请谨慎。",
        "nodeErrorView.dataBelowMayContain": "以下数据可能包含敏感信息。分享时请谨慎。",
        "nodeErrorView.details": "详情",
        "nodeErrorView.details.from": "来自{node}",
        "nodeErrorView.details.rawMessages": "完整消息",
        "nodeErrorView.details.errorData": "错误数据",
        "nodeErrorView.details.errorExtra": "错误额外信息",
        "nodeErrorView.details.request": "请求",
        "nodeErrorView.details.title": "错误详情",
        "nodeErrorView.details.message": "错误消息",
        "nodeErrorView.details.info": "其他信息",
        "nodeErrorView.details.nodeVersion": "节点版本",
        "nodeErrorView.details.nodeType": "节点类型",
        "nodeErrorView.details.n8nVersion": "n8n版本",
        "nodeErrorView.details.errorCause": "错误原因",
        "nodeErrorView.details.causeDetailed": "详细原因",
        "nodeErrorView.details.stackTrace": "堆栈跟踪",
        "nodeErrorView.error": "错误",
        "nodeErrorView.errorSubNode": "子节点‘{node}’出错",
        "nodeErrorView.httpCode": "HTTP代码",
        "nodeErrorView.errorCode": "错误代码",
        "nodeErrorView.inParameter": "在或下面参数",
        "nodeErrorView.itemIndex": "项目索引",
        "nodeErrorView.runIndex": "运行索引",
        "nodeErrorView.showMessage.title": "已复制到剪贴板",
        "nodeErrorView.stack": "堆栈",
        "nodeErrorView.theErrorCauseIsTooLargeToBeDisplayed": "错误原因太大，无法显示",
        "nodeErrorView.time": "时间",
        "nodeErrorView.inputPanel.previousNodeError.title": "运行节点'{nodeName}'出错",
        "nodeErrorView.description.pairedItemInvalidInfo": "这里使用的表达式不起作用，因为它使用了<code>.item</code>, 而n8n无法找出<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>匹配项</a>。这是因为节点<strong>'{nodeCause}'</strong>返回了不正确的匹配信息（对于运行{runIndex}的项目{itemIndex}）。 <br/><br/>尝试改用<code>.first()</code>, <code>.last()</code> 或 <code>.all()[index]</code>而不是<code>.item</code>。",
        "nodeErrorView.description.pairedItemNoInfo": "这里使用的表达式不起作用，因为它使用了<code>.item</code>, 而n8n无法找出<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>匹配项</a>。节点<strong>'{nodeCause}'</strong>没有返回足够的信息。",
        "nodeErrorView.description.pairedItemNoInfoCodeNode": "这里的表达式不起作用，因为它使用了<code>.item</code>, 而n8n无法确定<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>匹配项</a>。你可以： <ul><li>将<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-code-node/\'>缺失的信息</a>添加到节点<strong>'{nodeCause}'</strong></li><li>或者使用<code>.first()</code>, <code>.last()</code> 或 <code>.all()[index]</code> 替代<code>.item</code></li></ul>",
        "nodeErrorView.description.pairedItemNoConnection": "没有返回到节点 <strong>'{nodeCause}'</strong> 的连接，但它在这里的表达式中被使用。<br/><br/>请连接节点（可以有其他节点在中间）。",
        "nodeErrorView.description.pairedItemNoConnectionCodeNode": "没有返回到节点 <strong>'{nodeCause}'</strong> 的连接，但这里的代码使用了它。<br/><br/>请连接节点（可以有其他节点在中间）。",
        "nodeErrorView.description.noNodeExecutionData": "表达式引用了节点 <strong>'{nodeCause}'</strong>, 但它尚未执行。要么更改表达式，要么重新连接你的工作流以确保该节点首先执行。",
        "nodeErrorView.description.nodeNotFound": "节点 <strong>'{nodeCause}'</strong> 不存在，但在此处的表达式中使用了它。",
        "nodeErrorView.description.noInputConnection": "此节点没有任何输入数据。请确保此节点连接到另一个节点。",
        "nodeErrorView.description.pairedItemMultipleMatches": "这里的表达式不起作用，因为它使用了<code>.item</code>, 而n8n无法确定<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>匹配项</a>。（有多个可能的匹配项）<br/><br/>尝试使用<code>.first()</code>, <code>.last()</code> 或 <code>.all()[index]</code> 替代<code>.item</code> 或者<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-code-node/\'>引用不同的节点</a>。",
        "nodeErrorView.description.pairedItemMultipleMatchesCodeNode": "这里的代码不起作用，因为它使用了<code>.item</code>, 而n8n无法确定<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>匹配项</a>。（有多个可能的匹配项）<br/><br/>尝试使用<code>.first()</code>, <code>.last()</code> 或 <code>.all()[index]</code> 替代<code>.item</code> 或者<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-code-node/\'>引用不同的节点</a>。",
        "nodeErrorView.description.pairedItemPinned": "<a target=\'_blank\' href=\'https://docs.n8n.io/data/data-mapping/data-item-linking/item-linking-errors/\'>项目匹配</a>中的数据可能是过期的。它被此处使用<code>.item</code>的表达式所需要。",
        "nodeHelpers.credentialsUnset": "'{credentialType}' 的凭据未设置。",
        "nodeSettings.alwaysOutputData.description": "如果激活，将在输出为空时输出一个空的单一项。用于防止工作流在此节点结束。",
        "nodeSettings.alwaysOutputData.displayName": "总是输出数据",
        "nodeSettings.clickOnTheQuestionMarkIcon": "点击 '?' 图标在此节点上打开 n8n.io",
        "nodeSettings.onError.description": "节点执行失败时采取的动作",
        "nodeSettings.onError.displayName": "发生错误时",
        "nodeSettings.onError.options.continueRegularOutput.description": "将错误消息作为常规输出中的项传递",
        "nodeSettings.onError.options.continueRegularOutput.displayName": "继续",
        "nodeSettings.onError.options.continueErrorOutput.description": "将项传递给额外的 \`error\` 输出",
        "nodeSettings.onError.options.continueErrorOutput.displayName": "继续（使用错误输出）",
        "nodeSettings.onError.options.stopWorkflow.description": "停止执行并使工作流失败",
        "nodeSettings.onError.options.stopWorkflow.displayName": "停止工作流",
        "nodeSettings.docs": "文档",
        "nodeSettings.executeButtonTooltip.times": "将执行 {inputSize} 次，每个输入项一次",
        "nodeSettings.executeOnce.description": "如果激活，节点仅执行一次，使用从第一个接收项得到的数据",
        "nodeSettings.executeOnce.displayName": "仅执行一次",
        "nodeSettings.maxTries.description": "在执行失败前尝试执行节点的次数",
        "nodeSettings.maxTries.displayName": "最大尝试次数",
        "nodeSettings.noDescriptionFound": "未找到描述",
        "nodeSettings.nodeDescription": "节点描述",
        "nodeSettings.notes.description": "保存与节点一起的可选注释",
        "nodeSettings.notes.displayName": "注释",
        "nodeSettings.notesInFlow.description": "如果激活，上述注释将以副标题形式显示在流程中",
        "nodeSettings.notesInFlow.displayName": "在流程中显示注释？",
        "nodeSettings.parameters": "参数",
        "nodeSettings.settings": "设置",
        "nodeSettings.communityNodeTooltip": "这是一个 <a href=\'{docUrl}\' target=\'_blank\'/>社区节点</a>",
        "nodeSettings.retryOnFail.description": "如果激活，节点在失败时会尝试再次执行",
        "nodeSettings.retryOnFail.displayName": "失败时重试",
        "nodeSettings.scopes.expandedNoticeWithScopes": "<a data-key=\'toggle-expand\'>{count} 权限</a> 对于 {activeCredential} 凭据可用<br>{scopes}<br><a data-key=\'show-less\'>显示较少</a> | <a data-key=\'toggle-expand\'>{count} 权限</a> 对于 {activeCredential} 凭据可用<br>{scopes}<br><a data-key=\'show-less\'>显示较少</a>",
        "nodeSettings.scopes.notice": "<a data-key=\'toggle-expand\'>{count} 权限</a> 对于 {activeCredential} 凭据可用 | <a data-key=\'toggle-expand\'>{count} 权限</a> 对于 {activeCredential} 凭据可用",
        "nodeSettings.theNodeIsNotValidAsItsTypeIsUnknown": "节点无效，因为其类型 ({nodeType}) 未知",
        "nodeSettings.communityNodeUnknown.title": "安装此节点以使用它",
        "nodeSettings.communityNodeUnknown.description": "此节点当前未安装。它是 {action} 社区包的一部分。",
        "nodeSettings.communityNodeUnknown.installLink.text": "如何安装社区节点",
        "nodeSettings.nodeTypeUnknown.description": "此节点目前未安装。它来自更新版本的 n8n、一个 {action} 或具有无效结构",
        "nodeSettings.nodeTypeUnknown.description.customNode": "自定义节点",
        "nodeSettings.thisNodeDoesNotHaveAnyParameters": "此节点没有任何参数",
        "nodeSettings.useTheHttpRequestNode": "使用<b>HTTP 请求</b>节点进行自定义 API 调用。我们将为您处理{n8nAuth} 认证。<a target=\'_blank\' href=\'https://docs.n8n.io/integrations/custom-operations/\'>了解更多</a>",
        "nodeSettings.waitBetweenTries.description": "每次尝试之间等待的时间长度（毫秒）",
        "nodeSettings.waitBetweenTries.displayName": "等待时间（毫秒）",
        "nodeSettings.hasForeignCredential": "要编辑此节点，您需要：\\n a) 请求{owner}与您共享凭证，或\\n b) 复制节点并添加您自己的凭证",
        "nodeSettings.latest": "最新",
        "nodeSettings.deprecated": "已弃用",
        "nodeSettings.latestVersion": "最新版本： {version}",
        "nodeSettings.outputCleared.title": "参数已更改",
        "nodeSettings.outputCleared.message": "参数顺序已更改，传出连接已被清除",
        "nodeSettings.nodeVersion": "{node} 节点版本 {version}",
        "nodeView.addNode": "添加节点",
        "nodeView.openNodesPanel": "打开节点面板",
        "nodeView.addATriggerNodeFirst": "首先添加一个<a data-action='showNodeCreator'>触发节点</a>",
        "nodeView.addOrEnableTriggerNode": "<a data-action='showNodeCreator'>添加</a>或启用一个触发节点以执行工作流",
        "nodeView.addSticky": "单击添加便签",
        "nodeView.addStickyHint": "添加便签",
        "nodeView.cantExecuteNoTrigger": "无法执行工作流",
        "nodeView.canvasAddButton.addATriggerNodeBeforeExecuting": "在执行工作流之前添加一个触发节点",
        "nodeView.canvasAddButton.addFirstStep": "添加第一步…",
        "nodeView.confirmMessage.onClipboardPasteEvent.cancelButtonText": "",
        "nodeView.confirmMessage.onClipboardPasteEvent.confirmButtonText": "是的，导入",
        "nodeView.confirmMessage.onClipboardPasteEvent.headline": "导入工作流？",
        "nodeView.confirmMessage.onClipboardPasteEvent.message": "将从<br /><i>{plainTextData}<i>导入工作流",
        "nodeView.confirmMessage.debug.cancelButtonText": "取消",
        "nodeView.confirmMessage.debug.confirmButtonText": "取消固定",
        "nodeView.confirmMessage.debug.headline": "取消固定工作流数据",
        "nodeView.confirmMessage.debug.message": "加载此次执行将会取消固定当前这些节点中固定的数据",
        "nodeView.couldntImportWorkflow": "无法导入工作流",
        "nodeView.couldntLoadWorkflow.invalidWorkflowObject": "无效的工作流对象",
        "nodeView.deletesTheCurrentExecutionData": "删除当前执行数据",
        "nodeView.itLooksLikeYouHaveBeenEditingSomething": "看起来您进行了某些编辑。如果在保存前离开，您的更改将会丢失。",
        "nodeView.loadingTemplate": "加载模板",
        "nodeView.moreInfo": "更多信息",
        "nodeView.noNodesGivenToAdd": "未指定要添加的节点",
        "nodeView.prompt.cancel": "@:_reusableBaseText.cancel",
        "nodeView.prompt.invalidName": "无效名称",
        "nodeView.prompt.newName": "新名称",
        "nodeView.prompt.rename": "重命名",
        "nodeView.prompt.renameNode": "重命名节点",
        "nodeView.redirecting": "重定向",
        "nodeView.refresh": "刷新",
        "nodeView.resetZoom": "重置缩放",
        "nodeView.tidyUp": "整理",
        "nodeView.runButtonText.executeWorkflow": "测试工作流",
        "nodeView.runButtonText.executingWorkflow": "正在执行工作流",
        "nodeView.runButtonText.waitingForTriggerEvent": "等待触发事件",
        "nodeView.showError.workflowError": "工作流执行出错",
        "nodeView.showError.getWorkflowDataFromUrl.title": "加载工作流时出现问题",
        "nodeView.showError.importWorkflowData.title": "导入工作流时出现问题",
        "nodeView.showError.mounted1.message": "初始化数据加载时出现问题",
        "nodeView.showError.mounted1.title": "初始化问题",
        "nodeView.showError.mounted2.message": "初始化工作流时出现问题",
        "nodeView.showError.mounted2.title": "初始化问题",
        "nodeView.showError.openExecution.title": "执行加载问题",
        "nodeView.showError.openWorkflow.title": "打开工作流问题",
        "nodeView.showError.stopExecution.title": "停止执行问题",
        "nodeView.showError.stopWaitingForWebhook.title": "删除测试webhook问题",
        "nodeView.showError.nodeNodeCompatible.title": "无法连接",
        "nodeView.showError.nodeNodeCompatible.message": "节点“{sourceNodeName}”无法连接到节点“{targetNodeName}”，因为它们不兼容。",
        "nodeView.showMessage.addNodeButton.message": "'{nodeTypeName}' 是未知的节点类型",
        "nodeView.showMessage.addNodeButton.title": "无法插入节点",
        "nodeView.showMessage.keyDown.title": "工作流已创建",
        "nodeView.showMessage.showMaxNodeTypeError.message": "一个工作流中仅允许有一个 '{nodeTypeDataDisplayName}' 节点 | 一个工作流中仅允许有 {count} 个 '{nodeTypeDataDisplayName}' 节点",
        "nodeView.showMessage.showMaxNodeTypeError.title": "无法插入节点",
        "nodeView.showMessage.stopExecutionCatch.unsaved.message": "此执行已被取消",
        "nodeView.showMessage.stopExecutionCatch.unsaved.title": "执行已取消",
        "nodeView.showMessage.stopExecutionCatch.message": "在能够停止之前它已完成",
        "nodeView.showMessage.stopExecutionCatch.title": "工作流执行完毕",
        "nodeView.showMessage.stopExecutionTry.title": "执行已停止",
        "nodeView.showMessage.debug.title": "执行数据已导入",
        "nodeView.showMessage.debug.content": "您可以进行编辑并重新执行。完成后，取消固定第一个节点。",
        "nodeView.showMessage.debug.missingNodes.title": "部分执行数据未导入",
        "nodeView.showMessage.debug.missingNodes.content": "自执行以来，一些节点已被删除、重命名或添加到工作流。",
        "nodeView.stopCurrentExecution": "停止当前执行",
        "nodeView.stopWaitingForWebhookCall": "停止等待webhook调用",
        "nodeView.stoppingCurrentExecution": "正在停止当前执行",
        "nodeView.thereWasAProblemLoadingTheNodeParametersOfNode": "加载节点参数时出现问题",
        "nodeView.thisExecutionHasntFinishedYet": "此执行尚未完成",
        "nodeView.toSeeTheLatestStatus": "查看最新状态",
        "nodeView.workflowTemplateWithIdCouldNotBeFound": "找不到ID为“{templateId}”的工作流模板",
        "nodeView.workflowWithIdCouldNotBeFound": "找不到ID为“{workflowId}”的工作流",
        "nodeView.zoomIn": "放大",
        "nodeView.zoomOut": "缩小",
        "nodeView.zoomToFit": "缩放以适应",
        "nodeView.replaceMe": "替换我",
        "nodeView.setupTemplate": "设置模板",
        "nodeViewV2.showError.editingNotAllowed": "不允许编辑",
        "nodeViewV2.showError.failedToCreateNode": "创建节点失败",
        "contextMenu.node": "节点 | 节点",
        "contextMenu.sticky": "便签 | 便签",
        "contextMenu.selectAll": "全选",
        "contextMenu.deselectAll": "清除选择",
        "contextMenu.tidyUpWorkflow": "整理工作流",
        "contextMenu.tidyUpSelection": "整理选择",
        "contextMenu.duplicate": "复制 | 复制 {count} {subject}",
        "contextMenu.open": "打开...",
        "contextMenu.test": "测试步骤",
        "contextMenu.rename": "重命名",
        "contextMenu.copy": "复制 | 复制 {count} {subject}",
        "contextMenu.deactivate": "停用 | 停用 {count} {subject}",
        "contextMenu.activate": "激活 | 激活 {count} 节点",
        "contextMenu.pin": "固定 | 固定 {count} 节点",
        "contextMenu.unpin": "取消固定 | 取消固定 {count} 节点",
        "contextMenu.delete": "删除 | 删除 {count} {subject}",
        "contextMenu.addNode": "添加节点",
        "contextMenu.addSticky": "添加便签",
        "contextMenu.editSticky": "编辑便签",
        "contextMenu.changeColor": "更改颜色",
        "nodeWebhooks.clickToCopyWebhookUrls": "点击复制Webhook URL",
        "nodeWebhooks.clickToCopyWebhookUrls.formTrigger": "点击复制表单URL",
        "nodeWebhooks.clickToCopyWebhookUrls.chatTrigger": "点击复制聊天URL",
        "nodeWebhooks.clickToDisplayWebhookUrls": "点击显示Webhook URL",
        "nodeWebhooks.clickToDisplayWebhookUrls.formTrigger": "点击显示表单URL",
        "nodeWebhooks.clickToDisplayWebhookUrls.chatTrigger": "点击显示聊天URL",
        "nodeWebhooks.clickToHideWebhookUrls": "点击隐藏Webhook URL",
        "nodeWebhooks.clickToHideWebhookUrls.formTrigger": "点击隐藏表单URL",
        "nodeWebhooks.clickToHideWebhookUrls.chatTrigger": "点击隐藏聊天URL",
        "nodeWebhooks.invalidExpression": "[无效表达式]",
        "nodeWebhooks.productionUrl": "生产环境URL",
        "nodeWebhooks.showMessage.title": "URL已复制",
        "nodeWebhooks.showMessage.title.formTrigger": "表单URL已复制",
        "nodeWebhooks.showMessage.title.chatTrigger": "聊天URL已复制",
        "nodeWebhooks.showMessage.message.formTrigger": "通过此URL提交的表单将在工作流激活时触发它",
        "nodeWebhooks.showMessage.message.chatTrigger": "通过此URL提交的聊天将在工作流激活时触发它",
        "nodeWebhooks.testUrl": "测试URL",
        "nodeWebhooks.webhookUrls": "Webhook URLs",
        "nodeWebhooks.webhookUrls.formTrigger": "表单URLs",
        "nodeWebhooks.webhookUrls.chatTrigger": "聊天URL",
        "openWorkflow.workflowImportError": "无法导入工作流",
        "openWorkflow.workflowNotFoundError": "找不到工作流",
        "parameterInput.expressionResult": "例如：{result}",
        "parameterInput.tip": "提示",
        "parameterInput.dragTipBeforePill": "将一个",
        "parameterInput.inputField": "输入字段",
        "parameterInput.dragTipAfterPill": "从左侧拖到这里使用。",
        "parameterInput.learnMore": "了解更多",
        "parameterInput.result": "结果",
        "parameterInput.item": "项目",
        "parameterInput.hoverTableItemTip": "您也可以通过在表格视图中悬停在输入/输出项上来完成此操作",
        "parameterInput.emptyString": "[空]",
        "parameterInput.customApiCall": "自定义API调用",
        "parameterInput.error": "错误",
        "parameterInput.expression": "表达式",
        "parameterInput.fixed": "固定",
        "parameterInput.formatHtml": "格式化HTML",
        "parameterInput.issues": "问题",
        "parameterInput.loadingOptions": "正在加载选项...",
        "parameterInput.loadOptionsErrorService": "从{service}获取选项时出错",
        "parameterInput.loadOptionsError": "获取选项时出错",
        "parameterInput.loadOptionsCredentialsRequired": "设置凭据以查看选项",
        "parameterInput.openEditWindow": "打开编辑窗口",
        "parameterInput.parameter": "参数: \'{shortPath}\'",
        "parameterInput.parameterHasExpression": "参数: \'{shortPath}\' 包含一个表达式",
        "parameterInput.parameterHasIssues": "参数: \'{shortPath}\' 存在问题",
        "parameterInput.parameterHasIssuesAndExpression": "参数: \'{shortPath}\' 存在问题并且有一个表达式",
        "parameterInput.refreshList": "刷新列表",
        "parameterInput.clearContents": "清除内容",
        "parameterInput.resetValue": "重置值",
        "parameterInput.select": "选择",
        "parameterInput.selectDateAndTime": "选择日期和时间",
        "parameterInput.selectACredentialTypeFromTheDropdown": "从下拉菜单中选择一种凭证类型",
        "parameterInput.theValueIsNotSupported": "值 \'{checkValue}\' 不被支持！",
        "parameterInputExpanded.openDocs": "打开文档",
        "parameterInputExpanded.thisFieldIsRequired": "此字段是必需的",
        "parameterInputList.delete": "删除",
        "parameterInputList.deleteParameter": "删除参数",
        "parameterInputList.parameterOptions": "参数选项",
        "parameterInputList.loadingFields": "正在加载字段...",
        "parameterInputList.loadingError": "加载字段时出错。请刷新页面并重试。",
        "parameterOverride.overridePanelText": "由 <b>模型</b> 自动定义",
        "parameterOverride.applyOverrideButtonTooltip": "让模型定义此参数",
        "parameterOverride.descriptionTooltip": "向LLM解释应如何生成此值，一个好的、具体的描述将使LLMs更经常地产生预期结果",
        "personalizationModal.businessOwner": "企业主",
        "personalizationModal.continue": "继续",
        "personalizationModal.cicd": "CI/CD",
        "personalizationModal.cloudInfrastructureOrchestration": "云基础设施编排",
        "personalizationModal.customerIntegrations": "客户集成",
        "personalizationModal.customerSupport": "客户服务支持",
        "personalizationModal.customizeN8n": "自定义 n8n",
        "personalizationModal.dataScience": "数据科学",
        "personalizationModal.devops": "开发运维",
        "personalizationModal.digitalAgencyOrConsultant": "营销代理/咨询",
        "personalizationModal.eCommerce": "电子商务",
        "personalizationModal.education": "教育",
        "personalizationModal.engineering": "工程",
        "personalizationModal.engineeringOrDevops": "工程/开发运维",
        "personalizationModal.errorWhileSubmittingResults": "提交结果时出错",
        "personalizationModal.financeOrAccounting": "财务/会计",
        "personalizationModal.financeOrInsurance": "金融/保险",
        "personalizationModal.getStarted": "开始使用",
        "personalizationModal.government": "政府",
        "personalizationModal.healthcare": "医疗保健",
        "personalizationModal.howAreYourCodingSkills": "你的编程技能如何？",
        "personalizationModal.howBigIsYourCompany": "你的公司有多大？",
        "personalizationModal.hr": "人力资源",
        "personalizationModal.imNotUsingN8nForWork": "我使用n8n不是为了工作",
        "personalizationModal.it": "信息技术",
        "personalizationModal.legal": "法律",
        "personalizationModal.lessThan20People": "少于20人",
        "personalizationModal.managedServiceProvider": "管理服务提供商",
        "personalizationModal.manufacturing": "制造业",
        "personalizationModal.marketing": "市场营销",
        "personalizationModal.media": "媒体",
        "personalizationModal.notSureYet": "还不确定",
        "personalizationModal.operations": "运营",
        "personalizationModal.other": "其他",
        "personalizationModal.otherPleaseSpecify": "其他（请说明）",
        "personalizationModal.specifyReportedSource": "请说明您是如何得知n8n的",
        "personalizationModal.people": "人员",
        "personalizationModal.physicalRetailOrServices": "实体零售或服务",
        "personalizationModal.product": "产品（例如快速原型设计）",
        "personalizationModal.realEstateOrConstruction": "房地产/建筑",
        "personalizationModal.saas": "软件即服务",
        "personalizationModal.salesAndMarketing": "销售和市场营销",
        "personalizationModal.security": "安全",
        "personalizationModal.select": "请选择...",
        "personalizationModal.howDidYouHearAboutN8n": "您是如何得知n8n的？",
        "personalizationModal.friendWordOfMouth": "朋友/口碑",
        "personalizationModal.podcast": "播客",
        "personalizationModal.event": "活动",
        "personalizationModal.myself": "我自己",
        "personalizationModal.myTeam": "我的团队",
        "personalizationModal.otherTeams": "其他团队",
        "personalizationModal.specifyAutomationBeneficiary": "您的自动化主要是为了谁？",
        "personalizationModal.specifyYourRole": "请说明您的角色",
        "personalizationModal.specifyYourAutomationGoal": "请说明您的自动化目标",
        "personalizationModal.specifyYourCompanysIndustry": "请说明您公司的行业",
        "personalizationModal.support": "支持",
        "personalizationModal.systemsIntegrator": "系统集成商/自动化代理",
        "personalizationModal.telecoms": "电信",
        "personalizationModal.thanks": "谢谢！",
        "personalizationModal.theseQuestionsHelpUs": "这些问题帮助我们为您量身定制n8n",
        "personalizationModal.whichRoleBestDescribesYou": "哪个角色最能描述您？",
        "personalizationModal.whatAreYouLookingToAutomate": "您希望实现什么的自动化？",
        "personalizationModal.whatBestDescribesYourCompany": "哪项最能描述您的公司？",
        "personalizationModal.whichIndustriesIsYourCompanyIn": "您的公司在哪些行业？",
        "personalizationModal.specifySalesMarketingGoal": "销售和市场营销的哪些部分？",
        "personalizationModal.leadGeneration": "潜在客户生成、丰富、路由",
        "personalizationModal.customerCommunication": "客户沟通",
        "personalizationModal.customerActions": "当潜在客户状态改变时的操作",
        "personalizationModal.yourEmailAddress": "您的电子邮件地址",
        "personalizationModal.email": "输入您的电子邮件..",
        "personalizationModal.adCampaign": "广告活动管理",
        "personalizationModal.reporting": "报告",
        "personalizationModal.ticketingSystemsIntegrations": "票务系统集成",
        "personalizationModal.dataSynching": "数据同步",
        "personalizationModal.incidentResponse": "事件响应",
        "personalizationModal.monitoringAndAlerting": "监控和告警",
        "personalizationModal.specifyUsageMode": "您是否希望执行以下任何操作？",
        "personalizationModal.connectToInternalDB": "连接到我公司的内部数据库",
        "personalizationModal.buildBackendServices": "构建后端服务（端点）",
        "personalizationModal.manipulateFiles": "处理/传输文件",
        "personalizationModal.specifyOtherSalesAndMarketingGoal": "请说明您的其他销售和市场营销目标",
        "personalizationModal.registerEmailForTrial": "注册您的电子邮件以激活我们{trial}的14天免费试用",
        "personalizationModal.registerEmailForTrial.enterprise": "企业功能",
        "personalizationModal.registerEmailForTrial.notice": "勾选此框，即表示您同意让我们存储您的姓名和电子邮件以激活您的试用并发送许可证密钥。我们将在试用结束时进行跟进，确保您充分利用我们的企业功能。",
        "personalizationModal.registerEmailForTrial.success.title": "您的企业许可证即将发送",
        "personalizationModal.registerEmailForTrial.success.message": "您将很快收到一封激活企业许可证的电子邮件。如果未看到，请检查垃圾邮件文件夹。",
        "personalizationModal.registerEmailForTrial.success.button": "开始使用n8n",
        "personalizationModal.registerEmailForTrial.error": "注册企业试用版时出错",
        "pushConnection.nodeExecutedSuccessfully": "节点执行成功",
        "pushConnection.workflowExecutedSuccessfully": "工作流执行成功",
        "pushConnectionTracker.cannotConnectToServer": "您遇到了连接问题或服务器已关闭。<br />一旦问题解决，n8n应自动重新连接。",
        "pushConnectionTracker.connectionLost": "连接丢失",
        "pushConnectionTracker.connectionLost.message": "正在尝试重新连接...",
        "pushConnection.pollingNode.dataNotFound": "{service}数据未找到",
        "pushConnection.pollingNode.dataNotFound.message": "我们在{service}中没有找到任何可以模拟事件的数据。请在{service}中创建一个并重试。",
        "pushConnection.executionFailed": "执行失败",
        "pushConnection.executionFailed.message": "可能没有足够的内存来完成执行。避免这种情况的提示<a target=\'_blank\' href=\'https://docs.n8n.io/flow-logic/error-handling/memory-errors/\'>这里</a>",
        "pushConnection.executionError": "执行工作流时出现问题{error}",
        "pushConnection.executionError.openNode": "打开错误节点",
        "pushConnection.executionError.details": "<br /><strong>{details}</strong>",
        "prompts.productTeamMessage": "我们的产品团队会亲自与您联系",
        "prompts.npsSurvey.recommendationQuestion": "您向朋友或同事推荐n8n的可能性有多大？",
        "prompts.npsSurvey.greatFeedbackTitle": "很高兴听到！我们可以联系您看看如何让n8n对您来说更好吗？",
        "prompts.npsSurvey.defaultFeedbackTitle": "感谢您的反馈！我们很乐意了解如何改进。我们可以联系您吗？",
        "prompts.npsSurvey.notLikely": "不太可能",
        "prompts.npsSurvey.veryLikely": "非常可能",
        "prompts.npsSurvey.send": "发送",
        "prompts.npsSurvey.yourEmailAddress": "您的电子邮件地址",
        "prompts.npsSurvey.reviewUs": "如果您愿意提供更多帮助，请在<a target=\'_blank\' href=\'https://www.g2.com/products/n8n/reviews/start\'>G2上给我们留下评论</a>。",
        "prompts.npsSurvey.thanks": "感谢您的反馈",
        "resourceLocator.id.placeholder": "输入ID...",
        "resourceLocator.mode.id": "通过ID",
        "resourceLocator.mode.url": "通过URL",
        "resourceLocator.mode.list": "从列表中选择",
        "resourceLocator.mode.list.disabled.title": "更改为固定模式以从列表中选择",
        "resourceLocator.mode.list.error.title": "无法加载列表",
        "resourceLocator.mode.list.error.description.checkCredentials": "检查您的凭证",
        "resourceLocator.mode.list.error.description.noCredentials": "添加您的凭证",
        "resourceLocator.mode.list.noResults": "无结果",
        "resourceLocator.mode.list.openUrl": "打开URL",
        "resourceLocator.mode.list.placeholder": "选择...",
        "resourceLocator.mode.list.searchRequired": "输入搜索词以显示结果",
        "resourceLocator.modeSelector.placeholder": "模式...",
        "resourceLocator.openSpecificResource": "在{appName}中打开{entity}",
        "resourceLocator.openResource": "在{appName}中打开",
        "resourceLocator.search.placeholder": "搜索...",
        "resourceLocator.url.placeholder": "输入URL...",
        "resourceMapper.autoMappingNotice": "在此模式下，请确保传入的数据字段名称与{serviceName}中的{fieldWord}名称相同。（如果需要，在此节点前使用“编辑字段”节点更改它们。）",
        "resourceMapper.mappingMode.label": "映射列模式",
        "resourceMapper.mappingMode.defineBelow.name": "手动映射每一列",
        "resourceMapper.mappingMode.defineBelow.description": "为每个{fieldWord}设置值",
        "resourceMapper.mappingMode.autoMapInputData.name": "自动映射",
        "resourceMapper.mappingMode.autoMapInputData.description": "查找与{serviceName}中的{fieldWord}匹配的传入数据",
        "resourceMapper.fetchingFields.message": "获取{fieldWord}",
        "resourceMapper.fetchingFields.errorMessage": "无法获取{fieldWord}。",
        "resourceMapper.fetchingFields.noFieldsFound": "{serviceName}中未找到{fieldWord}。",
        "resourceMapper.columnsToMatchOn.label": "用于匹配的{fieldWord}",
        "resourceMapper.columnsToMatchOn.multi.description": "当将{nodeDisplayName}中的行与该节点的输入项匹配时使用的{fieldWord}。通常是ID。",
        "resourceMapper.columnsToMatchOn.single.description": "当将{nodeDisplayName}中的行与该节点的输入项匹配时使用的{fieldWord}。通常是ID。",
        "resourceMapper.columnsToMatchOn.tooltip": "在查找要更新的行时比较的{fieldWord}",
        "resourceMapper.columnsToMatchOn.noFieldsFound": "{serviceName}中未找到可用于匹配的{fieldWord}。",
        "resourceMapper.valuesToSend.label": "要发送的值",
        "resourceMapper.valuesToUpdate.label": "要更新的值",
        "resourceMapper.usingToMatch": "(使用进行匹配)",
        "resourceMapper.usingToMatch.description": "此{fieldWord}不会被更新且不能被移除，因为它用于匹配",
        "resourceMapper.removeField": "移除{fieldWord}",
        "resourceMapper.mandatoryField.title": "此{fieldWord}是必填项且不能被移除",
        "resourceMapper.addFieldToSend": "添加要发送的{fieldWord}",
        "resourceMapper.matching.title": "此{fieldWord}用于匹配且不能被移除",
        "resourceMapper.addAllFields": "添加所有{fieldWord}",
        "resourceMapper.removeAllFields": "移除所有{fieldWord}",
        "resourceMapper.refreshFieldList": "刷新{fieldWord}列表",
        "resourceMapper.staleDataWarning.tooltip": "{fieldWord}已过期。请刷新以查看更改。",
        "resourceMapper.staleDataWarning.notice": "请刷新以查看更新后的字段",
        "resourceMapper.attemptToConvertTypes.displayName": "尝试转换类型",
        "resourceMapper.attemptToConvertTypes.description": "映射字段时尝试转换类型",
        "runData.openSubExecutionSingle": "查看子执行",
        "runData.openSubExecutionWithId": "查看子执行{id}",
        "runData.openParentExecution": "查看父执行{id}",
        "runData.emptyItemHint": "这是一个项目，但是它是空的。",
        "runData.emptyArray": "[空数组]",
        "runData.emptyString": "[空]",
        "runData.emptyObject": "[空对象]",
        "runData.unnamedField": "[未命名字段]",
        "runData.switchToBinary.info": "此项目只有",
        "runData.switchToBinary.binary": "二进制数据",
        "runData.linking.hint": "链接显示的输入和输出运行",
        "runData.unlinking.hint": "取消链接显示的输入和输出运行",
        "runData.binary": "二进制",
        "runData.copyItemPath": "复制项目路径",
        "runData.copyItemPath.toast": "项目路径已复制",
        "runData.copyParameterPath": "复制参数路径",
        "runData.copyParameterPath.toast": "参数路径已复制",
        "runData.copyValue": "复制选择",
        "runData.copyValue.toast": "输出数据已复制",
        "runData.copyToClipboard": "复制到剪贴板",
        "runData.copyDisabled": "首先点击您想要复制的输出数据，然后点击此按钮。",
        "runData.editOutput": "编辑输出",
        "runData.editOutputInvalid": "输出数据有问题",
        "runData.editOutputInvalid.singleQuote": "意外的单引号。请使用双引号(\')代替",
        "runData.editOutputInvalid.onLine": "在第{line}行:",
        "runData.editOutputInvalid.atPosition": "(在位置 {position})",
        "runData.editValue": "编辑值",
        "runData.executionStatus.success": "执行成功",
        "runData.executionStatus.failed": "执行失败",
        "runData.downloadBinaryData": "下载",
        "runData.executeNode": "测试节点",
        "runData.executionTime": "执行时间",
        "runData.fileExtension": "文件扩展名",
        "runData.directory": "目录",
        "runData.fileName": "文件名",
        "runData.invalidPinnedData": "无效的固定数据",
        "runData.items": "项目",
        "runData.json": "JSON",
        "runData.schema": "模式",
        "runData.mimeType": "MIME类型",
        "runData.fileSize": "文件大小",
        "runData.ms": "毫秒",
        "runData.noBinaryDataFound": "未找到二进制数据",
        "runData.noData": "无数据",
        "runData.noTextDataFound": "未找到文本数据",
        "runData.nodeReturnedALargeAmountOfData": "节点返回了大量数据",
        "runData.output": "输出",
        "runData.showBinaryData": "查看",
        "runData.startTime": "开始时间",
        "runData.table": "表格",
        "runData.table.viewSubExecution": "查看子执行{id}",
        "runData.pindata.learnMore": "了解更多",
        "runData.pindata.thisDataIsPinned": "此数据已被固定。",
        "runData.pindata.unpin": "取消固定",
        "runData.editor.save": "保存",
        "runData.editor.cancel": "取消",
        "runData.editor.copyDataInfo": "您可以从之前的执行中复制数据并粘贴到上面。",
        "runData.aiContentBlock.startedAt": "开始于{startTime}",
        "runData.aiContentBlock.tokens": "{count} Tokens",
        "runData.aiContentBlock.tokens.prompt": "提示:",
        "runData.aiContentBlock.tokens.completion": "完成:",
        "runData.trimmedData.title": "数据暂不可视",
        "runData.trimmedData.message": "执行完成后，它将在此可用。",
        "runData.trimmedData.loading": "加载数据",
        "runData.panel.actions.collapse": "折叠面板",
        "runData.panel.actions.open": "打开面板",
        "runData.panel.actions.popOut": "弹出面板",
        "saveButton.save": "@:_reusableBaseText.save",
        "saveButton.saved": "已保存",
        "saveWorkflowButton.hint": "保存工作流",
        "saveButton.saving": "正在保存",
        "settings": "设置",
        "settings.communityNodes": "社区节点",
        "settings.communityNodes.empty.title": "使用社区节点增强您的工作流",
        "settings.communityNodes.empty.description": "安装由我们社区贡献的超过{count}个节点包。",
        "settings.communityNodes.empty.description.no-packages": "安装我们社区贡献的节点包。",
        "settings.communityNodes.empty.installPackageLabel": "安装社区节点",
        "settings.communityNodes.npmUnavailable.warning": "要使用此功能，请<a href=\'{npmUrl}\' target=\'_blank\' title=\'如何安装npm\'>安装npm</a>并重启n8n。",
        "settings.communityNodes.packageNodes.label": "{count} 节点 | {count} 节点",
        "settings.communityNodes.updateAvailable.tooltip": "有新版本可用",
        "settings.communityNodes.viewDocsAction.label": "文档",
        "settings.communityNodes.uninstallAction.label": "卸载包",
        "settings.communityNodes.upToDate.tooltip": "已是最新版本",
        "settings.communityNodes.failedToLoad.tooltip": "此包存在问题，尝试卸载后重新安装以解决此问题",
        "settings.communityNodes.fetchError.title": "获取已安装包时出现问题",
        "settings.communityNodes.fetchError.message": "您的互联网连接或n8n实例可能存在一些问题",
        "settings.communityNodes.installModal.title": "安装社区节点",
        "settings.communityNodes.installModal.description": "在npm公共注册表中查找要添加的社区节点。",
        "settings.communityNodes.browseButton.label": "浏览",
        "settings.communityNodes.installModal.packageName.label": "npm包名称",
        "settings.communityNodes.installModal.packageName.tooltip": "<img src='/static/community_package_tooltip_img.png'/><p>这是<a href='{npmURL}'>npmjs.com</a>上的包标题</p><p>通过在{'@'}之后添加具体版本号来安装特定版本，例如<code>package-name{'@'}0.15.0</code></p>",
        "settings.communityNodes.installModal.packageName.placeholder": "例如 n8n-nodes-chatwork",
        "settings.communityNodes.installModal.checkbox.label": "我了解从公共资源安装未验证代码的风险。",
        "settings.communityNodes.installModal.installButton.label": "安装",
        "settings.communityNodes.installModal.installButton.label.loading": "正在安装",
        "settings.communityNodes.installModal.error.packageNameNotValid": "包名必须以n8n-nodes-开头",
        "settings.communityNodes.messages.install.success": "包已安装",
        "settings.communityNodes.messages.install.error": "安装新包时出错",
        "settings.communityNodes.messages.uninstall.error": "卸载包时出现问题",
        "settings.communityNodes.messages.uninstall.success.title": "包已卸载",
        "settings.communityNodes.messages.update.success.title": "包已更新",
        "settings.communityNodes.messages.update.success.message": "{packageName} 已更新至版本 {version}",
        "settings.communityNodes.messages.update.error.title": "更新包时出现问题",
        "settings.communityNodes.confirmModal.uninstall.title": "卸载包？",
        "settings.communityNodes.confirmModal.uninstall.message": "使用来自 {packageName} 包的节点的所有工作流将无法运行。确定吗？",
        "settings.communityNodes.confirmModal.uninstall.buttonLabel": "卸载包",
        "settings.communityNodes.confirmModal.uninstall.buttonLoadingLabel": "正在卸载",
        "settings.communityNodes.confirmModal.update.title": "更新社区节点包？",
        "settings.communityNodes.confirmModal.update.message": "您即将更新 {packageName} 至版本 {version}",
        "settings.communityNodes.confirmModal.update.description": "我们建议您停用使用该包任何节点的工作流，并在更新完成后重新激活它们",
        "settings.communityNodes.confirmModal.update.buttonLabel": "更新包",
        "settings.communityNodes.confirmModal.update.buttonLoadingLabel": "正在更新...",
        "settings.goBack": "返回",
        "settings.personal": "个人",
        "settings.personal.basicInformation": "基本信息",
        "settings.personal.personalSettings": "个人设置",
        "settings.personal.personalSettingsUpdated": "个人信息已更新",
        "settings.personal.personalSettingsUpdatedError": "更新您的详细信息时出现问题",
        "settings.personal.save": "保存",
        "settings.personal.security": "安全",
        "settings.signup.signUpInviterInfo": "{firstName} {lastName} 邀请您加入 n8n",
        "settings.users": "用户",
        "settings.users.confirmDataHandlingAfterDeletion": "我们应该如何处理他们的数据？",
        "settings.users.confirmUserDeletion": "确定要删除此受邀用户吗？",
        "settings.users.delete": "删除",
        "settings.users.deleteConfirmationMessage": "输入\'删除所有数据\'以确认",
        "settings.users.deleteConfirmationText": "删除所有数据",
        "settings.users.deleteUser": "删除 {user}",
        "settings.users.actions.delete": "删除用户",
        "settings.users.actions.reinvite": "重新发送邀请",
        "settings.users.actions.copyInviteLink": "复制邀请链接",
        "settings.users.actions.copyPasswordResetLink": "复制密码重置链接",
        "settings.users.actions.allowSSOManualLogin": "允许手动登录",
        "settings.users.actions.disallowSSOManualLogin": "禁止手动登录",
        "settings.users.deleteWorkflowsAndCredentials": "删除他们的工作流和凭据",
        "settings.users.emailInvitesSent": "邀请邮件已发送到 {emails}",
        "settings.users.emailInvitesSentError": "无法邀请 {emails}",
        "settings.users.emailSentTo": "电子邮件已发送至 {email}",
        "settings.users.invalidEmailError": "{email} 不是有效的电子邮件",
        "settings.users.inviteLink.copy": "复制邀请链接",
        "settings.users.inviteLink.error": "无法获取邀请链接",
        "settings.users.invite": "邀请",
        "settings.users.invite.tooltip": "SAML 登录已激活。用户应在 IdP 中创建，并将在首次登录 n8n 时进行配置。",
        "settings.users.inviteNewUsers": "邀请新用户",
        "settings.users.copyInviteUrls": "现在您可以直接将邀请链接发送给您的用户",
        "settings.users.inviteResent": "邀请已重新发送",
        "settings.users.inviteUser": "邀请用户",
        "settings.users.inviteUser.inviteUrl": "创建邀请链接",
        "settings.users.inviteXUser": "邀请 {count} 位用户",
        "settings.users.inviteXUser.inviteUrl": "创建 {count} 个邀请链接",
        "settings.users.inviteUrlCreated": "邀请链接已复制到剪贴板",
        "settings.users.inviteUrlCreated.message": "将邀请链接发送给受邀者以激活",
        "settings.users.passwordResetUrlCreated": "密码重置链接已复制到剪贴板",
        "settings.users.passwordResetUrlCreated.message": "将重置链接发送给您的用户，让他们重置密码",
        "settings.users.allowSSOManualLogin": "允许手动登录",
        "settings.users.allowSSOManualLogin.message": "用户现在可以通过手动和单点登录登录",
        "settings.users.disallowSSOManualLogin": "禁止手动登录",
        "settings.users.disallowSSOManualLogin.message": "用户现在必须仅通过单点登录登录",
        "settings.users.multipleInviteUrlsCreated": "邀请链接已创建",
        "settings.users.multipleInviteUrlsCreated.message": "将邀请链接发送给受邀者以激活",
        "settings.users.newEmailsToInvite": "新用户电子邮件地址",
        "settings.users.noUsersToInvite": "没有用户可以邀请",
        "settings.users.setupMyAccount": "设置我的所有者账户",
        "settings.users.setupToInviteUsers": "要邀请用户，请先设置您自己的账户",
        "settings.users.setupToInviteUsersInfo": "除非升级，否则被邀请的用户将无法查看其他用户的工作流和凭据。<a href=\'https://docs.n8n.io/user-management/\' target=\'_blank\'>更多信息</a> <br /> <br />",
        "settings.users.smtpToAddUsersWarning": "在添加用户之前设置 SMTP（以便 n8n 可以向他们发送邀请电子邮件）。<a target=\'_blank\' href=\'https://docs.n8n.io/hosting/authentication/user-management-self-hosted/\'>说明</a>",
        "settings.users.transferWorkflowsAndCredentials": "将其工作流和凭据转移到另一个用户或项目",
        "settings.users.transferWorkflowsAndCredentials.user": "要转移至的用户或项目",
        "settings.users.transferWorkflowsAndCredentials.placeholder": "选择项目或用户",
        "settings.users.transferredToUser": "数据已转移到 {projectName}",
        "settings.users.userDeleted": "用户已被删除",
        "settings.users.userDeletedError": "删除用户时出现问题",
        "settings.users.userInvited": "用户已被邀请",
        "settings.users.userInvitedError": "无法邀请用户",
        "settings.users.userReinviteError": "无法重新邀请用户",
        "settings.users.userToTransferTo": "要转移给的用户",
        "settings.users.usersEmailedError": "无法发送邀请邮件",
        "settings.users.usersInvited": "已邀请的用户",
        "settings.users.usersInvitedError": "无法邀请用户",
        "settings.users.advancedPermissions.warning": "{link} 以解锁创建额外管理员用户的权限",
        "settings.users.advancedPermissions.warning.link": "升级",
        "settings.users.userRoleUpdated": "更改已保存",
        "settings.users.userRoleUpdated.message": "{user} 已成功更新为 {role}",
        "settings.users.userRoleUpdatedError": "无法更新角色",
        "settings.api": "API",
        "settings.n8napi": "n8n API",
        "settings.log-streaming": "日志流传输",
        "settings.log-streaming.heading": "日志流传输",
        "settings.log-streaming.add": "添加新目标",
        "settings.log-streaming.actionBox.title": "企业版可用",
        "settings.log-streaming.actionBox.description": "日志流传输是一项付费功能。了解更多。",
        "settings.log-streaming.actionBox.button": "查看方案",
        "settings.log-streaming.infoText": "将日志发送到您选择的外部端点。您也可以使用环境变量将日志写入文件或控制台。<a href=\'https://docs.n8n.io/log-streaming/\' target=\'_blank\'>更多信息</a>",
        "settings.log-streaming.addFirstTitle": "设置一个目标以开始",
        "settings.log-streaming.addFirst": "通过点击按钮并选择目标类型来添加您的第一个目标。",
        "settings.log-streaming.saving": "正在保存",
        "settings.log-streaming.delete": "删除",
        "settings.log-streaming.continue": "继续",
        "settings.log-streaming.selecttype": "选择类型创建",
        "settings.log-streaming.selecttypehint": "为新的日志流目标选择类型",
        "settings.log-streaming.tab.settings": "设置",
        "settings.log-streaming.tab.events": "事件",
        "settings.log-streaming.tab.events.title": "选择要订阅的组或单个事件：",
        "settings.log-streaming.tab.events.anonymize": "匿名化敏感数据",
        "settings.log-streaming.tab.events.anonymize.info": "包含姓名或电子邮件等个人信息的字段将被匿名化",
        "settings.log-streaming.eventGroup.n8n.ai": "AI节点日志",
        "settings.log-streaming.eventGroup.n8n.audit": "审计事件",
        "settings.log-streaming.eventGroup.n8n.audit.info": "当用户详情或其他审计数据发生变化时，将会发送事件",
        "settings.log-streaming.eventGroup.n8n.workflow": "工作流事件",
        "settings.log-streaming.eventGroup.n8n.workflow.info": "将发送工作流执行事件",
        "settings.log-streaming.eventGroup.n8n.user": "用户",
        "settings.log-streaming.eventGroup.n8n.node": "节点执行",
        "settings.log-streaming.eventGroup.n8n.node.info": "每次节点执行时都会发送逐步执行事件。请注意，这可能导致高频率的日志记录，并可能不适合常规使用。",
        "settings.log-streaming.eventGroup.n8n.worker": "工作者",
        "settings.log-streaming.$$AbstractMessageEventBusDestination": "通用",
        "settings.log-streaming.$$MessageEventBusDestinationWebhook": "Webhook",
        "settings.log-streaming.$$MessageEventBusDestinationSentry": "Sentry",
        "settings.log-streaming.$$MessageEventBusDestinationRedis": "Redis",
        "settings.log-streaming.$$MessageEventBusDestinationSyslog": "Syslog",
        "settings.log-streaming.destinationDelete.cancelButtonText": "",
        "settings.log-streaming.destinationDelete.confirmButtonText": "是的，删除",
        "settings.log-streaming.destinationDelete.headline": "删除目标？",
        "settings.log-streaming.destinationDelete.message": "您确定要删除 '{destinationName}' 吗？",
        "settings.log-streaming.addDestination": "添加新目标",
        "settings.log-streaming.destinations": "日志目标",
        "settings.api.trial.upgradePlan.title": "升级以使用API",
        "settings.api.trial.upgradePlan.description": "为防止滥用，我们在试用期间限制了您的工作区对API的访问。如果这影响了您对n8n的评估，请联系 <a href=\'mailto:support{'@'}n8n.io\'>support{'@'}n8n.io</a>",
        "settings.api.trial.upgradePlan.cta": "升级计划",
        "settings.api.create.description": "使用<a href=\'https://docs.n8n.io/api\' target=\'_blank\'>n8n API</a>以编程方式控制n8n",
        "settings.api.create.button": "创建API密钥",
        "settings.api.create.button.loading": "正在创建API密钥...",
        "settings.api.create.error": "API密钥创建失败。",
        "settings.api.edit.error": "API密钥更新失败。",
        "settings.api.delete.title": "删除此API密钥？",
        "settings.api.delete.description": "任何使用此API密钥的应用程序都将无法再访问n8n。此操作不可撤销。",
        "settings.api.delete.button": "永久删除",
        "settings.api.delete.error": "删除API密钥失败。",
        "settings.api.delete.toast": "API密钥已删除",
        "settings.api.create.toast": "API密钥已创建",
        "settings.api.update.toast": "API密钥已更新",
        "settings.api.creationTime": "API密钥创建于 {time}",
        "settings.api.expirationTime": "过期时间 {time}",
        "settings.api.expired": "此API密钥已过期",
        "settings.api.neverExpires": "永不过期",
        "settings.api.view.copy.toast": "API密钥已复制到剪贴板",
        "settings.api.view.apiPlayground": "API游乐场",
        "settings.api.view.info": "使用您的API密钥通过{apiAction}以编程方式控制n8n。但如果您只想触发工作流，请考虑改用{webhookAction}。",
        "settings.api.view.copy": "请确保现在就复制您的API密钥，因为您以后将无法再次看到它。",
        "settings.api.view.info.api": "n8n API",
        "settings.api.view.info.webhook": "webhook节点",
        "settings.api.view.tryapi": "尝试使用",
        "settings.api.view.more-details": "您可以在",
        "settings.api.view.external-docs": "API文档中找到更多详情",
        "settings.api.view.error": "无法检查API密钥是否已存在。",
        "settings.api.view.modal.form.label": "标签",
        "settings.api.view.modal.form.expiration": "过期时间",
        "settings.api.view.modal.form.expirationText": "API密钥将在{expirationDate}过期",
        "settings.api.view.modal.form.label.placeholder": "例如 内部项目",
        "settings.api.view.modal.form.expiration.custom": "自定义",
        "settings.api.view.modal.form.expiration.days": "{numberOfDays} 天",
        "settings.api.view.modal.form.expiration.none": "无过期时间",
        "settings.api.view.modal.title.created": "API密钥已创建",
        "settings.api.view.modal.title.create": "创建API密钥",
        "settings.api.view.modal.title.edit": "编辑API密钥",
        "settings.api.view.modal.done.button": "完成",
        "settings.api.view.modal.edit.button": "编辑",
        "settings.api.view.modal.save.button": "保存",
        "settings.version": "版本",
        "settings.usageAndPlan.title": "使用情况和计划",
        "settings.usageAndPlan.description": "您正在使用{name}{type}",
        "settings.usageAndPlan.plan": "计划",
        "settings.usageAndPlan.callOut": "{link}解锁付费功能（永久免费）",
        "settings.usageAndPlan.callOut.link": "解锁",
        "settings.usageAndPlan.edition": "版本",
        "settings.usageAndPlan.error": "@:_reusableBaseText.error",
        "settings.usageAndPlan.activeWorkflows": "活跃工作流",
        "settings.usageAndPlan.activeWorkflows.unlimited": "@:_reusableBaseText.unlimited",
        "settings.usageAndPlan.activeWorkflows.count": "{count} of {limit}",
        "settings.usageAndPlan.activeWorkflows.hint": "具有多个触发器的活跃工作流会多次计数",
        "settings.usageAndPlan.button.activation": "输入激活密钥",
        "settings.usageAndPlan.button.plans": "查看计划",
        "settings.usageAndPlan.button.manage": "管理计划",
        "settings.usageAndPlan.dialog.activation.title": "输入激活密钥",
        "settings.usageAndPlan.dialog.activation.label": "激活密钥",
        "settings.usageAndPlan.dialog.activation.activate": "@:_reusableBaseText.activate",
        "settings.usageAndPlan.dialog.activation.cancel": "@:_reusableBaseText.cancel",
        "settings.usageAndPlan.license.activation.error.title": "激活失败",
        "settings.usageAndPlan.license.activation.success.title": "许可证已激活",
        "settings.usageAndPlan.license.activation.success.message": "您的{name}{type}已成功激活。",
        "settings.usageAndPlan.license.communityRegistered.tooltip": "您已注册电子邮件以解锁社区计划中的其他功能",
        "settings.externalSecrets.title": "外部秘密",
        "settings.externalSecrets.info": "连接外部秘密工具，以实现跨环境的集中凭据管理，并增强系统安全性。",
        "settings.externalSecrets.info.link": "更多信息",
        "settings.externalSecrets.actionBox.title": "适用于企业计划",
        "settings.externalSecrets.actionBox.description": "连接外部秘密工具，以实现跨实例的集中凭据管理。{link}",
        "settings.externalSecrets.actionBox.description.link": "更多信息",
        "settings.externalSecrets.actionBox.buttonText": "查看计划",
        "settings.externalSecrets.card.setUp": "设置",
        "settings.externalSecrets.card.deprecated": "已弃用",
        "settings.externalSecrets.card.secretsCount": "{count}个秘密",
        "settings.externalSecrets.card.connectedAt": "于{date}连接",
        "settings.externalSecrets.card.connected": "已启用",
        "settings.externalSecrets.card.disconnected": "已禁用",
        "settings.externalSecrets.card.actionDropdown.setup": "编辑连接",
        "settings.externalSecrets.card.actionDropdown.reload": "重新加载秘密",
        "settings.externalSecrets.card.reload.success.title": "重新加载成功",
        "settings.externalSecrets.card.reload.success.description": "所有秘密已从{provider}重新加载。",
        "settings.externalSecrets.provider.title": "提交并推送更改",
        "settings.externalSecrets.provider.description": "选择您想要在提交中暂存的文件并添加提交信息。",
        "settings.externalSecrets.provider.buttons.cancel": "取消",
        "settings.externalSecrets.provider.buttons.save": "保存",
        "settings.externalSecrets.provider.buttons.saving": "正在保存",
        "settings.externalSecrets.card.connectedSwitch.title": "启用{provider}",
        "settings.externalSecrets.provider.save.success.title": "提供商设置保存成功",
        "settings.externalSecrets.provider.connected.success.title": "提供商连接成功",
        "settings.externalSecrets.provider.disconnected.success.title": "提供商断开成功",
        "settings.externalSecrets.provider.testConnection.success.connected": "服务已启用，在{provider}上可用{count}个秘密。",
        "settings.externalSecrets.provider.testConnection.success.connected.usage": "通过将参数设置为表达式并在其中键入：{code}来在凭据中使用秘密。",
        "settings.externalSecrets.provider.testConnection.success.connected.docs": "更多信息",
        "settings.externalSecrets.provider.testConnection.success": "连接到{provider}执行成功。启用服务以在凭据中使用秘密。",
        "settings.externalSecrets.provider.testConnection.error.connected": "连接不成功，请检查您的{provider}设置",
        "settings.externalSecrets.provider.testConnection.error": "连接不成功，请检查您的{provider}设置",
        "settings.externalSecrets.provider.closeWithoutSaving.title": "不保存就关闭？",
        "settings.externalSecrets.provider.closeWithoutSaving.description": "确定要放弃对{provider}设置所做的更改吗？",
        "settings.externalSecrets.provider.closeWithoutSaving.cancel": "关闭",
        "settings.externalSecrets.provider.closeWithoutSaving.confirm": "继续编辑",
        "settings.externalSecrets.docs": "https://docs.n8n.io/external-secrets/",
        "settings.externalSecrets.docs.use": "https://docs.n8n.io/external-secrets/#use-secrets-in-n8n-credentials",
        "settings.sourceControl.title": "环境",
        "settings.sourceControl.actionBox.title": "企业计划可用",
        "settings.sourceControl.actionBox.description": "对不同的环境（开发，生产等）使用多个实例，通过Git仓库在它们之间部署。",
        "settings.sourceControl.actionBox.description.link": "更多信息",
        "settings.sourceControl.actionBox.buttonText": "查看计划",
        "settings.sourceControl.connection.error": "源控制连接失败",
        "settings.sourceControl.connection.error.message": "我们找不到与此实例关联的仓库。请检查此实例上的{link}。",
        "settings.sourceControl.connection.error.link": "Git配置",
        "settings.sourceControl.description": "对不同的环境（开发，生产等）使用多个实例，通过Git仓库在它们之间部署。 {link}",
        "settings.sourceControl.description.link": "更多信息",
        "settings.sourceControl.gitConfig": "Git配置",
        "settings.sourceControl.repoUrl": "Git仓库URL（SSH）",
        "settings.sourceControl.repoUrlPlaceholder": "例如 git{'@'}github.com:my-team/my-repository",
        "settings.sourceControl.repoUrlInvalid": "Git仓库URL无效",
        "settings.sourceControl.authorName": "提交作者姓名",
        "settings.sourceControl.authorEmail": "提交作者电子邮件",
        "settings.sourceControl.authorEmailInvalid": "提供的电子邮件不正确",
        "settings.sourceControl.sshKey": "SSH密钥",
        "settings.sourceControl.sshKeyDescription": "将SSH密钥粘贴到您的git仓库/账户设置中。 {link}",
        "settings.sourceControl.sshKeyDescriptionLink": "更多信息",
        "settings.sourceControl.refreshSshKey": "刷新密钥",
        "settings.sourceControl.refreshSshKey.successful.title": "SSH密钥刷新成功",
        "settings.sourceControl.refreshSshKey.error.title": "SSH密钥刷新失败",
        "settings.sourceControl.button.continue": "继续",
        "settings.sourceControl.button.connect": "连接",
        "settings.sourceControl.button.disconnect": "断开Git连接",
        "settings.sourceControl.button.save": "保存设置",
        "settings.sourceControl.instanceSettings": "实例设置",
        "settings.sourceControl.branches": "连接到此n8n实例的分支",
        "settings.sourceControl.protected": "{bold}：防止编辑工作流（推荐用于生产环境）。",
        "settings.sourceControl.protected.bold": "受保护的实例",
        "settings.sourceControl.color": "颜色",
        "settings.sourceControl.switchBranch.title": "切换到{branch}分支",
        "settings.sourceControl.switchBranch.description": "请确认您要将当前的n8n实例切换到分支：{branch}",
        "settings.sourceControl.sync.prompt.title": "同步{branch}分支中的更改",
        "settings.sourceControl.sync.prompt.description": "您n8n实例上的所有更改都将与远程git仓库中的{branch}分支同步。将执行以下git序列：拉取 > 提交 > 推送。",
        "settings.sourceControl.sync.prompt.placeholder": "提交信息",
        "settings.sourceControl.sync.prompt.error": "请输入提交信息",
        "settings.sourceControl.button.push": "推送",
        "settings.sourceControl.button.pull": "拉取",
        "settings.sourceControl.modals.push.title": "提交并推送更改",
        "settings.sourceControl.modals.push.description": "以下内容将被提交： ",
        "settings.sourceControl.modals.push.description.learnMore": "了解更多",
        "settings.sourceControl.modals.push.filesToCommit": "待提交的文件",
        "settings.sourceControl.modals.push.workflowsToCommit": "选择工作流",
        "settings.sourceControl.modals.push.everythingIsUpToDate": "所有内容都是最新的",
        "settings.sourceControl.modals.push.noWorkflowChanges": "没有工作流变更，但以下内容将被提交： {link}",
        "settings.sourceControl.modals.push.noWorkflowChanges.moreInfo": "更多信息",
        "settings.sourceControl.modals.push.commitMessage": "提交信息",
        "settings.sourceControl.modals.push.commitMessage.placeholder": "例如. 我的提交",
        "settings.sourceControl.modals.push.buttons.cancel": "取消",
        "settings.sourceControl.modals.push.buttons.save": "提交并推送",
        "settings.sourceControl.modals.push.success.title": "推送成功",
        "settings.sourceControl.modals.push.success.description": "已提交并推送到你的远程仓库",
        "settings.sourceControl.status.modified": "已修改",
        "settings.sourceControl.status.deleted": "已删除",
        "settings.sourceControl.status.created": "新建",
        "settings.sourceControl.status.renamed": "重命名",
        "settings.sourceControl.pull.oneLastStep.title": "最后一步",
        "settings.sourceControl.pull.oneLastStep.description": "你有新的凭据/变量。填写它们以确保你的工作流能正常运行",
        "settings.sourceControl.pull.success.title": "拉取成功",
        "settings.sourceControl.pull.upToDate.title": "已是最新",
        "settings.sourceControl.pull.upToDate.description": "没有要从Git拉取的工作流更改",
        "settings.sourceControl.pull.upToDate.variables.title": "完成设置你的新变量以在工作流中使用",
        "settings.sourceControl.pull.upToDate.variables.description": "查看变量",
        "settings.sourceControl.pull.upToDate.credentials.title": "完成设置你的新凭据以在工作流中使用",
        "settings.sourceControl.pull.upToDate.credentials.description": "查看凭据",
        "settings.sourceControl.modals.pull.title": "拉取更改",
        "settings.sourceControl.modals.pull.description": "这些资源将被更新或删除，且对它们的所有本地更改都将丢失。要保留本地版本，请在拉取前推送它。",
        "settings.sourceControl.modals.pull.description.learnMore": "了解更多",
        "settings.sourceControl.modals.pull.buttons.cancel": "@:_reusableBaseText.cancel",
        "settings.sourceControl.modals.pull.buttons.save": "拉取并覆盖",
        "settings.sourceControl.modals.disconnect.title": "断开Git仓库连接",
        "settings.sourceControl.modals.disconnect.message": "请确认你想要断开此n8n实例与Git仓库的连接",
        "settings.sourceControl.modals.disconnect.confirm": "断开Git连接",
        "settings.sourceControl.modals.disconnect.cancel": "@:_reusableBaseText.cancel",
        "settings.sourceControl.modals.refreshSshKey.title": "刷新SSH密钥",
        "settings.sourceControl.modals.refreshSshKey.message": "这将删除当前的SSH密钥并创建一个新的。你将无法再使用当前密钥进行身份验证。",
        "settings.sourceControl.modals.refreshSshKey.cancel": "取消",
        "settings.sourceControl.modals.refreshSshKey.confirm": "刷新密钥",
        "settings.sourceControl.loading.connecting": "正在连接",
        "settings.sourceControl.toast.connected.title": "Git仓库已连接",
        "settings.sourceControl.toast.connected.message": "选择分支以完成配置",
        "settings.sourceControl.toast.connected.error": "连接到Git时出错",
        "settings.sourceControl.toast.disconnected.title": "Git仓库已断开连接",
        "settings.sourceControl.toast.disconnected.message": "你将无法再同步你的实例与远程仓库",
        "settings.sourceControl.toast.disconnected.error": "从Git断开时出错",
        "settings.sourceControl.loading.pull": "从远程拉取",
        "settings.sourceControl.loading.checkingForChanges": "检查更改",
        "settings.sourceControl.loading.push": "推送到远程",
        "settings.sourceControl.lastUpdated": "最后更新于{date} {time}",
        "settings.sourceControl.saved.title": "设置保存成功",
        "settings.sourceControl.refreshBranches.tooltip": "重新加载分支列表",
        "settings.sourceControl.refreshBranches.success": "分支列表更新成功",
        "settings.sourceControl.refreshBranches.error": "刷新分支时出错",
        "settings.sourceControl.docs.url": "https://docs.n8n.io/source-control-environments/",
        "settings.sourceControl.docs.setup.url": "https://docs.n8n.io/source-control-environments/setup/",
        "settings.sourceControl.docs.setup.ssh.url": "https://docs.n8n.io/source-control-environments/setup/#step-3-set-up-a-deploy-key",
        "settings.sourceControl.docs.using.url": "https://docs.n8n.io/source-control-environments/using/",
        "settings.sourceControl.docs.using.pushPull.url": "https://docs.n8n.io/source-control-environments/using/push-pull",
        "settings.sourceControl.error.not.connected.title": "环境未启用",
        "settings.sourceControl.error.not.connected.message": "请前往<a href='/settings/environments'>环境设置</a>连接一个git仓库以激活此功能。",
        "showMessage.cancel": "@:_reusableBaseText.cancel",
        "showMessage.ok": "确定",
        "showMessage.showDetails": "显示详情",
        "startupError": "连接到n8n时出错",
        "startupError.message": "无法连接到服务器。<a data-action='reload'>刷新</a>重试",
        "tagsDropdown.createTag": "创建标签 \'{filter}\'",
        "tagsDropdown.manageTags": "管理标签",
        "tagsDropdown.noMatchingTagsExist": "没有匹配的标签存在",
        "tagsDropdown.noTagsExist": "没有标签存在",
        "tagsDropdown.showError.message": "尝试创建'{name}'标签时出现问题",
        "tagsDropdown.showError.title": "无法创建标签",
        "tagsDropdown.typeToCreateATag": "键入以创建标签",
        "tagsManager.couldNotDeleteTag": "无法删除标签",
        "tagsManager.done": "完成",
        "tagsManager.manageTags": "管理标签",
        "tagsManager.showError.onFetch.title": "无法获取标签",
        "tagsManager.showError.onFetch.message": "尝试获取标签时出现问题",
        "tagsManager.showError.onCreate.message": "尝试创建标签'{escapedName}'时出现问题",
        "tagsManager.showError.onCreate.title": "无法创建标签",
        "tagsManager.showError.onDelete.message": "尝试删除标签'{escapedName}'时出现问题",
        "tagsManager.showError.onDelete.title": "无法删除标签",
        "tagsManager.showError.onUpdate.message": "尝试更新标签'{escapedName}'时出现问题",
        "tagsManager.showError.onUpdate.title": "无法更新标签",
        "tagsManager.showMessage.onDelete.title": "标签已删除",
        "tagsManager.showMessage.onUpdate.title": "标签已更新",
        "tagsManager.tagNameCannotBeEmpty": "标签名称不能为空",
        "tagsTable.areYouSureYouWantToDeleteThisTag": "您确定要删除此标签吗？",
        "tagsTable.cancel": "@:_reusableBaseText.cancel",
        "tagsTable.createTag": "创建标签",
        "tagsTable.deleteTag": "删除标签",
        "tagsTable.editTag": "编辑标签",
        "tagsTable.name": "@:_reusableBaseText.name",
        "tagsTable.noMatchingTagsExist": "没有匹配的标签存在",
        "tagsTable.saveChanges": "保存更改？",
        "tagsTable.usage": "使用情况",
        "tagsTableHeader.addNew": "添加新项",
        "tagsTableHeader.searchTags": "搜索标签",
        "tagsView.inUse": "{count} 个工作流",
        "tagsView.notBeingUsed": "未被使用",
        "onboarding.title": "演示：{name}",
        "template.buttons.goBackButton": "返回",
        "template.buttons.useThisWorkflowButton": "使用此工作流",
        "template.details.appsInTheCollection": "本集合包含",
        "template.details.appsInTheWorkflow": "此工作流中的应用程序",
        "template.details.by": "由",
        "template.details.categories": "分类",
        "template.details.created": "创建时间",
        "template.details.details": "详情",
        "template.details.times": "次",
        "template.details.viewed": "查看次数",
        "template.byAuthor": "作者：{name}",
        "templates.allCategories": "全部分类",
        "templates.categoriesHeading": "分类",
        "templates.collection": "合集",
        "templates.collections": "合集",
        "templates.collectionsNotFound": "找不到合集",
        "templates.connectionWarning": "⚠️ 获取工作流模板时出现问题，请检查您的网络连接",
        "templates.heading": "工作流模板",
        "templates.shareWorkflow": "分享模板",
        "templates.noSearchResults": "未找到结果，请调整搜索条件",
        "templates.searchPlaceholder": "搜索工作流",
        "templates.workflows": "工作流",
        "templates.workflowsNotFound": "找不到工作流",
        "textEdit.edit": "编辑",
        "timeAgo.daysAgo": "%s天前",
        "timeAgo.hoursAgo": "%s小时前",
        "timeAgo.inDays": "%s天后",
        "timeAgo.inHours": "%s小时后",
        "timeAgo.inMinutes": "%s分钟后",
        "timeAgo.inMonths": "%s个月后",
        "timeAgo.inOneDay": "1天后",
        "timeAgo.inOneHour": "1小时后",
        "timeAgo.inOneMinute": "1分钟后",
        "timeAgo.inOneMonth": "1个月后",
        "timeAgo.inOneWeek": "1周后",
        "timeAgo.inOneYear": "1年后",
        "timeAgo.inWeeks": "%s周后",
        "timeAgo.inYears": "%s年后",
        "timeAgo.justNow": "刚刚",
        "timeAgo.minutesAgo": "%s分钟前",
        "timeAgo.monthsAgo": "%个月前",
        "timeAgo.oneDayAgo": "1天前",
        "timeAgo.oneHourAgo": "1小时前",
        "timeAgo.oneMinuteAgo": "1分钟前",
        "timeAgo.oneMonthAgo": "1个月前",
        "timeAgo.oneWeekAgo": "1周前",
        "timeAgo.oneYearAgo": "1年前",
        "timeAgo.rightNow": "现在",
        "timeAgo.weeksAgo": "%周前",
        "timeAgo.yearsAgo": "%年前",
        "nodeIssues.credentials.notSet": "未设置{type}的凭据",
        "nodeIssues.credentials.notAvailable": "凭据不可用",
        "nodeIssues.credentials.doNotExist": "{type}不存在名为{name}的凭据",
        "nodeIssues.credentials.doNotExist.hint": "您可以创建同名凭据，刷新后将自动选中",
        "nodeIssues.credentials.notIdentified": "{type}存在名为{name}的凭据",
        "nodeIssues.credentials.notIdentified.hint": "凭据未被清晰识别。请选择正确的凭据。",
        "nodeIssues.input.missing": "没有节点连接到必需的输入“{inputName}”",
        "ndv.trigger.moreInfo": "更多信息",
        "ndv.trigger.copiedTestUrl": "测试URL已复制到剪贴板",
        "ndv.trigger.webhookBasedNode.executionsHelp.inactive": "<b>在构建您的工作流时</b>, 单击‘监听’按钮，然后转到{service}并触发一个事件。这将启动执行，并将在本编辑器中显示。<br /> <br /> <b>一旦您对工作流满意</b>, <a data-key=\'activate\'>激活</a>它。之后每当在{service}中有匹配事件时，工作流将被执行。这些执行将显示在<a data-key=\'executions\'>执行列表</a>中，但不会出现在编辑器中。",
        "ndv.trigger.webhookBasedNode.executionsHelp.active": "<b>在构建您的工作流时</b>, 单击‘监听’按钮，然后转到{service}并触发一个事件。这将启动执行，并将在本编辑器中显示。<br /> <br /> <b>您的工作流也会自动执行</b>, 因为它已被激活。每次在{service}中有匹配事件时，此节点将触发执行。这些执行将显示在<a data-key=\'executions\'>执行列表</a>中，但不会出现在编辑器中。",
        "ndv.trigger.webhookNode.listening": "正在监听测试事件",
        "ndv.trigger.chatTrigger.openChat": "打开聊天窗口",
        "ndv.trigger.webhookNode.formTrigger.listening": "正在监听测试表单提交",
        "ndv.trigger.webhookBasedNode.listening": "正在监听您的触发事件",
        "ndv.trigger.webhookNode.requestHint": "向以下地址发送{type}请求：",
        "ndv.trigger.webhookBasedNode.serviceHint": "转到{service}并创建一个事件",
        "ndv.trigger.webhookBasedNode.chatTrigger.serviceHint": "在聊天中发送消息",
        "ndv.trigger.webhookBasedNode.formTrigger.serviceHint": "提交刚刚在新标签页中打开的测试表单",
        "ndv.trigger.webhookBasedNode.activationHint.inactive": "完成构建工作流后,<a data-key=\'activate\'>激活</a>它以使其也能持续监听（只是那些执行不会在这里显示）。",
        "ndv.trigger.webhookBasedNode.activationHint.active": "此节点也会在新的{service}事件上自动触发（但这些执行不会在此处显示）。",
        "ndv.trigger.pollingNode.activationHint.inactive": "完成构建工作流后,<a data-key=\'activate\'>激活</a>它以使其也能定期检查事件（只是那些执行不会在这里显示）。",
        "ndv.trigger.pollingNode.activationHint.active": "此节点也会在新的{service}事件上自动触发（但这些执行不会在此处显示）。",
        "ndv.trigger.executionsHint.question": "何时此节点会触发我的流程？",
        "ndv.trigger.pollingNode.fetchingEvent": "获取事件",
        "ndv.trigger.pollingNode.fetchingHint": "此节点正在{name}中查找与您定义的事件相似的事件",
        "ndv.trigger.pollingNode.executionsHelp.inactive": "<b>在构建您的工作流时</b>, 单击‘获取’按钮来获取一个模拟事件。它将在本编辑器中显示。<br /><br /><b>一旦您对工作流满意</b>, <a data-key=\'activate\'>激活</a>它。然后n8n将定期检查{service}中的新事件，如果发现任何事件，则执行该工作流。这些执行将显示在<a data-key=\'executions\'>执行列表</a>中，但不会出现在编辑器中。",
        "ndv.trigger.pollingNode.executionsHelp.active": "<b>在构建您的工作流时</b>, 单击‘获取’按钮来获取一个模拟事件。它将在本编辑器中显示。<br /><br /><b>您的工作流也会自动执行</b>, 因为它已被激活。n8n将定期检查{app_name}中的新事件，如果发现任何事件，则执行该工作流。这些执行将显示在<a data-key=\'executions\'>执行列表</a>中，但不会出现在编辑器中。",
        "ndv.trigger.webhookBasedNode.action": "从{name}拉取事件",
        "ndv.search.placeholder.output": "搜索输出",
        "ndv.search.placeholder.input": "搜索选定节点",
        "ndv.search.placeholder.input.schema": "搜索先前节点的字段",
        "ndv.search.noMatch.title": "没有匹配项",
        "ndv.search.noNodeMatch.title": "没有匹配字段",
        "ndv.search.noMatch.description": "尝试更改或{link}过滤器以查看更多内容",
        "ndv.search.noMatch.description.link": "清除",
        "ndv.search.noMatchSchema.description": "要搜索字段值，请切换到表格或JSON视图。{link}",
        "ndv.search.noMatchSchema.description.link": "清除过滤器",
        "ndv.search.items": "{matched} 共 {count} 项 | {matched} 共 {count} 项",
        "updatesPanel.andIs": "并且是",
        "updatesPanel.behindTheLatest": "落后于最新的n8n版本",
        "updatesPanel.howToUpdateYourN8nVersion": "如何更新您的n8n版本",
        "updatesPanel.version": "{numberOfVersions} 版本{howManySuffix}",
        "updatesPanel.weVeBeenBusy": "我们一直很忙 ✨",
        "updatesPanel.youReOnVersion": "您当前使用的是{currentVersionName}, 发布于",
        "versionCard.breakingChanges": "破坏性变更",
        "versionCard.released": "发布日期",
        "versionCard.securityUpdate": "安全更新",
        "versionCard.thisVersionHasASecurityIssue": "此版本存在安全问题。<br />此处列出是为了完整性。",
        "versionCard.unknown": "未知",
        "versionCard.version": "版本",
        "workflowActivator.workflowIsActive": "工作流已激活",
        "workflowActivator.activateWorkflow": "激活工作流",
        "workflowActivator.deactivateWorkflow": "停用工作流",
        "workflowActivator.active": "活跃",
        "workflowActivator.inactive": "未激活",
        "workflowActivator.showError.title": "工作流无法被{newStateName}",
        "workflowActivator.showMessage.activeChangedNodesIssuesExistTrue.message": "请在激活前解决未处理的问题",
        "workflowActivator.showMessage.activeChangedNodesIssuesExistTrue.title": "激活工作流时出现问题",
        "workflowActivator.showMessage.activeChangedWorkflowIdUndefined.message": "请保存后再激活",
        "workflowActivator.showMessage.activeChangedWorkflowIdUndefined.title": "激活工作流时出现问题",
        "workflowActivator.showMessage.displayActivationError.message.catchBlock": "抱歉，请求错误时出现问题",
        "workflowActivator.showMessage.displayActivationError.message.errorDataNotUndefined": "工作流激活时发生以下错误：",
        "workflowActivator.showMessage.displayActivationError.message.errorDataUndefined": "未知错误",
        "workflowActivator.showMessage.displayActivationError.title": "激活工作流时出现问题",
        "workflowActivator.theWorkflowIsSetToBeActiveBut": "工作流已激活但无法启动。<br />点击显示错误信息。",
        "workflowActivator.thisWorkflowHasNoTriggerNodes": "此工作流没有需要激活的触发节点",
        "workflowActivator.thisWorkflowHasOnlyOneExecuteWorkflowTriggerNode": "'执行工作流触发器'不需要激活，因为它是由另一个工作流触发的",
        "workflowDetails.share": "分享",
        "workflowDetails.active": "激活",
        "workflowDetails.addTag": "添加标签",
        "workflowDetails.chooseOrCreateATag": "选择或创建一个标签",
        "workflowDetails.showMessage.message": "请输入名称，或按'esc'返回原来的名称",
        "workflowDetails.showMessage.title": "缺少名称",
        "workflowHelpers.showMessage.title": "保存工作流时出现问题",
        "workflowOpen.active": "激活",
        "workflowOpen.couldNotLoadActiveWorkflows": "无法加载活动的工作流",
        "workflowOpen.created": "已创建",
        "workflowOpen.filterWorkflows": "按标签过滤",
        "workflowOpen.name": "@:_reusableBaseText.name",
        "workflowOpen.openWorkflow": "打开工作流",
        "workflowOpen.searchWorkflows": "搜索工作流...",
        "workflowOpen.showError.title": "加载工作流时出现问题",
        "workflowOpen.showMessage.message": "这是当前的工作流",
        "workflowOpen.showMessage.title": "工作流已打开",
        "workflowOpen.updated": "已更新",
        "workflowOpen.newWFButton.label": "添加工作流",
        "workflowOpen.newWFButton.title": "创建新工作流",
        "workflowPreview.showError.arrayEmpty": "必须有节点数组",
        "workflowPreview.showError.missingWorkflow": "缺少工作流",
        "workflowPreview.showError.previewError.message": "无法预览工作流",
        "workflowPreview.showError.missingExecution": "缺少工作流执行",
        "workflowPreview.executionMode.showError.previewError.message": "无法预览工作流执行",
        "workflowPreview.showError.previewError.title": "预览错误",
        "workflowRun.noActiveConnectionToTheServer": "与服务器的连接丢失",
        "workflowRun.showError.deactivate": "停用工作流以执行",
        "workflowRun.showError.productionActive": "由于{nodeName}的限制，n8n不能同时监听测试执行和生产执行",
        "workflowRun.showError.title": "运行工作流时出现问题",
        "workflowRun.showError.payloadTooLarge": "请执行整个工作流，而不仅仅是节点。（现有执行数据太大。）",
        "workflowRun.showError.resolveOutstandingIssues": "请在激活前解决未处理的问题",
        "workflowRun.showMessage.message": "请在执行前修复它们",
        "workflowRun.showMessage.title": "工作流存在问题",
        "workflowSettings.callerIds": "可以调用此工作流的工作流ID",
        "workflowSettings.callerIds.placeholder": "例如 14, 18",
        "workflowSettings.callerPolicy": "此工作流可以被调用",
        "workflowSettings.callerPolicy.options.any": "任意工作流",
        "workflowSettings.callerPolicy.options.workflowsFromPersonalProject": "由{projectName}创建的工作流",
        "workflowSettings.callerPolicy.options.workflowsFromTeamProject": "仅限{projectName}中的工作流",
        "workflowSettings.callerPolicy.options.workflowsFromSameProject": "仅限同一项目中的工作流",
        "workflowSettings.callerPolicy.options.workflowsFromAList": "选定的工作流",
        "workflowSettings.callerPolicy.options.none": "无其他工作流",
        "workflowSettings.defaultTimezone": "默认 - {defaultTimezoneValue}",
        "workflowSettings.defaultTimezoneNotValid": "默认时区无效",
        "workflowSettings.errorWorkflow": "错误处理工作流",
        "workflowSettings.executionOrder": "执行顺序",
        "workflowSettings.helpTexts.errorWorkflow": "如果当前工作流失败，则运行的第二个工作流。<br />第二个工作流应该有一个'错误触发'节点。",
        "workflowSettings.helpTexts.executionTimeout": "工作流在超时前应等待多长时间",
        "workflowSettings.helpTexts.executionTimeoutToggle": "是否在定义的时间后取消工作流执行",
        "workflowSettings.helpTexts.saveDataErrorExecution": "是否保存执行失败的数据",
        "workflowSettings.helpTexts.saveDataSuccessExecution": "是否保存成功完成执行的数据",
        "workflowSettings.helpTexts.saveExecutionProgress": "是否在每个节点执行后保存数据。这允许您在发生错误时从中断的地方恢复执行，但可能会增加延迟。",
        "workflowSettings.helpTexts.saveManualExecutions": "是否保存从编辑器手动启动执行的数据",
        "workflowSettings.helpTexts.timezone": "工作流运行所在的时区。例如，被'cron'节点使用。",
        "workflowSettings.helpTexts.workflowCallerIds": "被允许执行此工作流（使用'执行工作流'节点）的工作流ID。可以在工作流URL的末尾找到ID。多个ID用逗号分隔。",
        "workflowSettings.helpTexts.workflowCallerPolicy": "使用执行工作流节点调用此工作流的工作流",
        "workflowSettings.hours": "小时",
        "workflowSettings.minutes": "分钟",
        "workflowSettings.noWorkflow": "- 无工作流 -",
        "workflowSettings.save": "@:_reusableBaseText.save",
        "workflowSettings.saveDataErrorExecution": "保存失败的生产执行",
        "workflowSettings.saveDataErrorExecutionOptions.defaultSave": "默认 - {defaultValue}",
        "workflowSettings.saveDataErrorExecutionOptions.doNotSave": "不保存",
        "workflowSettings.saveDataErrorExecutionOptions.save": "@:_reusableBaseText.save",
        "workflowSettings.saveDataSuccessExecution": "保存成功的生产执行",
        "workflowSettings.saveDataSuccessExecutionOptions.defaultSave": "默认 - {defaultValue}",
        "workflowSettings.saveDataSuccessExecutionOptions.doNotSave": "不保存",
        "workflowSettings.saveDataSuccessExecutionOptions.save": "@:_reusableBaseText.save",
        "workflowSettings.saveExecutionProgress": "保存执行进度",
        "workflowSettings.saveExecutionProgressOptions.defaultSave": "默认 - {defaultValue}",
        "workflowSettings.saveExecutionProgressOptions.doNotSave": "不保存",
        "workflowSettings.saveExecutionProgressOptions.save": "@:_reusableBaseText.save",
        "workflowSettings.saveManualExecutions": "保存手动执行",
        "workflowSettings.saveManualOptions.defaultSave": "默认 - {defaultValue}",
        "workflowSettings.saveManualOptions.doNotSave": "不保存",
        "workflowSettings.saveManualOptions.save": "@:_reusableBaseText.save",
        "workflowSettings.seconds": "秒",
        "workflowSettings.selectOption": "选择选项",
        "workflowSettings.settingsFor": "工作流设置为 {workflowName} (#{workflowId})",
        "workflowSettings.showError.saveSettings1.errorMessage": "已启用超时但设置为0",
        "workflowSettings.showError.saveSettings1.message": "保存设置时出现问题",
        "workflowSettings.showError.saveSettings1.title": "保存设置时出错",
        "workflowSettings.showError.saveSettings2.errorMessage": "最大超时时间为: {hours} 小时, {minutes} 分钟, {seconds} 秒",
        "workflowSettings.showError.saveSettings2.message": "超时时间长于允许的时间",
        "workflowSettings.showError.saveSettings2.title": "保存设置时出错",
        "workflowSettings.showError.saveSettings3.title": "保存设置时出错",
        "workflowSettings.showMessage.saveSettings.title": "工作流设置已保存",
        "workflowSettings.timeoutAfter": "超时后",
        "workflowSettings.timeoutWorkflow": "超时工作流",
        "workflowSettings.timezone": "时区",
        "workflowSettings.timeSavedPerExecution": "每次执行估计节省的时间",
        "workflowSettings.timeSavedPerExecution.hint": "每次生产执行的分钟数",
        "workflowSettings.timeSavedPerExecution.tooltip": "总时间节省在概览页面中总结。",
        "workflowHistory.title": "版本历史",
        "workflowHistory.content.title": "版本",
        "workflowHistory.content.editedBy": "编辑者",
        "workflowHistory.content.versionId": "版本ID",
        "workflowHistory.content.actions": "操作",
        "workflowHistory.item.id": "ID: {id}",
        "workflowHistory.item.createdAt": "{date} 在 {time}",
        "workflowHistory.item.actions.restore": "恢复此版本",
        "workflowHistory.item.actions.clone": "克隆为新工作流",
        "workflowHistory.item.actions.open": "在新标签页打开版本",
        "workflowHistory.item.actions.download": "下载",
        "workflowHistory.item.unsaved.title": "未保存的版本",
        "workflowHistory.item.latest": "最新保存",
        "workflowHistory.empty": "还没有版本。",
        "workflowHistory.hint": "保存工作流以创建第一个版本！",
        "workflowHistory.limit": "版本历史限制为 {evaluatedPruneTime} 天",
        "workflowHistory.upgrade": "{link} 激活完整历史",
        "workflowHistory.upgrade.link": "升级计划",
        "workflowHistory.action.error.title": "无法 {action}",
        "workflowHistory.action.restore.modal.title": "恢复以前的工作流版本？",
        "workflowHistory.action.restore.modal.subtitle": "您的工作流将恢复到 {date} 的版本",
        "workflowHistory.action.restore.modal.text": "您的工作流当前处于活动状态，因此生产执行将立即开始使用恢复的版本。如果您希望在恢复之前停用它，请单击 {buttonText}。",
        "workflowHistory.action.restore.modal.button.deactivateAndRestore": "停用并恢复",
        "workflowHistory.action.restore.modal.button.restore": "恢复",
        "workflowHistory.action.restore.modal.button.cancel": "取消",
        "workflowHistory.action.restore.success.title": "成功恢复工作流版本",
        "workflowHistory.action.clone.success.title": "成功克隆工作流版本",
        "workflowHistory.action.clone.success.message": "在新标签页中打开克隆的工作流",
        "workflowHistory.button.tooltip.empty": "这个工作流目前没有历史可以查看。一旦您进行了第一次保存，您就能查看以前的版本",
        "workflowHistory.button.tooltip.enabled": "工作流历史记录，用于查看和恢复以前的工作流版本",
        "workflowHistory.button.tooltip.disabled": "升级以解锁工作流历史记录，以查看和恢复以前的工作流版本。{link}",
        "workflowHistory.button.tooltip.disabled.link": "查看计划",
        "workflows.heading": "工作流",
        "workflows.add": "添加工作流",
        "workflows.project.add": "将工作流添加到项目",
        "workflows.item.open": "打开",
        "workflows.item.share": "分享...",
        "workflows.item.duplicate": "复制",
        "workflows.item.delete": "删除",
        "workflows.item.move": "移动",
        "workflows.item.changeOwner": "更改所有者",
        "workflows.item.updated": "最后更新",
        "workflows.item.created": "创建",
        "workflows.item.readonly": "只读",
        "workflows.search.placeholder": "搜索",
        "workflows.filters": "过滤器",
        "workflows.filters.tags": "标签",
        "workflows.filters.status": "状态",
        "workflows.filters.status.all": "全部",
        "workflows.filters.status.active": "活跃",
        "workflows.filters.status.deactivated": "已停用",
        "workflows.filters.ownedBy": "拥有者",
        "workflows.filters.sharedWith": "共享给",
        "workflows.filters.apply": "应用过滤器",
        "workflows.filters.reset": "重置所有",
        "workflows.filters.active": "由于应用了过滤器，某些工作流可能被隐藏。",
        "workflows.filters.active.reset": "移除过滤器",
        "workflows.sort.lastUpdated": "按最后更新排序",
        "workflows.sort.lastCreated": "按创建时间排序",
        "workflows.sort.nameAsc": "按名称排序（A-Z）",
        "workflows.sort.nameDesc": "按名称排序（Z-A）",
        "workflows.noResults": "未找到工作流",
        "workflows.noResults.withSearch.switchToShared.preamble": "一些工作流可能是",
        "workflows.noResults.withSearch.switchToShared.link": "隐藏的",
        "workflows.empty.heading": "👋 欢迎{name}！",
        "workflows.empty.heading.userNotSetup": "👋 欢迎！",
        "workflows.empty.description": "创建您的第一个工作流",
        "workflows.empty.description.readOnlyEnv": "这里还没有工作流",
        "workflows.empty.description.noPermission": "当前没有可查看的工作流",
        "workflows.empty.startFromScratch": "从头开始",
        "workflows.empty.browseTemplates": "浏览工作流模板",
        "workflows.empty.learnN8n": "学习 n8n",
        "workflows.empty.button.disabled.tooltip": "您在项目中的当前角色不允许您创建工作流",
        "workflows.empty.easyAI": "测试一个现成的AI代理示例",
        "workflows.list.easyAI": "通过这个现成的AI代理工作流，在n8n中测试AI的力量",
        "workflows.list.error.fetching": "获取工作流时出错",
        "workflows.shareModal.title": "分享'{name}'",
        "workflows.shareModal.title.static": "与{projectName}共享",
        "workflows.shareModal.select.placeholder": "添加用户...",
        "workflows.shareModal.list.delete": "移除访问权限",
        "workflows.shareModal.list.delete.confirm.title": "移除{name}的访问权限？",
        "workflows.shareModal.list.delete.confirm.lastUserWithAccessToCredentials.message": "如果您这样做，工作流将失去对{name}凭证的访问权。<strong>使用这些凭据的节点将停止工作</strong>。",
        "workflows.shareModal.list.delete.confirm.confirmButtonText": "移除访问权限",
        "workflows.shareModal.list.delete.confirm.cancelButtonText": "取消",
        "workflows.shareModal.onSave.success.title": "分享已更新",
        "workflows.shareModal.onSave.error.title": "保存分享设置时出现问题",
        "workflows.shareModal.saveBeforeClose.title": "保存分享更改吗？",
        "workflows.shareModal.saveBeforeClose.message": "您有未保存的更改。是否在关闭前保存它们？",
        "workflows.shareModal.saveBeforeClose.confirmButtonText": "保存",
        "workflows.shareModal.saveBeforeClose.cancelButtonText": "不保存并关闭",
        "workflows.shareModal.save": "保存",
        "workflows.shareModal.changesHint": "您做了更改",
        "workflows.shareModal.info.sharee": "只有{workflowOwnerName}或具有工作流分享权限的用户才能更改此工作流的共享对象",
        "workflows.shareModal.info.sharee.fallback": "所有者",
        "workflows.shareModal.info.members": "此工作流由{projectName}项目拥有，目前该项目中有{members}可以访问此工作流。",
        "workflows.shareModal.info.members.number": "{number} 成员 | {number} 成员",
        "workflows.shareModal.role.editor": "编辑者",
        "workflows.roles.editor": "编辑者",
        "workflows.concurrentChanges.confirmMessage.title": "工作流被其他人更改",
        "workflows.concurrentChanges.confirmMessage.message": "在您编辑此工作流时，有人保存了它。您可以<a href=\'{url}\' target=\'_blank\'>查看他们的版本</a>（在新标签页中打开）。<br/><br/>用您的更改覆盖他们的更改吗？",
        "workflows.concurrentChanges.confirmMessage.cancelButtonText": "取消",
        "workflows.concurrentChanges.confirmMessage.confirmButtonText": "覆盖并保存",
        "workflows.create.personal.toast.title": "工作流创建成功",
        "workflows.create.personal.toast.text": "此工作流已在您的个人空间内创建。",
        "workflows.create.project.toast.title": "{projectName} 中的工作流创建成功",
        "workflows.create.folder.toast.title": "\'{folderName}\'内的\'{projectName}\'中的工作流创建成功",
        "workflows.create.project.toast.text": "{projectName} 的所有成员都将有权访问此工作流。",
        "workflowSelectorParameterInput.createNewSubworkflow.name": "我的子工作流",
        "importCurlModal.title": "导入cURL命令",
        "importCurlModal.input.label": "cURL命令",
        "importCurlModal.input.placeholder": "在此粘贴cURL命令",
        "ImportCurlModal.notice.content": "这将覆盖您对当前节点已做的任何更改",
        "importCurlModal.button.label": "导入",
        "importCurlParameter.label": "导入cURL",
        "importCurlParameter.showError.invalidCurlCommand.title": "无法导入cURL命令",
        "importCurlParameter.showError.invalidCurlCommand.message": "此命令处于不受支持的格式",
        "importCurlParameter.showError.invalidProtocol1.title": "使用{node}节点",
        "importCurlParameter.showError.invalidProtocol2.title": "无效协议",
        "importCurlParameter.showError.invalidProtocol.message": "HTTP节点不支持{protocol}请求",
        "variables.heading": "变量",
        "variables.add": "添加变量",
        "variables.add.unavailable": "升级计划以继续使用变量",
        "variables.add.unavailable.empty": "升级计划以开始使用变量",
        "variables.add.onlyOwnerCanCreate": "只有所有者才能创建变量",
        "variables.empty.heading": "{name}，让我们设置一个变量",
        "variables.empty.heading.userNotSetup": "设置一个变量",
        "variables.empty.description": "变量可用于存储可以在多个工作流中轻松引用的数据。",
        "variables.empty.button": "添加第一个变量",
        "variables.empty.button.disabled.tooltip": "您在项目中的当前角色不允许您创建变量",
        "variables.empty.notAllowedToCreate.heading": "{name}，开始使用变量",
        "variables.empty.notAllowedToCreate.description": "请您的n8n实例所有者为您需要的变量进行创建。一旦配置完成，您可以使用语法$vars.MY_VAR在工作流中利用它们。",
        "variables.filters.active": "由于应用了过滤器，某些变量可能被隐藏。",
        "variables.filters.active.reset": "移除过滤器",
        "variables.noResults": "未找到变量",
        "variables.sort.nameAsc": "按名称排序 (A-Z)",
        "variables.sort.nameDesc": "按名称排序 (Z-A)",
        "variables.table.key": "键",
        "variables.table.value": "值",
        "variables.table.usage": "使用语法",
        "variables.editing.key.placeholder": "输入名称",
        "variables.editing.value.placeholder": "输入值",
        "variables.editing.key.error.startsWithLetter": "此字段只能以字母开头",
        "variables.editing.key.error.jsonKey": "此字段只能包含字母、数字和下划线",
        "variables.row.button.save": "保存",
        "variables.row.button.cancel": "取消",
        "variables.row.button.edit": "编辑",
        "variables.row.button.edit.onlyRoleCanEdit": "仅实例所有者和管理员可以编辑变量",
        "variables.row.button.delete": "删除",
        "variables.row.button.delete.onlyRoleCanDelete": "仅实例所有者可以删除变量",
        "variables.row.usage.copiedToClipboard": "已复制到剪贴板",
        "variables.row.usage.copyToClipboard": "复制到剪贴板",
        "variables.search.placeholder": "搜索变量...",
        "variables.errors.save": "保存变量时出错",
        "variables.errors.delete": "删除变量时出错",
        "variables.modals.deleteConfirm.title": "删除变量",
        "variables.modals.deleteConfirm.message": "您确定要删除变量“{name}”吗？此操作不可撤销。",
        "variables.modals.deleteConfirm.confirmButton": "删除",
        "variables.modals.deleteConfirm.cancelButton": "取消",
        "contextual.credentials.sharing.unavailable.title": "升级以协作",
        "contextual.credentials.sharing.unavailable.title.cloud": "升级以协作",
        "contextual.credentials.sharing.unavailable.description": "升级您的计划后，您可以与其他用户共享凭据。",
        "contextual.credentials.sharing.unavailable.description.cloud": "升级您的计划后，您可以与其他用户共享凭据。",
        "contextual.credentials.sharing.unavailable.button": "查看计划",
        "contextual.credentials.sharing.unavailable.button.cloud": "立即升级",
        "contextual.workflows.sharing.title": "共享",
        "contextual.workflows.sharing.unavailable.title": "共享",
        "contextual.workflows.sharing.unavailable.title.cloud": "升级以协作",
        "contextual.workflows.sharing.unavailable.description.modal": "升级您的计划后，您可以与他人在工作流上进行协作。",
        "contextual.workflows.sharing.unavailable.description.modal.cloud": "升级您的计划后，您可以与他人在工作流上进行协作。",
        "contextual.workflows.sharing.unavailable.description.tooltip": "升级您的计划后，您可以与他人在工作流上进行协作。 {action}",
        "contextual.workflows.sharing.unavailable.description.tooltip.cloud": "升级您的计划后，您可以与他人在工作流上进行协作。 {action}",
        "contextual.workflows.sharing.unavailable.button": "查看计划",
        "contextual.workflows.sharing.unavailable.button.cloud": "立即升级",
        "contextual.variables.unavailable.title": "企业版计划中可用",
        "contextual.variables.unavailable.title.cloud": "专业版计划中可用",
        "contextual.variables.unavailable.description": "变量可用于跨工作流存储和访问数据。使用前缀<code>$vars</code>引用它们（例如<code>$vars.myVariable</code>)。变量是不可变的，在工作流中无法修改。<br/><a href=\'https://docs.n8n.io/environments/variables/\' target=\'_blank\'>在文档中了解更多。</a>",
        "contextual.variables.unavailable.button": "查看计划",
        "contextual.variables.unavailable.button.cloud": "立即升级",
        "contextual.users.settings.unavailable.title": "升级以添加用户",
        "contextual.users.settings.unavailable.title.cloud": "升级以添加用户",
        "contextual.users.settings.unavailable.description": "在我们的高级计划中创建多个用户，并通过共享工作流和凭据来协作",
        "contextual.users.settings.unavailable.description.cloud": "在我们的高级计划中创建多个用户，并通过共享工作流和凭据来协作",
        "contextual.users.settings.unavailable.button": "查看计划",
        "contextual.users.settings.unavailable.button.cloud": "立即升级",
        "contextual.feature.unavailable.title": "企业计划中可用",
        "contextual.feature.unavailable.title.cloud": "专业计划中可用",
        "settings.ldap": "LDAP",
        "settings.ldap.note": "LDAP允许用户使用其中央账户进行身份验证。它兼容提供LDAP接口的服务，如Active Directory、Okta和Jumpcloud。",
        "settings.ldap.infoTip": "了解<a href='https://docs.n8n.io/user-management/ldap/' target='_blank'>文档中的LDAP</a>",
        "settings.ldap.save": "保存连接",
        "settings.ldap.connectionTestError": "测试LDAP连接时出现问题",
        "settings.ldap.connectionTest": "LDAP连接已测试",
        "settings.ldap.runSync.title": "LDAP同步完成",
        "settings.ldap.runSync.showError.message": "同步过程中出现问题。请检查日志",
        "settings.ldap.updateConfiguration": "LDAP配置已更新",
        "settings.ldap.testingConnection": "正在测试连接",
        "settings.ldap.testConnection": "测试连接",
        "settings.ldap.synchronizationTable.column.status": "状态",
        "settings.ldap.synchronizationTable.column.endedAt": "结束于",
        "settings.ldap.synchronizationTable.column.runMode": "运行模式",
        "settings.ldap.synchronizationTable.column.runTime": "运行时间",
        "settings.ldap.synchronizationTable.column.details": "详情",
        "settings.ldap.synchronizationTable.empty.message": "测试同步以预览更新",
        "settings.ldap.dryRun": "测试同步",
        "settings.ldap.synchronizeNow": "运行同步",
        "settings.ldap.synchronizationError": "LDAP同步错误",
        "settings.ldap.configurationError": "LDAP配置错误",
        "settings.ldap.usersScanned": "已扫描用户 {scanned}",
        "settings.ldap.confirmMessage.beforeSaveForm.cancelButtonText": "否",
        "settings.ldap.confirmMessage.beforeSaveForm.confirmButtonText": "是的，禁用它",
        "settings.ldap.confirmMessage.beforeSaveForm.headline": "您确定要禁用LDAP登录吗？",
        "settings.ldap.confirmMessage.beforeSaveForm.message": "如果您这样做，所有LDAP用户都将被转换为电子邮件用户。",
        "settings.ldap.disabled.title": "适用于企业计划",
        "settings.ldap.disabled.description": "LDAP作为付费功能提供。了解更多相关信息。",
        "settings.ldap.disabled.buttonText": "查看计划",
        "settings.ldap.toast.sync.success": "同步成功",
        "settings.ldap.toast.connection.success": "连接成功",
        "settings.ldap.form.loginEnabled.label": "启用LDAP登录",
        "settings.ldap.form.loginEnabled.tooltip": "即使禁用了LDAP登录，连接设置和数据仍将被保存",
        "settings.ldap.form.loginLabel.label": "LDAP登录",
        "settings.ldap.form.loginLabel.placeholder": "例如 LDAP用户名或电子邮件地址",
        "settings.ldap.form.loginLabel.infoText": "登录页面登录字段中显示的占位符文本",
        "settings.ldap.form.serverAddress.label": "LDAP服务器地址",
        "settings.ldap.form.serverAddress.placeholder": "123.123.123.123",
        "settings.ldap.form.serverAddress.infoText": "LDAP服务器的IP或域名",
        "settings.ldap.form.port.label": "LDAP服务器端口",
        "settings.ldap.form.port.infoText": "用于连接到LDAP服务器的端口",
        "settings.ldap.form.connectionSecurity.label": "连接安全",
        "settings.ldap.form.connectionSecurity.infoText": "连接安全类型",
        "settings.ldap.form.allowUnauthorizedCerts.label": "忽略SSL/TLS问题",
        "settings.ldap.form.baseDn.label": "基础DN",
        "settings.ldap.form.baseDn.placeholder": "o=acme,dc=example,dc=com",
        "settings.ldap.form.baseDn.infoText": "在AD/LDAP树中n8n开始搜索用户的起点的可分辨名称",
        "settings.ldap.form.bindingType.label": "绑定为",
        "settings.ldap.form.bindingType.infoText": "用于连接到LDAP服务器的绑定类型",
        "settings.ldap.form.adminDn.label": "绑定DN",
        "settings.ldap.form.adminDn.placeholder": "uid=2da2de69435c,ou=Users,o=Acme,dc=com",
        "settings.ldap.form.adminDn.infoText": "执行搜索所使用的用户的可分辨名称",
        "settings.ldap.form.adminPassword.label": "绑定密码",
        "settings.ldap.form.adminPassword.infoText": "在上面的绑定DN字段中提供的用户的密码",
        "settings.ldap.form.userFilter.label": "用户过滤器",
        "settings.ldap.form.userFilter.placeholder": "(ObjectClass=user)",
        "settings.ldap.form.userFilter.infoText": "搜索用户时使用的LDAP查询。仅允许此过滤器返回的用户在n8n中登录",
        "settings.ldap.form.attributeMappingInfo.label": "属性映射",
        "settings.ldap.form.ldapId.label": "ID",
        "settings.ldap.form.ldapId.placeholder": "uid",
        "settings.ldap.form.ldapId.infoText": "在LDAP服务器中用作n8n中唯一标识符的属性。它应该是像uid这样的唯一LDAP属性",
        "settings.ldap.form.loginId.label": "登录ID",
        "settings.ldap.form.loginId.placeholder": "mail",
        "settings.ldap.form.loginId.infoText": "LDAP服务器中用于在n8n中登录的属性",
        "settings.ldap.form.email.label": "电子邮件",
        "settings.ldap.form.email.placeholder": "mail",
        "settings.ldap.form.email.infoText": "LDAP服务器中用于填充n8n中的电子邮件的属性",
        "settings.ldap.form.firstName.label": "名字",
        "settings.ldap.form.firstName.placeholder": "givenName",
        "settings.ldap.form.firstName.infoText": "LDAP服务器中用于填充n8n中的名字的属性",
        "settings.ldap.form.lastName.label": "姓氏",
        "settings.ldap.form.lastName.placeholder": "sn",
        "settings.ldap.form.lastName.infoText": "LDAP服务器中用于填充n8n中的姓氏的属性",
        "settings.ldap.form.synchronizationEnabled.label": "启用周期性LDAP同步",
        "settings.ldap.form.synchronizationEnabled.tooltip": "允许用户被周期性地同步",
        "settings.ldap.form.synchronizationInterval.label": "同步间隔（分钟）",
        "settings.ldap.form.synchronizationInterval.infoText": "同步操作应多久执行一次",
        "settings.ldap.form.pageSize.label": "页面大小",
        "settings.ldap.form.pageSize.infoText": "每次同步时返回的最大记录数。0表示无限制",
        "settings.ldap.form.searchTimeout.label": "搜索超时（秒）",
        "settings.ldap.form.searchTimeout.infoText": "查询AD/LDAP服务器的超时值。如果你因为AD/LDAP服务器响应慢而收到超时错误，请增加这个值",
        "settings.ldap.section.synchronization.title": "同步",
        "settings.sso": "SSO",
        "settings.sso.title": "单点登录",
        "settings.sso.subtitle": "SAML 2.0配置",
        "settings.sso.info": "激活SAML SSO以通过现有的用户管理工具实现无密码登录，并通过统一的身份验证增强安全性。",
        "settings.sso.info.link": "了解如何配置SAML 2.0。",
        "settings.sso.activation.tooltip": "您需要先保存设置，然后才能激活SAML",
        "settings.sso.activated": "已激活",
        "settings.sso.deactivated": "未激活",
        "settings.sso.settings.redirectUrl.label": "重定向URL",
        "settings.sso.settings.redirectUrl.copied": "重定向URL已复制到剪贴板",
        "settings.sso.settings.redirectUrl.help": "复制重定向URL以配置您的SAML提供商",
        "settings.sso.settings.entityId.label": "实体ID",
        "settings.sso.settings.entityId.copied": "实体ID已复制到剪贴板",
        "settings.sso.settings.entityId.help": "复制实体ID URL以配置您的SAML提供商",
        "settings.sso.settings.ips.label": "身份提供商设置",
        "settings.sso.settings.ips.xml.help": "在此粘贴由您的身份提供商提供的原始Metadata XML",
        "settings.sso.settings.ips.url.help": "在此粘贴互联网提供商元数据URL",
        "settings.sso.settings.ips.url.placeholder": "例如 https://samltest.id/saml/idp",
        "settings.sso.settings.ips.options.url": "元数据URL",
        "settings.sso.settings.ips.options.xml": "XML",
        "settings.sso.settings.test": "测试设置",
        "settings.sso.settings.save": "保存设置",
        "settings.sso.settings.save.activate.title": "测试并激活SAML SSO",
        "settings.sso.settings.save.activate.message": "SAML SSO配置成功保存。首先测试您的SAML SSO设置，然后激活以对您的组织启用单点登录。",
        "settings.sso.settings.save.activate.cancel": "取消",
        "settings.sso.settings.save.activate.test": "测试设置",
        "settings.sso.settings.save.error": "保存SAML SSO配置时出错",
        "settings.sso.settings.footer.hint": "保存设置后，别忘了激活SAML SSO。",
        "settings.sso.actionBox.title": "适用于企业计划",
        "settings.sso.actionBox.description": "使用单点登录将身份验证整合到一个平台中，以提高安全性和灵活性。",
        "settings.sso.actionBox.buttonText": "查看计划",
        "settings.mfa.secret": "密钥 {secret}",
        "settings.mfa": "MFA",
        "settings.mfa.title": "多因素认证",
        "settings.mfa.updateConfiguration": "MFA配置已更新",
        "settings.mfa.invalidAuthenticatorCode": "无效的身份验证器代码",
        "projects.header.subtitle": "您可以访问的所有工作流、凭据和执行情况",
        "projects.header.create.workflow": "创建工作流",
        "projects.header.create.credential": "创建凭据",
        "projects.header.create.folder": "创建文件夹",
        "projects.create": "创建",
        "projects.create.personal": "在个人空间创建",
        "projects.create.team": "在项目中创建",
        "projects.menu.overview": "概览",
        "projects.menu.title": "项目",
        "projects.menu.personal": "个人",
        "projects.menu.addFirstProject": "添加项目",
        "projects.settings": "项目设置",
        "projects.settings.newProjectName": "我的项目",
        "projects.settings.iconPicker.button.tooltip": "选择项目图标",
        "projects.settings.name": "项目图标和名称",
        "projects.settings.projectMembers": "项目成员",
        "projects.settings.message.unsavedChanges": "您有未保存的更改",
        "projects.settings.danger.message": "删除项目时，您也可以选择将所有工作流和凭据移动到另一个项目。",
        "projects.settings.danger.title": "危险区域",
        "projects.settings.danger.deleteProject": "删除此项目",
        "projects.settings.button.save": "@:_reusableBaseText.save",
        "projects.settings.button.cancel": "@:_reusableBaseText.cancel",
        "projects.settings.button.deleteProject": "删除项目",
        "projects.settings.role.admin": "管理员",
        "projects.settings.role.editor": "编辑者",
        "projects.settings.role.viewer": "观察者",
        "projects.settings.delete.title": "删除 {projectName}",
        "projects.settings.delete.message": "我们应该如何处理项目数据？",
        "projects.settings.delete.question.transfer.label": "将其工作流和凭据转移到另一个项目或用户",
        "projects.settings.delete.question.transfer.title": "转移至项目或用户",
        "projects.settings.delete.question.wipe.label": "删除其工作流和凭据",
        "projects.settings.delete.question.wipe.title": "输入\'删除所有数据\'以确认",
        "projects.settings.delete.question.wipe.placeholder": "delete all data",
        "projects.settings.delete.confirm": "是的，我确定",
        "projects.settings.delete.cancel": "不，取消",
        "projects.settings.delete.successful.title": "项目 {projectName} 已成功删除",
        "projects.settings.delete.error.title": "删除项目时发生错误",
        "projects.settings.save.successful.title": "项目 {projectName} 已成功保存",
        "projects.settings.icon.update.successful.title": "项目图标已成功更新",
        "projects.settings.save.error.title": "保存项目时发生错误",
        "projects.settings.role.upgrade.title": "升级以解锁更多角色",
        "projects.settings.role.upgrade.message": "您目前在{planName}计划中仅限于使用{limit}个角色，并且只能为该项目中的用户分配管理员角色。要创建更多项目并解锁额外角色，请升级您的计划。",
        "projects.sharing.noMatchingProjects": "没有可用的项目",
        "projects.sharing.noMatchingUsers": "没有匹配的用户或项目",
        "projects.sharing.select.placeholder": "选择项目或用户",
        "projects.sharing.select.placeholder.user": "与用户共享",
        "projects.sharing.select.placeholder.project": "与项目或用户共享",
        "projects.error.title": "项目错误",
        "projects.create.limit": "{count} 个项目",
        "projects.create.limitReached": "您已达到{planName}计划的{limit}个项目的限制。升级您的计划以解锁更多项目。{link}",
        "projects.create.limitReached.cloud": "您已达到{planName}计划的{limit}个项目的限制。升级您的计划以解锁更多项目。",
        "projects.create.limitReached.self": "升级以解锁更多项目，以便对共享、访问和工作流组织进行更精细的控制",
        "projects.create.limitReached.link": "查看计划",
        "projects.create.permissionDenied": "您当前的角色不允许您创建项目",
        "projects.move.resource.modal.title": "选择一个项目或用户来移动此{resourceTypeLabel}",
        "projects.move.resource.modal.message": "\'{resourceName}\' 目前 {inPersonalProject}{inTeamProject}",
        "projects.move.resource.modal.message.team": "在“{resourceHomeProjectName}”项目中。",
        "projects.move.resource.modal.message.personal": "由“{resourceHomeProjectName}”拥有。",
        "projects.move.resource.modal.message.note": "注意",
        "projects.move.resource.modal.message.sharingNote": "{note}：移动将删除此{resourceTypeLabel}的所有现有共享。",
        "projects.move.resource.modal.message.sharingInfo": "(当前与{count}个项目共享) | (当前与{count}个项目共享)",
        "projects.move.resource.modal.message.usedCredentials": "同时共享此工作流使用的{usedCredentials}，以确保它能够继续正确运行",
        "projects.move.resource.modal.message.usedCredentials.number": "{count} 个凭据 | {count} 个凭据",
        "projects.move.resource.modal.message.unAccessibleCredentials": "某些凭据",
        "projects.move.resource.modal.message.unAccessibleCredentials.note": "{credentials} 在此工作流中使用，但不会被共享",
        "projects.move.resource.modal.message.noProjects": "目前没有任何项目或用户可供您移动此{resourceTypeLabel}。",
        "projects.move.resource.modal.button": "移动{resourceTypeLabel}",
        "projects.move.resource.modal.selectPlaceholder": "选择项目或用户...",
        "projects.move.resource.error.title": "移动{resourceName} {resourceTypeLabel}时出错",
        "projects.move.resource.success.title": "{resourceTypeLabel} '{resourceName}' 已移动到 '{targetProjectName}'",
        "projects.move.resource.success.message.workflow": "工作流的凭据未与项目共享。",
        "projects.move.resource.success.message.workflow.withAllCredentials": "工作流的凭据已与项目共享。",
        "projects.move.resource.success.message.workflow.withSomeCredentials": "由于缺少权限，不是所有工作流的凭据都能与项目共享。",
        "projects.move.resource.success.link": "查看{targetProjectName}",
        "projects.badge.tooltip.sharedOwned": "此{resourceTypeLabel}由您拥有并与{count}个用户共享",
        "projects.badge.tooltip.sharedPersonal": "此{resourceTypeLabel}由{name}拥有并与{count}个用户共享",
        "projects.badge.tooltip.personal": "此{resourceTypeLabel}由{name}拥有",
        "projects.badge.tooltip.team": "此{resourceTypeLabel}由{name}项目拥有和可访问。",
        "projects.badge.tooltip.sharedTeam": "此{resourceTypeLabel}由{name}项目拥有并与{count}个用户共享",
        "mfa.setup.invalidAuthenticatorCode": "{code} 不是一个有效的数字",
        "mfa.setup.invalidCode": "两步验证代码失败。请重试。",
        "mfa.code.modal.title": "两步验证",
        "mfa.recovery.modal.title": "两步验证恢复",
        "mfa.code.input.info": "没有您的认证设备？",
        "mfa.code.input.info.action": "输入恢复代码",
        "mfa.recovery.input.info.action": "输入恢复代码",
        "mfa.code.button.continue": "继续",
        "mfa.recovery.button.verify": "验证",
        "mfa.button.back": "返回",
        "mfa.code.input.label": "两步验证代码",
        "mfa.code.input.placeholder": "例如 123456",
        "mfa.code.recovery.input.label": "两步验证代码或恢复代码",
        "mfa.code.recovery.input.placeholder": "例如 123456 或 c79f9c02-7b2e-44...",
        "mfa.recovery.input.label": "恢复代码",
        "mfa.recovery.input.placeholder": "例如 c79f9c02-7b2e-44...",
        "mfa.code.invalid": "此代码无效，请重试或",
        "mfa.recovery.invalid": "此代码无效或已被使用，请重试",
        "mfa.setup.step1.title": "设置身份验证器应用 [1/2]",
        "mfa.setup.step2.title": "下载您的恢复代码 [2/2]",
        "mfa.setup.step1.instruction1.title": "1. 扫描二维码",
        "mfa.setup.step1.instruction1.subtitle": "{part1} {part2}",
        "mfa.setup.step1.instruction1.subtitle.part1": "使用手机上的身份验证器应用进行扫描。如果您无法扫描二维码，输入",
        "mfa.setup.step1.instruction1.subtitle.part2": "此文本代码",
        "mfa.setup.step1.instruction2.title": "2. 输入应用中的代码",
        "mfa.setup.step2.description": "您可以使用恢复代码作为第二种认证方式，在您失去访问设备的情况下进行身份验证。",
        "mfa.setup.step2.infobox.description": "{part1} {part2}",
        "mfa.setup.step2.infobox.description.part1": "将您的恢复代码保存在安全的地方。如果您丢失了设备和恢复代码，您将",
        "mfa.setup.step2.infobox.description.part2": "失去账户访问权限。",
        "mfa.setup.step2.button.download": "下载恢复代码",
        "mfa.setup.step2.button.save": "我已经下载了我的恢复代码",
        "mfa.setup.step1.button.continue": "继续",
        "mfa.setup.step1.input.label": "来自您的身份验证器应用的代码",
        "mfa.setup.step1.toast.copyToClipboard.title": "代码已复制到剪贴板",
        "mfa.setup.step1.toast.copyToClipboard.message": "在您的身份验证器应用中输入代码",
        "mfa.setup.step2.toast.setupFinished.message": "已启用双重身份验证",
        "mfa.setup.step2.toast.setupFinished.error.message": "启用双重身份验证时出错",
        "mfa.setup.step2.toast.tokenExpired.error.message": "MFA令牌已过期。关闭模态框并再次启用MFA",
        "mfa.prompt.code.modal.title": "需要两步验证代码或恢复代码",
        "settings.personal.mfa.section.title": "双重身份验证 (2FA)",
        "settings.personal.personalisation": "个性化",
        "settings.personal.theme": "主题",
        "settings.personal.theme.systemDefault": "系统默认",
        "settings.personal.theme.light": "浅色主题",
        "settings.personal.theme.dark": "深色主题",
        "settings.personal.mfa.button.disabled.infobox": "双重身份验证当前已禁用。",
        "settings.personal.mfa.button.enabled.infobox": "双重身份验证当前已启用。",
        "settings.personal.mfa.button.enabled": "启用2FA",
        "settings.personal.mfa.button.disabled": "禁用双重身份验证",
        "settings.personal.mfa.toast.disabledMfa.title": "双重身份验证已禁用",
        "settings.personal.mfa.toast.disabledMfa.message": "登录时不再需要您的身份验证器应用",
        "settings.personal.mfa.toast.disabledMfa.error.message": "禁用双重身份验证时出错",
        "settings.personal.mfa.toast.canEnableMfa.title": "MFA预设条件失败",
        "settings.mfa.toast.noRecoveryCodeLeft.title": "没有剩余的2FA恢复代码",
        "settings.mfa.toast.noRecoveryCodeLeft.message": "您已使用了所有恢复代码。禁用然后重新启用双重身份验证以生成新代码。<a href='/settings/personal' target='_blank'>打开设置</a>",
        "sso.login.divider": "或",
        "sso.login.button": "使用SSO继续",
        "executionUsage.currentUsage": "{text} {count}",
        "executionUsage.currentUsage.text": "您正在免费试用，有限制的执行次数。您还有",
        "executionUsage.currentUsage.count": "{n} 天剩余 | {n} 天剩余",
        "executionUsage.label.executions": "执行次数",
        "executionUsage.button.upgrade": "升级计划",
        "executionUsage.expired.text": "您的试用期已结束。立即升级以保留您的数据。",
        "executionUsage.ranOutOfExecutions.text": "您已用完执行次数。升级您的计划以继续自动化。",
        "openExecution.missingExeuctionId.title": "找不到执行ID",
        "openExecution.missingExeuctionId.message": "请确保此工作流通过设置保存执行记录",
        "type.string": "字符串",
        "type.number": "数字",
        "type.dateTime": "日期和时间",
        "type.boolean": "布尔值",
        "type.array": "数组",
        "type.object": "对象",
        "filter.operator.equals": "等于",
        "filter.operator.notEquals": "不等于",
        "filter.operator.contains": "包含",
        "filter.operator.notContains": "不包含",
        "filter.operator.startsWith": "开始于",
        "filter.operator.notStartsWith": "不开始于",
        "filter.operator.endsWith": "结束于",
        "filter.operator.notEndsWith": "不结束于",
        "filter.operator.exists": "存在",
        "filter.operator.notExists": "不存在",
        "filter.operator.regex": "匹配正则表达式",
        "filter.operator.notRegex": "不匹配正则表达式",
        "filter.operator.gt": "大于",
        "filter.operator.lt": "小于",
        "filter.operator.gte": "大于或等于",
        "filter.operator.lte": "小于或等于",
        "filter.operator.after": "在...之后",
        "filter.operator.before": "在...之前",
        "filter.operator.afterOrEquals": "在...之后或等于",
        "filter.operator.beforeOrEquals": "在...之前或等于",
        "filter.operator.true": "为真",
        "filter.operator.false": "为假",
        "filter.operator.lengthEquals": "长度等于",
        "filter.operator.lengthNotEquals": "长度不等于",
        "filter.operator.lengthGt": "长度大于",
        "filter.operator.lengthLt": "长度小于",
        "filter.operator.lengthGte": "长度大于或等于",
        "filter.operator.lengthLte": "长度小于或等于",
        "filter.operator.empty": "为空",
        "filter.operator.notEmpty": "不为空",
        "filter.combinator.or": "或",
        "filter.combinator.and": "与",
        "filter.addCondition": "添加条件",
        "filter.removeCondition": "移除条件",
        "filter.dragCondition": "拖动条件",
        "filter.maxConditions": "达到最大条件数",
        "filter.condition.resolvedTrue": "此条件对第一个输入项为真",
        "filter.condition.resolvedFalse": "此条件对第一个输入项为假",
        "filter.condition.placeholderLeft": "值1",
        "filter.condition.placeholderRight": "值2",
        "assignment.dragFields": "将输入字段拖到这里",
        "assignment.dropField": "拖到这里以添加字段",
        "assignment.or": "或",
        "assignment.add": "添加字段",
        "assignment.addAll": "添加全部",
        "assignment.clearAll": "清除全部",
        "templateSetup.title": "设置 '{name}' 模板",
        "templateSetup.instructions": "你需要 {0} 账户来设置此模板",
        "templateSetup.skip": "跳过",
        "templateSetup.continue.button": "继续",
        "templateSetup.credential.description": "你选择的凭据将在工作流模板的 {0} 节点中使用。| 你选择的凭据将在工作流模板的 {0} 节点中使用。",
        "templateSetup.continue.button.fillRemaining": "填写剩余凭据以继续",
        "setupCredentialsModal.title": "设置模板",
        "becomeCreator.text": "与4万多名用户分享你的工作流，解锁奖励，并作为特色模板创作者闪耀！",
        "becomeCreator.buttonText": "成为创作者",
        "becomeCreator.closeButtonTitle": "关闭",
        "feedback.title": "这对你有帮助吗？",
        "feedback.positive": "我发现这很有帮助",
        "feedback.negative": "我觉得这没有帮助",
        "communityPlusModal.badge": "限时优惠",
        "communityPlusModal.title": "获取免费的专业功能（永久）",
        "communityPlusModal.error.title": "许可证请求失败",
        "communityPlusModal.success.title": "请求已发送",
        "communityPlusModal.success.message": "许可证密钥将发送到 {email}",
        "communityPlusModal.description": "接收一个激活密钥以获得以下高级功能 - 终身访问。",
        "communityPlusModal.features.first.title": "工作流历史",
        "communityPlusModal.features.first.description": "查看并恢复过去24小时内的任何工作流版本",
        "communityPlusModal.features.second.title": "高级调试",
        "communityPlusModal.features.second.description": "轻松修复任何出错的工作流执行，然后重新运行它",
        "communityPlusModal.features.third.title": "执行搜索和标记",
        "communityPlusModal.features.third.description": "搜索并组织过去的执行流程以便于审查",
        "communityPlusModal.features.fourth.title": "文件夹",
        "communityPlusModal.features.fourth.description": "以嵌套文件夹结构组织您的工作流",
        "communityPlusModal.input.email.label": "输入邮箱以接收您的许可证密钥",
        "communityPlusModal.button.skip": "跳过",
        "communityPlusModal.button.confirm": "给我发送一个免费的许可证密钥",
        "communityPlusModal.notice": "包含的功能可能会更改，但一旦解锁，您将永久拥有它们。",
        "executeWorkflowTrigger.createNewSubworkflow": "在 {projectName} 中创建子工作流",
        "executeWorkflowTrigger.createNewSubworkflow.noProject": "创建新的子工作流",
        "testDefinition.edit.descriptionPlaceholder": "输入测试描述",
        "testDefinition.edit.showConfig": "显示配置",
        "testDefinition.edit.hideConfig": "隐藏配置",
        "testDefinition.edit.backButtonTitle": "返回到工作流评估",
        "testDefinition.edit.namePlaceholder": "输入测试名称",
        "testDefinition.edit.selectTag": "选择标签...",
        "testDefinition.edit.tagsHelpText": "具有此标签的执行将被添加为该测试的测试用例。",
        "testDefinition.edit.workflowSelectorLabel": "使用第二个工作流进行比较",
        "testDefinition.edit.workflowSelectorDisplayName": "工作流",
        "testDefinition.edit.workflowSelectorTitle": "使用第二个工作流进行比较",
        "testDefinition.edit.workflowSelectorHelpText": "此工作流将为每个测试用例调用一次。",
        "testDefinition.edit.updateTest": "更新测试",
        "testDefinition.edit.saveTest": "保存测试",
        "testDefinition.edit.runTest": "运行测试",
        "testDefinition.edit.testSaved": "测试已保存",
        "testDefinition.edit.testSaveFailed": "保存测试失败",
        "testDefinition.edit.description": "描述",
        "testDefinition.edit.description.description": "添加有关此测试评估的内容及成功标准的详细信息",
        "testDefinition.edit.pinNodes.noNodes.title": "没有可固定的节点",
        "testDefinition.edit.pinNodes.noNodes.description": "您的工作流至少需要有一个节点才能运行测试",
        "testDefinition.edit.tagName": "标签名称",
        "testDefinition.edit.step.intro": "在运行测试时",
        "testDefinition.edit.step.executions": "1. 获取基准执行 | 1. 获取 {count} 次基准执行 | 1. 获取 {count} 次基准执行",
        "testDefinition.edit.step.tag": "获取任何过去标记为 {tag} 的执行",
        "testDefinition.edit.step.tag.placeholder": "输入新标签名",
        "testDefinition.edit.step.tag.validation.required": "需要标签名",
        "testDefinition.edit.step.tag.validation.tooLong": "标签名太长",
        "testDefinition.edit.step.executions.tooltip": "过去的执行被用作基准数据。每次执行将在测试期间重新运行，以检查性能是否发生变化。",
        "testDefinition.edit.step.mockedNodes": "2. 模拟节点 |2. 模拟 {count} 个节点 |2. 模拟 {count} 个节点",
        "testDefinition.edit.step.nodes.tooltip": "模拟节点的数据将被重放而不是重新执行。这样做可以避免调用外部服务，或节省执行时间。",
        "testDefinition.edit.step.reRunExecutions": "3. 重新运行执行",
        "testDefinition.edit.step.reRunExecutions.tooltip": "每次过去的执行都将使用正在测试的工作流的最新版本重新运行",
        "testDefinition.edit.step.compareExecutions": "4. 对比每次过去的和新的执行",
        "testDefinition.edit.step.compareExecutions.tooltip": "每个过去的执行都将与其新的等效版本进行比较，以检查它们有多相似。这是通过单独的评估工作流完成的：它接收两个执行版本作为输入，并输出指标。",
        "testDefinition.edit.step.collapse": "折叠",
        "testDefinition.edit.step.configure": "配置",
        "testDefinition.edit.selectNodes": "固定要模拟的节点",
        "testDefinition.edit.modal.description": "选择重新运行执行时要保留哪些过去的数据。任何模拟的节点都将被重放而不是重新执行。触发器总是被模拟。",
        "testDefinition.edit.runExecution": "运行执行",
        "testDefinition.edit.pastRuns": "过去运行",
        "testDefinition.edit.pastRuns.total": "无运行 | 过去的运行 ({count}) | 过去的运行 ({count})",
        "testDefinition.edit.nodesPinning.pinButtonTooltip": "在评估执行期间为此节点使用基准数据",
        "testDefinition.edit.nodesPinning.pinButtonTooltip.pinned": "此节点不会重新执行",
        "testDefinition.edit.nodesPinning.triggerTooltip": "默认情况下，触发器节点被模拟",
        "testDefinition.edit.saving": "保存中...",
        "testDefinition.edit.saved": "测试已保存",
        "testDefinition.list.testDeleted": "测试已删除",
        "testDefinition.list.tests": "测试",
        "testDefinition.list.evaluations": "评估",
        "testDefinition.list.unitTests.badge": "即将到来",
        "testDefinition.list.unitTests.title": "单元测试",
        "testDefinition.list.unitTests.description": "通过检查特定条件来验证工作流逻辑",
        "testDefinition.list.unitTests.cta": "注册兴趣",
        "testDefinition.list.createNew": "创建新的评估",
        "testDefinition.list.runAll": "运行所有评估",
        "testDefinition.list.actionDescription": "通过随时间比较结果（针对AI工作流）来衡量输出的变化",
        "testDefinition.list.actionButton": "创建一个评估",
        "testDefinition.list.actionButton.unregistered": "解锁评估",
        "testDefinition.list.actionDescription.registered": "您的计划允许进行一项评估",
        "testDefinition.list.actionDescription.unregistered": "注册后解锁免费测试",
        "testDefinition.list.actionDescription.atLimit": "您已达到评估限制，升级以添加更多",
        "testDefinition.list.testRuns": "无测试运行 | {count} 次测试运行 | {count} 次测试运行",
        "testDefinition.list.lastRun": "运行于",
        "testDefinition.list.running": "运行中",
        "testDefinition.list.errorRate": "错误率：{errorRate}",
        "testDefinition.list.testStartError": "启动测试运行失败",
        "testDefinition.list.testStarted": "测试运行已启动",
        "testDefinition.list.testCancelled": "测试运行已取消",
        "testDefinition.list.loadError": "加载测试失败",
        "testDefinition.list.item.tests": "无测试用例 | {count} 个测试用例 | {count} 个测试用例",
        "testDefinition.list.item.missingFields": "无缺失字段 | {count} 个字段缺失 | {count} 个字段缺失",
        "testDefinition.listRuns.status.new": "新建",
        "testDefinition.listRuns.status.running": "运行中",
        "testDefinition.listRuns.status.evaluating": "评估中",
        "testDefinition.listRuns.status.completed": "已完成",
        "testDefinition.listRuns.status.cancelled": "已取消",
        "testDefinition.listRuns.status.error": "错误",
        "testDefinition.listRuns.status.success": "成功",
        "testDefinition.listRuns.status.warning": "警告",
        "testDefinition.listRuns.metricsOverTime": "随时间变化的指标",
        "testDefinition.listRuns.status": "状态",
        "testDefinition.listRuns.runNumber": "运行编号",
        "testDefinition.listRuns.runDate": "运行日期",
        "testDefinition.listRuns.runStatus": "运行状态",
        "testDefinition.listRuns.noRuns": "无测试运行",
        "testDefinition.listRuns.noRuns.description": "运行测试以在此查看结果",
        "testDefinition.listRuns.deleteRuns": "无运行可删除 | 删除 {count} 次运行 | 删除 {count} 次运行",
        "testDefinition.listRuns.noRuns.button": "运行测试",
        "testDefinition.listRuns.error.noPastExecutions": "未向指定标签添加任何执行",
        "testDefinition.listRuns.error.evaluationWorkflowNotFound": "选定的评估工作流不存在。{link}。",
        "testDefinition.listRuns.error.evaluationWorkflowNotFound.solution": "修复测试配置",
        "testDefinition.runDetail.ranAt": "运行于",
        "testDefinition.runDetail.testCase": "测试用例",
        "testDefinition.runDetail.testCase.id": "测试用例 ID",
        "testDefinition.runDetail.testCase.status": "测试用例状态",
        "testDefinition.runDetail.totalCases": "总用例数",
        "testDefinition.runDetail.error.mockedNodeMissing": "基准执行中不存在模拟节点的输出。{link}。",
        "testDefinition.runDetail.error.mockedNodeMissing.solution": "修复测试配置",
        "testDefinition.runDetail.error.executionFailed": "执行带有基准触发器的工作流失败。{link}。",
        "testDefinition.runDetail.error.executionFailed.solution": "查看执行情况",
        "testDefinition.runDetail.error.evaluationFailed": "执行评估工作流失败。{link}。",
        "testDefinition.runDetail.error.evaluationFailed.solution": "查看评估执行情况",
        "testDefinition.runDetail.error.triggerNoLongerExists": "基准执行中的触发器在工作流中不再存在。{link}。",
        "testDefinition.runDetail.error.triggerNoLongerExists.solution": "查看基准",
        "testDefinition.runDetail.error.invalidMetrics": "评估工作流返回了无效的指标。仅接受数值。查看评估执行情况。{link}。",
        "testDefinition.runDetail.error.invalidMetrics.solution": "查看评估执行情况",
        "testDefinition.runTest": "运行测试",
        "testDefinition.cancelTestRun": "取消测试运行",
        "testDefinition.notImplemented": "此功能尚未实现！",
        "testDefinition.viewDetails": "查看详情",
        "testDefinition.editTest": "编辑测试",
        "testDefinition.deleteTest": "删除测试",
        "testDefinition.deleteTest.warning": "此测试及其所有关联的运行都将被移除。此操作不可撤销。",
        "testDefinition.testIsRunning": "测试正在进行中。请等待其完成。",
        "testDefinition.completeConfig": "完成以下配置以运行测试：",
        "testDefinition.configError.noEvaluationTag": "未设置评估标签",
        "testDefinition.configError.noExecutionsAddedToTag": "未向此标签添加执行",
        "testDefinition.configError.noEvaluationWorkflow": "未设置评估工作流",
        "testDefinition.configError.noMetrics": "没有设置指标",
        "testDefinition.workflowInput.subworkflowName": "{name}的评估工作流",
        "testDefinition.workflowInput.subworkflowName.default": "我的评估子工作流",
        "testDefinition.executions.addTo": "添加到测试",
        "testDefinition.executions.addTo.new": "添加到新测试",
        "testDefinition.executions.addTo.existing": "添加到“{name}”",
        "testDefinition.executions.addedTo": "已添加到“{name}”",
        "testDefinition.executions.removeFrom": "从“{name}”中移除",
        "testDefinition.executions.removedFrom": "执行已从“{name}”中移除",
        "testDefinition.executions.toast.addedTo": "返回到“{name}”",
        "testDefinition.executions.tooltip.addTo": "添加到新测试",
        "testDefinition.executions.tooltip.noExecutions": "无法将评估执行添加到测试",
        "testDefinition.executions.tooltip.onlySuccess": "只有成功的执行才能添加到测试",
        "testDefinition.workflow.createNew": "创建新的评估工作流",
        "testDefinition.workflow.createNew.or": "或使用现有的评估子工作流",
        "testDefinition.executions.toast.addedTo.title": "执行已添加到测试",
        "testDefinition.executions.toast.closeTab": "关闭此选项卡",
        "testDefinition.executions.toast.removedFrom.title": "执行已从测试中移除",
        "freeAi.credits.callout.claim.title": "获取{credits}个免费的OpenAI API积分",
        "freeAi.credits.callout.claim.button.label": "领取积分",
        "freeAi.credits.callout.success.title.part1": "已领取{credits}个免费的OpenAI API积分！请注意，这些免费积分仅适用于以下模型：",
        "freeAi.credits.callout.success.title.part2": "gpt-4o-mini, text-embedding-3-small, dall-e-3, tts-1, whisper-1, 和 text-moderation-latest",
        "freeAi.credits.credentials.edit": "这是一个托管凭据，无法编辑。",
        "freeAi.credits.showError.claim.title": "免费AI积分",
        "freeAi.credits.showError.claim.message": "启用以领取积分",
        "freeAi.credits.showWarning.workflow.activation.title": "您正在使用免费的OpenAI API积分",
        "freeAi.credits.showWarning.workflow.activation.description": "为确保您的工作流未来顺利运行，请用您自己的API密钥替换免费的OpenAI API积分。",
        "insights.banner.title": "最近{count}天的生产执行情况",
        "insights.banner.timeSaved.tooltip": "尚未有估算值。要查看潜在的时间节省，请从工作流设置中为每个工作流{link}。",
        "insights.banner.timeSaved.tooltip.link.text": "添加时间估算",
        "insights.banner.title.total": "总计",
        "insights.banner.title.failed": "失败",
        "insights.banner.title.failureRate": "失败率",
        "insights.banner.title.timeSaved": "节省时间",
        "insights.banner.title.averageRunTime": "平均运行时间",


         "generic.archiveWorkflowError": "归档工作流时出错",
  "generic.unarchiveWorkflowError": "取消归档工作流时出错",
  "generic.officialNode.tooltip": "这是由 {author} 维护的官方节点",
  "generic.shortcutHint": "或按下",
  "generic.upgradeToEnterprise": "升级到企业版",
  "auth.roles.default": "默认",
  "aiAssistant.n8nAi": "n8n AI 助手",
  "aiAssistant.builder.name": "构建器",
  "aiAssistant.builder.mode": "AI 构建器",
  "aiAssistant.builder.placeholder": "你想要自动化什么？",
  "aiAssistant.builder.generateNew": "生成新工作流",
  "aiAssistant.builder.buildWorkflow": "构建工作流",
  "aiAssistant.builder.newWorkflowNotice": "创建的工作流将添加到编辑器中",
  "aiAssistant.builder.feedbackPrompt": "这个工作流有帮助吗？",
  "aiAssistant.builder.invalidPrompt": "提示验证失败。请尝试更清晰地描述你的工作流需求及支持的集成内容。",
  "dataMapping.schemaView.emptySchema": "没有字段 - 项目存在，但为空",
  "dataMapping.schemaView.emptySchemaWithBinary": "仅包含二进制数据。请使用“二进制”选项卡查看",
  "dataMapping.schemaView.executeSchema": "点击 {link} 查看数据结构",
  "error.entityNotFound.title": "{entity} 未找到",
  "error.entityNotFound.text": "我们无法找到你正在查找的 {entity}。请确保链接正确。",
  "error.entityNotFound.action": "返回概览页",
  "error.entityUnAuthorized.title": "你需要权限",
  "error.entityUnAuthorized.content": "你没有权限查看此 {entity}。请联系分享此链接的人请求访问权限。",
  "executionDetails.additionalActions": "附加操作",
  "executionsList.showMessage.retryError.title": "重试失败",
  "executionsList.showMessage.retrySuccess.title": "重试成功",
  "executionsList.showMessage.retryWaiting.title": "等待重试",
  "executionsList.showMessage.retryCrashed.title": "重试时崩溃",
  "executionsList.showMessage.retryCanceled.title": "重试已取消",
  "executionsList.showMessage.retryRunning.title": "重试执行中",
  "executionsList.debug.paywall.title": "升级以使用编辑器调试功能",
   "executionsList.debug.paywall.subContent": "该功能在我们的 Cloud 计划、企业版和",
  "fromAiParametersModal.title": "测试 {nodeName}",
  "fromAiParametersModal.execute": "执行步骤",
 "fromAiParametersModal.description": "提供通常来自 “{parentNodeName}” 节点的数据",
  "fromAiParametersModal.cancel": "取消",
  "executionsFilter.savedDataExactMatch": "完全匹配",
  "forgotPassword.oidcUserPasswordResetUnavailable": "请联系你的 OIDC 管理员以重置密码",
  "folders.rename.placeholder": "输入新文件夹名称",
  "folders.move.modal.folder.count": "{count} 个文件夹",
  "folders.move.modal.workflow.count": "{count} 个工作流",
  "folders.move.modal.project.label": "项目或用户",
  "folders.move.modal.project.placeholder": "选择一个项目或用户",
  "folders.move.modal.folder.label": "文件夹",
  "folders.move.modal.folder.placeholder": "选择一个文件夹",
  "folders.move.modal.folder.noData.label": "未找到文件夹",
  "folders.move.modal.message.usedCredentials.workflow": "还需共享此工作流所使用的 {usedCredentials}，以确保其正常运行",
  "folders.move.modal.message.usedCredentials.folder": "还需共享这些工作流使用的 {usedCredentials}，以确保它们正常运行",
  "folders.move.modal.message.usedCredentials.warning": "如果你选择不共享凭据，工作流可能无法正确执行。",
  "folders.move.success.messageNoAccess": "<b>{folderName}</b> 已移动至 <b>{newFolderName}</b>，其中包含所有工作流和子文件夹。",
  "folders.move.workflow.success.messageNoAccess": "<b>{workflowName}</b> 已移动至 <b>{newFolderName}</b>。",
  "genericHelpers.hrsShort": "小时",
  "logs.overview.body.summaryText.for": "{status}，用时 {time}",
  "logs.overview.body.summaryText.in": "{status}，耗时 {time}",
  "logs.overview.body.run": "执行步骤",
  "logs.overview.body.open": "打开...",
  "logs.overview.body.toggleRow": "展开/折叠行",
  "logs.details.header.actions.input": "输入",
  "logs.details.header.actions.output": "输出",
  "logs.details.body.itemCount": "{count} 项",
  "logs.details.body.multipleInputs": "有多个输入。通过 {button} 查看",
  "logs.details.body.multipleInputs.openingTheNode": "打开节点",
  "mainSidebar.confirmMessage.workflowArchive.cancelButtonText": "",
  "mainSidebar.confirmMessage.workflowArchive.confirmButtonText": "是的，归档",
  "mainSidebar.confirmMessage.workflowArchive.headline": "归档工作流？",
  "mainSidebar.confirmMessage.workflowArchive.message": "你确定要归档“{workflowName}”吗？",
  "mainSidebar.showMessage.handleArchive.title": "工作流“{workflowName}”已归档",
  "mainSidebar.showMessage.handleUnarchive.title": "工作流“{workflowName}”已取消归档",
  "menuActions.archive": "归档",
  "menuActions.unarchive": "取消归档",
  "ndv.input.fromAI": "来自 AI",
 "ndv.output.githubNodeWaitingForWebhook": "当以下 Webhook URL 被调用时，执行将继续：",
  "ndv.output.waitNodeWaiting.title": "等待输入",
  "ndv.output.waitNodeWaiting.description.webhook": "当接收到 Webhook 时，执行将继续：",
  "ndv.output.waitNodeWaiting.description.form": "当表单提交时，执行将继续：",
  "ndv.output.waitNodeWaiting.description.timer": "当等待时间结束时，执行将继续",
  "nodeCreator.categoryNames.moreFromCommunity": "来自社区的更多内容",
  "nodeCreator.ragStarterTemplate.openTemplateItem.title": "RAG 入门模板",
  "nodeCreator.ragStarterTemplate.openTemplateItem.description": "在 n8n 中体验向量数据库的使用",
  "nodeCreator.nodeItem.deprecated": "已弃用",
  "nodeSettings.communityNodeDetails.title": "节点详情",
  "nodeView.runButtonText.from": "来自 {nodeName}",
  "nodeView.showMessage.ndvUrl.missingNodes.title": "未找到节点",
  "nodeView.showMessage.ndvUrl.missingNodes.content": "URL 中引用了一个未知节点。可能该节点已被删除？",
  "contextMenu.extract": "转换为子工作流 | 将 {count} 个节点转换为子工作流",
  "contextMenu.openSubworkflow": "前往子工作流",
  "nodeWebhooks.clickToCopyWebhookUrls.mcpTrigger": "点击复制 MCP URL",
  "nodeWebhooks.clickToDisplayWebhookUrls.mcpTrigger": "点击显示 MCP URL",
  "nodeWebhooks.clickToHideWebhookUrls.mcpTrigger": "点击隐藏 MCP URL",
  "nodeWebhooks.showMessage.title.mcpTrigger": "MCP URL 已复制",
  "nodeWebhooks.webhookUrls.mcpTrigger": "MCP URL",
  "parameterInput.selectedWorkflowIsArchived": "所选工作流已归档",
  "parameterInputList.callout.dismiss.confirm.text": "你确定要永久隐藏此项吗？",
  "parameterInputList.callout.dismiss.confirm.confirmButtonText": "确认",
  "parameterInputList.callout.dismiss.confirm.cancelButtonText": "取消",
  "renameAction.emptyName.message": "请输入名称，或按下 'esc' 返回原名称",
  "renameAction.emptyName.title": "缺少名称",
  "renameAction.invalidName.title": "名称无效",
  "resourceLocator.mode.list.addNewResource.vectorStoreInMemory": "创建键 '{resourceName}'",
  "resourceLocator.placeholder.searchOrCreate": "搜索或创建...",
  "resourceLocator.placeholder.search": "搜索...",
  "runData.rendered": "已渲染",
  "runData.panel.actions.sync": "与画布同步选中项",
  "settings.communityNodes.empty.verified.only.title": "使用已验证的社区节点增强你的工作流",
  "settings.communityNodes.empty.verified.only.description": "你可以直接从节点面板安装由社区和合作伙伴构建并由 n8n 验证的节点包。已安装的包将显示在此处。",
  "settings.personal.role.tooltip.default": "新用户的默认角色",
  "settings.personal.role.tooltip.member": "创建和管理自己的工作流和凭据",
  "settings.personal.role.tooltip.admin": "全面管理工作流、标签、凭据、项目、用户等",
  "settings.personal.role.tooltip.owner": "管理所有内容{cloudAccess}",
  "settings.personal.role.tooltip.cloud": " 并访问 Cloud 仪表盘",
  "settings.api.scopes.upgrade": "{link} 以解锁修改 API Key 权限的功能",
  "settings.api.scopes.upgrade.link": "升级",
  "settings.log-streaming.eventGroup.n8n.runner": "运行任务",
  "settings.log-streaming.eventGroup.n8n.runner.info": "当任务运行器请求执行 Code 节点以及返回结果时，将发送事件",
  "settings.log-streaming.eventGroup.n8n.queue": "队列事件",
 "settings.log-streaming.eventGroup.n8n.queue.info": "当发生队列相关事件（如入队、出队、完成、失败或卡顿）时，将发送事件",
  "settings.api.scopes.placeholder": "请选择",
  "settings.api.scopes.selectAll": "全选",
  "settings.api.scopes.label": "作用域",
  "settings.sourceControl.button.pull.forbidden": "仅实例所有者或管理员可以拉取更改",
  "settings.sourceControl.button.push.forbidden": "你无法从受保护的实例推送更改",
  "workflowActivator.thisWorkflowIsArchived": "此工作流已归档，无法被激活",
  "workflowExtraction.error.failure": "子工作流转换失败",
  "workflowExtraction.error.selectionGraph.inputEdgeToNonRoot": "非输入节点 “{node}” 与当前选择之外的节点连接。",
  "workflowExtraction.error.selectionGraph.outputEdgeFromNonLeaf": "非输出节点 “{node}” 与当前选择之外的节点连接。",
  "workflowExtraction.error.selectionGraph.multipleInputNodes": "多个节点 [{nodes}] 有来自选择范围外的输入。",
  "workflowExtraction.error.selectionGraph.multipleOutputNodes": "多个节点 [{nodes}] 有输出连接至选择范围外。",
  "workflowExtraction.error.selectionGraph.noContinuousPathFromRootToLeaf": "起始节点 “{start}” 没有到达结束节点 “{end}” 的路径。",
  "workflowExtraction.error.selectionGraph.listHeader": "由于以下错误，所选内容无效：<br><br>{body}<br><br><a href=\'https://docs.n8n.io/workflows/subworkflow-conversion/\' target=\'_blank\'>查看文档</a> 了解更多信息。",
  "workflowExtraction.error.inputNodeHasMultipleInputBranches": "起始节点 “{node}” 有多个输入分支，子工作流不支持这种结构。",
  "workflowExtraction.error.outputNodeHasMultipleOutputBranches": "结束节点 “{node}” 有多个输出分支，子工作流不支持这种结构。",
  "workflowExtraction.error.triggerSelected": "触发器无法转换为子工作流。请取消选择 {nodes}。",
  "workflowExtraction.error.subworkflowCreationFailed": "子工作流创建失败，已中止转换。",
  "workflowExtraction.success.title": "已创建子工作流",
  "workflowExtraction.success.message": "<a href=\'{url}\' target=\'_blank\'>在新标签页中打开</a>",
  "workflowExtraction.modal.title": "转换为子工作流",
  "workflowExtraction.modal.description": "将 {nodeCount} 个节点转换为新的子工作流 | 将 {nodeCount} 个节点转换为新的子工作流",
  "workflows.item.archive": "归档",
  "workflows.item.unarchive": "取消归档",
  "workflows.item.archived": "已归档",
  "workflows.filters.showArchived": "显示已归档的工作流",
  "workflows.filters.active.shortText": "已应用筛选器。",
  "workflows.empty.shared-with-me": "没有 {resource} 与你共享",
  "workflows.empty.shared-with-me.link": "<a href=\'#\'>返回个人空间</a>",
  "workflows.deactivated": "工作流已停用",
  "settings.sso.settings.ips.url.invalid": "身份提供商元数据 URL 无效",
  "settings.oidc.confirmMessage.beforeSaveForm.headline": "你确定要禁用 OIDC 登录吗？",
  "settings.oidc.confirmMessage.beforeSaveForm.message": "如果禁用，所有 OIDC 用户将被转换为邮箱用户。",
  "projects.header.overview.subtitle": "你可访问的所有工作流、凭据和执行记录",
  "projects.header.shared.title": "共享给你",
  "projects.header.personal.subtitle": "你拥有的工作流和凭据",
  "projects.header.shared.subtitle": "其他用户与您共享的工作流和凭据",
  "projects.menu.shared": "共享给你",
  "projects.settings.description": "项目描述",
  "projects.settings.delete.message.empty": "此项目中没有工作流或凭据。",
  "evaluation.listRuns.status.new": "新建",
  "evaluation.listRuns.status.running": "运行中",
  "evaluation.listRuns.status.evaluating": "评估中",
  "evaluation.listRuns.status.completed": "已完成",
  "evaluation.listRuns.status.cancelled": "已取消",
  "evaluation.listRuns.status.error": "错误",
  "evaluation.listRuns.status.success": "成功",
  "evaluation.listRuns.status.warning": "警告",
  "evaluation.listRuns.metricsOverTime": "随时间变化的指标",
  "evaluation.listRuns.status": "状态",
  "evaluation.listRuns.runListHeader": "所有运行记录",
  "evaluation.listRuns.testCasesListHeader": "第 {index} 次运行",
  "evaluation.listRuns.runNumber": "运行次数",
  "evaluation.listRuns.runDate": "运行日期",
  "evaluation.listRuns.runStatus": "运行状态",
  "evaluation.listRuns.noRuns": "没有测试运行",
  "evaluation.listRuns.pastRuns.total": "无运行记录 | 所有运行 | 所有运行",
  "evaluation.listRuns.noRuns.description": "运行测试以在此查看结果",
  "evaluation.listRuns.deleteRuns": "无可删除运行记录 | 删除 {count} 条运行记录 | 删除 {count} 条运行记录",
  "evaluation.listRuns.noRuns.button": "运行测试",
  "evaluation.listRuns.toast.error.fetchTestCases": "加载运行详情失败",
  "evaluation.listRuns.error.testCasesNotFound": "数据集中未找到匹配行{description}",
  "evaluation.listRuns.error.testCasesNotFound.description": "请检查评估触发器中设置的筛选或限制条件",
  "evaluation.listRuns.error.executionInterrupted": "测试运行被中断",
  "evaluation.listRuns.error.unknownError": "执行出错{description}",
  "evaluation.listRuns.error.cantFetchTestRuns": "无法获取测试运行",
  "evaluation.listRuns.error.cantStartTestRun": "无法启动测试运行",
  "evaluation.listRuns.error.unknownError.description": "点击查看更多详情",
  "evaluation.listRuns.error.evaluationTriggerNotFound": "缺少评估触发器",
  "evaluation.listRuns.error.evaluationTriggerNotConfigured": "评估触发器未配置",
  "evaluation.listRuns.error.evaluationTriggerDisabled": "评估触发器已禁用",
  "evaluation.listRuns.error.setOutputsNodeNotFound": "工作流中没有“设置输出”节点",
  "evaluation.listRuns.error.setOutputsNodeNotConfigured": "“设置输出”节点未配置",
  "evaluation.listRuns.error.setMetricsNodeNotFound": "工作流中没有“设置指标”节点",
  "evaluation.listRuns.error.setMetricsNodeNotConfigured": "“设置指标”节点未配置",
  "evaluation.listRuns.error.cantFetchTestCases": "无法获取测试用例{description}",
  "evaluation.listRuns.error.cantFetchTestCases.description": "请检查评估触发器中 Google 表格的设置",
  "evaluation.runDetail.ranAt": "运行于",
  "evaluation.runDetail.testCase": "测试用例",
  "evaluation.runDetail.testCase.id": "测试用例 ID",
  "evaluation.runDetail.testCase.status": "测试用例状态",
  "evaluation.runDetail.totalCases": "用例总数",
  "evaluation.runDetail.error.mockedNodeMissing": "基准执行中不存在模拟节点的输出。{link}",
  "evaluation.runDetail.error.mockedNodeMissing.solution": "修复测试配置",
  "evaluation.runDetail.error.executionFailed": "工作流执行失败",
  "evaluation.runDetail.error.executionFailed.solution": "查看执行记录",
  "evaluation.runDetail.error.datasetTriggerNotFound": "工作流中不存在数据集触发器。{link}",
  "evaluation.runDetail.error.datasetTriggerNotFound.solution": "查看工作流",
  "evaluation.runDetail.error.invalidMetrics": "评估指标节点返回了无效值。仅支持数字类型。查看工作流。{link}",
  "evaluation.runDetail.error.invalidMetrics.solution": "查看工作流",
  "evaluation.runDetail.error.unknownError": "发生未知错误",
  "evaluation.runDetail.error.unknownError.solution": "查看执行记录",
  "evaluation.runDetail.error.noMetricsCollected": "未执行“设置指标”节点",
  "evaluation.runDetail.error.partialCasesFailed": "完成但存在错误",
  "evaluation.runTest": "运行测试",
  "evaluation.cancelTestRun": "取消测试运行",
  "evaluation.notImplemented": "该功能尚未实现！",
  "evaluation.viewDetails": "查看详情",
  "evaluation.editTest": "编辑测试",
  "evaluation.deleteTest": "删除测试",
  "evaluation.deleteTest.warning": "该测试及所有相关运行记录将被删除，此操作无法撤销",
  "evaluation.testIsRunning": "测试正在运行，请等待其完成",
  "evaluation.completeConfig": "请完成以下配置以运行测试：",
  "evaluation.configError.noEvaluationTag": "未设置评估标签",
  "evaluation.configError.noExecutionsAddedToTag": "此标签下未添加任何执行记录",
  "evaluation.configError.noEvaluationWorkflow": "未设置评估工作流",
  "evaluation.configError.noMetrics": "未设置指标",
  "evaluation.workflowInput.subworkflowName": "{name} 的评估工作流",
  "evaluation.workflowInput.subworkflowName.default": "我的评估子工作流",
  "evaluation.executions.addTo": "添加到测试",
  "evaluation.executions.addTo.new": "添加到新测试",
  "evaluation.executions.addTo.existing": "添加到“{name}”",
  "evaluation.executions.addedTo": "已添加到“{name}”",
  "evaluation.executions.removeFrom": "从“{name}”中移除",
  "evaluation.executions.removedFrom": "已从“{name}”中移除执行记录",
  "evaluation.executions.toast.addedTo": "返回“{name}”",
  "evaluation.executions.tooltip.addTo": "添加到新测试",
  "evaluation.executions.tooltip.noExecutions": "评估执行记录无法添加到测试中",
  "evaluation.executions.tooltip.onlySuccess": "仅成功的执行记录可添加到测试中",
  "evaluation.workflow.createNew": "创建新的评估工作流",
  "evaluation.workflow.createNew.or": "或使用现有的评估子工作流",
  "evaluation.executions.toast.addedTo.title": "执行记录已添加到测试",
  "evaluation.executions.toast.closeTab": "关闭此标签页",
  "evaluation.executions.toast.removedFrom.title": "执行记录已从测试中移除",
  "evaluations.paywall.title": "注册以启用评估功能",
  "evaluations.paywall.description": "注册你的社区版实例以解锁评估功能",
  "evaluations.paywall.cta": "注册实例",
  "evaluations.setupWizard.title": "通过多个输入测试你的 AI 工作流",
  "evaluations.setupWizard.description": "评估通过测试数据集衡量性能",
  "evaluations.setupWizard.moreInfo": "了解更多",
  "evaluations.setupWizard.stepHeader.optional": "可选",
  "evaluations.setupWizard.step1.title": "连接测试数据集",
  "evaluations.setupWizard.step1.item1": "使用 Google 表格，每行一个输入",
  "evaluations.setupWizard.step1.item2": "将评估触发器添加到你的工作流并连接",
  "evaluations.setupWizard.step1.button": "添加评估触发器",
  "evaluations.setupWizard.step2.title": "将工作流输出写回数据集",
  "evaluations.setupWizard.step2.item1": "添加“设置输出”操作，将每个输出记录到 Google 表格",
  "evaluations.setupWizard.step2.button": "添加“设置输出”节点",
  "evaluations.setupWizard.step3.title": "设置质量评分",
  "evaluations.setupWizard.step3.item1": "计算评分，例如通过对比预期输出与实际输出",
  "evaluations.setupWizard.step3.item2": "添加“设置指标”操作记录得分",
  "evaluations.setupWizard.step3.button": "添加“设置指标”节点",
  "evaluations.setupWizard.step3.skip": "跳过",
  "evaluations.setupWizard.step3.notice": "你的当前套餐仅支持一个工作流的自定义指标。{link}",
  "evaluations.setupWizard.step3.notice.link": "查看套餐",
  "evaluations.setupWizard.step4.title": "运行评估",
  "evaluations.setupWizard.step4.button": "开始评估",
  "evaluations.setupWizard.step4.altButton": "在编辑器中运行",
  "evaluations.setupWizard.limitReached": "已达使用上限。你的套餐仅支持一个工作流的自定义指标。可升级套餐以获取无限使用，或删除已有评估运行的工作流。",
  "insights.heading": "洞察",
 "insights.lastNDays": "最近 {count} 天",
  "insights.lastNHours": "最近 {count} 小时",
  "insights.months": "{count} 个月",
  "insights.oneYear": "一年",
  "insights.banner.noData.tooltip": "手动执行不会被统计。升级后数据可能最多需要 24 小时更新。{link}",
  "insights.banner.noData.tooltip.link": "了解更多",
  "insights.banner.noData.tooltip.link.url": "https://docs.n8n.io/insights/",
  "insights.banner.title.timeSavedDailyAverage": "每天节省的时间（平均）",
  "insights.dashboard.table.projectName": "项目名称",
  "insights.dashboard.table.estimate": "估算值",
  "insights.dashboard.title": "洞察",
  "insights.dashboard.paywall.cta": "升级",
  "insights.dashboard.paywall.title": "升级以访问更详细的洞察",
  "insights.dashboard.paywall.description": "获取更精细的每个工作流洞察，以及按时间段划分的生产执行图表。",
  "insights.banner.title.timeSaved.tooltip": "从你设置的每次执行节省的时间估算中，计算出的总节省时间",
  "insights.banner.failureRate.deviation.tooltip": "与上一周期相比的百分比变化",
  "insights.chart.failed": "失败",
  "insights.chart.succeeded": "成功",
  "insights.chart.loading": "正在加载数据",
  "communityNodesDocsLink.link.title": "打开社区节点文档",
  "communityNodesDocsLink.title": "文档",
  "communityNodeItem.node.hint": "安装此节点以开始使用",
  "communityNodeItem.actions.hint": "安装此节点以使用操作",
  "communityNodeItem.label": "添加到工作流",
  "communityNodeDetails.installed": "已安装",
  "communityNodeDetails.install": "安装节点",
  "communityNodeInfo.approved": "此社区节点已由 n8n 审核并通过",
  "communityNodeInfo.officialApproved": "此节点已由 n8n 审核并通过",
  "communityNodeInfo.approved.label": "已验证",
  "communityNodeInfo.unverified": "此社区节点是通过 npm 添加的，尚未由 n8n 验证",
  "communityNodeInfo.unverified.label": "通过 npm",
  "communityNodeInfo.downloads": "{downloads} 次下载",
  "communityNodeInfo.publishedBy": "由 {publisherName} 发布",
  "communityNodeInfo.contact.admin": "请联系管理员安装此社区节点：",
  "insights.upgradeModal.button.dismiss": "稍后再说",
  "insights.upgradeModal.button.upgrade": "立即升级",
  "insights.upgradeModal.content": "查看此时间范围需要企业版计划。升级到 Enterprise 以解锁高级功能。",
  "insights.upgradeModal.perks.0": "查看最长一年的历史洞察记录",
  "insights.upgradeModal.perks.1": "以小时为单位查看过去 24 小时内的趋势",
  "insights.upgradeModal.perks.2": "深入了解工作流随时间的趋势",
  "insights.upgradeModal.title": "升级到 Enterprise",
   "generic.retry": "重试",
  "nds.auth.roles.owner": "所有者",
  "nds.userInfo.you": "（你）",
  "nds.userSelect.selectUser": "选择用户",
  "nds.userSelect.noMatchingUsers": "无匹配用户",
  "notice.showMore": "显示更多",
  "notice.showLess": "显示更少",
  "formInput.validator.fieldRequired": "此字段为必填项",
  "formInput.validator.minCharactersRequired": "至少需要 {minimum} 个字符",
  "formInput.validator.maxCharactersRequired": "最多允许 {maximum} 个字符",
   "datatable.pageSize": "每页条数",
  "codeDiff.couldNotReplace": "无法替换代码",
  "codeDiff.codeReplaced": "代码已替换",
  "codeDiff.replaceMyCode": "替换我的代码",
  "codeDiff.replacing": "正在替换...",
  "codeDiff.undo": "撤销",
  "betaTag.beta": "测试版",
  "askAssistantButton.askAssistant": "询问助手",
  "assistantChat.builder.name": "AI 构建器",
  "assistantChat.builder.generatingFinalWorkflow": "正在生成最终工作流...",
  "assistantChat.builder.configuredNodes": "已配置节点",
  "assistantChat.builder.thumbsUp": "有帮助",
  "assistantChat.builder.thumbsDown": "无帮助",
  "assistantChat.builder.feedbackPlaceholder": "告诉我们你的使用体验",
  "assistantChat.builder.success": "感谢你的反馈！",
  "assistantChat.builder.submit": "提交反馈",
  "assistantChat.builder.workflowGenerated1": "你的工作流已成功创建！",
  "assistantChat.builder.workflowGenerated2": "测试前请先修复缺失的凭据。",
  "assistantChat.builder.configuringNodes": "正在配置节点...",
  "assistantChat.builder.selectedNodes": "已选择的工作流节点",
  "assistantChat.builder.selectingNodes": "正在选择节点...",
  "assistantChat.builder.generatedNodes": "生成的工作流节点",
  "assistantChat.errorParsingMarkdown": "解析 Markdown 内容时出错",
  "assistantChat.aiAssistantLabel": "AI 助手",
  "assistantChat.aiAssistantName": "助手",
  "assistantChat.sessionEndMessage.1": "此助手会话已结束。要开始新的会话，请点击",
  "assistantChat.sessionEndMessage.2": "n8n 中的按钮",
  "assistantChat.you": "你",
  "assistantChat.quickRepliesTitle": "快速回复 👇",
  "assistantChat.placeholder.2": "对于特定任务，你会看到",
  "assistantChat.placeholder.3": "界面中的按钮。",
  "assistantChat.placeholder.4": "我能帮你做些什么？",
  "assistantChat.inputPlaceholder": "请输入你的回复...",
  "assistantChat.copy": "复制",
  "assistantChat.copied": "已复制",
  "inlineAskAssistantButton.asked": "已提问",
  "iconPicker.button.defaultToolTip": "选择图标",
  "iconPicker.tabs.icons": "图标",
  "iconPicker.tabs.emojis": "表情符号",
  "selectableList.addDefault": "+ 添加一个",
  "auth.changePassword.passwordsMustMatchError": "密码必须一致",
  "generic.credentials": "凭据",
  "aiAssistant.tooltip": "咨询助手",
  "codeNodeEditor.askAi.generationFailedWithReason": "代码生成失败，错误：{error}。请几分钟后重试",
  "dataMapping.tableView.columnCollapsing": "折叠行",
  "dataMapping.tableView.columnCollapsing.tooltip": "折叠行（以便比较此列中的值）",
  "mainSidebar.whatsNew": "新功能",
  "mainSidebar.whatsNew.fullChangelog": "完整更新日志",
  "ndv.close.tooltip": "数据已保存，可安全关闭",
  "ndv.input.noOutputData.v2.title": "无输入数据",
  "ndv.input.noOutputData.v2.description": "{link}查看输入数据",
  "ndv.input.noOutputData.v2.action": "执行前面的节点",
  "ndv.input.noOutputData.v2.tooltip": "从最早未执行的节点开始，或已执行但之后被修改的节点",
  "ndv.input.notConnected.v2.title": "未连接输入",
  "ndv.input.notConnected.v2.description": "只有将此节点连接到另一个节点，它才能接收输入数据。{link}",
  "ndv.output.noOutputData.v2.title": "无输出数据",
  "ndv.output.noOutputData.v2.description": "{link}查看输出数据",
  "ndv.output.noOutputData.v2.action": "测试此步骤",
  "ndv.output.noOutputData.trigger.title": "无触发器输出",
  "ndv.output.noOutputData.trigger.action": "测试此触发器",
  "ndv.title.rename.placeholder": "输入新名称...",
  "nodeView.openFocusPanel": "打开焦点面板",
  "nodeView.templateLink": "或从模板开始",
  "nodeView.focusPanel.title": "焦点",
  "nodeView.focusPanel.noParameters": "无聚焦的参数。通过点击节点详情视图中的操作下拉菜单来聚焦参数。",
  "nodeView.focusPanel.missingParameter": "此参数在节点上已不再可见。可能是相关参数已更改，导致此参数被移除。",
  "nodeView.showError.openExecution.node": "打开执行中的节点时出现问题",
  "nodeView.expandAllNodes": "展开所有节点",
  "nodeView.collapseAllNodes": "折叠所有节点",
  "parameterInput.focusParameter": "聚焦参数",
  "settings.communityNodes.confirmModal.update.warning": "此版本未经过n8n验证，可能包含破坏性更改或错误。",
  "settings.users.search.placeholder": "按名称或电子邮件搜索",
  "settings.users.passwordResetLinkError": "无法获取密码重置链接",
  "settings.users.userNotFound": "未找到用户",
  "settings.users.table.update.error": "更新表格失败",
  "settings.users.table.header.user": "@:_reusableBaseText.user",
  "settings.users.table.header.accountType": "账户类型",
  "settings.users.table.header.2fa": "双重认证",
  "settings.users.table.header.lastActive": "最后活跃时间",
  "settings.users.table.row.allProjects": "所有项目",
  "settings.users.table.row.personalProject": "个人项目",
  "settings.users.table.row.deleteUser": "移除用户",
  "settings.users.table.row.role.description.admin": "对所有工作流、凭据、项目、用户等拥有完全访问权限",
  "settings.users.table.row.role.description.member": "管理和创建自己的工作流及凭据",
  "settings.users.table.row.2fa.enabled": "@:_reusableBaseText.enabled",
  "settings.users.table.row.2fa.disabled": "@:_reusableBaseText.disabled",
  "settings.sourceControl.modals.push.filter": "已应用筛选器。显示{count}个{entity}。",
  "settings.sourceControl.modals.push.projectAdmin.callout": "如果您想从个人空间推送工作流，请先将它们移至项目中。",
  "workflows.empty.startWithTemplate": "从模板开始",
  "settings.personal.mfa.enforced": "此实例的设置<strong>要求您设置双重认证</strong>。请启用它以继续在此实例中工作。",
  "settings.personal.mfa.enforce.message": "对该实例上的所有用户强制启用双重认证。",
  "settings.personal.mfa.enforce.unlicensed_tooltip": "升级计划后，您可以对该实例上的所有用户强制启用双重认证。{action}",
  "settings.personal.mfa.enforce.unlicensed_tooltip.link": "查看计划",
  "settings.personal.mfa.enforce.title": "强制双重认证",
  "settings.personal.mfa.enforce.error": "无法对所有用户强制启用双重认证",
  "settings.personal.mfa.enforce.enabled.title": "已强制双重认证",
  "settings.personal.mfa.enforce.enabled.message": "现在该实例上的所有用户都需要进行双重认证。",
  "whatsNew.versionsBehind": "落后{count}个版本 | 落后{count}个版本",
  "whatsNew.update": "更新",
  "whatsNew.updateAvailable": "您当前使用的是{currentVersion}版本。更新到{latestVersion}版本，即可获得{count}个版本的新功能、改进和修复。查看更改内容",
  "whatsNew.updateAvailable.changelogLink": "完整更新日志",
  "generic.clear": "清除",
  "generic.startNow": "立即开始",
  "generic.unknownError": "发生未知错误",
  "generic.never": "从不",
  "aiAssistant.builder.workflowParsingError.title": "无法插入工作流",
  "aiAssistant.builder.workflowParsingError.content": "AI 返回的工作流无法解析。请重试。",
  "aiAssistant.builder.canvasPrompt.buildWorkflow": "创建工作流",
  "aiAssistant.builder.canvasPrompt.title": "你想自动化什么？",
  "aiAssistant.builder.canvasPrompt.confirmTitle": "替换当前提示？",
  "aiAssistant.builder.canvasPrompt.confirmMessage": "这将替换你当前的提示。确定吗？",
  "aiAssistant.builder.canvasPrompt.confirmButton": "替换",
  "aiAssistant.builder.canvasPrompt.cancelButton": "取消",
  "aiAssistant.builder.canvasPrompt.startManually.title": "手动开始",
  "aiAssistant.builder.canvasPrompt.startManually.subTitle": "添加第一个节点",
  "aiAssistant.builder.streamAbortedMessage": "[任务已中止]",
  "aiAssistant.thinkingSteps.runningTools": "正在运行工具...",
  "aiAssistant.thinkingSteps.processingResults": "正在处理结果...",
  "ndv.input.noOutputData.embeddedNdv.link": "执行前置节点",
  "ndv.input.noOutputData.embeddedNdv.description": "在此使用它们的数据 {link}",
  "node.settings.continuesOnError": "即使节点失败也会继续执行",
  "node.settings.continuesOnError.title": "失败后继续",
  "node.settings.retriesOnFailure": "此节点失败时将自动重试",
  "node.settings.executeOnce": "无论有多少输入项，此节点只执行一次",
  "node.settings.alwaysOutputData": "如果通常没有返回内容，此节点将输出一个空项",
  "nodeCreator.preBuiltAgents.title": "预构建代理",
  "nodeCreator.preBuiltAgents.description": "使用现成的代理更快上手",
  "nodeSettings.parametersShort": "参数",
  "nodeSettings.action": "操作",
  "nodeSettings.credential": "认证",
  "nodeView.focusPanel.noExecutionData": "执行前置节点以启用自动补全",
  "nodeView.focusPanel.noParameters.title": "在此显示节点参数，方便迭代",
  "nodeView.focusPanel.noParameters.subtitle": "例如，让提示始终可见，这样可以在调整时运行工作流",
  "nodeView.enterZoomMode": "进入缩放模式",
  "nodeView.leaveZoomMode": "退出缩放模式",
  "prompts.npsSurvey.feedbackQuestionTitle": "谢谢！你为什么选择这个分数？",
  "settings.communityNodes.confirmModal.uninstall.description": "卸载该包将移除其中包含的所有节点。以下工作流将受到影响：",
  "settings.communityNodes.confirmModal.noWorkflowsUsingNodes": "此包中的节点未在任何工作流中使用",
  "settings.communityNodes.confirmModal.includedNodes": "包包含：{nodes}",
  "settings.communityNodes.confirmModal.cancel": "取消",
  "settings.users.count": "{count} 个用户",
  "userActivity.daysAgo": "{count} 天前",
  "userActivity.lastTime": "上次 {time}",
  "userActivity.today": "今天",
  "userActivity.yesterday": "昨天",
  "ndv.nodeHints.disabled": "此节点已禁用，仅会传递输入",
  "ndv.nodeHints.alwaysOutputData": "如果通常没有返回内容，此节点将输出一个空项",
  "ndv.nodeHints.alwaysOutputData.short": "如果没有返回内容则输出一个空项",
  "ndv.nodeHints.executeOnce": "无论有多少输入项，此节点只执行一次",
  "ndv.nodeHints.executeOnce.short": "只执行一次，无论输入多少",
  "ndv.nodeHints.retryOnFail": "此节点失败时将自动重试",
  "ndv.nodeHints.retryOnFail.short": "失败时自动重试",
  "ndv.nodeHints.continueOnError": "即使节点失败也会继续执行",
  "ndv.nodeHints.continueOnError.short": "失败时继续执行",
  "workflowProductionChecklist.title": "生产检查清单",
  "workflowProductionChecklist.readOnlyNotice": "只读环境。请在开发环境中更新这些项目并推送更改。",
  "workflowProductionChecklist.ignoreAllConfirmation.title": "全局忽略建议的操作",
  "workflowProductionChecklist.ignoreAllConfirmation.description": "关闭后，将在所有工作流中忽略这些建议",
  "workflowProductionChecklist.ignoreAllConfirmation.confirm": "对所有工作流忽略",
  "workflowProductionChecklist.turnOffWorkflowSuggestions": "对所有工作流忽略",
  "workflowProductionChecklist.evaluations.title": "测试 AI 步骤的可靠性",
  "workflowProductionChecklist.evaluations.description": "使用评估来检查在不同输入下的表现。",
  "workflowProductionChecklist.errorWorkflow.title": "设置错误通知",
  "workflowProductionChecklist.errorWorkflow.description": "通过设置错误工作流自定义通知方式",
  "workflowProductionChecklist.timeSaved.title": "跟踪节省的时间",
  "workflowProductionChecklist.timeSaved.description": "配置每次运行节省的时间，用于统计减少的人工工作。",
  "workflowSettings.name": "工作流名称",
  "workflowSettings.executionTimeout": "工作流超时",
  "workflowSettings.tags": "标签",
  "workflows.itemSuggestion.try": "尝试模板",
  "workflows.templateRecoV2.starterTemplates": "入门模板",
  "workflows.templateRecoV2.seeMoreStarterTemplates": "查看更多入门模板",
  "workflows.templateRecoV2.popularTemplates": "热门模板",
  "workflows.templateRecoV2.seeMorePopularTemplates": "查看更多热门模板",
  "workflows.templateRecoV2.tutorials": "教程",
  "workflows.templateRecoV2.loadingTemplates": "正在加载模板...",
  "workflows.templateRecoV2.useTemplate": "使用模板",
  "workflows.templateRecoV2.exploreTemplates": "或探索模板，快速获取灵感和学习：",
  "workflows.ai.starter.collection.callout": "学习如何在 n8n 中构建 AI 代理",
  "workflows.ai.starter.collection.card": "学习如何构建 AI 代理",
  "workflows.ai.starter.collection.folder.name": "🎁 n8n 基础：学习如何在 n8n 中构建代理",
  "workflows.ai.starter.collection.error": "加载 AI 代理入门合集出错，请稍后重试。",
  "workflows.readyToRunWorkflows.card": "尝试一个工作流 - 无需设置",
  "workflows.readyToRunWorkflows.card2": "运行一个工作流",
  "workflows.readyToRunWorkflows.card3": "查看 n8n 实际运行效果",
  "workflows.readyToRunWorkflows.callout": "查看 n8n 实际运行效果 - 无需设置",
  "workflows.readyToRunWorkflows.callout2": "运行一个工作流",
  "workflows.readyToRunWorkflows.callout3": "查看 n8n 实际运行效果",
  "workflows.readyToRunWorkflows.cta": "运行一个工作流",
  "workflows.readyToRunWorkflows.folder.name": "🚀 即开即用的工作流",
  "workflows.readyToRunWorkflows.error": "加载 n8n 合集出错，请稍后重试。",
  "workflows.archivedOnly.hint": "已归档的工作流在此视图中被隐藏。{link}",
  "workflows.archivedOnly.hint.link": "更新筛选条件",
  "dataStore.empty.label": "你还没有任何数据存储",
  "dataStore.empty.description": "创建项目数据存储后，它们将显示在此处",
  "dataStore.empty.button.label": "在“{projectName}”中创建数据存储",
  "dataStore.card.size": "{size}MB",
  "dataStore.card.column.count": "{count} 列",
  "dataStore.card.row.count": "{count} 条记录",
  "dataStore.sort.lastUpdated": "按最后更新时间排序",
  "dataStore.sort.lastCreated": "按创建时间排序",
  "dataStore.sort.nameAsc": "按名称排序 (A-Z)",
  "dataStore.sort.nameDesc": "按名称排序 (Z-A)",
  "dataStore.search.placeholder": "搜索",
  "dataStore.error.fetching": "加载数据存储出错",
  "dataStore.add.title": "创建数据存储",
  "dataStore.add.description": "设置一个新的数据存储来组织和管理你的数据。",
  "dataStore.add.button.label": "创建数据存储",
  "dataStore.add.input.name.label": "数据存储名称",
  "dataStore.add.input.name.placeholder": "输入数据存储名称",
  "dataStore.add.error": "创建数据存储出错",
  "dataStore.delete.confirm.title": "删除数据存储",
  "dataStore.delete.confirm.message": "确定要删除数据存储“{name}”吗？此操作无法撤销。",
  "dataStore.delete.error": "删除数据存储出错",
  "dataStore.rename.error": "重命名数据存储出错",
  "dataStore.getDetails.error": "获取数据存储详情出错",
  "dataStore.notFound": "未找到数据存储",
  "dataStore.noColumns.heading": "尚无列",
  "dataStore.noColumns.description": "添加列以开始在此数据存储中保存数据。",
  "dataStore.noColumns.button.label": "添加第一列",
  "dataStore.addColumn.label": "添加列",
  "dataStore.addColumn.nameInput.label": "@:_reusableBaseText.name",
  "dataStore.addColumn.nameInput.placeholder": "输入列名",
  "dataStore.addColumn.typeInput.label": "@:_reusableBaseText.type",
  "dataStore.addColumn.error": "添加列出错",
  "dataStore.addColumn.invalidName.error": "无效的列名",
  "dataStore.addColumn.invalidName.description": "列名只能包含字母、数字，且不能以短横线开头",
  "settings.personal.mfa.enforce.disabled.title": "不再强制启用两步验证",
  "settings.personal.mfa.enforce.disabled.message": "使用邮箱和密码登录的用户，不再强制启用双因素认证。",
  "evaluation.listRuns.allTestCases": "所有测试用例 | 所有测试用例 ({count})",
  "evaluation.listRuns.error.cantStopTestRun": "无法停止测试运行",
  "evaluation.runDetail.notice.useSetInputs": "提示：在工作流中添加评估节点的“设置输入”操作，可以在此显示数据集中的输入列",
  "evaluation.stopTest": "停止测试",
  "evaluations.readOnlyNotice": "只读模式下无法创建评估。请在开发环境中构建你的评估。",
  "insights.dashboard.table.title": "按工作流分解",
  "communityNodeUpdateInfo.available": "有新的节点包版本可用",
  "workflowDiff.changes": "更改",
  "workflowDiff.nodes": "节点",
  "workflowDiff.connectors": "连接器",
  "workflowDiff.settings": "设置",
  "workflowDiff.local": "本地",
  "workflowDiff.remote": "远程 ({branchName})",
  "workflowDiff.noChanges": "无更改",
  "workflowDiff.deletedWorkflow": "缺失的工作流",
  "workflowDiff.deletedWorkflow.database": "数据库中不存在此工作流",
  "workflowDiff.deletedWorkflow.remote": "远程不存在此工作流",
  "workflowDiff.newWorkflow": "新工作流",
  "workflowDiff.newWorkflow.database": "该工作流将在数据库中创建",
  "workflowDiff.newWorkflow.remote": "该工作流将在远程创建",
  "generic.saving": "正在保存",
  "generic.list.clearSelection": "清除选择",
  "generic.list.selected": "已选择 {count} 行：",
  "about.thirdPartyLicenses": "第三方许可证",
  "about.thirdPartyLicensesLink": "查看所有第三方许可证",
  "about.thirdPartyLicenses.downloadError": "下载第三方许可证文件失败",
  "aiAssistant.builder.plan.intro": "您要继续执行此计划吗？",
  "aiAssistant.builder.plan.approve": "批准计划",
  "aiAssistant.builder.plan.reject": "请求修改",
  "aiAssistant.builder.plan.whatToChange": "您想修改什么？",
  "workflows.empty.preBuiltAgents": "尝试使用预建代理",
  "workflows.preBuiltAgents.callout": "使用我们的",
  "workflows.preBuiltAgents.linkText": "预建代理",
  "dataStore.moveColumn.error": "移动列时出错",
  "dataStore.deleteColumn.error": "删除列时出错",
  "dataStore.deleteColumn.confirm.title": "删除列",
  "dataStore.deleteColumn.confirm.message": "确定要删除 \\"{name}\\" 列吗？此操作无法撤销。",
  "dataStore.fetchContent.error": "获取数据存储内容时出错",
  "dataStore.addRow.label": "添加行",
  "dataStore.addRow.error": "添加行时出错",
  "dataStore.updateRow.error": "更新行时出错",
  "dataStore.deleteRows.title": "删除行",
  "dataStore.deleteRows.confirmation": "确定要删除 {count} 行吗？",
  "dataStore.deleteRows.success": "行已成功删除",
  "dataStore.deleteRows.error": "删除行时出错",
  "settings.sso.settings.save.error_oidc": "保存 OIDC SSO 配置时出错",
  "projects.header.overview.subtitleWithDataTables": "您有权访问的所有工作流、凭据和数据表",
  "projects.header.personal.subtitleWithDataTables": "您拥有的工作流、凭据和数据表",
  "workflowDiff.compare": "比较版本",
  "preBuiltAgentTemplates.title": "预建代理",
  "preBuiltAgentTemplates.tutorials": "教程模板",
  "preBuiltAgentTemplates.viewAllLink": "查看所有模板",
    "generic.clear": "清除",
  "generic.betaProper": "测试版",
  "generic.error.subworkflowCreationFailed": "创建子工作流失败",
  "generic.startNow": "立即开始",
  "generic.saving": "保存中",
  "generic.name": "名称",
  "generic.update": "更新",
  "generic.credentials": "凭据",
  "generic.unknownError": "发生未知错误",
  "generic.never": "从不",
  "generic.list.clearSelection": "清除选择",
  "generic.list.selected": "{count} 行已选",
  "generic.project": "项目",
  "generic.your": "您的",
  "generic.apiKey": "API 密钥",
  "about.thirdPartyLicenses": "第三方许可证",
  "about.thirdPartyLicensesLink": "查看所有第三方许可证",
  "about.thirdPartyLicenses.downloadError": "下载第三方许可证文件失败",
  "auth.confirmPassword": "确认密码",
  "auth.confirmPassword.currentPassword": "当前密码",
  "auth.confirmPassword.confirmPasswordToChangeEmail": "请确认您的密码以更改邮箱地址。",
  "aiAssistant.tabs.ask": "提问",
  "aiAssistant.tabs.build": "构建",
  "aiAssistant.builder.assistantPlaceholder": "您想要修改或添加什么？",
  "aiAssistant.builder.characterLimit": "已达到 {limit} 字符限制",
  "aiAssistant.builder.workflowParsingError.title": "无法插入工作流",
  "aiAssistant.builder.workflowParsingError.content": "AI 返回的工作流无法解析。请重试。",
  "aiAssistant.builder.canvasPrompt.title": "您想自动化什么？",
  "aiAssistant.builder.canvasPrompt.confirmTitle": "替换当前提示？",
  "aiAssistant.builder.canvasPrompt.confirmMessage": "这将替换您当前的提示。确定吗？",
  "aiAssistant.builder.canvasPrompt.confirmButton": "替换",
  "aiAssistant.builder.canvasPrompt.cancelButton": "取消",
  "aiAssistant.builder.canvasPrompt.startManually.title": "手动开始",
  "aiAssistant.builder.canvasPrompt.startManually.subTitle": "添加第一个节点",
  "aiAssistant.builder.streamAbortedMessage": "[任务已中止]",
  "aiAssistant.builder.executeMessage.description": "在执行工作流前完成以下步骤：",
  "aiAssistant.builder.executeMessage.noIssues": "您的工作流已准备就绪，可以执行",
  "aiAssistant.builder.executeMessage.validationTooltip": "请先完成上述步骤再执行",
  "aiAssistant.builder.executeMessage.execute": "执行并优化",
  "aiAssistant.builder.executeMessage.noExecutionData": "无法启动工作流执行。请重试。",
  "aiAssistant.builder.executeMessage.executionSuccess": "工作流执行成功。",
  "aiAssistant.builder.executeMessage.executionFailedOnNode": "工作流在节点 \\"{nodeName}\\" 执行失败：{errorMessage}",
  "aiAssistant.builder.executeMessage.executionFailed": "工作流执行失败：{errorMessage}",
  "aiAssistant.builder.toast.title": "发送聊天消息以启动执行",
  "aiAssistant.builder.toast.description": "请在聊天面板中发送消息以启动工作流执行",
  "aiAssistant.tooltip": "向助手提问",
  "codeNodeEditor.askAi.generationFailedWithReason": "代码生成失败，错误为：{error}。请几分钟后重试。",
  "communityNodeFooter.legacy": "旧版",
  "communityNodeFooter.manage": "管理",
  "communityNodeFooter.reportIssue": "报告问题",
  "dataMapping.tableView.columnCollapsing": "收起行",
  "dataMapping.tableView.columnCollapsing.tooltip": "收起行（以便比较此列中的值）",
  "experiments.personalizedTemplatesV3.browseAllTemplates": "浏览我们的模板库",
  "experiments.personalizedTemplatesV3.couldntFind": "需要其他内容？",
  "experiments.personalizedTemplatesV3.exploreTemplates": "使用 HubSpot 工作流开始：",
  "experiments.personalizedTemplatesV3.loadingTemplates": "正在加载推荐...",
  "experiments.personalizedTemplatesV3.recommendationTooltip": "使用这些工作流加快您的自动化进程",
  "experiments.personalizedTemplatesV3.recommendedForYou": "为您推荐",
  "mainSidebar.whatsNew": "新功能",
  "mainSidebar.whatsNew.fullChangelog": "完整更新日志",
  "ndv.close.tooltip": "数据已保存，可安全关闭",
  "ndv.input.noOutputData.v2.title": "无输入数据",
  "ndv.input.noOutputData.v2.description": "{link} 查看输入数据",
    "ndv.input.noOutputData.v2.action": "执行前置节点",
  "ndv.input.noOutputData.v2.tooltip": "从最早未执行或已修改的已执行节点开始执行",
  "ndv.input.noOutputData.embeddedNdv.link": "执行前置节点",
  "ndv.input.noOutputData.embeddedNdv.description": "{link} 以在此处使用其数据",
  "ndv.input.notConnected.v2.title": "未连接输入",
  "ndv.input.notConnected.v2.description": "只有连接到其他节点时，此节点才能接收输入数据。{link}",
  "ndv.output.itemsTotal": "共 {count} 项",
  "ndv.output.noOutputData.v2.title": "无输出数据",
  "ndv.output.noOutputData.v2.description": "{link} 查看输出数据",
  "ndv.output.noOutputData.v2.action": "测试此步骤",
  "ndv.output.noOutputData.trigger.title": "无触发器输出",
  "ndv.output.noOutputData.trigger.action": "测试此触发器",
  "ndv.title.rename.placeholder": "输入新名称...",
  "node.settings.continuesOnError": "即使节点失败，执行也会继续",
  "node.settings.continuesOnError.title": "失败时继续",
  "node.settings.retriesOnFailure": "此节点在失败时将自动重试",
  "node.settings.executeOnce": "此节点仅执行一次，无论输入项目有多少",
  "node.settings.alwaysOutputData": "如果通常不返回任何内容，此节点将输出一个空项目",
  "nodeCreator.nodeItem.beta": "测试版",
  "nodeCreator.preBuiltAgents.title": "预建代理",
  "nodeCreator.preBuiltAgents.description": "使用现成的代理更快地开始",
  "nodeSettings.parametersShort": "参数",
  "nodeSettings.action": "操作",
  "nodeSettings.credential": "认证",
  "nodeView.openFocusPanel": "打开聚焦面板",
  "nodeView.templateLink": "或从模板开始",
  "nodeView.focusPanel.noExecutionData": "执行前置节点以启用自动补全",
  "nodeView.focusPanel.noParameters.title": "在此处显示一个节点参数以便轻松迭代",
  "nodeView.focusPanel.noParameters.subtitle": "例如，始终显示您的提示，以便在调整时运行工作流",
  "nodeView.focusPanel.v2.noParameters.title": "选择一个节点在此处编辑",
  "nodeView.focusPanel.v2.noParameters.subtitle": "或者点击其旁边的按钮，显示您想迭代的单个节点参数：",
  "nodeView.focusPanel.missingParameter": "此参数在节点上不再可见。可能是相关参数被更改，导致此参数被移除。",
  "nodeView.showError.openExecution.node": "打开执行中的节点时出现问题",
  "nodeView.expandAllNodes": "展开所有节点",
  "nodeView.collapseAllNodes": "收起所有节点",
  "nodeView.enterZoomMode": "进入缩放模式",
  "nodeView.leaveZoomMode": "退出缩放模式",
  "parameterInput.focusParameter": "聚焦参数",
  "prompts.npsSurvey.feedbackQuestionTitle": "谢谢！您为什么选择这个评分？",
  "resourceLocator.dataTable.createNew": "创建新数据表",
  "runData.executionStatus.canceled": "执行已取消",
  "settings.communityNodes.confirmModal.uninstall.description": "卸载此包将删除该包中所有节点的实例。以下工作流将受到影响：",
  "settings.communityNodes.confirmModal.noWorkflowsUsingNodes": "此包的节点未在任何工作流中使用",
  "settings.communityNodes.confirmModal.includedNodes": "包包含：{nodes}",
  "settings.communityNodes.confirmModal.update.warning": "此版本未经 n8n 验证，可能包含破坏性更改或错误。",
  "settings.communityNodes.confirmModal.cancel": "取消",
  "settings.mcp": "MCP 访问权限",
  "settings.mcp.toggle.label": "启用 MCP",
  "settings.mcp.toggle.description": "允许访问此 n8n 实例的 MCP",
  "settings.mcp.available.workflows.heading": "可用工作流",
  "settings.mcp.connection.info.heading": "如何连接",
  "settings.mcp.workflows.table.action.removeMCPAccess": "移除 MCP 访问权限",
  "settings.mcp.empty.title": "无可用的 MCP 工作流",
  "settings.mcp.empty.description": "在每个工作流的设置中启用 MCP 访问权限，即可在此处看到它们。",
  "settings.mcp.toggle.disabled.tooltip": "仅实例所有者可更改此设置",
  "settings.mcp.instructions.enableAccess": "在至少一个工作流的设置中启用工作流访问权限",
  "settings.mcp.instructions.serverUrl": "服务器 URL",
  "settings.mcp.instructions.apiKey.part1": "创建一个",
  "settings.mcp.instructions.apiKey.part2": "无需作用域，MCP 使用您的角色进行授权",
  "settings.mcp.instructions.json": "或在您的 'mcp.json' 文件中使用以下代码",
  "settings.mcp.instructions.docs.part1": "有关更详细的说明和示例，请查看",
  "settings.mcp.instructions.docs.part2": "我们的文档",
  "settings.users.count": "{count} 个用户",
  "settings.users.search.placeholder": "按名称或邮箱搜索",
  "settings.users.passwordResetLinkError": "无法获取密码重置链接",
  "settings.users.userNotFound": "用户未找到",
  "settings.users.table.update.error": "更新表格失败",
  "settings.users.table.header.user": "用户",
  "settings.users.table.header.accountType": "账户类型",
  "settings.users.table.header.2fa": "双重验证 (2FA)",
  "settings.users.table.header.lastActive": "最后活跃时间",
  "settings.users.table.row.allProjects": "所有项目",
  "settings.users.table.row.personalProject": "个人项目",
  "settings.users.table.row.deleteUser": "移除用户",
  "settings.users.table.row.role.description.admin": "完全访问所有工作流、凭据、项目、用户等",
  "settings.users.table.row.role.description.member": "管理和创建自己的工作流及凭据",
  "settings.users.table.row.2fa.enabled": "已启用",
  "settings.users.table.row.2fa.disabled": "已禁用",
  "settings.sourceControl.connectionType": "连接类型",
  "settings.sourceControl.enterValidHttpsUrl": "请输入有效的 HTTPS URL",
  "settings.sourceControl.modals.push.filter": "已应用过滤器。显示 {count} 个 {entity}。",
  "settings.sourceControl.modals.push.projectAdmin.callout": "如需推送个人空间中的工作流，请先将其移至项目。",
  "settings.sourceControl.saved.error": "设置分支时出错",
  "settings.sourceControl.sshRepoUrl": "SSH 仓库 URL",
  "settings.sourceControl.httpsRepoUrl": "HTTPS 仓库 URL",
  "settings.sourceControl.sshRepoUrlPlaceholder": "git{'@'}github.com:用户/仓库.git",
  "settings.sourceControl.httpsRepoUrlPlaceholder": "https://github.com/用户/仓库.git",
  "settings.sourceControl.sshFormatNotice": "使用 SSH 格式：git{'@'}github.com:用户/仓库.git",
  "settings.sourceControl.httpsFormatNotice": "使用 HTTPS 格式：https://github.com/用户/仓库.git",
  "settings.sourceControl.httpsUsername": "用户名",
  "settings.sourceControl.httpsUsernamePlaceholder": "输入您的 GitHub 用户名",
  "settings.sourceControl.httpsPersonalAccessToken": "个人访问令牌",
  "settings.sourceControl.httpsPersonalAccessTokenPlaceholder": "输入您的个人访问令牌 (PAT)",
  "settings.sourceControl.httpsWarningNotice": "{strong} 如需在 GitHub 上创建：前往 设置 → 开发者设置 → 个人访问令牌 → 令牌（经典版）。所需作用域：{repo}（私有仓库）或 {publicRepo}（公有仓库）。也支持其他平台。",
  "settings.sourceControl.httpsWarningNotice.strong": "需要个人访问令牌：",
  "userActivity.daysAgo": "{count} 天前",
  "userActivity.lastTime": "上次 {time}",
  "userActivity.today": "今天",
  "userActivity.yesterday": "昨天",
    "ndv.search.placeholder.shortcutHint": "搜索 ({shortcut})",
  "ndv.nodeHints.disabled": "此节点已禁用，将直接传递输入数据",
  "ndv.nodeHints.alwaysOutputData": "如果通常不返回任何内容，此节点将输出一个空项目",
  "ndv.nodeHints.alwaysOutputData.short": "在无正常返回时输出空项目",
  "ndv.nodeHints.executeOnce": "此节点仅执行一次，无论输入项目有多少",
  "ndv.nodeHints.executeOnce.short": "无论输入多少项目，仅执行一次",
  "ndv.nodeHints.retryOnFail": "此节点在失败时将自动重试",
  "ndv.nodeHints.retryOnFail.short": "失败时自动重试",
  "ndv.nodeHints.continueOnError": "即使节点失败，执行也会继续",
  "ndv.nodeHints.continueOnError.short": "即使节点失败也继续执行",
  "workflowProductionChecklist.title": "生产环境检查清单",
  "workflowProductionChecklist.readOnlyNotice": "只读环境。请在开发环境中更新这些项目并推送更改。",
  "workflowProductionChecklist.ignoreAllConfirmation.title": "全局忽略建议操作",
  "workflowProductionChecklist.ignoreAllConfirmation.description": "关闭此选项后，这些建议将从所有工作流中消失",
  "workflowProductionChecklist.ignoreAllConfirmation.confirm": "对所有工作流忽略",
  "workflowProductionChecklist.turnOffWorkflowSuggestions": "对所有工作流忽略",
  "workflowProductionChecklist.evaluations.title": "测试 AI 步骤的可靠性",
  "workflowProductionChecklist.evaluations.description": "使用评估功能检查在各种输入下的性能表现。",
  "workflowProductionChecklist.errorWorkflow.title": "设置错误通知",
  "workflowProductionChecklist.errorWorkflow.description": "通过设置错误工作流，自定义您接收通知的方式。",
  "workflowProductionChecklist.timeSaved.title": "跟踪节省的时间",
  "workflowProductionChecklist.timeSaved.description": "配置每次运行节省的时间，以追踪其替代的手动工作量。",
  "workflowSettings.name": "工作流名称",
  "workflowSettings.executionTimeout": "工作流超时",
  "workflowSettings.tags": "标签",
  "workflowSettings.availableInMCP": "在 MCP 中可用",
  "workflowSettings.availableInMCP.tooltip": "通过 n8n MCP 使此工作流对 AI 代理可见",
  "workflowSettings.toggleMCP.error.title": "更新 MCP 设置时出错",
  "workflowSettings.toggleMCP.notFoundError": "未找到工作流",
  "workflows.item.availableInMCP": "在 MCP 中可用",
  "workflows.item.enableMCPAccess": "启用 MCP 访问权限",
  "workflows.item.disableMCPAccess": "移除 MCP 访问权限",
  "workflows.itemSuggestion.try": "尝试模板",
  "workflows.templateRecoV2.starterTemplates": "入门模板",
  "workflows.templateRecoV2.seeMoreStarterTemplates": "查看更多入门模板",
  "workflows.templateRecoV2.popularTemplates": "热门模板",
  "workflows.templateRecoV2.seeMorePopularTemplates": "查看更多热门模板",
  "workflows.templateRecoV2.tutorials": "教程",
  "workflows.templateRecoV2.loadingTemplates": "正在加载模板...",
  "workflows.templateRecoV2.useTemplate": "使用模板",
  "workflows.templateRecoV2.exploreTemplates": "或浏览模板以获取灵感并快速学习：",
  "workflows.empty.startWithTemplate": "从模板开始",
  "workflows.empty.preBuiltAgents": "尝试预建代理",
  "workflows.empty.readyToRunV2": "尝试一个 AI 工作流",
  "workflows.ai.starter.collection.callout": "学习如何在 n8n 中构建 AI 代理",
  "workflows.ai.starter.collection.card": "学习如何构建 AI 代理",
  "workflows.ai.starter.collection.folder.name": "🎁 n8n 基础：学习如何在 n8n 中构建代理",
  "workflows.ai.starter.collection.error": "加载 AI 代理入门集合时出错。请稍后重试。",
  "workflows.readyToRunWorkflows.card": "尝试一个工作流 - 无需设置",
  "workflows.readyToRunWorkflows.card2": "运行一个工作流",
  "workflows.readyToRunWorkflows.card3": "查看 n8n 的实际效果",
  "workflows.readyToRunWorkflows.callout": "查看 n8n 的实际效果 - 无需设置",
  "workflows.readyToRunWorkflows.callout2": "运行一个工作流",
  "workflows.readyToRunWorkflows.callout3": "查看 n8n 的实际效果",
  "workflows.readyToRunWorkflows.cta": "运行一个工作流",
  "workflows.readyToRunWorkflows.folder.name": "🚀 即开即用的工作流",
  "workflows.readyToRunWorkflows.error": "加载 n8n 集合时出错。请稍后重试。",
  "workflows.archivedOnly.hint": "已归档的工作流在此视图中被隐藏。{link}",
  "workflows.archivedOnly.hint.link": "更新筛选条件",
  "workflows.preBuiltAgents.callout": "使用我们的",
  "workflows.preBuiltAgents.linkText": "预建代理",
  "dataStore.dataStores": "数据表",
  "dataStore.empty.label": "您还没有任何数据表",
  "dataStore.empty.description": "使用数据表来持久化执行结果、在工作流之间共享数据，并为评估跟踪指标。",
  "dataStore.card.size": "{size}MB",
  "dataStore.card.column.count": "{count} 列",
  "dataStore.card.row.count": "{count} 条记录",
  "dataStore.sort.lastUpdated": "按最后更新时间排序",
  "dataStore.sort.lastCreated": "按创建时间排序",
  "dataStore.sort.nameAsc": "按名称排序 (A-Z)",
  "dataStore.sort.nameDesc": "按名称排序 (Z-A)",
  "dataStore.search.placeholder": "搜索",
  "dataStore.error.fetching": "加载数据表时出错",
  "dataStore.add.title": "创建新数据表",
  "dataStore.add.button.label": "创建数据表",
  "dataStore.add.input.name.label": "数据表名称",
  "dataStore.add.input.name.placeholder": "输入数据表名称",
  "dataStore.add.error": "创建数据表时出错",
  "dataStore.delete.confirm.title": "删除数据表",
  "dataStore.delete.confirm.message": "您确定要删除数据表 '{name}' 吗？此操作无法撤销。",
  "dataStore.delete.error": "删除数据表时出错",
  "dataStore.rename.error": "重命名数据表时出错",
  "dataStore.getDetails.error": "获取数据表详情时出错",
  "dataStore.notFound": "未找到数据表",
  "dataStore.noColumns.heading": "尚无列",
  "dataStore.noColumns.description": "添加列以开始在此数据表中存储数据。",
  "dataStore.noColumns.button.label": "添加首列",
  "dataStore.addColumn.label": "添加列",
  "dataStore.addColumn.nameInput.label": "名称",
  "dataStore.addColumn.nameInput.placeholder": "输入列名称",
  "dataStore.addColumn.typeInput.label": "类型",
  "dataStore.addColumn.error": "添加列时出错",
  "dataStore.addColumn.alreadyExistsError": "该列已存在",
  "dataStore.addColumn.alreadyExistsDescription": "列名已存在，请选择其他名称",
  "dataStore.moveColumn.error": "移动列时出错",
  "dataStore.deleteColumn.error": "删除列时出错",
  "dataStore.deleteColumn.confirm.title": "删除列",
  "dataStore.deleteColumn.confirm.message": "您确定要删除列 '{name}' 吗？此操作无法撤销。",
  "dataStore.addColumn.invalidName.error": "无效的列名",
  "dataStore.addColumn.invalidName.description": "列名必须以字母开头，且只能包含字母、数字或下划线",
  "dataStore.fetchContent.error": "获取数据存储内容时出错",
  "dataStore.addRow.label": "添加行",
  "dataStore.addRow.error": "添加行时出错",
  "dataStore.updateRow.error": "更新行时出错",
  "dataStore.deleteRows.title": "删除行",
  "dataStore.deleteRows.confirmation": "您确定要删除 {count} 行吗？",
  "dataStore.deleteRows.error": "删除行时出错",
  "dataStore.banner.storageLimitWarning.message": "数据表存储已使用 {usage}。请删除数据以避免错误",
  "dataStore.banner.storageLimitError.message": "数据表存储已使用 {usage}，操作可能会失败。请删除数据以避免错误",
  "dataStore.error.tableNotInitialized": "表未初始化",
  "dataStore.noRows": "无行数据",
  "dataStore.filters.isNull": "为空",
  "dataStore.filters.isNotNull": "不为空",
  "dataStore.filters.isEmpty": "为空值",
  "dataStore.filters.isNotEmpty": "不为空值",
  "dataStore.filters.between": "介于",
  "dataStore.filters.true": "为真",
  "dataStore.filters.false": "为假",
  "dataStore.filters.greaterThan": "大于",
  "dataStore.filters.greaterThanOrEqual": "大于或等于",
  "dataStore.filters.lessThan": "小于",
  "dataStore.filters.lessThanOrEqual": "小于或等于",
  "settings.sso.settings.oidc.prompt.none": "无（静默认证）",
  "settings.sso.settings.oidc.prompt.login": "登录（强制用户登录）",
  "settings.sso.settings.oidc.prompt.consent": "同意（询问用户是否同意）",
  "settings.sso.settings.oidc.prompt.select_account": "选择账户（允许用户选择账户）",
  "settings.sso.settings.oidc.prompt.create": "创建（要求 OP 首先显示注册页面）",
  "settings.sso.settings.save.error_oidc": "保存 OIDC SSO 配置时出错",
  "projects.header.overview.subtitleWithDataTables": "所有您有权访问的工作流、凭据和数据表",
  "projects.header.personal.subtitleWithDataTables": "您拥有的工作流、凭据和数据表",
  "projects.settings.info": "项目信息",
  "projects.settings.table.header.user": "用户",
  "projects.settings.table.header.role": "角色",
  "projects.settings.table.row.removeUser": "移除用户",
  "projects.settings.role.admin.description": "可编辑工作流、凭据和项目设置",
  "projects.settings.role.editor.description": "可编辑工作流和凭据",
  "projects.settings.role.viewer.description": "可查看工作流和执行记录",
  "projects.settings.role.personalOwner": "所有者",
  "projects.settings.members.search.placeholder": "搜索成员...",
  "projects.settings.memberRole.updated.title": "成员角色已成功更新",
  "projects.settings.memberRole.update.error.title": "更新成员角色时发生错误",
  "projects.settings.member.removed.title": "成员已成功移除",
  "projects.settings.member.remove.error.title": "移除成员时发生错误",
  "projects.settings.member.added.title": "成员已成功添加",
  "settings.personal.mfa.enforced": "此实例的设置<strong>要求您设置双重验证 (2FA)</strong>。请启用它以继续在此实例中工作。",
  "settings.personal.mfa.enforce.message": "对通过邮箱和密码登录此实例的所有用户强制启用双重验证 (2FA)。",
  "settings.personal.mfa.enforce.unlicensed_tooltip": "升级您的计划后，您可以对此实例上通过邮箱和密码登录的所有用户强制启用双重验证 (2FA)。{action}",
  "settings.personal.mfa.enforce.unlicensed_tooltip.link": "查看计划",
  "settings.personal.mfa.enforce.title": "强制启用双重验证",
  "settings.personal.mfa.enforce.error": "无法为所有用户强制启用双重验证 (2FA)",
  "settings.personal.mfa.enforce.enabled.title": "已强制启用 2FA",
  "settings.personal.mfa.enforce.enabled.message": "现在，对此实例上通过邮箱和密码登录的所有用户，强制要求启用双重验证 (2FA)。",
  "settings.personal.mfa.enforce.disabled.title": "2FA 不再强制启用",
  "settings.personal.mfa.enforce.disabled.message": "不再强制要求此实例上通过邮箱和密码登录的用户启用双重验证 (2FA)。",
  "type.binary": "二进制数据",
  "assignment.binaryData.placeholder": "二进制输入的名称（或引用它的表达式）",
  "evaluation.listRuns.allTestCases": "所有测试用例 ({count})",
  "evaluation.listRuns.error.cantStopTestRun": "无法停止测试运行",
  "evaluation.runDetail.notice.useSetInputs": "提示：通过在工作流中添加评估节点的“设置输入”操作，将数据集中的输入列显示在此处",
  "evaluation.stopTest": "停止测试",
  "evaluations.readOnlyNotice": "无法在只读模式下构建评估。请在您的开发环境中构建评估。",
  "insights.dashboard.table.title": "按工作流细分",
  "insights.dashboard.search.placeholder": "所有项目",
  "communityNodeUpdateInfo.available": "有新的节点包版本可用",
  "whatsNew.versionsBehind": "{count} 个版本落后",
  "whatsNew.update": "更新",
  "whatsNew.updateNudgeTooltip": "只有所有者可以执行更新",
  "whatsNew.updateAvailable": "您当前使用的是版本 {currentVersion}。更新至 {latestVersion} 以获取 {count} 个版本的新功能、改进和修复。查看变更内容",
  "whatsNew.updateAvailable.changelogLink": "完整更新日志",
  "workflowDiff.changes": "变更",
  "workflowDiff.nodes": "节点",
  "workflowDiff.connectors": "连接器",
  "workflowDiff.compare": "比较版本",
  "workflowDiff.settings": "设置",
  "workflowDiff.local": "本地",
  "workflowDiff.remote": "远程 ({branchName})",
  "workflowDiff.noChanges": "无变更",
  "workflowDiff.deletedWorkflow": "缺失的工作流",
  "workflowDiff.deletedWorkflow.database": "该工作流在数据库中不存在",
  "workflowDiff.deletedWorkflow.remote": "该工作流在远程不存在",
  "workflowDiff.newWorkflow": "新工作流",
  "workflowDiff.newWorkflow.database": "该工作流将在数据库中创建",
  "workflowDiff.newWorkflow.remote": "该工作流将在远程创建",
  "preBuiltAgentTemplates.title": "预建代理",
  "preBuiltAgentTemplates.tutorials": "教程模板",
  "preBuiltAgentTemplates.viewAllLink": "查看所有模板",

  "generic.copied": "已复制",
  "aiAssistant.builder.canvasPrompt.buildWithAI": "用 AI 构建",
  "aiAssistant.builder.executeMessage.fillParameter": "更新“{label}”参数",
  "codeNodeEditor.completer.$vars.varName.global": "为此 n8n 实例定义的全局变量。所有变量均解析为字符串。",
  "codeNodeEditor.completer.$vars.varName.global.overridden": "此全局变量已被项目 {projectName} 的变量覆盖。所有变量均解析为字符串。",
  "codeNodeEditor.completer.$vars.varName.project": "在 {projectName} 项目中定义的项目变量。所有变量均解析为字符串。",
  "codeNodeEditor.completer.section.variable.project": "项目变量",
  "codeNodeEditor.completer.section.variable.global": "全局变量",
  "mcp.workflowNotEligable.description": "只有处于激活状态且由 Webhook 触发的工作流才能通过 MCP 访问",
  "contextMenu.replace": "替换",
  "settings.mcp.toggle.error": "更新 MCP 访问权限时出错",
  "settings.mcp.instructions.apiKey.label": "访问令牌",
  "settings.mcp.instructions.rotateKey.tooltip": "生成新令牌。<br/>当前令牌将被自动撤销。",
  "settings.mcp.instructions.apiKey.tip": "将此用作授权令牌。在不同客户端中可能名称不同",
  "settings.mcp.newKey.notice": "请务必立即复制您的访问令牌。您将无法再次查看或复制它！",
  "settings.mcp.error.fetching.apiKey": "获取访问令牌时出错",
  "settings.mcp.error.rotating.apiKey": "生成新访问令牌时出错",
  "variables.table.scope": "作用域",
  "variables.table.scope.global": "全局",
  "variables.editing.key.error.regex": "此字段只能包含字母、数字和下划线",
  "variables.delete.successful.message": "变量 {variableName} 已删除",
  "variables.modal.title.create": "新建变量",
  "variables.modal.title.edit": "编辑变量",
  "variables.modal.key.label": "键",
  "variables.modal.value.label": "值",
  "variables.modal.scope.label": "作用域",
  "variables.modal.scope.global": "全局",
  "variables.modal.scope.all": "全部",
  "variables.modal.button.cancel": "取消",
  "variables.modal.button.save": "保存",
  "variables.modal.error.keyExistsInProject": "此键已存在于该项目中",
  "variables.modal.warning.globalKeyExists": "相同的键已存在于全局作用域中。此变量将在项目内覆盖全局变量",
  "dataTable.dataTables": "数据表",
  "dataTable.empty.label": "您还没有任何数据表",
  "dataTable.empty.description": "使用数据表来持久化执行结果、在工作流之间共享数据，并跟踪指标用于评估。",
  "dataTable.card.size": "{size}MB",
  "dataTable.card.column.count": "{count} 列",
  "dataTable.add.title": "创建新数据表",
  "dataTable.add.button.label": "创建数据表",
  "dataTable.add.input.name.label": "数据表名称",
  "dataTable.add.input.name.placeholder": "输入数据表名称",
  "dataTable.add.error": "创建数据表时出错",
  "dataTable.delete.confirm.title": "删除数据表",
  "dataTable.delete.confirm.message": "确定要删除数据表 '{name}' 吗？此操作无法撤销。",
  "dataTable.delete.error": "删除数据表时出错",
  "dataTable.rename.error": "重命名数据表时出错",
  "dataTable.getDetails.error": "获取数据表详情时出错",
  "dataTable.notFound": "未找到数据表",
  "dataTable.noColumns.heading": "尚无列",
  "dataTable.noColumns.description": "添加列以开始在此数据表中存储数据。",
  "dataTable.noColumns.button.label": "添加首列",
  "dataTable.addColumn.label": "添加列",
  "dataTable.addColumn.nameInput.label": "@:_reusableBaseText.name",
  "dataTable.addColumn.nameInput.placeholder": "输入列名称",
  "dataTable.addColumn.typeInput.label": "@:_reusableBaseText.type",
  "dataTable.addColumn.error": "添加列时出错",
  "dataTable.addColumn.alreadyExistsError": "此列已存在",
  "dataTable.addColumn.alreadyExistsDescription": "列名已存在，请选择其他名称",
  "dataTable.moveColumn.error": "移动列时出错",
  "dataTable.deleteColumn.error": "删除列时出错",
  "dataTable.deleteColumn.confirm.title": "删除列",
  "dataTable.deleteColumn.confirm.message": "确定要删除列 '{name}' 吗？此操作无法撤销。",
  "dataTable.addColumn.invalidName.error": "无效的列名",
  "dataTable.addColumn.invalidName.description": "列名必须以字母开头，且只能包含字母、数字或下划线",
  "dataTable.fetchContent.error": "获取数据表内容时出错",
  "dataTable.addRow.label": "添加行",
  "dataTable.addRow.error": "添加行时出错",
  "dataTable.updateRow.error": "更新行时出错",
  "dataTable.deleteRows.title": "删除行",
  "dataTable.deleteRows.confirmation": "确定要删除 {count} 行吗？",
  "dataTable.deleteRows.error": "删除行时出错",
  "dataTable.banner.storageLimitWarning.message": "已使用 {usage} 的数据表存储空间。请删除数据以避免错误",
  "dataTable.banner.storageLimitError.message": "已使用 {usage} 的数据表存储空间，操作可能会失败。请删除数据以避免错误",
  "dataTable.error.tableNotInitialized": "表未初始化",
  "dataTable.noRows": "无行",
  "dataTable.filters.isNull": "为空",
  "dataTable.filters.isNotNull": "不为空",
  "dataTable.filters.isEmpty": "为空值",
  "dataTable.filters.isNotEmpty": "不为空值",
  "dataTable.filters.between": "介于之间",
  "dataTable.filters.true": "真",
  "dataTable.filters.false": "假",
  "dataTable.filters.greaterThan": "大于",
  "dataTable.filters.greaterThanOrEqual": "大于或等于",
  "dataTable.filters.lessThan": "小于",
  "dataTable.filters.lessThanOrEqual": "小于或等于",
  "dataTable.addColumn.systemColumnDescription": "这是系统列，请选择其他名称",
  "dataTable.addColumn.testingColumnDescription": "此列用于测试，请选择其他名称",
  "projects.settings.role.upgrade.tooltip": "升级到专业版或企业版以分配编辑者和查看者角色",
  "commandBar.placeholder": "输入命令...",
  "commandBar.noResults": "未找到结果",
  "commandBar.sections.nodes": "节点",
  "commandBar.sections.workflow": "工作流",
  "commandBar.sections.workflows": "工作流",
  "commandBar.sections.credentials": "凭据",
  "commandBar.sections.dataTables": "数据表",
  "commandBar.sections.templates": "模板",
  "commandBar.sections.demo": "演示",
  "commandBar.nodes.addNode": "添加节点",
  "commandBar.nodes.addStickyNote": "添加便签",
  "commandBar.nodes.openNode": "打开节点",
  "commandBar.nodes.openNodeWithPrefix": "打开节点 > {nodeName}",
  "commandBar.nodes.addNodeWithPrefix": "添加节点 > {nodeName}",
  "commandBar.nodes.searchPlaceholder": "按节点名称、类型等搜索",
  "commandBar.nodes.keywords.insert": "插入",
  "commandBar.nodes.keywords.add": "添加",
  "commandBar.nodes.keywords.create": "创建",
  "commandBar.nodes.keywords.node": "节点",
  "commandBar.workflow.test": "测试工作流",
  "commandBar.workflow.save": "保存工作流",
  "commandBar.workflow.activate": "激活工作流",
  "commandBar.workflow.deactivate": "停用工作流",
  "commandBar.workflow.selectAll": "全选",
  "commandBar.workflow.tidyUp": "整理工作流",
  "commandBar.workflow.duplicate": "复制工作流",
  "commandBar.workflow.download": "下载工作流",
  "commandBar.workflow.openCredential": "打开凭据",
  "commandBar.workflow.openSubworkflow": "打开子工作流",
  "commandBar.workflow.keywords.test": "测试",
  "commandBar.workflow.keywords.execute": "执行",
  "commandBar.workflow.keywords.run": "运行",
  "commandBar.workflow.keywords.workflow": "工作流",
  "commandBar.workflows.create": "在 {projectName} 中创建工作流",
  "commandBar.workflows.open": "打开工作流",
  "commandBar.workflows.searchPlaceholder": "按工作流名称或节点类型搜索...",
  "commandBar.workflows.prefixPersonal": "[个人] > ",
  "commandBar.workflows.prefixProject": "[{projectName}] > ",
  "commandBar.workflows.openPrefixPersonal": "打开工作流 > [个人] > ",
  "commandBar.workflows.openPrefixProject": "打开工作流 > [{projectName}] > ",
  "commandBar.workflows.unnamed": "(未命名工作流)",
  "commandBar.credentials.create": "在 {projectName} 中创建凭据",
  "commandBar.credentials.open": "打开凭据",
  "commandBar.credentials.searchPlaceholder": "按凭据名称搜索...",
  "commandBar.credentials.prefixPersonal": "[个人] > ",
  "commandBar.credentials.prefixProject": "[{projectName}] > ",
  "commandBar.credentials.openPrefixPersonal": "打开凭据 > [个人] > ",
  "commandBar.credentials.openPrefixProject": "打开凭据 > [{projectName}] > ",
  "commandBar.credentials.unnamed": "(未命名凭据)",
  "commandBar.dataTables.create": "在 {projectName} 中创建数据表",
  "commandBar.dataTables.open": "打开数据表",
  "commandBar.dataTables.searchPlaceholder": "按数据表名称搜索...",
  "commandBar.dataTables.prefixPersonal": "[个人] > ",
  "commandBar.dataTables.prefixProject": "[{projectName}] > ",
  "commandBar.dataTables.openPrefixPersonal": "打开数据表 > [个人] > ",
  "commandBar.dataTables.openPrefixProject": "打开数据表 > [{projectName}] > ",
  "commandBar.dataTables.unnamed": "(未命名数据表)",
  "commandBar.templates.import": "导入模板",
  "commandBar.templates.importWithPrefix": "导入模板 > {templateName}",
  "commandBar.demo.availableEverywhere": "此功能处处可用",
   "generic.allow": "允许",
    "generic.deny": "拒绝",
    "generic.openResource": "打开 {resource}",
    "generic.add": "添加",
    "generic.keepBuilding": "继续构建",
    "generic.templates": "模板",
    "generic.description": "描述",
    "generic.projects": "项目",
    "chatHub.agent.customAgents": "自定义智能体",
    "chatHub.agent.newAgent": "新建智能体",
    "chatHub.agent.editor.title.new": "新建智能体",
    "chatHub.agent.editor.title.edit": "编辑智能体",
    "chatHub.agent.editor.name.label": "名称",
    "chatHub.agent.editor.name.placeholder": "请输入智能体名称",
    "chatHub.agent.editor.description.label": "描述",
    "chatHub.agent.editor.description.placeholder": "请输入智能体描述（可选）",
    "chatHub.agent.editor.systemPrompt.label": "系统提示",
    "chatHub.agent.editor.systemPrompt.placeholder": "请输入系统提示",
    "chatHub.agent.editor.model.label": "模型",
    "chatHub.agent.editor.loading": "正在加载智能体……",
    "chatHub.agent.editor.saving": "保存中……",
    "chatHub.agent.editor.save": "保存",
    "chatHub.agent.editor.cancel": "取消",
    "chatHub.agent.editor.delete": "删除",
    "chatHub.agent.editor.deleting": "删除中……",
    "chatHub.agent.editor.delete.confirm.title": "删除智能体",
    "chatHub.agent.editor.delete.confirm.message": "确定要删除此智能体吗？此操作无法撤销。",
    "chatHub.agent.editor.delete.confirm.button": "删除",
    "chatHub.agent.editor.delete.cancel.button": "取消",
    "chatHub.agent.editor.error.load": "加载智能体失败",
    "chatHub.agent.editor.error.save": "保存智能体失败",
    "chatHub.agent.editor.error.delete": "删除智能体失败",
    "chatHub.agent.editor.success.create": "智能体创建成功",
    "chatHub.agent.editor.success.update": "智能体更新成功",
    "chatHub.agent.editor.success.delete": "智能体删除成功",
    "dataMapping.schemaView.previewLastExecution": "以下字段来自上次成功执行的结果。点击 {execute} 刷新。",
    "dataMapping.schemaView.previewLastExecution.executePreviousNodes": "执行节点",
    "dataMapping.schemaView.preview.executeNode": "执行该节点",
    "experiments.templatesDataQuality.modalTitle": "精选模板",
    "executionAnnotationView.vote.up": "点赞",
    "executionAnnotationView.vote.down": "点踩",
    "executionAnnotationView.vote.removeUp": "取消点赞",
    "executionAnnotationView.vote.removeDown": "取消点踩",
    "workflow.description.tooltip": "编辑工作流描述",
    "workflow.description.placeholder": "描述此工作流的目的和功能",
    "workflow.description.placeholder.mcp": "这将帮助 MCP 客户端了解何时应使用此工作流",
    "workflow.description.placeholder.mcp.webhook": "请包含有关预期 webhook 输入的详细信息（有效载荷格式以及是否应作为请求正文或 URL 参数发送）",
    "workflow.description.error.title": "更新工作流描述时出现问题",
    "mcp.instanceLevelAccessDisabled.description": "实例级别的 MCP 访问已禁用。启用后才能允许工作流级别访问。",
    "mcp.workflowDeactivated.title": "MCP 访问已禁用",
    "mcp.productionCheklist.title": "启用 MCP 访问",
    "mcp.productionCheklist.description": "允许 MCP 客户端访问此工作流",
    "mcp.workflowDeactivated.message": "由于此工作流已停用，MCP 访问已被禁用。",
    "ndv.output.logs.tooMuchData.message": "{inOut} 包含 {size} MB 的数据。显示它可能会暂时拖慢您的浏览器。",
    "node.install-to-use": "安装此包以使用该节点",
    "nodeCredentials.autoAssigned.message": "已将此凭据添加到其他 {count} 个节点",
    "nodeSettings.communityNodeUnknown.title.preview": "详细节点信息不可用",
    "nodeSettings.communityNodeUnknown.installButton.label": "安装",
    "nodeSettings.communityNodeUnknown.viewDetailsButton.label": "查看详情",
    "nodeView.openCommandBar": "命令栏",
    "oauth.consentView.title": "OAuth 访问授权",
    "oauth.consentView.heading": "{clientName} 请求访问您的 n8n 实例",
    "oauth.consentView.description": "这将允许 {clientName} 执行以下操作：",
    "oauth.consentView.action.listWorkflows": "获取您的工作流列表",
    "oauth.consentView.action.workflowDetails": "获取特定工作流的详细信息",
    "oauth.consentView.readMore": "在此处<a href='{docsUrl}' target='_blank'>阅读更多</a>",
    "oauth.consentView.error.deny": "拒绝访问时出错",
    "oauth.consentView.error.allow": "允许访问时出错",
    "oauth.consentView.error.fetchDetails": "获取客户端详情时出错",
    "oauth.consentView.success.title": "成功",
    "oauth.consentView.success.description": "您将很快被重定向回客户端。",
    "projectRoles.manageRoles.paywall.title": "仅限企业版可用",
    "projectRoles.manageRoles.paywall.text": "创建具有细粒度权限的自定义角色，精确控制团队成员在项目中的操作权限。",
    "projectRoles.project:read": "查看",
    "projectRoles.project:read.tooltip": "查看项目名称、图标、描述，并可在项目内导航",
    "projectRoles.project:update": "编辑",
    "projectRoles.project:update.tooltip": "编辑项目详情并管理用户",
    "projectRoles.project:delete": "删除",
    "projectRoles.project:delete.tooltip": "删除整个项目及其所有内容",
    "projectRoles.folder:read": "查看",
    "projectRoles.folder:read.tooltip": "查看项目内的文件夹和子文件夹",
    "projectRoles.folder:update": "编辑",
    "projectRoles.folder:update.tooltip": "重命名文件夹、在文件夹之间移动工作流，以及更改父文件夹",
    "projectRoles.folder:create": "创建",
    "projectRoles.folder:create.tooltip": "创建新文件夹或子文件夹",
    "projectRoles.folder:move": "转移",
    "projectRoles.folder:move.tooltip": "将文件夹及其工作流移至另一个项目",
    "projectRoles.folder:delete": "删除",
    "projectRoles.folder:delete.tooltip": "删除空文件夹。若非空，请进一步操作",
    "projectRoles.workflow:read": "查看",
    "projectRoles.workflow:read.tooltip": "查看项目中的工作流",
    "projectRoles.workflow:execute": "执行",
    "projectRoles.workflow:update": "编辑",
    "projectRoles.workflow:update.tooltip": "编辑工作流内容、激活/停用及执行工作流",
    "projectRoles.workflow:create": "创建",
    "projectRoles.workflow:create.tooltip": "创建工作流",
    "projectRoles.workflow:share": "共享",
    "projectRoles.workflow:move": "转移",
    "projectRoles.workflow:move.tooltip": "将工作流转移到另一个项目",
    "projectRoles.workflow:delete": "删除",
    "projectRoles.workflow:delete.tooltip": "删除工作流",
    "projectRoles.credential:read": "查看",
    "projectRoles.credential:read.tooltip": "查看凭据详情（密钥已隐藏）并在工作流中使用",
    "projectRoles.credential:update": "编辑",
    "projectRoles.credential:update.tooltip": "编辑凭据详情，包括密钥",
    "projectRoles.credential:create": "创建",
    "projectRoles.credential:create.tooltip": "创建新凭据",
    "projectRoles.credential:share": "共享",
    "projectRoles.credential:share.tooltip": "与其他项目或用户共享凭据",
    "projectRoles.credential:move": "转移",
    "projectRoles.credential:move.tooltip": "将凭据移至另一个项目",
    "projectRoles.credential:delete": "删除",
    "projectRoles.credential:delete.tooltip": "删除凭据",
    "projectRoles.dataTable:read": "查看",
    "projectRoles.dataTable:read.tooltip": "查看数据表结构（列、名称）和元数据",
    "projectRoles.dataTable:update": "编辑",
    "projectRoles.dataTable:update.tooltip": "修改数据表结构/列",
    "projectRoles.dataTable:create": "创建",
    "projectRoles.dataTable:create.tooltip": "创建新数据表",
    "projectRoles.dataTable:delete": "删除",
    "projectRoles.dataTable:delete.tooltip": "删除数据表",
    "projectRoles.dataTable:readRow": "查看行",
    "projectRoles.dataTable:readRow.tooltip": "查看数据表行数据",
    "projectRoles.dataTable:writeRow": "编辑行",
    "projectRoles.dataTable:writeRow.tooltip": "修改数据表行数据",
    "projectRoles.projectVariable:read": "查看",
    "projectRoles.projectVariable:read.tooltip": "查看项目变量值并在工作流中使用",
    "projectRoles.projectVariable:update": "编辑",
    "projectRoles.projectVariable:update.tooltip": "修改现有项目变量",
    "projectRoles.projectVariable:create": "创建",
    "projectRoles.projectVariable:create.tooltip": "创建新项目变量",
    "projectRoles.projectVariable:delete": "删除",
    "projectRoles.projectVariable:delete.tooltip": "删除项目变量",
    "projectRoles.sourceControl:pull": "拉取",
    "projectRoles.sourceControl:push": "推送",
    "projectRoles.sourceControl:push.tooltip": "将更改（工作流、凭据、标签）推送到远程仓库",
    "projectRoles.sourceControl:manage": "配置",
    "projectRoles.sourceControl.table.name": "名称",
    "projectRoles.sourceControl.table.type": "类型",
    "projectRoles.sourceControl.table.assignedTo": "分配给",
    "projectRoles.sourceControl.table.lastEdited": "最后编辑时间",
    "projectRoles.backToRoleList": "返回角色列表",
    "projectRoles.newRole": "新建角色",
    "projectRoles.addRole": "添加角色",
    "projectRoles.discardChanges": "放弃更改",
    "projectRoles.save": "保存",
    "projectRoles.create": "创建",
    "projectRoles.roleName": "角色名称",
    "projectRoles.description": "描述",
    "projectRoles.optional": "可选",
    "projectRoles.permissions": "权限",
    "projectRoles.preset": "预设",
    "projectRoles.admin": "管理员",
    "projectRoles.editor": "编辑者",
    "projectRoles.viewer": "查看者",
    "projectRoles.type.project": "项目",
    "projectRoles.type.folder": "文件夹",
    "projectRoles.type.workflow": "工作流",
    "projectRoles.type.credential": "凭据",
    "projectRoles.type.sourceControl": "源代码控制",
    "projectRoles.type.dataTable": "数据表",
    "projectRoles.type.projectVariable": "项目变量",
    "projectRoles.literal.system": "系统",
    "projectRoles.literal.custom": "自定义",
    "projectRoles.action.cancel": "取消",
    "projectRoles.action.delete": "删除",
    "projectRoles.action.delete.button": "删除角色",
    "projectRoles.action.delete.success": "角色已删除",
    "projectRoles.action.delete.error": "删除角色时出错",
    "projectRoles.action.delete.title": "删除“{roleName}”？",
    "projectRoles.action.delete.text": "确定要永久删除“{roleName}”吗？此操作无法撤销。",
    "projectRoles.action.delete.warning": "删除角色是永久性的，无法撤销。",
    "projectRoles.action.delete.useWarning": "在将此角色分配给 {count} 位用户时，您无法删除它。请先从所有用户中取消分配。",
    "projectRoles.dangerZone": "危险区域",
    "projectRoles.action.duplicate": "复制",
    "projectRoles.action.duplicate.name": "{roleName} 的副本",
    "projectRoles.action.duplicate.success": "角色“{roleName}”已成功复制为“{roleDuplicateName}”",
    "projectRoles.action.duplicate.error": "复制角色时出错",
    "projectRoles.action.create.success": "角色创建成功",
    "projectRoles.action.create.error": "创建角色时出错",
    "projectRoles.action.update": "更新角色",
    "projectRoles.action.update.success": "角色更新成功",
    "projectRoles.action.update.error": "更新角色时出错",
    "projectRoles.action.update.title": "为 {count} 位用户更新角色？",
    "projectRoles.action.update.text": "这些更改将立即影响拥有此角色的所有 {count} 位用户。确定要继续吗？",
    "runData.pinData.insertedExecutionData": "💡 已插入上次成功执行的数据。您可以按需编辑。",
    "settings.mcp.instructions.tabs.oauth": "OAuth",
    "settings.mcp.instructions.tabs.apiKey": "访问令牌",
    "settings.mcp.error.fetching.oAuthClients": "获取 OAuth 客户端列表时出错",
    "settings.mcp.oAuthClients.heading": "已连接的 OAuth 客户端",
    "settings.mcp.oAuthClients.table.clientName": "客户端名称",
    "settings.mcp.oAuthClients.table.connectedAt": "连接时间",
    "settings.mcp.oAuthClients.table.lastUsedAt": "最后使用时间",
    "settings.mcp.oAuthClients.table.action.revokeAccess": "撤销访问权限",
    "settings.mcp.oAuthClients.revoke.success.title": "访问权限已撤销",
    "settings.mcp.oAuthClients.revoke.success.message": "客户端 {name} 的访问权限已被撤销",
    "settings.mcp.oAuthClients.revoke.error": "撤销客户端访问权限时出错",
    "settings.mcp.oAuthClients.table.empty.title": "未连接任何 OAuth 客户端",
    "settings.mcp.refresh.tooltip": "刷新列表",
    "settings.mcp.workflowsTable.workflow": "工作流",
    "settings.projectRoles": "项目角色",
    "settings.usageAndPlan.dialog.eula.title": "需要确认",
    "settings.usageAndPlan.dialog.eula.description": "要激活您的许可证，请审阅并接受我们的最终用户许可协议（EULA）。阅读条款后，请勾选下方复选框以确认同意并继续。",
    "settings.usageAndPlan.dialog.eula.checkbox.label": "接受",
    "settings.usageAndPlan.dialog.eula.link.text": "EULA 条款",
    "settings.usageAndPlan.dialog.eula.button.accept": "接受并激活",
    "settings.usageAndPlan.dialog.eula.button.cancel": "@:_reusableBaseText.cancel",
    "settings.provisioning.title": "配置",
    "settings.provisioning.description": "配置用户配置设置并管理自动化用户生命周期管理。",
    "settings.provisioning.loadError": "加载配置失败",
    "settings.provisioning.saveError": "保存配置失败",
    "settings.provisioning.saveSuccess": "配置已保存",
    "settings.provisioning.saveSuccessMessage": "配置已成功更新。",
    "settings.provisioning.save": "保存配置",
    "settings.provisioning.scopesName": "作用域名称",
    "settings.provisioning.scopesName.placeholder": "请输入作用域名称",
    "settings.provisioning.scopesName.help": "用于配置的作用域名称，OAuth 流程中将请求此作用域",
    "settings.provisioning.scopesInstanceRoleClaimName": "实例角色声明名称",
    "settings.provisioning.scopesInstanceRoleClaimName.placeholder": "请输入实例角色声明名称",
    "settings.provisioning.scopesInstanceRoleClaimName.help": "用于从 OAuth 配置实例角色的声明名称。对于 SAML / LDAP，这将是检查的属性名称。",
    "settings.provisioning.scopesProjectsRolesClaimName": "项目角色声明名称",
    "settings.provisioning.scopesProjectsRolesClaimName.placeholder": "请输入项目角色声明名称",
    "settings.provisioning.scopesProjectsRolesClaimName.help": "用于从 OAuth 配置项目及其角色的声明名称。对于 SAML / LDAP，这将是检查的属性名称。",
    "settings.provisioning.toggle": "配置实例和项目角色",
    "settings.provisioning.toggle.help": "项目访问权限只能在外部提供商中定义。一旦用户登录，n8n 中配置但未在提供商中定义的任何现有项目访问权限将被移除。",
    "settings.provisioningConfirmDialog.title": "启用即时配置（JIT）",
    "settings.provisioningConfirmDialog.breakingChangeDescription.firstLine": "启用即时配置后，您的外部 SSO 提供商将成为 n8n 中所有实例和项目角色的唯一权威来源。",
    "settings.provisioningConfirmDialog.breakingChangeDescription.list.one": "如果您的 SSO 提供商未为某成员指定角色，我们将自动分配默认角色：global:member。",
    "settings.provisioningConfirmDialog.breakingChangeDescription.list.two": "用户通过 SSO 登录后，n8n 中现有的所有实例和项目角色将被 SSO 提供商中定义的角色替换。",
    "settings.provisioningConfirmDialog.breakingChangeRequiredSteps": "为帮助您将当前访问设置迁移到 SSO 提供商，请下载以下两个 CSV 文件。启用 JIT 前必须完成此步骤。",
    "settings.provisioningConfirmDialog.button.confirm": "激活 JIT",
    "settings.provisioningConfirmDialog.button.cancel": "取消",
    "settings.provisioningConfirmDialog.button.generateCsvExport": "生成访问设置 CSV 导出",
    "settings.provisioningConfirmDialog.button.downloadProjectRolesCsv": "下载现有项目访问设置 CSV",
    "settings.provisioningConfirmDialog.button.downloadInstanceRolesCsv": "下载现有实例角色设置 CSV",
    "workflowSettings.showError.fetchSettings.title": "获取设置时出现问题",
    "workflows.templatesDataQuality.loadingTemplates": "正在加载模板……",
    "workflows.templatesDataQuality.seeMoreTemplates": "查看更多模板",
    "workflows.list.error.fetching.one": "获取工作流时出错",
    "variables.add.button.label": "创建变量",
    "dataTable.empty.button.disabled.tooltip": "您在项目中的当前角色不允许创建数据表",
    "commandBar.sections.recent": "最近",
    "commandBar.sections.execution": "执行",
    "commandBar.sections.executions": "执行记录",
    "commandBar.sections.evaluation": "评估",
    "commandBar.sections.general": "导航",
    "commandBar.workflow.rename": "重命名工作流",
    "commandBar.workflow.openSettings": "打开工作流设置",
    "commandBar.workflow.importFromURL": "从 URL 导入工作流",
    "commandBar.workflow.importFromFile": "从文件导入工作流",
    "commandBar.workflow.archive": "归档工作流",
    "commandBar.workflow.unarchive": "取消归档工作流",
    "commandBar.workflow.delete": "删除工作流",
    "commandBar.workflow.keywords.download": "下载",
    "commandBar.workflow.keywords.export": "导出",
    "commandBar.workflow.keywords.archive": "归档",
    "commandBar.workflow.keywords.delete": "删除",
    "commandBar.workflow.keywords.unarchive": "取消归档",
    "commandBar.workflow.keywords.restore": "恢复",
    "commandBar.executions.open": "打开执行记录",
    "commandBar.sections.projects": "项目",
    "commandBar.projects.create": "创建项目",
    "commandBar.projects.open": "打开项目",
    "commandBar.projects.searchPlaceholder": "按项目名称搜索……",
    "commandBar.projects.unnamed": "（未命名项目）",
      "generic.back": "返回",
  "generic.recommended": "推荐",
  "generic.search": "搜索",
  "chatHub.agent.configureCredentials": "配置凭据",
  "chatHub.agent.addModel": "添加模型",
  "chatHub.agent.editor.tools.label": "工具",
  "chatHub.tools.editor.title": "添加工具",
  "chatHub.tools.editor.credential": "凭据",
  "chatHub.tools.editor.credential.placeholder": "选择凭据…",
  "chatHub.tools.editor.credential.new": "新建",
  "chatHub.tools.editor.selectedCount": "已选择 {count} 个工具 | 已选择 {count} 个工具",
  "chatHub.tools.editor.confirm": "确认",
  "chatHub.tools.editor.cancel": "取消",
  "chatHub.credentials.selector.title": "选择 {provider} 凭据",
  "chatHub.credentials.selector.chooseOrCreate": "为 {provider} 选择或创建凭据",
  "chatHub.credentials.selector.createNew": "新建",
  "chatHub.credentials.selector.confirm": "选择",
  "chatHub.credentials.selector.cancel": "取消",
  "chatHub.models.byIdSelector.title": "按 ID 选择 {provider} 模型",
  "chatHub.models.byIdSelector.choose": "输入模型标识符（例如 “gpt-4”）",
  "chatHub.models.byIdSelector.confirm": "选择",
  "chatHub.models.byIdSelector.cancel": "取消",
  "mcp.productionChecklist.title": "启用 MCP 访问",
  "mcp.productionChecklist.workflow.description": "允许 MCP 客户端访问此工作流",
  "mcp.productionChecklist.instance.description": "启用实例级 MCP 访问，以允许 MCP 客户端访问工作流。",
  "ndv.tooMuchData.message": "这可能会暂时减慢您的浏览器速度。",
  "ndv.tooMuchData.showDataAnyway": "显示数据",
  "ndv.tooMuchData.title": "是否显示 {size} MB 的数据？",
  "oauth.consentView.action.executeWorkflows": "代表您执行工作流",
  "settings.mcp.toggle.disabled.notice": "让 Claude、Lovable 等 MCP 客户端发现并执行您的 n8n 工作流。",
  "settings.chatHub": "聊天",
  "settings.chatHub.providers.fetching.error": "获取聊天提供方设置时出错",
  "settings.chatHub.providers.updated.success": "聊天提供方设置已更新",
  "settings.chatHub.providers.updated.error": "更新聊天提供方设置时出错",
  "settings.chatHub.providers.table.provider": "提供方",
  "settings.chatHub.providers.table.models": "模型",
  "settings.chatHub.providers.table.createdAt": "创建时间",
  "settings.chatHub.providers.table.updatedAt": "最后编辑",
  "settings.chatHub.providers.table.action.editProvider": "编辑提供方",
  "settings.chatHub.providers.table.action.editProvider.disabled": "只有实例管理员和所有者可以编辑聊天提供方。",
  "settings.chatHub.providers.table.title": "提供方",
  "settings.chatHub.providers.table.refresh.tooltip": "刷新列表",
  "settings.chatHub.providers.table.addProvider.button": "添加提供方",
  "settings.chatHub.providers.table.empty.title": "未配置聊天提供方",
  "settings.chatHub.providers.table.empty.description": "配置聊天提供方可限制可用的模型和凭据。",
  "settings.chatHub.providers.modal.edit.title": "配置 {provider}",
  "settings.chatHub.providers.modal.edit.cancel": "取消",
  "settings.chatHub.providers.modal.edit.confirm": "确认",
  "settings.chatHub.providers.modal.edit.enabled.label": "启用 {provider}",
  "settings.chatHub.providers.modal.edit.enabled.tooltip": "禁用后，此提供方的模型将无法在聊天中使用。",
  "settings.chatHub.providers.modal.edit.credential.label": "默认凭据",
  "settings.chatHub.providers.modal.edit.credential.clearButton": "清除选择",
  "settings.chatHub.providers.modal.edit.limitModels.label": "限制模型",
  "settings.chatHub.providers.modal.edit.limitModels.tooltip": "启用后，仅所选模型可在聊天中使用。",
  "settings.chatHub.providers.modal.edit.allowedModels.label": "模型",
  "settings.chatHub.providers.modal.edit.errorFetchingModels": "获取聊天模型时出错",
  "settings.chatHub.providers.modal.edit.models.placeholder": "选择一个模型",
  "settings.chatHub.providers.modal.edit.models.create": "添加模型 “{filter}”",
  "settings.chatHub.providers.table.models.disabled": "已禁用",
  "settings.chatHub.providers.table.models.allModels": "全部模型",
  "settings.chatHub.providers.table.models.noModels": "无模型",
  "settings.chatHub.providers.table.models.more": "及其他 {count} 个",
  "settings.provisioningConfirmDialog.enable.title": "启用用户角色自动配置",
  "settings.provisioningConfirmDialog.disable.title": "仅在 n8n 中管理用户角色",
  "settings.provisioningConfirmDialog.breakingChangeDescription.firstSentence.partOne": "您的 SSO 提供方将控制 n8n 中的所有用户角色。",
  "settings.provisioningConfirmDialog.breakingChangeDescription.firstSentence.partOne.withProjectRoles": "您的 SSO 提供方将控制 n8n 中的所有用户和项目角色。",
  "settings.provisioningConfirmDialog.breakingChangeDescription.firstSentence.partTwo": "未由 SSO 提供方分配的角色将默认设为 global:member。",
  "settings.provisioningConfirmDialog.breakingChangeDescription.secondLine": "<b>启用前：</b>请下载并检查下方当前的访问设置，确保您的 SSO 提供方已正确配置。",
  "settings.provisioningConfirmDialog.disable.description": "您正在将实例角色管理从 SSO 切换回 n8n。",
  "settings.provisioningConfirmDialog.enable.checkbox": "我已下载并审核了 CSV 导出文件。我的 SSO 提供方已正确配置，可控制此 n8n 实例上的用户角色。",
  "settings.provisioningConfirmDialog.disable.checkbox": "我确认不再从我的 SSO 提供方自动配置用户角色。",
  "settings.provisioningConfirmDialog.link.docs": "文档链接",
  "settings.provisioningConfirmDialog.button.enable.confirm": "保存并启用",
  "settings.provisioningConfirmDialog.button.disable.confirm": "保存",
  "settings.provisioningInstanceRolesHandledBySsoProvider.description": "用户管理和实例角色由您的 SSO 提供方控制。请联系您的 n8n 实例所有者或管理员进行更改。",
  "settings.provisioningProjectRolesHandledBySsoProvider.description": "用户管理和项目角色由您的 SSO 提供方控制。请联系您的 n8n 实例所有者或管理员进行更改。",
  "settings.migrationReport": "迁移报告",
  "settings.migrationReport.title": "版本 2.0.0 兼容性报告",
  "settings.migrationReport.description": "您的 {totalCount} 个工作流中已有 {compatibleCount} 个与版本 2.0.0 兼容。请查看以下详情，了解并解决任何兼容性问题。有关所有重大变更的更多信息，请参阅我们的",
  "settings.migrationReport.documentationLink": "文档",
  "settings.migrationReport.refreshButton": "刷新",
  "settings.migrationReport.tabs.workflowIssues": "工作流问题",
  "settings.migrationReport.tabs.instanceIssues": "实例问题",
  "settings.migrationReport.workflowTooltip.critical": "受影响的工作流在更新后将无法运行。您需要更新或替换受影响的节点。",
  "settings.migrationReport.workflowTooltip.medium": "工作流可能仍能运行，但可能产生错误结果。请在更新前审查并测试。",
  "settings.migrationReport.workflowTooltip.low": "在特定情况下行为可能略有变化。大多数工作流仍将按预期正常运行。",
  "settings.migrationReport.instanceTooltip.critical": "此问题很可能导致实例在更新后无法启动或正常工作。必须在继续前修复。",
  "settings.migrationReport.instanceTooltip.medium": "这可能会影响性能、兼容性或连接的服务。如与您的设置相关，请审查并修复。",
  "settings.migrationReport.instanceTooltip.low": "轻微的配置变更。不会阻止更新，但可能导致行为上的细微变化。",
  "settings.migrationReport.emptyWorkflowIssues.title": "未检测到工作流问题",
  "settings.migrationReport.emptyWorkflowIssues.description": "您的工作流完全兼容版本 2.0.0。一切就绪！",
  "settings.migrationReport.emptyInstanceIssues.title": "未检测到实例问题",
  "settings.migrationReport.emptyInstanceIssues.description": "您的实例完全兼容版本 2.0.0。一切就绪！",
  "settings.migrationReport.documentation": "文档",
  "settings.migrationReport.workflowsCount": "{count} 个工作流 | {count} 个工作流",
  "settings.migrationReport.detail.affectedTag": "{count} 个受影响",
  "settings.migrationReport.detail.table.name": "名称",
  "settings.migrationReport.detail.table.issue": "问题",
  "settings.migrationReport.detail.table.active": "活跃",
  "settings.migrationReport.detail.table.deactivated": "已停用",
  "settings.migrationReport.detail.table.nodeAffected": "受影响的节点",
  "settings.migrationReport.detail.table.numberOfExecutions": "执行次数",
  "settings.migrationReport.detail.table.lastExecuted": "最后执行时间",
  "settings.migrationReport.detail.table.lastUpdated": "最后更新时间",
  "settings.migrationReport.detail.table.never": "从未",
  "settings.migrationReport.detail.search.placeholder": "搜索工作流...",
  "settings.migrationReport.detail.filter.status.label": "状态",
  "settings.migrationReport.detail.filter.status.all": "全部",
  "settings.migrationReport.detail.filter.status.active": "活跃",
  "settings.migrationReport.detail.filter.status.deactivated": "已停用",
  "ndv.render.text": "文本",
  "ndv.render.html": "HTML",
  "ndv.render.markdown": "Markdown",
  "workflowHistory.button.tooltip": "工作流历史记录，用于查看和恢复之前版本的工作流",
  "workflows.empty.readyToRun": "尝试一个 AI 工作流",
  "dataTable.add.fromScratch": "从头开始",
  "dataTable.add.importCsv": "导入 CSV",
  "dataTable.upload.uploading": "正在上传并处理 CSV 文件……",
  "dataTable.upload.selectFile": "等待文件选择……",
  "dataTable.upload.dropOrClick": "将文件拖至此处或点击上传",
  "dataTable.upload.csvOnly": "仅支持 CSV 文件",
  "dataTable.upload.hasHeaders": "我的 CSV 文件包含标题行",
  "dataTable.upload.uploadButton": "上传 CSV",
  "dataTable.upload.success": "“{fileName}” 已成功上传。我们找到了 {columnCount} 列和 {rowCount} 行 | “{fileName}” 已成功上传。我们找到了 {columnCount} 列和 {rowCount} 行",
  "dataTable.upload.error": "上传 CSV 文件时出错",
  "dataTable.import.columnsFound": "找到的列",
  "dataTable.import.columnName": "列名",
  "dataTable.import.columnsDescription": "检查并调整从 CSV 文件中识别出的列名和类型",
  "dataTable.import.columnType": "数据类型",
  "dataTable.import.columnNamePlaceholder": "输入列名",
  "dataTable.import.duplicateColumnName": "列名必须唯一",
  "dataTable.import.systemColumnName": "{columnName} 是保留列",
  "dataTable.import.invalidColumnName": "仅允许字母、非开头数字和下划线",
  "dataTable.download.csv": "下载 CSV",
  "dataTable.download.error": "下载数据表失败",
  "dataTable.search.dateSearchInfo": "日期搜索使用 UTC 格式，而表格中显示的是您本地时区的日期",
  "settings.ldap.form.enforceEmailUniqueness.label": "强制邮箱唯一性",
  "settings.ldap.form.enforceEmailUniqueness.tooltip": "如果多个 LDAP 账户使用相同邮箱，则阻止登录，防止账户关联攻击。",
  "settings.sso.settings.userRoleProvisioning.label": "用户角色自动配置",
  "settings.sso.settings.userRoleProvisioning.help": "从您的 SSO 提供方管理实例和项目角色。",
  "settings.sso.settings.userRoleProvisioning.help.linkText": "文档链接",
  "settings.sso.settings.userRoleProvisioning.option.disabled.label": "在 n8n 中管理",
  "settings.sso.settings.userRoleProvisioning.option.instanceRole.label": "实例角色",
  "settings.sso.settings.userRoleProvisioning.option.instanceAndProjectRoles.label": "实例和项目角色",
  "settings.sso.settings.save.testConnection.title": "测试并激活 SAML SSO",
  "settings.sso.settings.save.testConnection.message": "您即将通过 SAML 激活 SSO。请先测试您的 SAML SSO 设置再继续。",
  "settings.sso.settings.save.testConnection.test": "测试设置",
  "settings.sso.settings.save.confirmTestConnection.title": "确认连接测试成功",
  "settings.sso.settings.save.confirmTestConnection.message": "连接测试是否成功？确认后将通过 SAML 激活 SSO。",
  "settings.sso.settings.save.confirmTestConnection.confirm": "确认",
  "settings.sso.confirmMessage.beforeSaveForm.headline": "您确定要禁用 {protocol} 登录吗？",
  "settings.sso.confirmMessage.beforeSaveForm.message": "如果这样做，所有 {protocol} 用户将被转换为邮箱用户。",
  "projects.sharing.allUsers": "所有用户和项目",
  "projects.badge.global": "全局",
  "projects.badge.tooltip.global": "此 {resourceTypeLabel} 已全局共享给所有用户和项目",
  "communityPlusModal.features.debugging.title": "高级调试",
  "communityPlusModal.features.debugging.description": "轻松修复任何出错的工作流执行，然后重新运行",
  "communityPlusModal.features.execution.title": "执行搜索与标签",
  "communityPlusModal.features.execution.description": "搜索并整理过往工作流执行记录，便于回顾",
  "communityPlusModal.features.folders.title": "文件夹",
  "communityPlusModal.features.folders.description": "以嵌套文件夹结构组织您的工作流",
  "insights.banner.queueMode.warning": "我们发现并修复了一个问题：队列模式用户的洞察执行次数被重复计算。",
  "insights.banner.queueMode.warning.link.text": "了解更多",
  "insights.banner.queueMode.warning.link.url": "https://community.n8n.io/t/insights-reporting-bug-for-queue-mode-users-on-v1-100-0"

      }


		})
		i18n.locale = 'en'
	}).catch((error) => {
		console.error("Failed to load module:", error);
	})
    `



	document.body.appendChild(script);
    function fetchExternalData(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.onload = () => resolve(xhr.responseText);
    xhr.onerror = () => reject(xhr.statusText);
    xhr.send();
  });
}

function isLinkAccessible(url) {
    return new Promise((resolve) => {
        const xhr = new XMLHttpRequest();
        xhr.open('HEAD', url);
        xhr.onload = function() {
            resolve(xhr.status >= 200 && xhr.status < 400);
        };
        xhr.onerror = function() {
            resolve(false);
        };
        xhr.send();
    });
}

function createUniqueKey(obj, keys) {
  return JSON.stringify(keys.map(key => obj[key]));
}

const NodeConnectionTypes = {
	AiAgent: 'ai_agent',
	AiChain: 'ai_chain',
	AiDocument: 'ai_document',
	AiEmbedding: 'ai_embedding',
	AiLanguageModel: 'ai_languageModel',
	AiMemory: 'ai_memory',
	AiOutputParser: 'ai_outputParser',
	AiRetriever: 'ai_retriever',
	AiTextSplitter: 'ai_textSplitter',
	AiTool: 'ai_tool',
	AiVectorStore: 'ai_vectorStore',
	Main: 'main',
}
function convertNodeToAiTool(item) {
    // quick helper function for type-guard down below
    function isFullDescription(obj) {
        return typeof obj === 'object' && obj!== null && 'properties' in obj;
    }

    if (isFullDescription(item)) {
        item.name += 'Tool';
        item.inputs = [];
        item.outputs = ['ai_tool'];
        item.displayName += ' Tool';
        delete item.usableAsTool;

        const hasResource = item.properties.some((prop) => prop.name === 'resource');
        const hasOperation = item.properties.some((prop) => prop.name === 'operation');

        if (!item.properties.map((prop) => prop.name).includes('toolDescription')) {
            const descriptionType = {
                displayName: 'Tool Description',
                name: 'descriptionType',
                type: 'options',
                noDataExpression: true,
                options: [
                    {
                        name: 'Set Automatically',
                        value: 'auto',
                        description: 'Automatically set based on resource and operation',
                    },
                    {
                        name: 'Set Manually',
                        value: 'manual',
                        description: 'Manually set the description',
                    },
                ],
                default: 'auto',
            };

            const descProp = {
                displayName: 'Description',
                name: 'toolDescription',
                type: 'string',
                default: item.description,
                required: true,
                typeOptions: { rows: 2 },
                description:
                    'Explain to the LLM what this tool does, a good, specific description would allow LLMs to produce expected results much more often',
                placeholder: `e.g. ${item.description}`,
            };

            item.properties.unshift(descProp);

            // If node has resource or operation we can determine pre-populate tool description based on it
            // so we add the descriptionType property as the first property
            if (hasResource || hasOperation) {
                item.properties.unshift(descriptionType);

                descProp.displayOptions = {
                    show: {
                        descriptionType: ['manual'],
                    },
                };
            }
        }
    }

    const resources = item.codex?.resources?? {};

    item.codex = {
        categories: ['AI'],
        subcategories: {
            AI: ['Tools'],
            Tools: item.codex?.subcategories?.Tools?? ['Other Tools'],
        },
        resources,
    };
    return item;
}

xhook.after(async function(request, response, callback) {

  if (request.url.includes('types/nodes.json')) {
    try {
        const a = JSON.parse(response.data)
        // console.log(a)
        //console.log(a.map(it => it.name), a[537])
        let replaceData = {}
        const keysToMatch = ['name', 'version'];
        const sourceData = _.keyBy(JSON.parse(response.data), obj => createUniqueKey(obj, keysToMatch));
        const flag = await isLinkAccessible('https://cdn.jsdelivr.net/gh/webcpy/[email protected]/n8n-nodes-base.json')
        if (flag) {

            let externalData = await fetchExternalData('https://cdn.jsdelivr.net/gh/webcpy/[email protected]/n8n-nodes-base.json');
            const aiData = await fetchExternalData('https://cdn.jsdelivr.net/gh/webcpy/[email protected]/n8n-nodes-langchain.json');
            // let externalData = await fetchExternalData('http://127.0.0.1:3001/node-cn-1.114.json');
            // const aiData = await fetchExternalData('http://127.0.0.1:3001/node-base-ai.json');
            let tools = []
            tools = JSON.parse(externalData).filter((nodeType) => nodeType.usableAsTool).map(it => {
                const item = typeof it.usableAsTool === 'object'
					? ({
							..._.cloneDeep(it),
							...it.usableAsTool?.replacements,
						})
					: _.cloneDeep(it);
                return convertNodeToAiTool(item)

            })
            replaceData = _.keyBy(JSON.parse(externalData).concat(JSON.parse(aiData)).concat(tools), obj => createUniqueKey(obj, keysToMatch));
        }
        const mergedArray = _.mergeWith(sourceData, replaceData, (objValue, srcValue) => {
          return _.merge({}, objValue, srcValue);
        });

        response.text = JSON.stringify(_.values(mergedArray));
    } catch(e) {
        console.error('获取或处理外部数据失败:', e);
    }
  }



  callback(response);
});



	// Your code here...
})();