3097 lines
144 KiB
TypeScript
3097 lines
144 KiB
TypeScript
import { withEnglishFallback } from "./fallback";
|
||
|
||
export default withEnglishFallback({
|
||
app: {
|
||
name: "DBX",
|
||
},
|
||
auth: {
|
||
setupTitle: "Configurar contraseña de acceso",
|
||
setupDescription: "Establece una contraseña para proteger tu instancia",
|
||
loginDescription: "Herramienta de administración de bases de datos",
|
||
newPassword: "Ingresa la nueva contraseña",
|
||
confirmPassword: "Confirmar contraseña",
|
||
enterPassword: "Ingresa la contraseña de acceso",
|
||
passwordMismatch: "Las contraseñas no coinciden",
|
||
setPassword: "Establecer contraseña",
|
||
login: "Iniciar sesión",
|
||
processing: "Procesando...",
|
||
loginFailed: "Contraseña incorrecta",
|
||
connectFailed: "Error de conexión",
|
||
changePassword: "Cambiar contraseña",
|
||
oldPassword: "Contraseña actual",
|
||
oldPasswordWrong: "La contraseña actual es incorrecta",
|
||
passwordChanged: "Contraseña cambiada exitosamente",
|
||
changePasswordFailed: "Error al cambiar la contraseña",
|
||
changePasswordDescription: "Ingresa tu contraseña actual y elige una nueva",
|
||
},
|
||
toolbar: {
|
||
newConnection: "Nueva conexión",
|
||
newQuery: "Nueva consulta",
|
||
execute: "Ejecutar",
|
||
executeShortcut: "Ejecutar selección/consulta (Cmd+Enter)",
|
||
stopQuery: "Detener consulta",
|
||
explainPlan: "Plan de ejecución",
|
||
stopExplain: "Detener análisis",
|
||
formatSql: "Formatear SQL",
|
||
formatSqlFailed: "Error al formatear el SQL",
|
||
keywordCaseLower: "Usar palabras clave SQL en minúsculas",
|
||
keywordCaseUpper: "Usar palabras clave SQL en mayúsculas",
|
||
previewSql: "Vista previa de SQL",
|
||
hidePreviewSql: "Ocultar vista previa de SQL",
|
||
saveSql: "Guardar en biblioteca SQL",
|
||
openSql: "Abrir archivo SQL",
|
||
theme: "Tema",
|
||
themeLight: "Claro",
|
||
themeDark: "Oscuro",
|
||
themeSystem: "Seguir sistema",
|
||
sqlSaved: "SQL guardado",
|
||
sqlOpenFailed: "Error al abrir el archivo: {message}",
|
||
sqlSaveFailed: "Error al guardar el archivo: {message}",
|
||
driverManager: "Administrador de drivers",
|
||
updatableDriverCount: "Cantidad de drivers actualizables",
|
||
blockDangerousRedisCommands: "Bloquear comandos peligrosos",
|
||
},
|
||
updates: {
|
||
title: "Actualizaciones",
|
||
check: "Buscar actualizaciones",
|
||
availableTitle: "Actualización disponible",
|
||
availableMessage: "DBX {latest} está disponible. Estás usando la versión {current}.",
|
||
upToDate: "DBX está actualizado ({version}).",
|
||
failed: "Error al buscar actualizaciones: {error}",
|
||
rateLimited: "Las verificaciones de actualizaciones de GitHub están temporalmente limitadas. Puedes abrir la página de lanzamientos para verificar manualmente.",
|
||
openRelease: "Abrir lanzamiento",
|
||
downloadAndInstall: "Descargar e instalar",
|
||
portableManualUpdate: "Las versiones portables no pueden usar el instalador integrado. Descarga el ZIP portable desde la página de lanzamiento y extráelo sobre la carpeta actual de DBX para conservar portable.dbx y data.",
|
||
downloading: "Descargando {progress}%",
|
||
downloadFailed: "Error al descargar la actualización: {error}",
|
||
restart: "Salir y reiniciar",
|
||
restartFailed: "Error al reiniciar la aplicación: {error}",
|
||
exitAndUpdate: "Salir y actualizar",
|
||
reopenHint: "La aplicación se reiniciará para completar la actualización",
|
||
dockerUsersRun: "Los usuarios de Docker deben ejecutar",
|
||
toUpdate: "para actualizar",
|
||
},
|
||
sidebar: {
|
||
connections: "CONEXIONES",
|
||
noConnections: "Sin conexiones",
|
||
import: "Importar conexiones",
|
||
importDbx: "Importar configuración DBX",
|
||
importNavicat: "Importar Navicat NCX",
|
||
importDbeaver: "Importar DBeaver",
|
||
importDatagrip: "Importar DataGrip",
|
||
export: "Exportar conexiones",
|
||
collapse: "Contraer barra lateral",
|
||
expand: "Expandir barra lateral",
|
||
showMore: "Mostrar {count} más...",
|
||
filterByType: "Filtrar por tipo",
|
||
searchScopeConnection: "Conexión",
|
||
searchScopeDatabase: "Base de datos",
|
||
searchScopeSchema: "Schema",
|
||
searchScopeTable: "Tabla",
|
||
searchScopeView: "Vista",
|
||
clearFilter: "Limpiar filtro",
|
||
locateActiveTab: "Localizar en la barra lateral",
|
||
},
|
||
savedSql: {
|
||
saveToLibrary: "Guardar en biblioteca SQL",
|
||
saveToFile: "Guardar localmente",
|
||
save: "Guardar",
|
||
saved: "SQL guardado",
|
||
saveFailed: "Error al guardar el SQL: {message}",
|
||
fileName: "Nombre de archivo",
|
||
folder: "Carpeta",
|
||
rootFolder: "Biblioteca SQL",
|
||
newQuery: "Nueva consulta",
|
||
newFolder: "Nueva carpeta SQL",
|
||
newFolderDefault: "Nueva carpeta",
|
||
renameFolder: "Renombrar carpeta",
|
||
deleteFolder: "Eliminar carpeta",
|
||
deleteFolderConfirm: "¿Eliminar “{name}” y los archivos SQL que contiene?",
|
||
open: "Abrir SQL",
|
||
renameFile: "Renombrar SQL",
|
||
deleteFile: "Eliminar SQL",
|
||
deleteFileConfirm: "¿Eliminar “{name}”?",
|
||
},
|
||
sqlLibrary: {
|
||
title: "Biblioteca SQL",
|
||
empty: "Sin consultas guardadas",
|
||
emptyFolder: "Carpeta vacía",
|
||
unfiled: "Sin categoría",
|
||
exportFile: "Exportar SQL",
|
||
exportFolder: "Exportar carpeta",
|
||
exportLibrary: "Exportar biblioteca SQL",
|
||
importDirectory: "Importar carpeta local",
|
||
importIntoFolder: "Importar a esta carpeta",
|
||
openStorageDirectory: "Abrir directorio de SQL",
|
||
chooseSyncDirectory: "Definir directorio de sincronización local",
|
||
disableSyncDirectory: "Desactivar sincronización local",
|
||
syncDirectorySaved: "Directorio de sincronización local de SQL guardado",
|
||
syncDirectoryDisabled: "Sincronización local de SQL desactivada",
|
||
syncDirectoryFailed: "Error al definir el directorio de sincronización: {message}",
|
||
openDirectoryFailed: "Error al abrir el directorio: {message}",
|
||
noSyncDirectory: "Primero defina un directorio de sincronización local",
|
||
exported: "Exportado",
|
||
exportFailed: "Error al exportar: {message}",
|
||
importFailed: "Error al importar: {message}",
|
||
importNone: "No se encontraron archivos .sql en la carpeta seleccionada",
|
||
imported: "Se importaron {count} archivos SQL",
|
||
desktopOnly: "Esta función solo está disponible en escritorio",
|
||
noConnection: "No hay conexión disponible para importar",
|
||
batchDelete: "Eliminación por lotes",
|
||
batchDeleteConfirm: "¿Está seguro de que desea eliminar {count} elementos seleccionados? Esta acción no se puede deshacer.",
|
||
batchDeleteSuccess: "Se eliminaron {count} elementos con éxito",
|
||
clearSelection: "Limpiar selección",
|
||
sortByDate: "Ordenar por fecha de modificación",
|
||
sortByFolder: "Ordenar por estructura de carpetas",
|
||
},
|
||
|
||
connection: {
|
||
title: "Nueva conexión",
|
||
name: "Nombre",
|
||
namePlaceholder: "Nombre de conexión, se genera automáticamente si está vacío",
|
||
type: "Tipo",
|
||
host: "Host",
|
||
filePath: "Ruta del archivo",
|
||
h2FileMode: "Archivo",
|
||
h2TcpMode: "TCP",
|
||
h2FilePathRequired: "La ruta del archivo H2 no puede estar vacía",
|
||
createDuckDbFile: "Crear archivo DuckDB",
|
||
createSqliteFile: "Crear base de datos SQLite",
|
||
memoryDatabasePathHint: "Usa :memory: para crear una base de datos SQLite o DuckDB en memoria.",
|
||
sqliteExtensions: "Extensiones de SQLite",
|
||
sqliteExtensionsPlaceholder: "/ruta/a/regexp.dylib\n/ruta/a/text.dylib|sqlite3_text_init",
|
||
sqliteExtensionsHint: 'Una .dylib/.so/.dll por línea. Usa "ruta|punto de entrada" cuando se requiera un punto de entrada. Se cargan al conectar, luego load_extension se deshabilita.',
|
||
sqliteExtensionBrowse: "Seleccionar extensión de SQLite",
|
||
user: "Usuario",
|
||
password: "Contraseña",
|
||
database: "Base de datos",
|
||
databasePlaceholder: "Opcional",
|
||
databasePlaceholderWithDefault: "Opcional, por defecto {database}",
|
||
defaultDatabase: "BD predeterminada",
|
||
authDatabase: "BD de autenticación",
|
||
authDatabasePlaceholder: "Opcional, normalmente admin",
|
||
authMechanism: "Mecanismo de autenticación",
|
||
authMechanismDefault: "Predeterminado",
|
||
driverMode: "Controlador",
|
||
mongoDriverAuto: "Automático",
|
||
mongoDriverLegacy: "Legacy",
|
||
serviceName: "Servicio/SID",
|
||
serviceNameOnly: "Nombre de servicio",
|
||
version: "Versión",
|
||
driverInstallHintPrefix: "Instala el driver requerido desde ",
|
||
driverInstallHintSuffix: " en la barra superior antes de conectar.",
|
||
driverName: "Nombre del driver",
|
||
driverNamePlaceholder: "Nombre del proveedor o entorno",
|
||
urlParams: "Parámetros de URL",
|
||
gbaseServer: "GBASEDBTSERVER",
|
||
informixServer: "INFORMIXSERVER",
|
||
sslEnable: "Habilitar conexión cifrada",
|
||
caCertPath: "Certificado CA",
|
||
caCertPathPlaceholder: "Opcional, p. ej. ~/.yandex/RootCA.crt",
|
||
caCertPathBrowse: "Buscar certificado",
|
||
redisTlsInsecure: "Omitir verificación del certificado",
|
||
redisTlsInsecureHint: "Equivale a redis-cli --tls --insecure, para certificados autofirmados o CA privadas.",
|
||
mysqlTlsMode: "Modo TLS",
|
||
mysqlTlsModePreferred: "Preferido",
|
||
mysqlTlsModeDisabled: "Deshabilitado",
|
||
mysqlTlsModeRequired: "Requerido",
|
||
mysqlTlsModeVerifyCa: "Verificar CA",
|
||
mysqlTlsModeVerifyIdentity: "Verificar identidad",
|
||
mysqlCaCertHint: "Requerido para Verificar CA e Identidad cuando el certificado usa una CA privada.",
|
||
mysqlClientCert: "Autenticación cliente",
|
||
mysqlClientCertPlaceholder: "/ruta/a/client.crt",
|
||
mysqlClientKeyPlaceholder: "/ruta/a/client.key",
|
||
mysqlClientCertHint: "El certificado y la clave privada deben indicarse juntos si MySQL requiere mTLS.",
|
||
mysqlClientCertBrowse: "Elegir certificado cliente",
|
||
mysqlClientKeyBrowse: "Elegir clave privada cliente",
|
||
postgresSslMode: "Modo TLS",
|
||
postgresSslModeDisable: "Deshabilitar",
|
||
postgresSslModePrefer: "Preferir",
|
||
postgresSslModeRequire: "Requerir",
|
||
postgresSslModeVerifyCa: "Verificar CA",
|
||
postgresSslModeVerifyFull: "Verificar completo",
|
||
postgresServerCert: "CA del servidor",
|
||
postgresRootCertPlaceholder: "/ruta/a/ca.crt",
|
||
postgresRootCertHint: "Úsalo con verify-ca o verify-full cuando el certificado del servidor use una CA privada.",
|
||
postgresRootCertBrowse: "Elegir certificado CA",
|
||
postgresClientCert: "Autenticación cliente",
|
||
postgresClientCertPlaceholder: "/ruta/a/client.crt",
|
||
postgresClientKeyPlaceholder: "/ruta/a/client.key",
|
||
postgresClientCertHint: "El certificado y la clave privada deben indicarse juntos si PostgreSQL requiere mTLS.",
|
||
postgresClientCertBrowse: "Elegir certificado cliente",
|
||
postgresClientKeyBrowse: "Elegir clave privada cliente",
|
||
connectionUrlOptional: "URL (opcional)",
|
||
connectionUrlPlaceholder: "postgresql://usuario:contraseña{'@'}host:5432/db?sslmode=require",
|
||
parseConnectionUrl: "Analizar URL de conexión",
|
||
parseConnectionUrlApplied: "URL de conexión aplicada",
|
||
parseConnectionUrlFailed: "Error al analizar la URL de conexión: {message}",
|
||
mode: "Modo de conexión",
|
||
modeForm: "Formulario",
|
||
redisStandaloneMode: "Directa",
|
||
redisSentinelMode: "Sentinel",
|
||
redisClusterMode: "Cluster",
|
||
oceanbaseMySQLMode: "Modo MySQL",
|
||
oceanbaseOracleMode: "Modo Oracle",
|
||
redisFirstSentinel: "Primer Sentinel",
|
||
redisFirstClusterNode: "Primer nodo semilla",
|
||
redisSentinelNodes: "Nodos Sentinel",
|
||
redisClusterNodes: "Nodos semilla del cluster",
|
||
redisSentinelMaster: "Nombre del master",
|
||
redisSentinelUser: "Usuario Sentinel",
|
||
redisSentinelPassword: "Contraseña Sentinel",
|
||
redisSentinelTls: "TLS Sentinel",
|
||
redisSentinelTlsHint: "Usar TLS al conectar con nodos Sentinel",
|
||
redisKeySeparator: "Separador de espacio de nombres de clave",
|
||
etcdEndpoints: "Endpoints",
|
||
etcdEndpointsHint: "Una entrada por línea. Déjalo en blanco para usar el host y puerto de arriba.",
|
||
etcdCaCertPlaceholder: "/ruta/a/ca.crt",
|
||
etcdCaCertBrowse: "Elegir certificado CA",
|
||
etcdClientAuth: "Autenticación de cliente",
|
||
etcdClientCertPlaceholder: "/ruta/a/client.crt",
|
||
etcdClientKeyPlaceholder: "/ruta/a/client.key",
|
||
etcdClientCertHint: "El certificado y la clave privada deben proporcionarse juntos cuando etcd requiere mTLS.",
|
||
etcdClientCertBrowse: "Elegir certificado de cliente",
|
||
etcdClientKeyBrowse: "Elegir clave privada de cliente",
|
||
etcdClientCertPairRequired: "El certificado y la clave privada deben proporcionarse juntos.",
|
||
zookeeperConnectString: "Cadena de conexión",
|
||
zookeeperConnectStringHint: "Entradas host:puerto separadas por coma o por línea. Déjalo en blanco para usar el host y puerto de arriba.",
|
||
zookeeperCreateModePersistent: "Persistente",
|
||
zookeeperCreateModeEphemeral: "Efímero",
|
||
zookeeperCreateModePersistentSequential: "Persistente secuencial",
|
||
zookeeperCreateModeEphemeralSequential: "Efímero secuencial",
|
||
nacosConsoleUrl: "URL de consola",
|
||
nacosConsoleUrlHint: "Usa la dirección de consola/admin API de Nacos. Nacos 3 Docker normalmente expone la consola en 8085; despliegues antiguos pueden compartir 8848 con el puerto de servicio.",
|
||
nacosConsoleUrlRequired: "La URL de consola de Nacos es obligatoria",
|
||
nacosConsoleUrlAutoAdjusted: "URL de consola de Nacos ajustada de {from} a {to}.",
|
||
nacosNamespace: "Namespace",
|
||
nacosContextPath: "Context Path",
|
||
nacosContextPathPlaceholder: "Dejar vacío o /nacos",
|
||
nacosAuth: "Autenticación",
|
||
nacosAuthNone: "Ninguna",
|
||
nacosAuthUserPassword: "Usuario / Contraseña",
|
||
nacosUsernameRequired: "El usuario de Nacos es obligatorio",
|
||
nacosTls: "TLS",
|
||
nacosTlsSkipVerify: "Omitir verificación de certificado",
|
||
nacosPageSize: "Tamaño de página",
|
||
searchDatabasePlaceholder: "Buscar tipos de bases de datos",
|
||
iconView: "Vista de íconos",
|
||
listView: "Vista de lista",
|
||
selectedDatabase: "Seleccionada",
|
||
noDatabaseMatches: "Sin bases de datos coincidentes",
|
||
next: "Siguiente",
|
||
back: "Anterior",
|
||
basicTab: "Conexión",
|
||
tlsTab: "TLS/SSL",
|
||
test: "Probar",
|
||
testing: "Probando...",
|
||
copyTestResult: "Copiar resultado de prueba",
|
||
saveAndConnect: "Guardar y conectar",
|
||
save: "Guardar",
|
||
editTitle: "Editar conexión",
|
||
testSuccess: "Conexión exitosa",
|
||
connecting: "Conectando a {name}...",
|
||
connectSuccess: "Conectado a {name}",
|
||
connectFailed: "Error de conexión: {message}",
|
||
driverNotInstalled: "El controlador {driver} no está instalado. Instálelo desde el Administrador de controladores.",
|
||
jreNotInstalled: "El entorno JRE {jre} no está instalado. Instálelo desde el Administrador de controladores.",
|
||
systemJavaNotFound: "No se encontró Java en el PATH del sistema. Instale Java o elija un ejecutable personalizado.",
|
||
customJavaPathEmpty: "La ruta de Java personalizada está vacía. Elija un ejecutable de Java.",
|
||
agentJavaTooOld: "Este controlador requiere Java 21. Use el JRE 21 administrado por DBX o seleccione un ejecutable Java 21 en el Administrador de controladores.",
|
||
jdbcPluginNotInstalled: "El plugin JDBC no está instalado. Instale el plugin JDBC opcional para usar esta conexión.",
|
||
lastError: "Error de conexión",
|
||
clearError: "Limpiar error de conexión",
|
||
saveFailed: "Error al guardar la conexión: {message}",
|
||
deleted: "Conexión eliminada",
|
||
deletedSelected: "{count} conexiones eliminadas",
|
||
copied: "Copiado",
|
||
disconnected: "Desconectado",
|
||
databaseConnectionClosed: "Conexión de base de datos cerrada: {name}",
|
||
duplicated: "Conexión duplicada",
|
||
groupDeleted: "Grupo eliminado",
|
||
loadFailed: "Error al cargar las conexiones guardadas: {message}",
|
||
sshTunnel: "Túnel SSH / Proxy",
|
||
advancedTab: "Avanzado",
|
||
sshEnable: "Usar túnel SSH / proxy",
|
||
sshHost: "Host SSH",
|
||
sshUser: "Usuario SSH",
|
||
sshPassword: "Contraseña SSH",
|
||
sshPasswordPlaceholder: "Dejar vacío para usar clave",
|
||
sshKeyPath: "Ruta de clave",
|
||
sshKeyPassphrase: "Frase de clave",
|
||
sshKeyPassphrasePlaceholder: "Dejar vacío si la clave no está cifrada",
|
||
sshKeyPathBrowse: "Examinar",
|
||
sshExposeLan: "Exponer túnel a la red local",
|
||
sshConnectTimeout: "Tiempo de espera SSH (segundos)",
|
||
sshHops: "Capas de túnel SSH / proxy",
|
||
sshHopAdd: "Agregar capa SSH",
|
||
sshHopDuplicate: "Duplicar",
|
||
sshHopDelete: "Eliminar",
|
||
sshHopMoveUp: "Subir",
|
||
sshHopMoveDown: "Bajar",
|
||
sshHopName: "Nombre de la capa",
|
||
sshHopNamePlaceholder: "Bastión, jump host, puerta de producción",
|
||
sshHopDefaultName: "Capa {index}",
|
||
sshHopInvalidHost: "{hop}: el host SSH es obligatorio",
|
||
sshHopInvalidUser: "{hop}: el usuario SSH es obligatorio",
|
||
sshHopInvalidPort: "{hop}: el puerto SSH debe estar entre 1 y 65535",
|
||
sshHopInvalidAuth: "{hop}: se requiere contraseña, ruta de clave o ssh-agent",
|
||
sshUseAgent: "Usar ssh-agent",
|
||
sshAgentSockPath: "Ruta del socket del agente",
|
||
sshAgentSockPathPlaceholder: "ej. ~/.ssh/agent.sock",
|
||
sshHopInvalidTimeout: "{hop}: el tiempo de espera SSH debe estar entre 1 y 300 segundos",
|
||
connectTimeout: "Tiempo de espera de conexión (segundos)",
|
||
queryTimeout: "Tiempo de espera de consulta (segundos)",
|
||
idleTimeout: "Tiempo de espera inactivo (segundos)",
|
||
keepaliveInterval: "Intervalo de keepalive (segundos)",
|
||
readOnly: "Solo lectura",
|
||
readOnlyHint: "Bloquear todas las operaciones de escritura (INSERT, UPDATE, DELETE, etc.)",
|
||
readOnlyBadge: "Solo lectura",
|
||
proxy: "Proxy",
|
||
proxyEnable: "Conectar la base de datos mediante proxy",
|
||
proxyType: "Tipo de proxy",
|
||
proxyHost: "Host del proxy",
|
||
proxyUsername: "Usuario del proxy",
|
||
proxyUsernamePlaceholder: "Opcional",
|
||
proxyPassword: "Contraseña del proxy",
|
||
proxyPasswordPlaceholder: "Opcional",
|
||
dremioArrowFlightSqlMode: "Arrow Flight SQL",
|
||
dremioLegacyJdbcMode: "JDBC heredado",
|
||
jdbcUrl: "URL JDBC",
|
||
jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/base_de_datos",
|
||
jdbcDriverClass: "Clase del driver (opcional)",
|
||
jdbcDriverClassPlaceholder: "La mayoría de los drivers se registran automáticamente; usa com.vendor.jdbc.Driver si es necesario",
|
||
jdbcDriverPaths: "JARs del driver JDBC",
|
||
jdbcDriverSelectPlaceholder: "Seleccionar driver importado",
|
||
jdbcManualClasspath: "Classpath manual",
|
||
jdbcManualClasspathCount: "{count} rutas",
|
||
jdbcDriverPathsPlaceholder: "/ruta/al/driver.jar\n/ruta/a/otro-driver.jar",
|
||
jdbcDriverBrowse: "Seleccionar JAR del driver JDBC",
|
||
jdbcDocs: "Ver documentación JDBC",
|
||
jdbcPluginHint: "Instala primero el plugin JDBC de DBX y luego importa el JAR del driver JDBC del proveedor.",
|
||
dmCompatHint: "Requiere el driver ODBC DM8 instalado en el sistema.",
|
||
dmDownload: "Descargar desde Dameng",
|
||
mongoLegacyHint: "Usa Legacy para servidores MongoDB antiguos, especialmente versiones anteriores a 4.2. Si falla la autenticación y el usuario se creó en admin, define Auth DB como admin.",
|
||
compatible: "Compatible",
|
||
mainstream: "Popular",
|
||
color: "Color",
|
||
colorNone: "Sin color",
|
||
colorGreen: "Verde",
|
||
colorYellow: "Amarillo",
|
||
colorOrange: "Naranja",
|
||
colorRed: "Rojo",
|
||
colorBlue: "Azul",
|
||
colorPurple: "Morado",
|
||
colorCustom: "Color personalizado",
|
||
},
|
||
editor: {
|
||
pressToExecute: "Presiona {mod}+Enter para ejecutar",
|
||
pressToSaveSql: "Presiona {mod}+S para guardar el SQL",
|
||
queryTimeoutError: "La consulta agotó el tiempo ({seconds}s). Comprueba la conexión a la base de datos.",
|
||
changeQueryTimeout: "Cambiar tiempo de espera de consulta",
|
||
connectionMayBeLost: "Es posible que la conexión se haya perdido. Actualiza los datos e inténtalo de nuevo.",
|
||
showResultsPane: "Mostrar resultados",
|
||
hideResultsPane: "Ocultar resultados",
|
||
noDatabase: "Sin base de datos seleccionada",
|
||
unsavedChangesTitle: "Cambios sin guardar",
|
||
unsavedChangesMessage: "Esta pestaña tiene cambios sin guardar que se perderán si se cierra. ¿Guardar antes de cerrar?",
|
||
discardChanges: "Descartar",
|
||
selectConnection: "Seleccionar conexión",
|
||
searchConnection: "Buscar conexiones...",
|
||
selectDatabase: "Seleccionar base de datos",
|
||
selectDatabaseRequired: "Selecciona una base de datos primero",
|
||
searchDatabase: "Buscar bases de datos...",
|
||
selectSchema: "Seleccionar esquema",
|
||
setDefaultDatabase: "Establecer como predeterminada",
|
||
defaultDatabase: "Predeterminada",
|
||
clearDatabase: "Limpiar base de datos",
|
||
completion: {
|
||
nullValue: "Valor NULL",
|
||
isNull: "Comprobar si es NULL",
|
||
isNotNull: "Comprobar si no es NULL",
|
||
stringLiteral: "Literal de cadena",
|
||
numericLiteral: "Literal numérico",
|
||
booleanValue: "Valor booleano",
|
||
starExpansionColumns: "{count} columnas",
|
||
functionDescriptions: {
|
||
COUNT: "Devuelve el número de filas",
|
||
SUM: "Devuelve la suma de una columna numérica",
|
||
AVG: "Devuelve el promedio de una columna numérica",
|
||
MIN: "Devuelve el valor mínimo",
|
||
MAX: "Devuelve el valor máximo",
|
||
GROUP_CONCAT: "Concatena valores de grupo en una cadena",
|
||
STRING_AGG: "Concatena cadenas de grupo",
|
||
CONCAT: "Concatena múltiples cadenas",
|
||
CONCAT_WS: "Concatena cadenas con separador",
|
||
SUBSTRING: "Extrae una subcadena",
|
||
REPLACE: "Reemplaza contenido en una cadena",
|
||
TRIM: "Elimina espacios al inicio y final",
|
||
UPPER: "Convierte a mayúsculas",
|
||
LOWER: "Convierte a minúsculas",
|
||
LENGTH: "Devuelve la longitud de la cadena",
|
||
REGEXP_REPLACE: "Reemplaza usando expresión regular",
|
||
DATE_FORMAT: "Formatea una fecha con el formato dado",
|
||
DATEDIFF: "Calcula la diferencia entre dos fechas",
|
||
DATE_ADD: "Añade un intervalo a una fecha",
|
||
DATE_SUB: "Resta un intervalo de una fecha",
|
||
EXTRACT: "Extrae una parte de la fecha",
|
||
NOW: "Devuelve la fecha y hora actual",
|
||
ROUND: "Redondea a los decimales especificados",
|
||
FLOOR: "Redondea hacia abajo",
|
||
CEIL: "Redondea hacia arriba",
|
||
ABS: "Devuelve el valor absoluto",
|
||
MOD: "Devuelve el resto de la división",
|
||
COALESCE: "Devuelve el primer argumento no NULL",
|
||
IFNULL: "Devuelve un valor de reemplazo si es NULL",
|
||
NULLIF: "Devuelve NULL si los argumentos son iguales",
|
||
CAST: "Convierte una expresión a un tipo de destino",
|
||
JSON_EXTRACT: "Extrae un valor de JSON",
|
||
JSON_VALUE: "Extrae un valor escalar de JSON",
|
||
JSON_OBJECT: "Crea un objeto JSON",
|
||
JSON_ARRAY: "Crea un array JSON",
|
||
},
|
||
},
|
||
contextMenu: {
|
||
executeSelection: "Ejecutar seleccion",
|
||
executeCurrent: "Ejecutar SQL",
|
||
copySelection: "Copiar seleccion",
|
||
selectAll: "Seleccionar todo",
|
||
},
|
||
search: {
|
||
find: "Buscar",
|
||
replace: "Reemplazar",
|
||
replaceAll: "Reemplazar todo",
|
||
caseSensitive: "Distinguir mayúsculas",
|
||
regex: "Expresión regular",
|
||
collapseReplace: "Contraer reemplazo",
|
||
expandReplace: "Expandir reemplazo",
|
||
prevMatch: "Anterior (Shift+Enter)",
|
||
nextMatch: "Siguiente (Enter)",
|
||
close: "Cerrar (Esc)",
|
||
noResults: "Sin resultados",
|
||
},
|
||
executionPicker: {
|
||
title: "Execution Target",
|
||
currentStatement: "Current SQL",
|
||
allStatements: "All SQL",
|
||
currentCommand: "Current command",
|
||
allCommands: "All commands",
|
||
},
|
||
},
|
||
tabs: {
|
||
sql: "SQL",
|
||
table: "Tabla",
|
||
tableData: "Datos de tabla",
|
||
redis: "Redis",
|
||
etcd: "etcd",
|
||
zookeeper: "ZooKeeper",
|
||
vector: "Vector",
|
||
users: "Usuarios y Privilegios",
|
||
executionSummary: "Resumen de ejecución",
|
||
mongo: "Mongo",
|
||
objects: "Objetos",
|
||
tooltipTitle: "Título:",
|
||
tooltipConnection: "Conexión:",
|
||
tooltipDatabase: "Base de datos:",
|
||
tooltipTable: "Tabla:",
|
||
tooltipCollection: "Colección:",
|
||
tooltipSchema: "Esquema:",
|
||
resultN: "Resultado {n}",
|
||
runN: "Ejecutar {n}",
|
||
resultRuns: "Ejecuciones de resultado",
|
||
removeRun: "Eliminar ejecución {n}",
|
||
autoKeepResults: "Conservar resultados automáticamente",
|
||
autoKeepResultsEnabled: "Conservación automática activada",
|
||
autoKeepResultsDisabled: "Conservación automática desactivada",
|
||
missingResultRun: "Este resultado ya no está disponible",
|
||
exportResultArchive: "Guardar archivo de resultados",
|
||
importResultArchive: "Importar resultados",
|
||
importedResultArchive: "Resultados importados",
|
||
resultArchiveExported: "Resultados exportados",
|
||
resultArchiveImported: "Resultados importados",
|
||
resultArchiveUnavailable: "No hay resultados guardados disponibles para exportar",
|
||
resultArchiveImportInvalid: "No se pudo abrir este archivo de resultados",
|
||
resultArchiveExportFailed: "Error al exportar resultados: {message}",
|
||
resultArchiveImportFailed: "Error al importar resultados: {message}",
|
||
scrollLeft: "Desplazar pestañas a la izquierda",
|
||
scrollRight: "Desplazar pestañas a la derecha",
|
||
openTabs: "Pestañas abiertas",
|
||
openDataTabs: "Tablas abiertas",
|
||
},
|
||
executionSummary: {
|
||
empty: "Sin resumen de ejecución",
|
||
executing: "Ejecutando...",
|
||
statement: "Sentencia",
|
||
type: "Tipo",
|
||
rows: "Filas",
|
||
affected: "Afectadas",
|
||
time: "Tiempo",
|
||
success: "Éxito",
|
||
error: "Error",
|
||
returnedTable: "Devolvió una tabla de resultados de {count} columnas",
|
||
noTable: "No se devolvió ninguna tabla de resultados",
|
||
},
|
||
chart: {
|
||
title: "Gráfico",
|
||
type: "Tipo",
|
||
line: "Línea",
|
||
bar: "Barras",
|
||
pie: "Circular",
|
||
noNumericData: "No hay datos numéricos disponibles para graficar",
|
||
},
|
||
grid: {
|
||
rows: "{count} filas",
|
||
totalRows: "Total {count} filas",
|
||
totalRowCount: "({count} en total)",
|
||
totalRowCountLoading: "(contando...)",
|
||
loadingMore: "Cargando más datos...",
|
||
allLoaded: "todo cargado",
|
||
calculateTotalRows: "Contar filas totales",
|
||
calculateTotalRowsInline: "(contar filas totales)",
|
||
calculateTotalRowsFailed: "Error al contar: {message}",
|
||
rowsAffected: "{count} filas afectadas",
|
||
querySuccess: "Consulta ejecutada exitosamente",
|
||
noRows: "Sin datos",
|
||
noRowsDescription: "Este conjunto de resultados no tiene registros.",
|
||
noSearchResults: "Sin coincidencias",
|
||
noSearchResultsDescription: "Intenta con otra palabra clave.",
|
||
noFilteredRows: "Ninguna fila coincide con el filtro",
|
||
noFilteredRowsDescription: "Ajusta el texto de búsqueda o el filtro de estado de filas.",
|
||
copy: "Copiar",
|
||
copyDdl: "Copiar DDL",
|
||
copyCell: "Copiar celda",
|
||
copyRow: "Copiar fila (JSON)",
|
||
copyColumnJson: "Copiar columna (JSON)",
|
||
copyColumnNames: "Copiar nombres de columnas",
|
||
copyRowInsert: "Copiar como INSERT",
|
||
copyRowInsertWithoutPrimaryKeys: "Copiar como INSERT sin claves primarias",
|
||
copyRowUpdate: "Copiar como UPDATE",
|
||
copyAll: "Copiar todo (TSV)",
|
||
selection: "Selección",
|
||
selectionSum: "SUM: {value}",
|
||
selectionCells: "{count} celdas",
|
||
copySelectionTsv: "Copiar selección (TSV)",
|
||
copySelectionTsvWithHeaders: "Copiar selección con encabezados (TSV)",
|
||
copySelectionCsv: "Copiar selección (CSV)",
|
||
copySelectionJson: "Copiar selección (JSON)",
|
||
copySelectionSql: "Copiar selección como lista SQL IN",
|
||
clearSelection: "Limpiar selección",
|
||
export: "Exportar",
|
||
exportCsv: "Exportar CSV",
|
||
exportXlsx: "Exportar XLSX",
|
||
exportCurrentPageCsv: "Exportar página actual como CSV",
|
||
exportCurrentPageXlsx: "Exportar página actual como XLSX",
|
||
exportCurrentPageJson: "Exportar página actual como JSON",
|
||
exportCurrentPageMarkdown: "Exportar página actual como Markdown",
|
||
exportCurrentPageSql: "Exportar página actual como SQL INSERT",
|
||
exportCurrentResultCsv: "Exportar todos los datos del resultado actual como CSV",
|
||
exportCurrentResultXlsx: "Exportar todos los datos del resultado actual como XLSX",
|
||
exportCurrentResultJson: "Exportar todos los datos del resultado actual como JSON",
|
||
exportCurrentResultMarkdown: "Exportar todos los datos del resultado actual como Markdown",
|
||
exportCurrentResultSql: "Exportar todos los datos del resultado actual como SQL INSERT",
|
||
exportAllResultsXlsx: "Exportar todos los resultados de esta ejecución como XLSX",
|
||
exportJson: "Exportar JSON",
|
||
exportMarkdown: "Exportar Markdown",
|
||
exportSql: "Exportar SQL INSERT",
|
||
exportSelectedRowsCsv: "Exportar filas seleccionadas como CSV",
|
||
exportSelectedRowsXlsx: "Exportar filas seleccionadas como XLSX",
|
||
exportSelectedRowsJson: "Exportar filas seleccionadas como JSON",
|
||
exportSelectedRowsMarkdown: "Exportar filas seleccionadas como Markdown",
|
||
exportSelectedRowsSql: "Exportar filas seleccionadas como SQL INSERT",
|
||
exported: "Exportado",
|
||
exportFailed: "Error al exportar: {message}",
|
||
copied: "Copiado",
|
||
copyFailed: "Error al copiar: {message}",
|
||
previewSqlEmpty: "No hay cambios SQL pendientes para previsualizar",
|
||
domRenderMode: "DOM",
|
||
canvasRenderMode: "Canvas",
|
||
renderModeHint: "Alterna entre el renderizado Canvas y la cuadrícula DOM de respaldo.",
|
||
filter: "Filtrar",
|
||
filterBuilder: "Filtros",
|
||
filterBuilderTitle: "Filtros",
|
||
filterBuilderHint: "Crea condiciones visuales y combínalas con el campo WHERE.",
|
||
filterBuilderSummary: "{count} reglas",
|
||
filterBuilderAddRule: "Agregar regla",
|
||
filterBuilderColumn: "Columna",
|
||
filterBuilderValue: "Valor",
|
||
filterBuilderNoValue: "No requiere valor",
|
||
filterBuilderEmpty: "Agrega una regla para empezar a filtrar filas.",
|
||
resetFilterBuilder: "Restablecer reglas",
|
||
filterBuilderEquals: "Igual a",
|
||
filterBuilderNotEquals: "Distinto de",
|
||
filterBuilderContains: "Contiene",
|
||
filterBuilderNotContains: "No contiene",
|
||
filterBuilderGreaterThan: "Mayor que",
|
||
filterBuilderLessThan: "Menor que",
|
||
filterBuilderIsNull: "Es NULL",
|
||
filterBuilderIsNotNull: "No es NULL",
|
||
columnActions: "Acciones de columna",
|
||
localFilter: "Filtro local de valores",
|
||
localFilterFor: "Valores locales para '{column}'",
|
||
databaseValueFilter: "Filtro de valores de base de datos",
|
||
databaseValueFilterFor: "Valores de base de datos para '{column}'",
|
||
columnFormatter: "Formateador de columna",
|
||
columnFormatterFor: "Formateador para '{column}'",
|
||
columnFormatterHint: "Solo formatea la visualización; los valores sin procesar no cambian.",
|
||
formatterType: "Tipo",
|
||
formatterDatetime: "Marca de tiempo Unix",
|
||
formatterJsonPath: "Ruta JSON",
|
||
formatterMask: "Enmascarar texto",
|
||
formatterCustomTemplate: "Plantilla personalizada",
|
||
formatterTimestampUnit: "Unidad de marca de tiempo",
|
||
formatterUnitAuto: "Automático",
|
||
formatterUnitSeconds: "Segundos",
|
||
formatterUnitMilliseconds: "Milisegundos",
|
||
formatterDatetimePattern: "Patrón de fecha y hora",
|
||
formatterDatetimePatternPlaceholder: "Seleccionar o ingresar el formato de fecha y hora",
|
||
formatterDatetimePatternEmpty: "Formato ISO8601 por defecto",
|
||
formatterJsonPathInput: "Ruta JSON",
|
||
formatterMaskPrefix: "Prefijo visible",
|
||
formatterMaskSuffix: "Sufijo visible",
|
||
formatterSavedCustom: "Plantillas guardadas",
|
||
formatterNewCustom: "Nueva plantilla",
|
||
formatterCustomName: "Nombre de plantilla",
|
||
formatterCustomNamePlaceholder: "Ejemplo: Etiqueta de usuario",
|
||
formatterCustomTemplateInput: "Plantilla",
|
||
formatterCustomTemplateHint: "Variables disponibles: ${value}, ${upper}, ${lower}, ${length}. Asígnale un nombre para guardarla en la lista.",
|
||
formatterPreview: "Vista previa",
|
||
saveFormatter: "Guardar",
|
||
clearFormatter: "Limpiar",
|
||
searchValues: "Buscar valores...",
|
||
filterTypedValue: "Usar '{value}'",
|
||
value: "Valor",
|
||
count: "Conteo",
|
||
applyFilter: "Aplicar filtro",
|
||
clearLocalFilters: "Limpiar filtros locales de valores",
|
||
clearLocalFiltersShort: "Limpiar local",
|
||
localFiltersActive: "{count} filtros locales de valores",
|
||
localFilterMoreValues: " +{count} más",
|
||
columnVisibility: "Columnas",
|
||
columnVisibilityHint: "Al menos una columna permanece visible.",
|
||
searchColumns: "Buscar columnas...",
|
||
dragColumnToReorder: "Arrastra el encabezado para reordenar",
|
||
invertColumnVisibility: "Invertir",
|
||
resetColumnOrder: "Restablecer orden",
|
||
showAllColumns: "Mostrar todo",
|
||
viewOptions: "Opciones de vista",
|
||
hideNullColumns: "Ocultar NULL",
|
||
hideNullColumnsHint: "Alterna columnas cuyos valores son todos NULL en el resultado actual.",
|
||
moreValues: "{count} valores más, sigue escribiendo para acotar los resultados",
|
||
filterByValue: "Filtrar por este valor",
|
||
filterExcludeValue: "Excluir este valor",
|
||
filterLike: "Contiene este valor",
|
||
filterNotLike: "No contiene este valor",
|
||
filterLessThan: "Menor que este valor",
|
||
filterGreaterThan: "Mayor que este valor",
|
||
filterIsNull: "Mostrar valores NULL",
|
||
filterIsNotNull: "Mostrar valores no NULL",
|
||
clearFilter: "Limpiar filtro",
|
||
sort: "Ordenar",
|
||
sortAscending: "Orden ascendente",
|
||
sortDescending: "Orden descendente",
|
||
sortCurrentPageAscending: "Ordenar página actual ascendente",
|
||
sortCurrentPageDescending: "Ordenar página actual descendente",
|
||
sortDatabaseAscending: "Ordenar base de datos ascendente",
|
||
sortDatabaseDescending: "Ordenar base de datos descendente",
|
||
clearSort: "Limpiar orden",
|
||
pasted: "¡Pegado!",
|
||
search: "Buscar...",
|
||
searchOrWhere: "Buscar, o ingresar una cláusula WHERE...",
|
||
applyWhere: "Aplicar WHERE",
|
||
filterRows: "Filtrar filas",
|
||
filterAllRows: "Todas las filas",
|
||
filterChangedRows: "Modificadas",
|
||
page: "Página {page}",
|
||
rowsPerPage: "Filas por página",
|
||
customRowsPerPage: "Filas personalizadas",
|
||
applyPageSize: "Aplicar",
|
||
save: "Guardar",
|
||
discard: "Descartar",
|
||
dismiss: "Cerrar",
|
||
quickEntryDraftPlaceholder: "Nueva",
|
||
addRow: "Agregar fila",
|
||
cloneRow: "Clonar como fila nueva",
|
||
deleteRow: "Eliminar fila",
|
||
deleteRows: "Eliminar {count} filas",
|
||
cloneRows: "Clonar {count} como filas nuevas",
|
||
restoreRows: "Restaurar {count} filas",
|
||
copyRows: "Copiar {count} filas (JSON)",
|
||
copyColumnsJson: "Copiar {count} columnas (JSON)",
|
||
copyRowsInsert: "Copiar {count} filas como INSERT",
|
||
copyRowsInsertWithoutPrimaryKeys: "Copiar {count} filas como INSERT sin claves primarias",
|
||
copyRowsUpdate: "Copiar {count} filas como UPDATE",
|
||
selectedRows: "{count} filas seleccionadas",
|
||
restoreRow: "Restaurar fila",
|
||
statusClean: "Sin cambios",
|
||
statusNew: "Elementos nuevos",
|
||
statusEdited: "Elementos modificados",
|
||
statusDeleted: "Elementos eliminados",
|
||
pendingChanges: "{count} pendientes",
|
||
selectedCells: "{count} seleccionadas",
|
||
bulkEditSelection: "Edición masiva de selección",
|
||
bulkEditTitle: "Edición masiva de selección",
|
||
bulkEditDescription: "Establecer {count} celda(s) seleccionada(s) en este valor.",
|
||
bulkEditValuePlaceholder: "Valor, o NULL",
|
||
applyBulkEdit: "Aplicar",
|
||
cellDetails: "Detalles de celda",
|
||
cellDetailLayoutBottom: "Mover abajo",
|
||
cellDetailLayoutRight: "Mover a la derecha",
|
||
openCellDetailsDialog: "Abrir detalles de celda",
|
||
rowDetails: "Detalles de fila",
|
||
rowDetailsFor: "Detalles de fila {row}",
|
||
openRowDetailsDialog: "Abrir detalles de fila",
|
||
openColumnDetailsDialog: "Abrir detalles de columna",
|
||
columnDetailsFor: "Detalles de columna {column}",
|
||
columnsCount: "{count} columnas",
|
||
rowCount: "Filas",
|
||
rowsCount: "{count} filas",
|
||
fieldIndex: "N.º",
|
||
cellValue: "Valor",
|
||
valueEditor: "Editor de valor",
|
||
hexViewer: "Visor hexadecimal",
|
||
hexViewerByteCount: "{count} bytes",
|
||
hexViewerOffset: "Desplazamiento",
|
||
hexViewerHex: "Hex",
|
||
hexViewerAscii: "ASCII",
|
||
hexViewerEmpty: "No hay bytes binarios para mostrar.",
|
||
imagePreview: "Vista previa de imagen",
|
||
imageLoadFailed: "No se pudo cargar la imagen",
|
||
geometryPreview: "Vista previa de geometría",
|
||
layerPreview: "Vista previa de capa",
|
||
zoomIn: "Acercar",
|
||
zoomOut: "Alejar",
|
||
fitImage: "Ajustar a la vista",
|
||
openImage: "Abrir imagen",
|
||
columnName: "Columna",
|
||
columnType: "Tipo",
|
||
columnComment: "Comentario",
|
||
rowNumber: "Fila",
|
||
valueLength: "Longitud",
|
||
nullValue: "NULL",
|
||
noComment: "Sin comentario",
|
||
formattedJson: "JSON formateado",
|
||
formattedValue: "Valor formateado",
|
||
detailSearchPlaceholder: "Buscar campo o valor…",
|
||
detailSearchNoMatch: "Sin coincidencias",
|
||
rawValue: "Valor sin procesar",
|
||
largeValuePreviewHint: "Mostrando los primeros {count} caracteres. Copiar sigue usando el valor completo.",
|
||
copyValue: "Copiar valor",
|
||
downloadBinaryValue: "Descargar valor",
|
||
downloadSaved: "Guardado en {path}",
|
||
downloadStarted: "Descarga iniciada: {fileName}",
|
||
binaryDownload: {
|
||
binary: "Binario sin procesar",
|
||
utf8: "Texto decodificado (UTF-8)",
|
||
gbk: "Texto decodificado (GBK)",
|
||
},
|
||
copyRowTsv: "Copiar fila (TSV)",
|
||
copyColumnValues: "Copiar columna (JSON)",
|
||
copyColumnTsv: "Copiar columna (TSV)",
|
||
editValue: "Editar valor",
|
||
formatJson: "Formatear JSON",
|
||
formattedJsonEditWarning: "Estás editando JSON formateado. Al guardar se escribirá como JSON, por lo que el formato original puede cambiar.",
|
||
setNull: "Establecer NULL",
|
||
restoreOriginalValue: "Restaurar original",
|
||
copyColumnName: "Copiar nombre de columna",
|
||
copySqlCondition: "Copiar condición SQL",
|
||
copyAlterColumnSql: "Copiar como SQL ALTER",
|
||
alterSqlCopied: "SQL ALTER copiado al portapapeles",
|
||
alterSqlCopiedWithWarnings: "SQL ALTER copiado al portapapeles ({count} advertencia(s))",
|
||
noAlterSqlAvailable: "No hay SQL ALTER disponible para esta columna",
|
||
copyAlterSqlFailed: "Error al copiar: {message}",
|
||
transpose: "Transponer fila",
|
||
transposeMultiRowToggle: "Varias filas",
|
||
transposeSingleRow: "Fila actual",
|
||
transposeMultiRow: "Varias filas",
|
||
transposeMultiRowHint: "Cuando está activado, la vista transpuesta muestra varias filas. Cuando está desactivado, solo muestra la fila actual.",
|
||
rowsPerPageShort: " filas",
|
||
columnDetails: "Detalles de columna",
|
||
tableInfoSearch: "Buscar...",
|
||
tableInfoNoResults: "Sin resultados",
|
||
tableInfo: "Información de tabla",
|
||
tableInfoColumns: "Columnas",
|
||
tableInfoIndexes: "Índices",
|
||
tableInfoForeignKeys: "Claves foráneas",
|
||
tableInfoTriggers: "Disparadores",
|
||
tableInfoNullable: "Nulable",
|
||
tableInfoEmpty: "Sin metadatos",
|
||
queryError: "Error de consulta",
|
||
dataUnavailable: "Los datos de la tabla deben volver a cargarse.",
|
||
dataUnavailableHintPrefix: "Presiona ",
|
||
dataUnavailableHintSuffix: " o haz clic en Actualizar abajo para recargar.",
|
||
refresh: "Actualizar",
|
||
undoChange: "Deshacer cambio",
|
||
redoChange: "Rehacer cambio",
|
||
commit: "Confirmar",
|
||
rollback: "Revertir",
|
||
transactionSaveHint: "Confirma {count} cambio(s) pendiente(s) en una transacción.",
|
||
nonTransactionalSaveHint: "Guarda {count} cambio(s) pendiente(s) uno por uno. Si uno falla, los cambios anteriores correctos no se revierten.",
|
||
keylessEditWarning: "Sin clave primaria",
|
||
keylessEditWarningHint: "Esta tabla no tiene clave primaria. Las actualizaciones y eliminaciones usan todos los valores originales de la fila en WHERE; filas duplicadas exactas pueden verse afectadas juntas.",
|
||
queryEditReady: "Editable",
|
||
queryEditReadyHint: 'Este resultado de una sola tabla proviene de "{table}". Puedes editar, eliminar o agregar filas, luego usa la acción de cambios pendientes para guardar.',
|
||
queryEditReadOnly: "Resultado de solo lectura",
|
||
queryEditUnsupported: {
|
||
"not-select": "Solo los resultados de consultas SELECT pueden editarse directamente.",
|
||
cte: "Las consultas con WITH/CTE aún no son editables. Usa un SELECT simple de una sola tabla.",
|
||
"set-operation": "Los resultados de UNION, INTERSECT o EXCEPT no pueden asignarse de forma segura a las filas de origen.",
|
||
aggregation: "Los resultados con DISTINCT, GROUP BY, HAVING y agregaciones no pueden editarse directamente.",
|
||
"external-source": "Los archivos externos y los resultados de funciones de tabla no pueden escribirse directamente. Impórtalos a una tabla de base de datos antes de editarlos.",
|
||
"complex-source": "JOINs, múltiples tablas y subconsultas no pueden asignarse de forma segura a una fila de origen.",
|
||
"computed-columns": "Las expresiones calculadas o los resultados de funciones no pueden escribirse de vuelta. Selecciona nombres de columna originales.",
|
||
"no-table": "No se detectó ninguna tabla de origen editable.",
|
||
"no-primary-key": "La tabla de destino no tiene clave primaria, por lo que las filas no pueden actualizarse o eliminarse de forma segura.",
|
||
"primary-key-not-returned": "Al resultado le falta la columna de clave primaria original. Inclúyela por su nombre de columna original.",
|
||
"aliased-columns": "Las columnas de resultado usan alias o expresiones. Selecciona columnas editables por sus nombres originales.",
|
||
"metadata-unavailable": "DBX no pudo cargar los metadatos de la tabla, por lo que la edición de resultados está deshabilitada.",
|
||
},
|
||
sortUnsupported: "Este SQL no admite ordenamiento del resultado completo. Intenta con una consulta SELECT simple.",
|
||
truncatedHint: "Los resultados están limitados a 10.000 filas. Usa LIMIT/OFFSET en tu consulta para paginar.",
|
||
},
|
||
exportProgress: {
|
||
title: "Exportando datos de la tabla",
|
||
fetching: "Obteniendo datos de la base de datos...",
|
||
writing: "Escribiendo en el archivo...",
|
||
done: "¡Exportación completada!",
|
||
error: "Error de exportación",
|
||
cancelled: "Exportación cancelada.",
|
||
rowsCount: "{exported} / {total} filas",
|
||
rowsExported: "{count} filas exportadas",
|
||
rowsShort: "filas",
|
||
cancel: "Cancelar",
|
||
close: "Cerrar",
|
||
tooltip: "Progreso de exportación",
|
||
popoverTitle: "Exportaciones",
|
||
noTasks: "Sin exportaciones",
|
||
clearFinished: "Limpiar finalizados",
|
||
showMore: "Mostrar {count} más",
|
||
showLess: "Mostrar menos",
|
||
failedTooltip: "{count} tarea en segundo plano fallida | {count} tareas en segundo plano fallidas",
|
||
databaseExportTitle: "Copia de seguridad: {name}",
|
||
sqlFileTitle: "Archivo SQL: {name}",
|
||
dataTransferTitle: "Transferencia de datos: {name}",
|
||
objectsCount: "{current} / {total} objetos",
|
||
tablesCount: "{current} / {total} tablas",
|
||
statementsCount: "{done} exitosas, {failed} fallidas",
|
||
delete: "Eliminar",
|
||
},
|
||
welcome: {
|
||
title: "Espacio de trabajo de base de datos",
|
||
subtitle: "Selecciona una conexión a la izquierda para explorar el esquema, o abre una pestaña de consulta directamente.",
|
||
connections: "Conexiones",
|
||
connected: "Conectado",
|
||
databaseTypes: "Tipos de bases de datos",
|
||
quickConnections: "Inicio rápido",
|
||
quickConnectionsHint: "Haz clic en una conexión para abrir una pestaña de consulta.",
|
||
shortcuts: "Atajos",
|
||
shortcutsHint: "Inicia la siguiente acción desde aquí.",
|
||
sqlHistory: "Historial de consultas",
|
||
sqlHistoryEmpty: "Aún no hay registros de la biblioteca SQL",
|
||
sqlHistoryOpenCount: "Abierto {count} veces",
|
||
unknownConnection: "Conexión desconocida",
|
||
tip: "También puedes expandir las conexiones a la izquierda y hacer clic derecho en bases de datos o tablas para más opciones.",
|
||
tipSidebar: "Haz clic en una tabla a la izquierda para ver los datos",
|
||
tipExecute: "para ejecutar la consulta",
|
||
fileOpened: "Abierto {name}",
|
||
mcpTitle: "Integración con agentes de IA",
|
||
mcpDescription: "Además del asistente de IA integrado, puedes usar Claude Code, Cursor y otros agentes de programación para consultar tus bases de datos mediante MCP.",
|
||
mcpLearnMore: "Más información",
|
||
},
|
||
common: {
|
||
language: "Idioma",
|
||
loading: "Cargando...",
|
||
stopping: "Deteniendo...",
|
||
close: "Cerrar",
|
||
cancel: "Cancelar",
|
||
save: "Guardar",
|
||
copy: "Copiar",
|
||
import: "Importar",
|
||
remove: "Eliminar",
|
||
retry: "Reintentar",
|
||
more: "Más",
|
||
done: "Listo",
|
||
connection: "Conexión",
|
||
database: "Base de datos",
|
||
table: "Tabla",
|
||
view: "Vista",
|
||
materializedView: "Vista Materializada",
|
||
procedure: "Procedimiento",
|
||
function: "Función",
|
||
sequence: "Secuencia",
|
||
package: "Paquete",
|
||
packageBody: "Cuerpo del Paquete",
|
||
noResults: "Sin resultados",
|
||
},
|
||
quickOpen: {
|
||
placeholder: "Buscar conexiones, bases de datos, tablas y otros objetos...",
|
||
emptyPlaceholder: "Comienza a escribir para buscar",
|
||
noResults: "No se encontraron resultados",
|
||
results: "resultados",
|
||
navigate: "Navegar",
|
||
select: "Seleccionar",
|
||
close: "Cerrar",
|
||
},
|
||
explain: {
|
||
title: "Plan de ejecución",
|
||
tree: "Árbol",
|
||
summary: "Resumen",
|
||
running: "Leyendo plan de ejecución...",
|
||
empty: "Sin plan de ejecución",
|
||
nodeCount: "{count} nodos",
|
||
node: "Nodo",
|
||
relation: "Tabla",
|
||
index: "Índice",
|
||
cost: "Costo",
|
||
rows: "Filas",
|
||
details: "Detalles",
|
||
unsupported: "El plan de ejecución aún no está disponible para esta base de datos",
|
||
emptySql: "No hay SQL para analizar",
|
||
unsafe: "Esta versión solo analiza sentencias SELECT / WITH / TABLE / VALUES",
|
||
},
|
||
lineage: {
|
||
title: "Linaje de campo",
|
||
open: "Ver linaje de campo",
|
||
loading: "Leyendo metadatos {done}/{total}",
|
||
empty: "Sin linaje relacionado",
|
||
noFiltered: "Ningún resultado coincide con los filtros actuales",
|
||
targetField: "Campo actual",
|
||
searchPlaceholder: "Buscar tablas, campos, vistas o fragmentos SQL...",
|
||
showing: "Mostrando {shown}/{total} resultados",
|
||
all: "Todos",
|
||
certain: "Confirmado",
|
||
likely: "Probable",
|
||
possible: "Posible",
|
||
queryHistory: "Historial de consultas",
|
||
openTable: "Abrir tabla",
|
||
copy: "Copiar nombre",
|
||
copied: "Copiado",
|
||
kind: {
|
||
foreignKey: "Clave foránea",
|
||
viewReference: "Vista",
|
||
historyReference: "Historial SQL",
|
||
sameName: "Mismo nombre",
|
||
},
|
||
description: {
|
||
foreignKeyIncoming: "{target} apunta al campo actual mediante una clave foránea. Esta es una dependencia verificada.",
|
||
foreignKeyOutgoing: "El campo actual referencia a {target} mediante una clave foránea. Esta es una dependencia verificada.",
|
||
viewLikely: "La definición de la vista menciona tanto la tabla como el campo destino, lo que generalmente indica una dependencia de consulta.",
|
||
viewPossible: "La definición de la vista menciona un campo con el mismo nombre pero no la tabla destino, por lo que requiere confirmación.",
|
||
historyLikely: "Una sentencia SQL del historial menciona tanto la tabla como el campo destino. Úsala como contexto de análisis de impacto.",
|
||
historyPossible: "Una sentencia SQL del historial menciona un campo con el mismo nombre. Puede estar relacionado pero requiere verificación.",
|
||
sameName: "Otra tabla tiene un campo con el mismo nombre. Puede compartir significado de negocio, pero no es una dependencia verificada en la base de datos.",
|
||
},
|
||
cancel: "Cancelar",
|
||
refresh: "Analizar de nuevo",
|
||
},
|
||
connectionGroup: {
|
||
createGroup: "Nuevo grupo",
|
||
groupNamePlaceholder: "Nombre del grupo",
|
||
renameGroup: "Renombrar grupo",
|
||
deleteGroup: "Eliminar grupo",
|
||
moveToGroup: "Mover al grupo",
|
||
moveToNewGroup: "Mover a nuevo grupo",
|
||
ungrouped: "Sin grupo",
|
||
newGroup: "Nuevo grupo...",
|
||
newGroupDefault: "Nuevo grupo",
|
||
deleteGroupConfirmTitle: "Eliminar grupo",
|
||
deleteGroupConfirmMessage: '¿Eliminar el grupo "{name}"? Las conexiones dentro serán movidas al nivel superior.',
|
||
},
|
||
databaseSearch: {
|
||
title: "Buscar en base de datos",
|
||
open: "Buscar en base de datos",
|
||
keyword: "Palabra clave",
|
||
keywordPlaceholder: "Ingresa un ID de usuario, correo, número de orden...",
|
||
limitPerTable: "Por tabla",
|
||
search: "Buscar",
|
||
searching: "Buscando",
|
||
stop: "Detener",
|
||
hint: "Analiza las tablas regulares de la base de datos o esquema actual. Se omiten las columnas binarias y cada tabla tiene un límite para evitar cargar demasiados datos a la vez.",
|
||
loadingTables: "Leyendo lista de tablas...",
|
||
progress: "Analizadas {done}/{total} tablas",
|
||
resultCount: "{count} coincidencias",
|
||
limitedTables: "Esquema grande detectado; solo se analizan las primeras {count} tablas",
|
||
results: "Resultados",
|
||
openResult: "Abrir",
|
||
waiting: "Esperando coincidencias...",
|
||
noResults: "Sin coincidencias aún",
|
||
errors: "Algunas tablas fallaron",
|
||
},
|
||
configExport: {
|
||
passphraseTitle: "Cifrar y exportar",
|
||
passphraseImportTitle: "Descifrar e importar",
|
||
passphraseExportHint: "Para incluir las contraseñas de conexión en la exportación, define una frase de paso para el cifrado. Necesitarás la misma frase para importar.",
|
||
passphraseImportHint: "Este archivo está cifrado. Ingresa la frase de paso para descifrarlo e importarlo.",
|
||
passphrase: "Frase de paso",
|
||
passphraseConfirm: "Confirmar frase de paso",
|
||
passphrasePlaceholder: "Ingresa la frase de paso",
|
||
passphraseConfirmPlaceholder: "Vuelve a ingresar la frase de paso",
|
||
passphraseRequired: "La frase de paso es obligatoria",
|
||
passphraseMismatch: "Las frases de paso no coinciden",
|
||
passphraseTooShort: "La frase de paso debe tener al menos 4 caracteres",
|
||
exportEncrypted: "Exportar",
|
||
decryptImport: "Descifrar e importar",
|
||
wrongPassphrase: "Frase de paso incorrecta o archivo corrupto",
|
||
cryptoUnavailable: "La importación cifrada no está disponible en este navegador. Usa HTTPS, localhost o DBX Desktop.",
|
||
exportSuccess: "Conexiones exportadas exitosamente",
|
||
importSuccess: "Se importaron {count} conexión(es)",
|
||
importNavicatSuccess: "Se importaron {count} conexión(es) de Navicat. Completa la contraseña de las conexiones que aún la tengan vacía antes de probarlas.",
|
||
importDatagripSuccess: "Se importaron {count} conexión(es) de DataGrip, se llenaron {filled} contraseña(s) del Keychain.",
|
||
importDbeaverSuccess: "Se importaron {count} conexión(es) de DBeaver. Completa la contraseña de las conexiones que aún la tengan vacía antes de probarlas.",
|
||
importNone: "No hay nuevas conexiones para importar",
|
||
importLayoutConfirm: "El archivo importado contiene grupos de conexiones. ¿Deseas aplicarlos?",
|
||
importLayoutTitle: "Importar grupos",
|
||
importLayoutApply: "Aplicar",
|
||
},
|
||
ai: {
|
||
placeholder: "Describe tu consulta en lenguaje natural...",
|
||
settings: "Configuración de IA",
|
||
noConfig: "La IA no está configurada. Configura tu proveedor de IA en Ajustes > IA.",
|
||
provider: "Proveedor",
|
||
model: "Modelo",
|
||
browseModels: "Explorar modelos",
|
||
refreshModels: "Actualizar modelos",
|
||
loadingModels: "Cargando modelos...",
|
||
searchModels: "Buscar modelos",
|
||
noModels: "No hay modelos cargados",
|
||
modelListHint: "Pulsa actualizar para cargar los modelos del proveedor.",
|
||
modelListUnsupported: "Este proveedor no admite obtener una lista de modelos.",
|
||
modelListEndpointRequired: "Ingresa un endpoint antes de cargar modelos.",
|
||
modelListApiKeyRequired: "Ingresa una clave API antes de cargar modelos.",
|
||
codexMcpRequiredTitle: "Se requiere DBX MCP Server",
|
||
codexMcpRequiredDescription: "Codex CLI usa DBX MCP Server para acceder al esquema de la base de datos y a las herramientas de consulta. Instálalo antes de usar Codex en el asistente de IA.",
|
||
codexCliPathEnvError: "Codex CLI Path debe contener solo la ruta del ejecutable. Agrega las variables de entorno abajo.",
|
||
codexCliEnv: "Variables de entorno",
|
||
codexCliEnvAdd: "Agregar variable",
|
||
codexCliEnvHint: "Variables opcionales para Codex CLI, como HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE o CODEX_CA_CERTIFICATE.",
|
||
codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
|
||
codexCliEnvValuePlaceholder: "http://proxy:9800",
|
||
codexCliEnvInvalidName: "Nombre de variable de entorno no válido: {name}",
|
||
codexCliEnvReservedName: "{name} lo administra DBX para MCP Server y no se puede configurar aquí.",
|
||
reasoningLevel: "Nivel de razonamiento",
|
||
reasoningLevelDefault: "Predeterminado",
|
||
reasoningLevelMinimal: "Mínimo",
|
||
reasoningLevelLow: "Bajo",
|
||
reasoningLevelMedium: "Medio",
|
||
reasoningLevelHigh: "Alto",
|
||
reasoningLevelHint: "Controla model_reasoning_effort de Codex CLI. Predeterminado usa tu configuración de Codex.",
|
||
run: "Ejecutar",
|
||
readingSchema: "Leyendo esquema",
|
||
noConnection: "No hay una conexión disponible para esta pestaña",
|
||
noSql: "No hay SQL para procesar",
|
||
sqlPreview: "Vista previa de SQL",
|
||
copySql: "Copiar SQL",
|
||
copyCode: "Copiar código",
|
||
executeSql: "Ejecutar SQL",
|
||
copyAll: "Copiar todo",
|
||
copied: "Copiado",
|
||
copyTestResult: "Copiar resultado de prueba",
|
||
replace: "Reemplazar en el editor",
|
||
append: "Agregar al editor",
|
||
apply: "Aplicar al editor",
|
||
clear: "Limpiar chat",
|
||
welcome: "Dime qué quieres consultar y escribiré el SQL",
|
||
newChat: "Nuevo chat",
|
||
thinking: "Procesando...",
|
||
reasoningProcess: "Proceso de razonamiento",
|
||
stopGenerating: "Detener generación",
|
||
tableMentionEmpty: "Sin tablas coincidentes",
|
||
tableMentionPlaceholderHint: "Escribe {'@'} para mencionar tablas como contexto",
|
||
tableMentionTypes: {
|
||
table: "Tabla",
|
||
view: "Vista",
|
||
systemTable: "Tabla del sistema",
|
||
temporaryTable: "Tabla temporal",
|
||
},
|
||
modes: {
|
||
ask: "Preguntar",
|
||
agent: "Agente",
|
||
},
|
||
modeHints: {
|
||
ask: "Genera SQL y explicaciones sin ejecutarlos automáticamente",
|
||
agent: "Ejecuta consultas seguras automáticamente cuando sea posible",
|
||
},
|
||
fixWithAi: "Corregir con IA",
|
||
truncated: "Contexto truncado",
|
||
contextSummary: "{database} · {tables} tablas",
|
||
autoSqlBlocked: "El SQL generado por la IA parecía demasiado riesgoso para ejecutarse automáticamente. Revísalo manualmente antes de ejecutar.",
|
||
proposalConfirmYes: "Sí, continuar",
|
||
proposalConfirmNo: "No, gracias",
|
||
proposalConfirmTitle: "Confirmación de acción requerida",
|
||
agentSteps: {
|
||
generated: "SQL generado",
|
||
noSql: "No se encontró SQL",
|
||
safe: "Verificación de seguridad superada",
|
||
needsConfirm: "Requiere confirmación",
|
||
blocked: "Bloqueado",
|
||
autoExecute: "Listo para ejecutar",
|
||
notRequested: "No se solicitó ejecución",
|
||
skipped: "No ejecutado",
|
||
callingTool: "Llamando herramienta...",
|
||
toolDone: "Herramienta completada",
|
||
toolError: "Error de herramienta",
|
||
executeSafe: "Verificación de seguridad superada · Ejecutado",
|
||
executeBlocked: "Bloqueado por verificación de seguridad",
|
||
contextCompacted: "Contexto comprimido",
|
||
},
|
||
agentStepTitles: {
|
||
riskCheck: "Verificación de riesgo: {action} · {category} · {environment} · {reasons}",
|
||
blocked: "La ejecución fue bloqueada por la política de riesgos. Revisa el SQL manualmente.",
|
||
requiresConfirmation: "Este SQL requiere confirmación antes de ejecutarse.",
|
||
askMode: "El modo Preguntar no ejecuta SQL automáticamente.",
|
||
unsupportedAction: "La acción de IA actual no ejecuta SQL automáticamente.",
|
||
noSql: "La respuesta no incluía un bloque de código SQL ejecutable.",
|
||
notRequested: "El usuario no solicitó ejecutar el SQL.",
|
||
skipped: "Este paso no se ejecutó.",
|
||
},
|
||
proxy: "Proxy",
|
||
proxyEnable: "Enviar solicitudes de IA mediante proxy",
|
||
proxyUrl: "URL del proxy",
|
||
enableThinking: "Razonamiento",
|
||
enableThinkingOn: "Activado",
|
||
enableThinkingOff: "Desactivado",
|
||
enableThinkingHint: "Esta opción solo tiene efecto en APIs /chat/completions y modelos compatibles. Cuando está desactivado, puede reducir significativamente el uso de tokens, pero la calidad de los resultados generados puede disminuir ligeramente.",
|
||
anthropicMessagesHint: "Las API compatibles con Anthropic Messages suelen usar /v1/messages.",
|
||
contextWindow: "Ventana de contexto",
|
||
contextWindowAuto: "Auto (detectar desde el nombre del modelo)",
|
||
contextWindowHint: "Tokens. Déjalo vacío para detección automática. Configúralo manualmente para modelos locales/personalizados.",
|
||
codexCliPath: "Ruta de Codex CLI",
|
||
codexCliPathHint: "Déjalo vacío para usar codex desde PATH. Inicia sesión por separado con codex login.",
|
||
actions: {
|
||
generate: "Generar SQL",
|
||
explain: "Explicar SQL",
|
||
optimize: "Optimizar SQL",
|
||
fix: "Corregir error",
|
||
convert: "Convertir dialecto",
|
||
sampleData: "Datos de ejemplo",
|
||
},
|
||
placeholders: {
|
||
generate: "Describe lo que quieres consultar, p. ej. pedidos por usuario en los últimos 7 días",
|
||
explain: "Opcional: indica qué quieres entender",
|
||
optimize: "Opcional: indica un objetivo, p. ej. reducir los escaneos completos de tabla",
|
||
fix: "Pega el error o describe el resultado esperado",
|
||
convert: "P. ej. convertir a PostgreSQL / MySQL / SQL Server",
|
||
sampleData: "Describe los datos de ejemplo o sentencias de prueba a generar",
|
||
},
|
||
},
|
||
contextMenu: {
|
||
openConnection: "Abrir conexión",
|
||
closeConnection: "Cerrar conexión",
|
||
closeDatabaseConnection: "Cerrar conexión de base de datos",
|
||
deleteConnection: "Eliminar conexión",
|
||
deleteSelectedConnections: "Eliminar {count} conexiones seleccionadas",
|
||
confirmDeleteTitle: "Eliminar conexión",
|
||
confirmDeleteMessage: '¿Estás seguro de que deseas eliminar "{name}"? Esta acción no se puede deshacer.',
|
||
confirmDeleteSelectedMessage: "¿Eliminar las {count} conexiones seleccionadas? Esta acción no se puede deshacer.",
|
||
editConnection: "Editar conexión",
|
||
revealDatabaseFile: "Mostrar en el explorador",
|
||
selectVisibleDatabases: "Seleccionar bases visibles",
|
||
configureVisibleObjects: "Filtro de objetos visibles",
|
||
userAdmin: "Usuarios y Privilegios",
|
||
openUserAdmin: "Abrir Usuarios y Privilegios",
|
||
duplicateConnection: "Duplicar conexión",
|
||
instanceInfo: "Información de la instancia",
|
||
newQuery: "Nueva consulta",
|
||
newSql: "Nuevo SQL",
|
||
generateSql: "Generar SQL",
|
||
newInsert: "Nueva Inserción",
|
||
newUpdate: "Nueva Actualización",
|
||
sqlHistory: "Historial de consultas",
|
||
noSqlHistory: "Sin SQL relacionado",
|
||
openObjectBrowser: "Explorar objetos",
|
||
viewData: "Ver datos",
|
||
editStructure: "Editar estructura",
|
||
refreshChildren: "Actualizar",
|
||
expandAll: "Expandir todo",
|
||
pin: "Fijar",
|
||
unpin: "Desfijar",
|
||
refreshTab: "Actualizar datos",
|
||
renameTab: "Renombrar pestaña",
|
||
duplicateTab: "Duplicar pestaña",
|
||
compactTabTitle: "Acortar títulos de pestañas",
|
||
closeTab: "Cerrar pestaña",
|
||
closeOtherTabs: "Cerrar otras pestañas",
|
||
closeAllTabs: "Cerrar todas las pestañas",
|
||
copyName: "Copiar nombre",
|
||
copyFinalProxyPort: "Copiar puerto proxy final",
|
||
finalProxyPortCopied: "Puerto proxy final {port} copiado",
|
||
setDefaultDatabase: "Establecer como base de datos predeterminada",
|
||
clearDefaultDatabase: "Limpiar base de datos predeterminada",
|
||
exportDatabase: "Exportar base de datos",
|
||
exportDatabaseSuccess: "Se exportaron {count} tablas, hasta {limit} filas cada una",
|
||
exportDatabaseFailed: "Error al exportar la base de datos: {message}",
|
||
backupSqliteDatabase: "Backup SQLite Database",
|
||
backupSqliteDatabaseInProgress: "Backing up SQLite database...",
|
||
backupSqliteDatabaseSuccess: "SQLite database backed up",
|
||
backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
|
||
importData: "Importar datos",
|
||
exportData: "Exportar datos",
|
||
exportStructure: "Exportar estructura",
|
||
exportStructurePreviewTitle: "Estructura - {name}",
|
||
exportStructurePreviewTitleMultiple: "Estructura - {count} objetos",
|
||
exportStructureLoading: "Cargando estructura...",
|
||
copyStructure: "Copiar estructura",
|
||
copyStructureAs: "Copiar estructura como",
|
||
copyStructureAsTsv: "TSV (para Excel)",
|
||
copyStructureAsMarkdown: "Tabla Markdown",
|
||
structureDocTable: "Tabla",
|
||
structureDocColumn: "Columna",
|
||
structureDocType: "Tipo",
|
||
structureDocPrimaryKey: "Clave primaria",
|
||
structureDocNullable: "Permite NULL",
|
||
structureDocDefault: "Valor predeterminado",
|
||
structureDocComment: "Comentario",
|
||
structureDocYes: "Sí",
|
||
structureDocNo: "No",
|
||
structureDocCopied: "Estructura copiada",
|
||
structureDocCopyFallbackHint: "La copia automática fue bloqueada. Haz clic en Copiar de nuevo o selecciona el contenido inferior.",
|
||
saveStructure: "Guardar SQL",
|
||
exportStructureCopied: "Estructura copiada",
|
||
createTable: "Crear tabla",
|
||
createView: "Crear vista",
|
||
dropTable: "Eliminar tabla",
|
||
emptyTable: "Vaciar tabla",
|
||
truncateTable: "Truncar tabla",
|
||
duplicateStructure: "Clonar como tabla nueva",
|
||
renameObject: "Renombrar",
|
||
renameObjectTitle: "Renombrar objeto",
|
||
renameObjectNamePlaceholder: "Nuevo nombre",
|
||
renameObjectSuccess: '"{oldName}" renombrado a "{newName}"',
|
||
confirmDropTableTitle: "Eliminar tabla",
|
||
confirmDropTableMessage: '¿Estás seguro de que deseas eliminar "{name}"? Esto borrará permanentemente la tabla y todos sus datos.',
|
||
confirmEmptyTableTitle: "Vaciar tabla",
|
||
confirmEmptyTableMessage: '¿Estás seguro de que deseas eliminar todos los datos de "{name}"?',
|
||
confirmTruncateTableTitle: "Truncar tabla",
|
||
confirmTruncateTableMessage: '¿Estás seguro de que deseas truncar "{name}"? Esto eliminará todas las filas.',
|
||
dropTableSuccess: 'Tabla "{name}" eliminada',
|
||
editView: "Editar vista",
|
||
viewSource: "Ver código fuente",
|
||
viewDdl: "Ver DDL",
|
||
viewDdlLoading: "Cargando DDL...",
|
||
ddlCopied: "DDL copiado",
|
||
dropObject: "Eliminar objeto",
|
||
dropView: "Eliminar vista",
|
||
dropColumn: "Eliminar columna",
|
||
dropIndex: "Eliminar índice",
|
||
dropForeignKey: "Eliminar clave foránea",
|
||
dropTrigger: "Eliminar disparador",
|
||
batchDrop: "Eliminar seleccionados ({count})",
|
||
executeProcedure: "Ejecutar procedimiento",
|
||
confirmExecuteProcedureTitle: "Ejecutar procedimiento",
|
||
confirmExecuteProcedureMessage: '¿Ejecutar el procedimiento "{name}"? Puedes completar o ajustar los valores de los parámetros primero.',
|
||
loadingProcedureParameters: "Cargando parámetros...",
|
||
procedureParametersUnavailable: "No se pudo cargar la metadata de parámetros. Aún puedes editar el SQL inferior y ejecutarlo.",
|
||
noProcedureParameters: "No se encontraron parámetros. El SQL actual se ejecutará tal como se muestra.",
|
||
inputParameters: "{count} parámetros de entrada",
|
||
outputParameters: "{count} parámetros de salida",
|
||
parameterName: "Name",
|
||
parameterType: "Type",
|
||
parameterMode: "Mode",
|
||
parameterValue: "Value",
|
||
parameterNull: "NULL",
|
||
parameterDefault: "DEFAULT",
|
||
parameterDefaultHint: "Cuando DEFAULT está marcado, DBX omite ese argumento para que la base de datos use el valor predeterminado.",
|
||
parameterValuePlaceholder: "Ingresa un valor",
|
||
outputOnly: "Solo salida",
|
||
sqlPreview: "Vista previa SQL",
|
||
resetSqlPreview: "Restablecer SQL",
|
||
openInSqlEditor: "Abrir en editor",
|
||
dropProcedure: "Eliminar procedimiento",
|
||
dropFunction: "Eliminar función",
|
||
confirmDropViewTitle: "Eliminar vista",
|
||
confirmDropViewMessage: '¿Seguro que deseas eliminar la vista "{name}"?',
|
||
confirmDropObjectTitle: "Eliminar objeto",
|
||
confirmDropObjectMessage: '¿Seguro que deseas eliminar "{name}"?',
|
||
confirmDropColumnTitle: "Eliminar columna",
|
||
confirmDropIndexTitle: "Eliminar índice",
|
||
confirmDropForeignKeyTitle: "Eliminar clave foránea",
|
||
confirmDropTriggerTitle: "Eliminar disparador",
|
||
confirmDropTableChildObjectMessage: '¿Seguro que deseas eliminar "{name}" de "{table}"?',
|
||
confirmBatchDropTitle: "Eliminar objetos seleccionados",
|
||
confirmBatchDropMessage: "¿Seguro que deseas eliminar {count} objetos seleccionados? Esta acción no se puede deshacer.",
|
||
confirmDropProcedureTitle: "Eliminar procedimiento",
|
||
confirmDropProcedureMessage: '¿Seguro que deseas eliminar el procedimiento "{name}"?',
|
||
confirmDropFunctionTitle: "Eliminar función",
|
||
confirmDropFunctionMessage: '¿Seguro que deseas eliminar la función "{name}"?',
|
||
dropViewSuccess: 'Vista "{name}" eliminada',
|
||
dropProcedureSuccess: 'Procedimiento "{name}" eliminado',
|
||
dropFunctionSuccess: 'Función "{name}" eliminada',
|
||
dropTableChildObjectSuccess: '"{name}" eliminado',
|
||
batchDropSuccess: "{count} objetos eliminados",
|
||
emptyTableSuccess: 'Todos los datos eliminados de "{name}"',
|
||
truncateTableSuccess: 'Tabla "{name}" truncada',
|
||
duplicateStructureSuccess: 'Tabla clonada como "{name}"',
|
||
tableOperationFailed: "Error en la operación: {message}",
|
||
duplicateNameTitle: "Clonar como tabla nueva",
|
||
duplicateNamePlaceholder: "Nombre de la nueva tabla",
|
||
createDatabase: "Crear base de datos",
|
||
createDuckDbFile: "Crear archivo de base de datos",
|
||
dropDatabase: "Eliminar base de datos",
|
||
confirmDropDatabaseTitle: "Eliminar base de datos",
|
||
confirmDropDatabaseMessage: '¿Estás seguro de que deseas eliminar la base de datos "{name}"? Esto borrará permanentemente la base de datos y todos sus datos.',
|
||
createDatabaseSuccess: 'Base de datos "{name}" creada',
|
||
createDuckDbFileSuccess: 'Archivo de base de datos DuckDB "{name}" creado y adjuntado',
|
||
createDuckDbFileDesktopOnly: "Crear archivos de base de datos DuckDB solo está disponible en la app de escritorio",
|
||
dropDatabaseSuccess: 'Base de datos "{name}" eliminada',
|
||
dropCollection: "Eliminar colección",
|
||
confirmDropCollectionTitle: "Eliminar colección",
|
||
confirmDropCollectionMessage: '¿Estás seguro de que deseas eliminar la colección "{name}"? Esto borrará permanentemente la colección y todos sus documentos.',
|
||
dropCollectionSuccess: 'Colección "{name}" eliminada',
|
||
createDatabaseNamePlaceholder: "Nombre de la base de datos",
|
||
createDatabaseCharset: "Conjunto de caracteres",
|
||
createDatabaseCharsetPlaceholder: "ej. utf8mb4",
|
||
createDatabaseCharsetSearchPlaceholder: "Buscar o escribir un conjunto de caracteres",
|
||
createDatabaseCharsetEmpty: "No se encontraron conjuntos de caracteres",
|
||
createDatabaseCharsetLoading: "Cargando conjuntos de caracteres...",
|
||
createDatabaseCharsetCustomOption: 'Usar "{value}"',
|
||
createDatabaseCollation: "Cotejamiento",
|
||
createDatabaseCollationPlaceholder: "ej. utf8mb4_unicode_ci",
|
||
createDatabaseCollationSearchPlaceholder: "Buscar o escribir un cotejamiento",
|
||
createDatabaseCollationEmpty: "No se encontraron cotejamientos",
|
||
createDatabaseCollationLoading: "Cargando cotejamientos...",
|
||
createDatabaseCollationCustomOption: 'Usar "{value}"',
|
||
createSchema: "Crear esquema",
|
||
dropSchema: "Eliminar esquema",
|
||
confirmDropSchemaTitle: "Eliminar esquema",
|
||
confirmDropSchemaMessage: '¿Estás seguro de que deseas eliminar el esquema "{name}"? Esto borrará permanentemente el esquema y todos sus objetos.',
|
||
createSchemaSuccess: 'Esquema "{name}" creado',
|
||
dropSchemaSuccess: 'Esquema "{name}" eliminado',
|
||
createSchemaNamePlaceholder: "Nombre del esquema",
|
||
editSchemaComment: "Editar comentario",
|
||
editSchemaCommentTitle: 'Editar comentario: "{name}"',
|
||
schemaCommentPlaceholder: "Introduce un comentario del esquema...",
|
||
schemaCommentSaving: "Guardando...",
|
||
editSchemaCommentSuccess: 'Comentario del esquema "{name}" actualizado',
|
||
},
|
||
visibleDatabases: {
|
||
title: "Bases de datos visibles",
|
||
description: 'Elige qué bases de datos se muestran bajo "{connection}".',
|
||
searchPlaceholder: "Buscar bases de datos...",
|
||
selectedCount: "{selected}/{total} seleccionadas",
|
||
selectAll: "Seleccionar todo",
|
||
selectFiltered: "Seleccionar resultados de búsqueda",
|
||
clear: "Limpiar",
|
||
showAll: "Mostrar todo",
|
||
showSystemDatabases: "Mostrar bases de datos del sistema",
|
||
save: "Guardar",
|
||
emptySelection: "Selecciona al menos una base de datos, o usa Mostrar todo para quitar el filtro.",
|
||
loadFailed: "No se pudieron cargar las bases de datos: {message}",
|
||
},
|
||
visibleSchemas: {
|
||
title: "Filtro de Schema",
|
||
description: 'Elige qué schemas se muestran bajo "{connection}".',
|
||
searchPlaceholder: "Buscar schemas...",
|
||
selectedCount: "{selected}/{total} seleccionados",
|
||
selectAll: "Seleccionar todo",
|
||
selectFiltered: "Seleccionar resultados de búsqueda",
|
||
clear: "Limpiar",
|
||
showAll: "Mostrar todo",
|
||
save: "Guardar",
|
||
emptySelection: "Selecciona al menos un schema, o usa Mostrar todo para quitar el filtro.",
|
||
loadFailed: "No se pudieron cargar los schemas: {message}",
|
||
},
|
||
tree: {
|
||
savedSql: "Biblioteca SQL",
|
||
userAdmin: "Usuarios y Privilegios",
|
||
linkedServers: "Servidores vinculados",
|
||
defaultDatabase: "Base predeterminada",
|
||
columns: "Columnas",
|
||
indexes: "Índices",
|
||
foreignKeys: "Claves foráneas",
|
||
triggers: "Disparadores",
|
||
tables: "Tablas",
|
||
views: "Vistas",
|
||
materializedViews: "Vistas materializadas",
|
||
procedures: "Procedimientos",
|
||
functions: "Funciones",
|
||
sequences: "Secuencias",
|
||
packages: "Paquetes",
|
||
partitions: "Particiones",
|
||
loadMore: "Cargar más...",
|
||
objectBrowser: "Explorar en el navegador de objetos ({count})",
|
||
},
|
||
userAdmin: {
|
||
title: "Usuarios y Privilegios",
|
||
unsupported: "Se admiten conexiones compatibles con MySQL y PostgreSQL. Los modelos de permisos de SQL Server, Oracle y otros se pueden agregar próximamente.",
|
||
newUser: "Nuevo usuario",
|
||
anonymous: "Anónimo",
|
||
roleName: "Nombre del rol",
|
||
allowLogin: "Permitir inicio de sesión",
|
||
searchUser: "Buscar usuario o host",
|
||
loadingUsers: "Cargando usuarios...",
|
||
loadingGrants: "Cargando permisos...",
|
||
emptyUsers: "No se encontraron usuarios, o la cuenta actual no puede leer la lista de usuarios.",
|
||
pluginUnknown: "Plugin de autenticación desconocido",
|
||
grants: "Permisos",
|
||
noGrants: "No se encontraron permisos",
|
||
privilegeEditor: "Editor de privilegios",
|
||
privilegeHint: "Elige privilegios, base de datos y tabla, luego previsualiza el SQL antes de aplicar. * significa global o todas las tablas.",
|
||
database: "Base de datos",
|
||
schema: "Esquema",
|
||
table: "Tabla",
|
||
scope: "Ámbito de concesión",
|
||
scopeDatabase: "Base de datos",
|
||
scopeSchema: "Esquema",
|
||
scopeTable: "Tabla",
|
||
scopeRole: "Pertenencia a rol",
|
||
memberRole: "Rol miembro",
|
||
privileges: "Privilegios",
|
||
grantOption: "Permitir más concesiones (WITH GRANT OPTION)",
|
||
adminOption: "Permitir gestión de membresía (WITH ADMIN OPTION)",
|
||
grant: "Conceder",
|
||
revoke: "Revocar",
|
||
username: "Nombre de usuario",
|
||
host: "Host",
|
||
changePassword: "Cambiar contraseña",
|
||
newPassword: "Nueva contraseña",
|
||
lock: "Bloquear",
|
||
unlock: "Desbloquear",
|
||
disableLogin: "Deshabilitar inicio de sesión",
|
||
enableLogin: "Habilitar inicio de sesión",
|
||
dropUser: "Eliminar usuario",
|
||
previewSql: "Vista previa de SQL",
|
||
sqlPreview: "Vista previa de SQL",
|
||
applySql: "Aplicar SQL",
|
||
applySuccess: "Privilegios de usuario actualizados",
|
||
applyFailed: "Ejecución fallida: {message}",
|
||
},
|
||
objects: {
|
||
all: "Todos",
|
||
tables: "Tablas",
|
||
views: "Vistas",
|
||
procedures: "Procedimientos",
|
||
functions: "Funciones",
|
||
sequences: "Secuencias",
|
||
packages: "Paquetes",
|
||
table: "Tabla",
|
||
partitions: "{count} particiones",
|
||
view: "Vista",
|
||
procedure: "Procedimiento",
|
||
function: "Función",
|
||
sequence: "Secuencia",
|
||
package: "Paquete",
|
||
packageBody: "Cuerpo del paquete",
|
||
name: "Nombre",
|
||
type: "Tipo",
|
||
rows: "Filas",
|
||
size: "Tamaño",
|
||
statisticsHint: "Estimado desde estadísticas de la base de datos; no se ejecuta COUNT(*).",
|
||
createdAt: "Creado",
|
||
updatedAt: "Actualizado",
|
||
source: "Código fuente",
|
||
saveSource: "Guardar",
|
||
cancelEdit: "Cancelar",
|
||
sourceSaved: "Código fuente guardado",
|
||
sourceSaveFailed: "Error al guardar el código fuente: {message}",
|
||
schemaColumn: "Esquema",
|
||
comment: "Comentario",
|
||
loadingSchemas: "Cargando esquemas...",
|
||
schema: "Esquema",
|
||
search: "Buscar tablas, vistas, funciones, secuencias o procedimientos...",
|
||
loading: "Cargando objetos...",
|
||
empty: "No se encontraron objetos",
|
||
selectedTables: "{count} tablas seleccionadas",
|
||
exportSelected: "Exportar seleccionadas",
|
||
dropSelected: "Eliminar seleccionadas",
|
||
clearSelection: "Limpiar selección",
|
||
confirmBatchDropTitle: "Eliminar tablas seleccionadas",
|
||
confirmBatchDropMessage: "¿Seguro que quieres eliminar {count} tablas seleccionadas? Esta acción no se puede deshacer.",
|
||
batchDropSuccess: "{count} tablas eliminadas",
|
||
},
|
||
structureEditor: {
|
||
title: "Editar estructura de tabla",
|
||
createTitle: "Crear tabla",
|
||
editTabTitle: "Editar: {tableName}",
|
||
tableName: "Nombre de tabla",
|
||
refresh: "Actualizar estructura",
|
||
density: "Densidad",
|
||
densityCompact: "Compacta",
|
||
densityStandard: "Estándar",
|
||
densityComfortable: "Cómoda",
|
||
columns: "Columnas",
|
||
indexes: "Índices",
|
||
foreignKeys: "Claves foráneas",
|
||
triggers: "Disparadores",
|
||
ddl: "DDL",
|
||
addColumn: "Agregar columna",
|
||
columnTemplates: "Insertar campos predefinidos",
|
||
configureColumnTemplates: "Configurar campos predefinidos",
|
||
presetFieldsTemplate: "Conjunto de campos predefinidos",
|
||
addIndex: "Agregar índice",
|
||
addForeignKey: "Agregar clave foránea",
|
||
addTrigger: "Agregar disparador",
|
||
columnName: "Columna",
|
||
dataType: "Tipo",
|
||
typePlaceholder: "Seleccionar o escribir...",
|
||
noMatchingType: "Sin coincidencias",
|
||
length: "Longitud",
|
||
nullable: "Admite nulos",
|
||
primaryKey: "Clave primaria",
|
||
defaultValue: "Valor por defecto",
|
||
defaultValuePresets: "Valores predeterminados preestablecidos",
|
||
comment: "Comentario",
|
||
editComment: "Editar comentario",
|
||
commentPlaceholder: "Ingresar comentario de columna...",
|
||
tableCommentPlaceholder: "Ingresar comentario de tabla...",
|
||
tableCommentUnsupported: "La base de datos no admite comentarios de tabla",
|
||
actions: "Acciones",
|
||
indexName: "Índice",
|
||
indexColumns: "Columnas",
|
||
indexColumnsPlaceholder: "Seleccionar columnas...",
|
||
unique: "Único",
|
||
indexType: "Tipo",
|
||
includedColumns: "Incluidas",
|
||
includedColumnsPlaceholder: "Seleccionar columnas...",
|
||
filter: "Filtro",
|
||
foreignKeyName: "Clave foránea",
|
||
referencedSchema: "Esquema ref",
|
||
referencedTable: "Tabla ref",
|
||
referencedColumn: "Columna ref",
|
||
onDelete: "Al eliminar",
|
||
onUpdate: "Al actualizar",
|
||
defaultAction: "Predeterminado",
|
||
triggerName: "Disparador",
|
||
triggerStatement: "Sentencia del disparador",
|
||
primary: "Primaria",
|
||
drop: "Eliminar",
|
||
restore: "Restaurar",
|
||
remove: "Quitar",
|
||
moveColumnUp: "Mover columna arriba",
|
||
moveColumnDown: "Mover columna abajo",
|
||
yes: "Sí",
|
||
no: "No",
|
||
emptyReadonly: "Sin registros",
|
||
sqlPreview: "Vista previa de SQL",
|
||
noChanges: "Sin cambios",
|
||
apply: "Aplicar cambios",
|
||
ready: "Listo",
|
||
saved: "Estructura de tabla actualizada",
|
||
copySql: "Copiar SQL",
|
||
extendedProperties: "Extendido",
|
||
autoIncrement: "Auto Incremento",
|
||
onUpdateCurrentTimestamp: "Actualización Auto",
|
||
identity: "Identidad",
|
||
identityGeneration: "Generación",
|
||
identitySeed: "Semilla",
|
||
identityIncrement: "Incremento",
|
||
},
|
||
diagram: {
|
||
title: "Diagrama de relaciones",
|
||
open: "Ver diagrama",
|
||
selectConnection: "Seleccionar conexión",
|
||
selectDatabase: "Seleccionar base de datos",
|
||
selectSchema: "Seleccionar esquema",
|
||
searchTables: "Buscar tablas, columnas, claves...",
|
||
refresh: "Actualizar diagrama",
|
||
loading: "Leyendo relaciones...",
|
||
loadingProgress: "Leyendo relaciones... {loaded}/{total}",
|
||
partialError: "Se omitieron los metadatos de {count} tablas que no pudieron cargarse",
|
||
selectTarget: "Selecciona una conexión y base de datos",
|
||
empty: "No hay tablas para mostrar",
|
||
noMatches: "No hay tablas coincidentes",
|
||
tablesCount: "{count} tablas",
|
||
relationshipsCount: "{count} relaciones",
|
||
tableMode: "Vista de tabla",
|
||
engineeringMode: "ER de ingeniería",
|
||
allTables: "Todas las tablas",
|
||
relatedTables: "Tablas relacionadas",
|
||
moreColumns: "+ {count} columnas",
|
||
exportSvg: "Exportar SVG",
|
||
exportedSvg: "SVG exportado",
|
||
exportSvgFailed: "Error al exportar SVG: {message}",
|
||
zoomIn: "Acercar",
|
||
zoomOut: "Alejar",
|
||
resetLayout: "Restablecer diseño",
|
||
modelRelationships: "Relaciones de modelo",
|
||
copyJoinSql: "Copiar SQL",
|
||
customRelationshipsCount: "{count} modeladas",
|
||
relationshipName: "Nombre",
|
||
relationshipNamePlaceholder: "Opcional",
|
||
sourceTable: "Tabla de origen",
|
||
sourceColumn: "Columna de origen",
|
||
targetTable: "Tabla de destino",
|
||
targetColumn: "Columna de destino",
|
||
cardinality: "Cardinalidad",
|
||
cardinalityOneToMany: "1:N",
|
||
cardinalityManyToOne: "N:1",
|
||
cardinalityOneToOne: "1:1",
|
||
addRelationship: "Agregar relación",
|
||
removeRelationship: "Eliminar relación",
|
||
relationshipIncomplete: "Selecciona ambas columnas de origen y destino",
|
||
relationshipSelfInvalid: "Una relación no puede apuntar a la misma columna",
|
||
relationshipExists: "Esta relación ya existe",
|
||
relationshipAdded: "Relación agregada",
|
||
noJoinSql: "No hay SQL de relación para copiar",
|
||
},
|
||
etcd: {
|
||
prefixPlaceholder: "Prefijo, ej. /app/",
|
||
newKey: "Nueva clave",
|
||
loadingKeys: "Cargando claves...",
|
||
empty: "No se encontraron claves",
|
||
loadMore: "Cargar más",
|
||
selectKey: "Selecciona una clave para ver su valor",
|
||
loadingValue: "Cargando valor...",
|
||
notFound: "Clave no encontrada",
|
||
edit: "Editar",
|
||
editKey: "Editar clave",
|
||
delete: "Eliminar",
|
||
deleteTitle: "Eliminar clave de etcd",
|
||
keyPlaceholder: "/ruta/a/clave",
|
||
keyRequired: "La clave es obligatoria",
|
||
saved: "Clave guardada",
|
||
deleted: "Clave eliminada",
|
||
base64Readonly: "Los valores Base64 son de solo lectura en esta versión.",
|
||
},
|
||
zookeeper: {
|
||
prefixPlaceholder: "Prefijo de ruta, ej. /app/",
|
||
newKey: "Nuevo Znode",
|
||
loadingKeys: "Cargando znodes...",
|
||
empty: "No se encontraron znodes",
|
||
loadMore: "Cargar más",
|
||
selectKey: "Selecciona un znode para ver su valor",
|
||
loadingValue: "Cargando valor...",
|
||
notFound: "Znode no encontrado",
|
||
edit: "Editar",
|
||
editKey: "Editar Znode",
|
||
delete: "Eliminar",
|
||
deleteTitle: "Eliminar znode de ZooKeeper",
|
||
keyPlaceholder: "/ruta/a/znode",
|
||
keyRequired: "La ruta del znode es obligatoria",
|
||
saved: "Znode guardado",
|
||
deleted: "Znode eliminado",
|
||
base64Readonly: "Los valores Base64 son de solo lectura en esta versión.",
|
||
createMode: "Modo de creación",
|
||
createModePersistent: "Persistente",
|
||
createModeEphemeral: "Efímero",
|
||
createModePersistentSequential: "Persistente secuencial",
|
||
createModeEphemeralSequential: "Efímero secuencial",
|
||
add: "Agregar",
|
||
value: "Valor",
|
||
metadata: "Información del nodo",
|
||
prettyJson: "Bonito",
|
||
invalidJson: "JSON no válido",
|
||
summaryRevision: "rev",
|
||
summaryVersion: "ver",
|
||
summaryLease: "lease",
|
||
summarySize: "tamaño",
|
||
},
|
||
redis: {
|
||
selectKey: "Selecciona una clave para ver su valor",
|
||
noKeys: "No se encontraron claves",
|
||
noKeysInScanHint: "No se encontraron claves en el rango de escaneo actual",
|
||
pattern: "patrón (p. ej. usuario:*)",
|
||
fuzzyPattern: "la clave contiene...",
|
||
fuzzyMatch: "Difusa",
|
||
fuzzyMatchTitle: "Coincidencia difusa: busca claves que contengan texto plano",
|
||
valueSearchPlaceholder: "el valor contiene...",
|
||
allSearchPlaceholder: "la clave o el valor contiene...",
|
||
searchByKey: "Clave",
|
||
searchByValue: "Valor",
|
||
searchByAll: "Todo",
|
||
keys: "{count} claves",
|
||
loadedKeys: "{loaded} / {total} claves cargadas",
|
||
loadingKeys: "Cargando claves...",
|
||
searchingValues: "Buscando por valor...",
|
||
searchingAll: "Buscando claves y valores...",
|
||
loadMoreKeys: "Cargar más claves",
|
||
fetchAllKeys: "Cargar todas",
|
||
stopFetchAll: "Detener",
|
||
fetchAllProgress: "{loaded} de {total} claves cargadas",
|
||
fetchAllProgressUnknown: "{loaded} claves cargadas",
|
||
items: "{count} elementos",
|
||
fields: "{count} campos",
|
||
members: "{count} miembros",
|
||
loadedItems: "{loaded} de {total} elementos cargados",
|
||
loadedFields: "{loaded} de {total} campos cargados",
|
||
loadedMembers: "{loaded} de {total} miembros cargados",
|
||
entries: "{count} entradas",
|
||
noExpiry: "sin expiración",
|
||
ttlDay: "{count}d",
|
||
columnType: "Tipo",
|
||
columnKey: "Clave",
|
||
columnValue: "Valor",
|
||
columnSize: "Tamaño",
|
||
columnTTL: "TTL",
|
||
binaryStringReadonlyHint: "Los valores de cadena binaria se muestran como texto escapado en modo de solo lectura; la edición de bytes sin procesar no está disponible.",
|
||
selectedKeys: "Claves seleccionadas",
|
||
deleteGroup: "Eliminar grupo",
|
||
deleteGroupDetails: "{target}\n{count} claves",
|
||
flushDb: "Limpiar DB actual",
|
||
flushDbMessage: "Esto eliminará todas las claves de la base de datos Redis actual y no se puede deshacer. ¿Continuar?",
|
||
flushDbDetails: "Destino: Redis db{db}\nAlcance: todas las claves de la DB actual",
|
||
flushDbConfirm: "Limpiar DB",
|
||
flushDbSuccess: "Redis db{db} limpiada",
|
||
keyDetail: "Detalle de clave",
|
||
commandLine: "Línea de comandos",
|
||
selectKeyForDetail: "Selecciona una clave para ver detalles",
|
||
commandWelcome: "Bienvenido a la consola de comandos Redis",
|
||
commandPlaceholder: "Comando Redis, p. ej. GET user:1",
|
||
commandPrefix: "CMD",
|
||
commandHint: "Ingresa un comando Redis, p. ej. SMEMBERS feature:flags",
|
||
executeCommand: "Ejecutar comando",
|
||
commandEmpty: "Ingresa un comando Redis",
|
||
commandEmptyResult: "Ejecuta un comando Redis para ver el resultado",
|
||
commandBlocked: "Este comando Redis está bloqueado por seguridad",
|
||
createKey: "Crear clave",
|
||
createKeyName: "Clave",
|
||
createKeyNamePlaceholder: "user:1",
|
||
createKeyType: "Tipo",
|
||
createValue: "Valor",
|
||
createMember: "Miembro",
|
||
createField: "Campo",
|
||
createFieldPlaceholder: "name",
|
||
createScore: "Puntuación",
|
||
createKeyTtl: "TTL (segundos)",
|
||
createKeyTtlPlaceholder: "vacío = sin expiración",
|
||
createKeyAddEntry: "Agregar entrada",
|
||
createKeyEntryId: "ID de entrada",
|
||
createKeyRawMode: "Entrada bruta",
|
||
createKeyEntries: "Entradas",
|
||
createValuePlaceholder: "valor",
|
||
jsonModuleNotAvailable: "El módulo ReJSON no está cargado en este servidor Redis",
|
||
createKeySubmit: "Crear",
|
||
createKeyNameRequired: "Ingresa una clave",
|
||
createFieldRequired: "Ingresa un campo hash",
|
||
createScoreInvalid: "Ingresa una puntuación válida",
|
||
fieldRequired: "Ingresa un nombre de campo",
|
||
valueRequired: "Ingresa un valor",
|
||
memberRequired: "Ingresa un miembro",
|
||
ttlInvalid: "Ingresa un TTL válido en segundos (-1 para sin caducidad)",
|
||
member: "Miembro",
|
||
memberDetail: "Detalle del miembro",
|
||
viewMember: "Ver valor completo",
|
||
copyMember: "Copiar miembro",
|
||
copied: "Copiado",
|
||
editMember: "Editar",
|
||
jsonView: "Vista JSON",
|
||
rawContent: "Contenido original",
|
||
wordWrap: "Ajuste de línea",
|
||
clearHistory: "Borrar historial de comandos",
|
||
historyCleared: "Historial de comandos Redis borrado",
|
||
blockedCommand: "El comando {command} está bloqueado por seguridad. Desactiva el icono de escudo en la barra de herramientas para permitirlo.",
|
||
pubsub: "Pub/Sub",
|
||
pubsubConnected: "Conectado",
|
||
pubsubConnecting: "Conectando...",
|
||
pubsubDisconnected: "Desconectado",
|
||
pubsubConnect: "Conectar",
|
||
pubsubDisconnect: "Desconectar",
|
||
pubsubChannels: "Canales",
|
||
pubsubChannelPlaceholder: "Nombre del canal",
|
||
pubsubSubscribe: "Suscribirse",
|
||
pubsubPatterns: "Patrones",
|
||
pubsubPatternPlaceholder: "Patrón (ej. news:*)",
|
||
pubsubPsubscribe: "PSuscribirse",
|
||
pubsubMessages: "Mensajes",
|
||
pubsubClear: "Limpiar",
|
||
pubsubEmpty: "Sin mensajes. Suscríbete a un canal para recibir mensajes.",
|
||
pubsubPublish: "Publicar",
|
||
pubsubPublishChannel: "Canal",
|
||
pubsubPublishMessage: "Mensaje",
|
||
pubsubSend: "Enviar",
|
||
pubsubPublishFailed: "Publicación fallida: {error}",
|
||
pubsubWsConnectFailed: "Conexión WebSocket fallida: {error}",
|
||
copyInsertStatement: "Copiar sentencia INSERT",
|
||
copyInsertStatementBinary: "No se puede generar una sentencia INSERT para datos binarios",
|
||
formatJson: "Formatear",
|
||
compressJson: "Comprimir",
|
||
jsonFormatError: "Formato JSON no válido",
|
||
slowlog: "Slow Log",
|
||
slowlogCount: "Conteo",
|
||
slowlogQuery: "Consulta",
|
||
slowlogNode: "Nodo",
|
||
slowlogSelectNode: "Seleccionar un nodo",
|
||
slowlogNodeRequired: "Selecciona un nodo primero",
|
||
slowlogEmpty: "Haz clic en Consultar para obtener entradas del slow log",
|
||
slowlogFetchFailed: "Error al obtener slow log: {error}",
|
||
slowlogColumnId: "ID",
|
||
slowlogColumnTimestamp: "Marca de tiempo",
|
||
slowlogColumnDuration: "Duración (μs)",
|
||
slowlogColumnCommand: "Comando",
|
||
slowlogColumnClientAddr: "Cliente",
|
||
slowlogColumnClientName: "Nombre del cliente",
|
||
slowlogTotal: "{count} entradas",
|
||
slowlogDetailTitle: "Entrada de Slow Log #{id}",
|
||
},
|
||
mongo: {
|
||
documents: "{count} documentos",
|
||
addField: "Agregar campo",
|
||
deleteField: "Eliminar campo",
|
||
field: "Campo",
|
||
value: "Valor",
|
||
fieldPlaceholder: "Nombre del campo",
|
||
emptyCollection: "Colección vacía",
|
||
selectDocument: "Selecciona un documento",
|
||
readonlyId: "_id es de solo lectura",
|
||
invalidJsonValue: "Esta celda no contiene un valor JSON válido",
|
||
duplicateField: "Nombre de campo duplicado: {field}",
|
||
edit: "Editar",
|
||
documentView: "Vista de documento",
|
||
tableView: "Vista de tabla",
|
||
filterPlaceholder: "Filtro...",
|
||
sortPlaceholder: "Orden...",
|
||
},
|
||
vector: {
|
||
collectionFallback: "colección",
|
||
productCollection: "Colección de {product}",
|
||
browse: "Examinar",
|
||
upsert: "Upsert",
|
||
delete: "Eliminar",
|
||
reset: "Restablecer",
|
||
refresh: "Actualizar",
|
||
run: "Ejecutar",
|
||
apply: "Aplicar",
|
||
requestEditor: "Editor de solicitudes vectoriales",
|
||
operationSuccess: "Operación completada. La vista previa de la colección se ha actualizado.",
|
||
},
|
||
history: {
|
||
title: "Historial",
|
||
search: "Buscar en historial...",
|
||
empty: "Sin historial aún",
|
||
emptyFilteredRecent: "No hay registros coincidentes en las últimas 200 entradas del historial de ejecución",
|
||
failed: "Fallida",
|
||
success: "Exitosa",
|
||
restore: "Restaurar en el editor",
|
||
copy: "Copiar SQL",
|
||
delete: "Eliminar",
|
||
clear: "Limpiar historial",
|
||
viewDetails: "Ver detalles",
|
||
analyzeWithAi: "Analizar con IA",
|
||
aiAnalyzeNoConnection: "No se puede analizar esta entrada porque su conexión ya no existe.",
|
||
aiAnalysisTab: "Análisis del historial",
|
||
rollback: "Revertir",
|
||
rollbackSql: "SQL de reversión",
|
||
rollbackAvailable: "Disponible",
|
||
rollbackUnavailable: "Sin SQL de reversión",
|
||
rollbackConfirm: "¿Ejecutar el SQL de reversión generado para esta entrada del historial?",
|
||
rollbackSuccess: "Reversión ejecutada",
|
||
rollbackFailed: "Error al revertir: {message}",
|
||
confirmDelete: "¿Eliminar esta entrada del historial?",
|
||
confirmClear: "¿Limpiar todo el historial?",
|
||
filters: {
|
||
all: "Todas",
|
||
query: "Consultas",
|
||
data_change: "Cambios de datos",
|
||
schema_change: "Cambios de esquema",
|
||
failed: "Fallidas",
|
||
},
|
||
dateRange: {
|
||
title: "Rango de tiempo",
|
||
label: "Hora de ejecución:",
|
||
start: "Fecha inicial",
|
||
end: "Fecha final",
|
||
apply: "Aplicar",
|
||
clear: "Limpiar",
|
||
invalid: "La fecha inicial no puede ser posterior a la fecha final",
|
||
unboundedStart: "Inicio",
|
||
unboundedEnd: "Fin",
|
||
},
|
||
kinds: {
|
||
query: "Consulta",
|
||
data_change: "Cambio de datos",
|
||
schema_change: "Cambio de esquema",
|
||
import: "Importación",
|
||
transfer: "Transferencia",
|
||
redis_command: "Comando Redis",
|
||
},
|
||
kindShort: {
|
||
query: "SQL",
|
||
data_change: "Datos",
|
||
schema_change: "DDL",
|
||
import: "Import",
|
||
transfer: "Mover",
|
||
redis_command: "Redis",
|
||
},
|
||
detail: {
|
||
kind: "Tipo",
|
||
operation: "Operación",
|
||
connection: "Conexión",
|
||
database: "Base de datos",
|
||
target: "Destino",
|
||
time: "Hora",
|
||
duration: "Duración",
|
||
affectedRows: "Filas afectadas",
|
||
rollback: "Reversión",
|
||
status: "Estado",
|
||
error: "Error",
|
||
},
|
||
},
|
||
dangerDialog: {
|
||
title: "Operación peligrosa",
|
||
message: "Esta sentencia SQL puede modificar o eliminar datos de forma irreversible. ¿Estás seguro de que deseas ejecutarla?",
|
||
suppressFuturePrompts: "No volver a preguntar para SQL peligroso",
|
||
wrapLines: "Alternar ajuste de línea",
|
||
deleteMessage: "Esta operación de eliminación puede ser irreversible. ¿Continuar?",
|
||
deleteConfirm: "Confirmar eliminación",
|
||
deleteRowMessage: "Esta fila quedará marcada para eliminación y se borrará de la base de datos al guardar. ¿Continuar?",
|
||
deleteRowsMessage: "Estas {count} filas se marcarán para eliminación y se eliminarán de la base de datos después de guardar. ¿Continuar?",
|
||
deleteRowDetails: "Tabla: {table}",
|
||
deleteRowDetailsNoTable: "Fila actual del resultado",
|
||
redisKeyDetails: "Clave Redis: {key}",
|
||
redisHashFieldDetails: "Hash Redis: {key}\nCampo: {field}",
|
||
redisListItemDetails: "Lista Redis: {key}\nÍndice: {index}",
|
||
redisSetMemberDetails: "Conjunto Redis: {key}\nMiembro: {member}",
|
||
mongoDocumentDetails: "Colección MongoDB: {collection}\nDocumento _id: {id}",
|
||
mongoFieldDetails: "Campo: {field}",
|
||
mongoArrayItemDetails: "Índice del elemento del arreglo: {index}",
|
||
cancel: "Cancelar",
|
||
confirm: "Ejecutar",
|
||
},
|
||
sqlParameters: {
|
||
title: "Parámetros SQL",
|
||
description: "Completa valores para marcadores de plantilla SQL. DBX los reemplaza antes de ejecutar el SQL.",
|
||
name: "Parámetro",
|
||
type: "Tipo",
|
||
value: "Valor",
|
||
valuePlaceholder: "Introduce un valor",
|
||
preview: "Vista previa SQL",
|
||
execute: "Ejecutar",
|
||
kind: {
|
||
string: "Cadena",
|
||
number: "Número",
|
||
boolean: "Booleano",
|
||
null: "NULL",
|
||
raw: "SQL sin procesar",
|
||
},
|
||
},
|
||
transfer: {
|
||
title: "Transferencia de datos",
|
||
source: "Origen",
|
||
target: "Destino",
|
||
sourceConnection: "Conexión de origen",
|
||
sourceDatabase: "Base de datos de origen",
|
||
targetConnection: "Conexión de destino",
|
||
targetDatabase: "Base de datos de destino",
|
||
tables: "Tablas",
|
||
selectAll: "Seleccionar todas",
|
||
deselectAll: "Deseleccionar todas",
|
||
createTable: "Crear tabla si no existe",
|
||
transferMode: "Modo de transferencia",
|
||
modeAppend: "Agregar (INSERT)",
|
||
modeOverwrite: "Sobrescribir (TRUNCATE + INSERT)",
|
||
modeUpsert: "Upsert (INSERT o UPDATE por PK)",
|
||
targetTableNameCase: "Mayúsculas/minúsculas de tabla destino",
|
||
tableNameCasePreserve: "Conservar",
|
||
tableNameCaseLower: "Convertir a minúsculas",
|
||
tableNameCaseUpper: "Convertir a mayúsculas",
|
||
batchSize: "Tamaño de lote",
|
||
start: "Iniciar transferencia",
|
||
cancel: "Cancelar",
|
||
progress: "Transfiriendo...",
|
||
transferring: "Transfiriendo {table}...",
|
||
completed: "Transferencia completada",
|
||
completedWithErrors: "Completada con {count} tabla con error | Completada con {count} tablas con error",
|
||
failed: "Error en la transferencia",
|
||
cancelled: "Transferencia cancelada",
|
||
rowsTransferred: "{count} filas transferidas",
|
||
tableProgress: "{current} / {total} tablas",
|
||
noSqlConnections: "No hay conexiones SQL disponibles",
|
||
selectTables: "Selecciona las tablas a transferir",
|
||
searchTables: "Buscar tablas...",
|
||
noTables: "Sin tablas",
|
||
selectSourceFirst: "Selecciona primero la conexión y base de datos de origen",
|
||
tableError: "Error en tabla {table}: {error}",
|
||
overallProgress: "Progreso general",
|
||
dataTransfer: "Transferencia de datos",
|
||
sourceSchema: "Esquema de origen",
|
||
targetSchema: "Esquema de destino",
|
||
runInBackground: "Ejecutar en segundo plano",
|
||
newTask: "Nueva transferencia",
|
||
editConfig: "Editar config",
|
||
retry: "Reintentar",
|
||
targetTableBusy: "Otra transferencia ya está escribiendo en la(s) tabla(s) de destino: {tables}",
|
||
selectConnection: "Seleccionar conexión",
|
||
selectDatabase: "Seleccionar base de datos",
|
||
selectSchema: "Seleccionar esquema",
|
||
searchConnection: "Buscar conexiones...",
|
||
searchDatabase: "Buscar bases de datos...",
|
||
searchSchema: "Buscar esquemas...",
|
||
},
|
||
tableImport: {
|
||
title: "Importar datos a tabla",
|
||
target: "Tabla destino",
|
||
selectFile: "Seleccionar archivo",
|
||
file: "Archivo",
|
||
rows: "Filas",
|
||
mapped: "Mapeadas",
|
||
mapping: "Mapeo de columnas",
|
||
skipColumn: "Omitir",
|
||
preview: "Vista previa",
|
||
mode: "Modo de importación",
|
||
append: "Agregar datos",
|
||
truncate: "Truncar e importar",
|
||
progress: "Progreso",
|
||
start: "Iniciar importación",
|
||
success: "Se importaron {count} filas",
|
||
},
|
||
dataGenerate: {
|
||
title: "Generación de datos",
|
||
target: "Destino",
|
||
rowCount: "Filas a generar",
|
||
columns: "Columnas",
|
||
column: "Columna",
|
||
type: "Tipo",
|
||
generator: "Generador",
|
||
columnProps: "Propiedades de columna",
|
||
databaseObjects: "Objetos de base de datos",
|
||
selectTable: "Seleccione una tabla a la izquierda",
|
||
saveProfile: "Guardar perfil",
|
||
loadProfile: "Cargar perfil",
|
||
options: "Opciones",
|
||
generateOrder: "Orden de generación",
|
||
nextStep: "Siguiente",
|
||
insertSuccess: "Se insertaron {count} filas",
|
||
noData: "No data yet, please configure generation rules first",
|
||
noResult: "No execution results",
|
||
regenerate: "Regenerate",
|
||
first50Rows: "Showing first 50 rows, total {count} rows",
|
||
resultTitle: "Resultados de ejecución",
|
||
successLabel: "{count} exitosas",
|
||
failLabel: "{count} fallidas",
|
||
totalLabel: "/ {count} filas",
|
||
copyAllSql: "Copy All SQL",
|
||
prevStep: "Anterior",
|
||
startInsert: "Start Insert",
|
||
confirm: "Confirmar",
|
||
back: "Volver",
|
||
reset: "Reset",
|
||
selectGenerator: "Select a generator...",
|
||
selectGeneratorHint: "Please select a generator",
|
||
preview: "Preview",
|
||
noValue: "(ninguno)",
|
||
startDate: "Start Date",
|
||
endDate: "End Date",
|
||
allDay: "All day",
|
||
startTime: "Start Time",
|
||
endTime: "End Time",
|
||
weekday: "Weekday",
|
||
all: "All",
|
||
weekdayOnly: "Weekdays",
|
||
custom: "Custom",
|
||
values: "Values",
|
||
min: "Min",
|
||
max: "Max",
|
||
increment: "Incremento",
|
||
cycle: "Cycle when exceeded",
|
||
includeDefault: "Include DEFAULT",
|
||
includeNull: "Include NULL",
|
||
unique: "Set unique",
|
||
disableLinks: "Disable data links between columns",
|
||
imageMode: "Mode",
|
||
generate: "Generate",
|
||
fromFolder: "From folder",
|
||
imageWidth: "Image Width",
|
||
imageHeight: "Image Height",
|
||
imageFormat: "Image Format",
|
||
folderPath: "Folder Path",
|
||
filterByExtension: "Filter by extensions",
|
||
errorContinue: "Continue on error",
|
||
truncateBefore: "Truncate table before generation",
|
||
useTransaction: "Use transaction",
|
||
extendedInsert: "Use extended INSERT",
|
||
ok: "OK",
|
||
noTablesSelected: "No tables selected",
|
||
orderHint: "Use arrow buttons to reorder",
|
||
gen: {
|
||
general: "General",
|
||
personal: "Personal",
|
||
payment: "Payment",
|
||
business: "Business",
|
||
location: "Location",
|
||
product: "Product",
|
||
computer: "Computer",
|
||
number: "Number",
|
||
datetime: "Date Time",
|
||
date: "Date",
|
||
time: "Time",
|
||
sequence: "Sequence",
|
||
enum: "Enum",
|
||
text: "Text",
|
||
image: "Image or Binary",
|
||
foreign_key: "Foreign Key",
|
||
uuid: "UUID",
|
||
regex: "Regex",
|
||
full_name: "Full Name",
|
||
gender: "Gender",
|
||
title: "Title",
|
||
marital_status: "Marital Status",
|
||
phone: "Phone",
|
||
email: "Email",
|
||
job_title: "Job Title",
|
||
social_id: "Social ID",
|
||
payment_method: "Payment Method",
|
||
credit_card_type: "Credit Card Type",
|
||
credit_card_number: "Credit Card Number",
|
||
credit_card_date: "Credit Card Date",
|
||
company_name: "Company Name",
|
||
department: "Department",
|
||
industry: "Industry",
|
||
address: "Address",
|
||
city: "City",
|
||
region: "Region",
|
||
product_name: "Product Name",
|
||
product_category: "Product Category",
|
||
color: "Color",
|
||
size: "Size",
|
||
weight_unit: "Weight Unit",
|
||
barcode: "Barcode",
|
||
sku: "SKU",
|
||
ip_address: "IP Address",
|
||
mac_address: "MAC Address",
|
||
file_path: "File Path",
|
||
file_name: "File Name",
|
||
file_extension: "File Extension",
|
||
url: "URL",
|
||
hostname: "Hostname",
|
||
id_number: "Número de documento",
|
||
},
|
||
idTypes: {
|
||
title: "Tipo de documento",
|
||
customPattern: "Patrón personalizado",
|
||
customPatternPlaceholder: "p. ej. ([A-Z]{2})-([0-9]{8})",
|
||
customPatternHint: "Admite patrones simples como [A-Z] letras, [0-9] dígitos, {n} repeticiones, guiones",
|
||
id_card: "DNI chino",
|
||
passport: "Pasaporte",
|
||
hk_macau_pass: "Permiso HK/Macao",
|
||
taiwan_pass: "Permiso Taiwán",
|
||
uscc: "Código social unificado",
|
||
bank_card: "Tarjeta bancaria",
|
||
drivers_license: "Carnet de conducir",
|
||
custom: "Personalizado",
|
||
},
|
||
},
|
||
tableToolbox: {
|
||
title: "Herramientas de datos",
|
||
generateData: "Generar datos",
|
||
importData: "Importar datos",
|
||
exportData: "Exportar datos",
|
||
generateDataComingSoon: "Próximamente",
|
||
},
|
||
sqlFile: {
|
||
title: "Ejecutar archivo SQL",
|
||
file: "Archivo",
|
||
selectSqlFile: "Seleccionar archivo SQL",
|
||
browse: "Examinar",
|
||
previewingLines: "Vista previa de {count} líneas",
|
||
previewingFirstLines: "Vista previa de las primeras {count} líneas",
|
||
target: "Destino",
|
||
connection: "Conexión",
|
||
selectConnection: "Seleccionar conexión",
|
||
database: "Base de datos",
|
||
selectDatabase: "Seleccionar base de datos",
|
||
databasePlaceholder: "Nombre de la base de datos",
|
||
options: "Opciones",
|
||
continueOnError: "Continuar en caso de error",
|
||
runInBackground: "Ejecutar en segundo plano",
|
||
cancelling: "Cancelando...",
|
||
cancel: "Cancelar",
|
||
execute: "Ejecutar",
|
||
statement: "Sentencia",
|
||
succeeded: "Exitosa",
|
||
failed: "Fallida",
|
||
affectedRows: "Filas afectadas",
|
||
currentStatement: "Sentencia actual",
|
||
status: {
|
||
idle: "Inactivo",
|
||
started: "Iniciado",
|
||
running: "En ejecución",
|
||
statementDone: "Sentencia completada",
|
||
statementFailed: "Sentencia fallida",
|
||
done: "Completado",
|
||
error: "Error",
|
||
cancelled: "Cancelado",
|
||
},
|
||
},
|
||
diff: {
|
||
title: "Comparar esquemas",
|
||
source: "Origen",
|
||
target: "Destino",
|
||
selectConnection: "Seleccionar conexión",
|
||
selectDatabase: "Seleccionar base de datos",
|
||
selectSchema: "Seleccionar esquema",
|
||
connection: "Conexión",
|
||
database: "Base de datos",
|
||
schema: "Esquema",
|
||
recentConfigs: "Configs recientes",
|
||
selectRecentConfig: "Seleccionar config reciente",
|
||
ignoreComments: "Ignorar diferencias de comentarios",
|
||
compare: "Comparar",
|
||
comparing: "Comparando esquemas...",
|
||
noDifferences: "No se encontraron diferencias",
|
||
table: "Tabla",
|
||
status: "Estado",
|
||
details: "Detalles",
|
||
added: "Agregada",
|
||
removed: "Eliminada",
|
||
modified: "Modificada",
|
||
indexes: "Índices",
|
||
foreignKeys: "Claves foráneas",
|
||
triggers: "Disparadores",
|
||
comments: "Comentarios",
|
||
newTable: "Nueva tabla",
|
||
dropTable: "Eliminar tabla",
|
||
generatedSql: "SQL de sincronización",
|
||
copySql: "Copiar SQL",
|
||
executeSync: "Ejecutar sincronización",
|
||
syncSuccess: "Sincronización ejecutada exitosamente",
|
||
swap: "Intercambiar origen y destino",
|
||
syncProgress: "Ejecutando: {current}/{total}",
|
||
syncSummary: "Exitosos {success}, fallidos {failed}",
|
||
configSaved: "Config guardada",
|
||
configDeleted: "Config eliminada",
|
||
sourceObject: "Objeto de origen",
|
||
targetObject: "Objeto de destino",
|
||
operation: "Operación",
|
||
selectedCount: "{selected} seleccionados de {total}",
|
||
saveConfig: "Guardar config",
|
||
loadConfig: "Cargar config",
|
||
options: "Opciones",
|
||
ddlCompare: "DDL comparar",
|
||
deployScript: "Script de despliegue",
|
||
deployScriptAll: "Todos los scripts de despliegue",
|
||
deployScriptDesc: "Script SQL para el objeto seleccionado",
|
||
deployScriptAllDesc: "Script SQL para todos los objetos seleccionados",
|
||
copy: "Copiar",
|
||
execute: "Ejecutar",
|
||
executeAll: "Ejecutar todo",
|
||
executeSuccess: "Ejecutado exitosamente",
|
||
selectObjectToCompare: "Selecciona un objeto para ver la comparación DDL",
|
||
noDdlAvailable: "No hay DDL disponible",
|
||
noDeployScript: "No hay script de despliegue",
|
||
noDeployScriptAll: "No hay script de despliegue para los objetos seleccionados",
|
||
sourceDdl: "DDL de origen",
|
||
targetDdl: "DDL de destino",
|
||
objectNotExistsInSource: "Este objeto no existe en la base de datos de origen",
|
||
objectNotExistsInTarget: "Este objeto no existe en la base de datos de destino",
|
||
nextStepDeploy: "Siguiente (Revisar despliegue)",
|
||
deployReview: "Revisión de despliegue",
|
||
backToResult: "Volver al resultado",
|
||
copyScript: "Copiar script",
|
||
exportSql: "Exportar .sql",
|
||
deployToServer: "Desplegar en servidor",
|
||
deployConfirmTitle: "Confirmación final",
|
||
deployConfirmMessage: "Estás a punto de desplegar los siguientes cambios en la base de datos de destino",
|
||
targetServer: "Servidor de destino",
|
||
dbVersion: "Versión de base de datos",
|
||
targetDatabase: "Base de datos de destino",
|
||
targetSchema: "Esquema de destino",
|
||
useTransaction: "Ejecutar en transacción (reversión automática en caso de error)",
|
||
confirmDeploy: "Confirmar despliegue",
|
||
exportSuccess: "Exportación exitosa",
|
||
create: "Crear",
|
||
delete: "Eliminar",
|
||
modify: "Modificar",
|
||
cancel: "Cancelar",
|
||
prevStep: "Anterior",
|
||
recompare: "Comparar de nuevo",
|
||
maximize: "Maximizar",
|
||
restore: "Restaurar",
|
||
operationLabel: {
|
||
modify: "Objetos a modificar",
|
||
create: "Objetos a crear",
|
||
delete: "Objetos a eliminar",
|
||
none: "Sin operación",
|
||
},
|
||
objectKindLabel: {
|
||
table: "Tabla",
|
||
view: "Vista",
|
||
function: "Función",
|
||
sequence: "Secuencia",
|
||
rule: "Regla",
|
||
owner: "Propietario",
|
||
index: "Índice",
|
||
foreignKey: "Clave foránea",
|
||
trigger: "Disparador",
|
||
},
|
||
noObjectsSelected: "Selecciona objetos para desplegar",
|
||
deploySuccess: "Despliegue exitoso",
|
||
deployFailed: "Despliegue fallido",
|
||
deploySuccessMessage: "Script SQL ejecutado exitosamente en la base de datos de destino",
|
||
deployFailedMessage: "Ocurrió un error durante la ejecución",
|
||
affectedRows: "Filas afectadas",
|
||
executedStatements: "Sentencias ejecutadas",
|
||
serverVersion: "Versión del servidor",
|
||
info: "Información",
|
||
connType: "Tipo de conexión",
|
||
connName: "Nombre de conexión",
|
||
host: "Host",
|
||
port: "Puerto",
|
||
copied: "Copiado al portapapeles",
|
||
saveConfigPrompt: "Por favor ingresa el nombre de la config:",
|
||
close: "Cerrar",
|
||
searchConnection: "Buscar conexiones...",
|
||
searchDatabase: "Buscar bases de datos...",
|
||
searchSchema: "Buscar esquemas...",
|
||
},
|
||
schemaDiff: {
|
||
optionsTitle: "Opciones de comparación",
|
||
selectConfig: "Select config",
|
||
newConfigName: "New Config",
|
||
newConfig: "New Config",
|
||
renameConfig: "Rename Config",
|
||
duplicateConfig: "Duplicate Config",
|
||
deleteConfig: "Delete Config",
|
||
exportConfig: "Export Config",
|
||
exportAllConfigs: "Export All Configs",
|
||
importConfig: "Import Config",
|
||
importFromFile: "Import from File",
|
||
importFromText: "Import from Text",
|
||
importPlaceholder: "Paste JSON config...",
|
||
importInvalidJson: "Invalid JSON format",
|
||
configName: "Config Name",
|
||
tableFilter: "Table filter",
|
||
tableFilterHint: "Matches table names with JavaScript regex. Empty include means all tables; empty exclude means no exclusions.",
|
||
tableFilterHintShort: "Limit compare by table name regex",
|
||
tableFilterHelp: "Table filter help",
|
||
tableFilterHelpRule: "Matches full table names. Do not type /.../.",
|
||
tableFilterHelpBlank: "Blank include means all tables. Blank skip means no exclusions.",
|
||
tableFilterHelpExample: "^user_ means starts with user_; _bak$ means ends with _bak; a|b means a or b.",
|
||
tableIncludePattern: "Include table regex",
|
||
tableIncludePatternPlaceholder: "e.g. ^user_",
|
||
tableExcludePattern: "Exclude table regex",
|
||
tableExcludePatternPlaceholder: "e.g. _bak$",
|
||
tableFilterPriority: "When both match",
|
||
tableFilterPriorityExclude: "Exclude wins",
|
||
tableFilterPriorityInclude: "Include wins",
|
||
options: {
|
||
tables: "Compare tables",
|
||
primaryKeys: "Compare primary keys",
|
||
foreignKeys: "Compare foreign keys",
|
||
uniqueKeys: "Compare unique keys",
|
||
checks: "Compare check constraints",
|
||
exclusions: "Compare exclusion constraints",
|
||
views: "Compare views",
|
||
functions: "Compare functions",
|
||
indexes: "Compare indexes",
|
||
sequences: "Compare sequences",
|
||
triggers: "Compare triggers",
|
||
rules: "Compare rules",
|
||
owners: "Compare owners",
|
||
cascadeDelete: "Use CASCADE delete",
|
||
sequenceLastValues: "Compare sequence last values",
|
||
compareColumnOrder: "Compare column order",
|
||
},
|
||
},
|
||
dataCompare: {
|
||
title: "Comparar datos",
|
||
selectTable: "Seleccionar tabla",
|
||
searchTable: "Buscar tablas...",
|
||
sourceTables: "Tablas de origen",
|
||
targetTable: "Tabla de destino",
|
||
searchTables: "Buscar tablas...",
|
||
selectedTables: "{selected}/{total} seleccionadas",
|
||
selectAllTables: "Seleccionar todo",
|
||
deselectAllTables: "Deseleccionar todo",
|
||
selectSourceTables: "Selecciona primero la conexión y base de datos de origen, luego las tablas a comparar",
|
||
noTables: "No hay tablas disponibles para comparar",
|
||
autoMatchHint: "El modo por lotes empareja automáticamente tablas de destino con el mismo nombre",
|
||
matchedTables: "{matched}/{total} tablas emparejadas",
|
||
missingTargetTables: "Faltan tablas de destino con el mismo nombre: {tables}",
|
||
keyColumns: "Columnas clave",
|
||
keyColumnsPlaceholder: "Columnas primarias o únicas separadas por comas",
|
||
keyColumnsAutoHint: "Déjalo vacío para detectar claves primarias automáticamente en comparación simple o por tabla en lote.",
|
||
rowCounts: "Origen {source} filas, destino {target} filas; comparación completa terminada",
|
||
previewLimitOption: "Vista previa {count}",
|
||
compare: "Comparar datos",
|
||
summary: "Agregadas {added}, eliminadas {removed}, modificadas {modified}",
|
||
batchSummary: "Se compararon {tables} tablas: {different} con diferencias, {same} iguales, {failed} con error; agregadas {added}, eliminadas {removed}, modificadas {modified}",
|
||
comparingTable: "Comparando {current}/{total}: {table}",
|
||
keyColumnsInline: "Columnas clave: {columns}",
|
||
selectedInline: "Seleccionadas {selected}/{total}",
|
||
selectedSummary: "Seleccionado: agregadas {added}, eliminadas {removed}, modificadas {modified}",
|
||
selectAllKind: "Seleccionar todas las {kind}",
|
||
clearKind: "Limpiar {kind}",
|
||
clearSelection: "Limpiar toda la selección",
|
||
showAllRows: "Mostrar las {count}",
|
||
showLessRows: "Mostrar menos",
|
||
remainingRows: "Quedan {count} filas fuera de la vista previa",
|
||
planningSync: "Actualizando el plan de sincronización...",
|
||
noSelectedDifferences: "No hay diferencias seleccionadas para ejecutar",
|
||
planSummary: "Plan: {inserts} inserciones, {updates} actualizaciones, {deletes} eliminaciones, {statements} sentencias",
|
||
statusDifferent: "Con diferencias",
|
||
statusSame: "Igual",
|
||
statusError: "Error",
|
||
noKeyColumns: "Selecciona al menos una columna clave",
|
||
missingKeyColumns: "Las columnas clave deben existir en las tablas de origen y destino: {columns}",
|
||
noCommonColumns: "Las tablas de origen y destino no tienen columnas en común para comparar",
|
||
targetTableMissing: "No se encontró la tabla de destino: {table}",
|
||
noComparableTables: "No se encontraron tablas comparables. Verifica si existen tablas de destino con el mismo nombre.",
|
||
noDifferences: "Los datos son idénticos, no se necesita SQL de sincronización",
|
||
syncSuccess: "Sincronización de datos ejecutada exitosamente",
|
||
},
|
||
settings: {
|
||
title: "Configuración",
|
||
editorTab: "Editor",
|
||
sqlFormatterTab: "Formateador SQL",
|
||
sqlFormatterImport: "Importar configuración",
|
||
sqlFormatterExport: "Exportar configuración",
|
||
sqlFormatterImportSuccess: "Configuración del formateador importada.",
|
||
sqlFormatterCopyJson: "Copiar JSON",
|
||
sqlFormatterCopyJsonSuccess: "JSON copiado.",
|
||
sqlFormatterCopyJsonFailed: "Error al copiar: {message}",
|
||
sqlFormatterJsonEditorLoadFailed: "No se pudo cargar el editor JSON. Se cambió a una entrada básica: {message}",
|
||
sqlFormatterRestoreDefaults: "Restaurar valores por defecto",
|
||
sqlFormatterFormMode: "Formulario",
|
||
sqlFormatterJsonMode: "JSON",
|
||
sqlFormatterKeywordCase: "Mayúsculas/minúsculas de palabras clave",
|
||
sqlFormatterFunctionCase: "Mayúsculas/minúsculas de funciones",
|
||
sqlFormatterDataTypeCase: "Mayúsculas/minúsculas de tipos de datos",
|
||
sqlFormatterIdentifierCase: "Mayúsculas/minúsculas de identificadores",
|
||
sqlFormatterCaseUpper: "Mayúsculas",
|
||
sqlFormatterCaseLower: "Minúsculas",
|
||
sqlFormatterCasePreserve: "Conservar",
|
||
sqlFormatterIndent: "Sangría",
|
||
sqlFormatterIndentSpaces: "Espacios",
|
||
sqlFormatterIndentTabs: "Tabulaciones",
|
||
sqlFormatterTabWidth: "Ancho de tabulación",
|
||
sqlFormatterIndentStyle: "Estilo de sangría",
|
||
sqlFormatterIndentStyleStandard: "Estándar",
|
||
sqlFormatterIndentStyleTabularLeft: "Tabular izquierda",
|
||
sqlFormatterIndentStyleTabularRight: "Tabular derecha",
|
||
sqlFormatterLogicalOperatorNewline: "Salto de línea en operador lógico",
|
||
sqlFormatterLogicalBefore: "Antes del operador",
|
||
sqlFormatterLogicalAfter: "Después del operador",
|
||
sqlFormatterExpressionWidth: "Ancho de expresión",
|
||
sqlFormatterLinesBetweenQueries: "Líneas entre consultas",
|
||
sqlFormatterDenseOperators: "Operadores compactos",
|
||
sqlFormatterNewlineBeforeSemicolon: "Punto y coma en nueva línea",
|
||
sqlFormatterAdvancedOptions: "Opciones avanzadas",
|
||
sqlFormatterParams: "Parámetros",
|
||
sqlFormatterParamTypes: "Tipos de parámetro",
|
||
sqlFormatterEditorShortcuts: "Atajos",
|
||
sqlFormatterShortcutAction: "Acción",
|
||
sqlFormatterShortcutEnabled: "Activo",
|
||
sqlFormatterShortcutWindows: "Windows",
|
||
sqlFormatterShortcutLinux: "Linux",
|
||
sqlFormatterShortcutMacos: "macOS",
|
||
sqlFormatterShortcutFind: "Buscar",
|
||
sqlFormatterShortcutReplace: "Reemplazar",
|
||
sqlFormatterShortcutIndentMore: "Aumentar sangría",
|
||
sqlFormatterShortcutIndentLess: "Reducir sangría",
|
||
sqlFormatterShortcutDuplicateLine: "Duplicar línea actual",
|
||
sqlFormatterShortcutDeleteLine: "Eliminar línea actual",
|
||
sqlFormatterShortcutMoveLine: "Mover línea",
|
||
sqlFormatterShortcutMoveLineUp: "Mover línea arriba",
|
||
sqlFormatterShortcutMoveLineDown: "Mover línea abajo",
|
||
sqlFormatterShortcutCopyLine: "Copiar línea",
|
||
sqlFormatterShortcutCopyLineUp: "Copiar línea arriba",
|
||
sqlFormatterShortcutCopyLineDown: "Copiar línea abajo",
|
||
sqlFormatterShortcutUndo: "Deshacer",
|
||
sqlFormatterShortcutRedo: "Rehacer",
|
||
sqlFormatterShortcutSelectAll: "Seleccionar todo",
|
||
sqlFormatterShortcutFormatJson: "Formatear JSON",
|
||
sqlFormatterShortcutApply: "Aplicar configuración",
|
||
sqlFormatterConfigErrorInvalidJson: "JSON no válido.",
|
||
sqlFormatterConfigErrorObject: "La configuración debe ser un objeto JSON.",
|
||
sqlFormatterConfigErrorVersion: "Versión de configuración no compatible.",
|
||
sqlFormatterConfigErrorFormatter: "Formateador no compatible.",
|
||
sqlFormatterConfigErrorUnsupportedParams: "La sustitución params no es compatible. El formateo SQL no reemplazará marcadores.",
|
||
sqlFormatterConfigErrorOptionsObject: "Las opciones de configuración deben ser un objeto JSON.",
|
||
sqlFormatterConfigErrorEditorObject: "La configuración del editor debe ser un objeto JSON.",
|
||
sqlFormatterConfigErrorEditorScope: "Ámbito de editor no compatible.",
|
||
sqlFormatterConfigErrorEditorPlatforms: "Plataformas de editor no válidas.",
|
||
sqlFormatterConfigErrorEditorShortcutsArray: "Los atajos del editor deben ser un array.",
|
||
sqlFormatterConfigErrorEditorShortcutValue: "Atajo de editor no válido.",
|
||
sqlFormatterConfigErrorUnknownOption: "Opción desconocida del formateador: {option}.",
|
||
sqlFormatterConfigErrorInvalidOptionValue: "Valor no válido para {option}.",
|
||
sqlFormatterConfigErrorUnknownEditorShortcut: "Atajo de editor desconocido: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidEditorShortcut: "Atajo de editor no válido: {shortcut}.",
|
||
sqlFormatterConfigErrorDuplicateEditorShortcut: "Atajo de editor duplicado: {shortcut}.",
|
||
sqlFormatterConfigErrorInvalidConfig: "Configuración del formateador no válida.",
|
||
appearanceTab: "Apariencia",
|
||
navigationTab: "Navegación",
|
||
dataTab: "Datos",
|
||
redisTab: "Redis",
|
||
shortcutsTab: "Atajos",
|
||
snippetsTab: "Fragmentos",
|
||
syncTab: "Sync",
|
||
aiTab: "IA",
|
||
mcpTab: "MCP",
|
||
jdbcTab: "Drivers JDBC",
|
||
securityTab: "Seguridad",
|
||
aboutTab: "Acerca de",
|
||
fontFamily: "Familia tipográfica",
|
||
selectFont: "Seleccionar fuente...",
|
||
searchFont: "Buscar fuentes...",
|
||
loadingFonts: "Cargando fuentes...",
|
||
noFontsFound: "No se encontraron fuentes",
|
||
useCustomFont: "Usar “{font}”",
|
||
languageTitle: "Idioma / Language",
|
||
fontSize: "Tamaño de fuente",
|
||
toolbarTitle: "Barra de herramientas",
|
||
toolbarHiddenHint: "Los botones ocultos de la izquierda aparecerán en el menú «Más».",
|
||
uiScale: "Escala de interfaz",
|
||
uiScaleDescription: "Escala toda la interfaz de escritorio para pantallas de alta densidad. Los cambios se aplican al instante y se restauran al volver a abrir.",
|
||
theme: "Tema",
|
||
selectTheme: "Seleccionar tema...",
|
||
followAppTheme: "Seguir el tema de la aplicación",
|
||
appLayout: "Diseño de la interfaz",
|
||
appLayoutSeparated: "Moderno separado",
|
||
appLayoutSeparatedDescription: "Separación clara de paneles con pestañas en bloque.",
|
||
appLayoutClassic: "Clásico compacto",
|
||
appLayoutClassicDescription: "Barra de pestañas continua con encabezados de panel compactos.",
|
||
iconTheme: "Estilo de icono y logo",
|
||
iconThemeDefault: "Predeterminado",
|
||
iconThemeDefaultDescription: "Usar el icono de color de DBX.",
|
||
iconThemeBlack: "Negro",
|
||
iconThemeBlackDescription: "Usar la marca negra de DBX en ventana, bandeja y logo.",
|
||
showTrayIcon: "Mostrar icono en bandeja/barra de menú",
|
||
showTrayIconDescription: "Si está desactivado, no se muestra el icono, pero cerrar la ventana sigue ocultando DBX en segundo plano como antes.",
|
||
quitOnClose: "Salir al cerrar la ventana",
|
||
quitOnCloseDescription: "Si está activado, al pulsar el botón de cerrar DBX se cierra por completo en lugar de ocultarse en la bandeja.",
|
||
closeActionPromptTitle: "Cerrar ventana",
|
||
closeActionPromptDescription: "Elige qué ocurre al pulsar el botón de cerrar. Puedes cambiarlo después en Ajustes → Apariencia.",
|
||
closeActionQuit: "Salir de DBX",
|
||
closeActionMinimize: "Minimizar a la bandeja",
|
||
updateNotificationsEnabled: "Activar recordatorios de actualización",
|
||
updateNotificationsEnabledDescription: "Al desactivarlo, DBX no comprobará automáticamente actualizaciones de la app ni de los controladores, ni mostrará indicadores. Las comprobaciones manuales siguen disponibles.",
|
||
updateDownloadSource: "Origen de descarga de actualizaciones",
|
||
updateDownloadSourceDescription: "Elige de dónde se descargan los instaladores de actualización. Se recomienda la fuente oficial; CNB puede ser más rápida en redes de China continental.",
|
||
updateDownloadSourceOfficial: "Fuente oficial (recomendada)",
|
||
updateDownloadSourceCnb: "CNB",
|
||
debugLoggingEnabled: "Activar logs de depuración",
|
||
debugLoggingEnabledDescription: "Registra logs de diagnóstico locales del lado del usuario al investigar reportes. Desactivado por defecto.",
|
||
debugLogsCopy: "Copiar logs",
|
||
debugLogsCopied: "Copiado",
|
||
debugLogsDownload: "Descargar logs",
|
||
debugLogsDownloaded: "Descargado",
|
||
debugLogsClear: "Borrar logs",
|
||
tableStructureSection: "Estructura de tabla",
|
||
dataGridDisplay: "Visualización de la tabla",
|
||
showColumnCommentsInHeader: "Mostrar comentarios bajo los nombres",
|
||
showColumnCommentsInHeaderDescription: "Muestra los comentarios de columnas directamente debajo del nombre de la columna.",
|
||
showColumnTypesInHeader: "Mostrar tipos de columna bajo los nombres",
|
||
showColumnTypesInHeaderDescription: "Muestra el tipo de dato de cada columna directamente debajo del nombre de la columna.",
|
||
compactColumnHeaderActions: "Compactar herramientas del encabezado",
|
||
compactColumnHeaderActionsDescription: "Mueve formatear y filtrar a un menú de más acciones para priorizar el nombre de columna.",
|
||
dataGridQuickEntry: "Entrada rápida en grilla",
|
||
dataGridQuickEntryDescription: "Al activarlo, editar una celda o llenar la fila vacía inferior se guarda en la base de datos al perder el foco. Agiliza la captura frecuente, pero puede causar escrituras accidentales.",
|
||
infiniteScroll: "Carga de desplazamiento infinito",
|
||
infiniteScrollDescription: "Carga automáticamente la siguiente página de datos al desplazarse hasta el final de la tabla.",
|
||
infiniteScrollMaxRows: "Máximo de filas en desplazamiento infinito",
|
||
infiniteScrollMaxRowsDescription: "Número máximo de filas a cargar en modo desplazamiento infinito (1000–50000).",
|
||
tableColumnTemplateFields: "Campos predefinidos para tablas nuevas",
|
||
tableColumnTemplateFieldsDescription: "Elige un tipo de base de datos y configura los tipos de campo predefinidos usados al crear tablas nuevas.",
|
||
tableColumnTemplateAdd: "Agregar campo",
|
||
tableColumnTemplateColumn: "Campo",
|
||
tableColumnTemplateDatabase: "Base de datos",
|
||
tableColumnTemplateType: "Tipo",
|
||
tableColumnTemplateLength: "Longitud",
|
||
tableColumnTemplateDefault: "Valor por defecto",
|
||
tableColumnTemplateNoPresetType: "Sin tipo predefinido",
|
||
tableColumnTemplateRequired: "Obligatorio",
|
||
tableColumnTemplateComment: "Descripción",
|
||
tableColumnTemplateDragHandle: "Arrastrar para reordenar",
|
||
sidebarActivation: "Activación de la barra lateral",
|
||
sidebarActivationSingle: "Un clic",
|
||
sidebarActivationSingleDescription: "Abrir elementos accionables de la barra lateral con un clic.",
|
||
sidebarActivationDouble: "Doble clic",
|
||
sidebarActivationDoubleDescription: "Un clic selecciona la fila; doble clic abre elementos.",
|
||
sidebarObjectDisplay: "Diseño de objetos en la barra lateral",
|
||
sidebarObjectDisplayGrouped: "Vista avanzada",
|
||
sidebarObjectDisplayGroupedDescription: "Agrupa objetos por tablas, vistas, procedimientos y funciones para bases con más tipos de objeto.",
|
||
sidebarObjectDisplaySimple: "Vista simple",
|
||
sidebarObjectDisplaySimpleDescription: "Muestra tablas y vistas directamente bajo cada base de datos o esquema para reducir niveles intermedios.",
|
||
autoSelectActiveSidebarNode: "Seleccionar siempre el elemento abierto",
|
||
autoSelectActiveSidebarNodeDescription: "Al cambiar de pestaña, selecciona la tabla, colección o archivo SQL visible correspondiente en la barra lateral.",
|
||
disconnectTabHandlingMode: "Pestañas tras desconectar",
|
||
disconnectTabHandlingModeDescription: "Elige cómo conservar las pestañas relacionadas al cerrar una conexión o base de datos.",
|
||
disconnectTabHandlingModeCloseTabs: "Cerrar todas las pestañas",
|
||
disconnectTabHandlingModeCloseTabsDescription: "Cierra todas las pestañas relacionadas de la conexión o base de datos.",
|
||
disconnectTabHandlingModeKeepTabsClearResults: "Cerrar objetos y conservar SQL",
|
||
disconnectTabHandlingModeKeepTabsClearResultsDescription: "Cierra pestañas de datos, explorador de objetos y estructura, conserva las pestañas SQL y limpia el estado de ejecución y las sesiones.",
|
||
disconnectTabHandlingModeKeepTabsKeepResults: "No cerrar pestañas relacionadas",
|
||
disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Conserva las pestañas relacionadas, el texto SQL y los resultados actuales sin limpieza adicional.",
|
||
reuseDataTab: "Reutilizar pestaña de datos",
|
||
reuseDataTabDescription: "Al hacer clic en una tabla en la barra lateral, reutiliza la pestaña de datos existente en lugar de crear una nueva cada vez.",
|
||
sidebarHiddenTablePrefixes: "Prefijos ocultos de tablas",
|
||
sidebarHiddenTablePrefixesDescription: "Un prefijo por linea. Solo acorta etiquetas de tablas, vistas y colecciones en la barra lateral; las acciones y ayudas usan el nombre completo.",
|
||
sidebarHiddenTablePrefixesPlaceholder: "Ejemplo:\nODS_\nT8Y2_LONG_",
|
||
sidebarTablePageSize: "Tamaño de página de la barra lateral",
|
||
sidebarTablePageSizeDescription: "Número máximo de tablas/objetos cargados por página en el árbol lateral. Auméntalo si tienes muchas tablas para reducir páginas.",
|
||
sidebarHideTableComments: "Ocultar comentarios de tablas en la barra lateral",
|
||
sidebarHideTableCommentsDescription: "Oculta los comentarios de tablas/vistas junto a los nombres en el árbol de la barra lateral para ahorrar espacio horizontal.",
|
||
sidebarAllowHorizontalScroll: "Permitir desplazamiento horizontal lateral",
|
||
sidebarAllowHorizontalScrollDescription: "Muestra completos los nombres largos de tablas, vistas y colecciones permitiendo desplazamiento horizontal en la barra lateral.",
|
||
snippetsDescription: "Personaliza plantillas SQL activadas en el editor.",
|
||
snippetsAdd: "Agregar fragmento",
|
||
snippetsLabel: "Etiqueta",
|
||
snippetsPrefix: "Prefijo",
|
||
snippetsBody: "SQL",
|
||
snippetsLabelPlaceholder: "p. ej. select *",
|
||
snippetsPrefixPlaceholder: "p. ej. sel",
|
||
snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
|
||
snippetsRestoreDefaults: "Restaurar valores por defecto",
|
||
snippetsAddTitle: "Agregar fragmento",
|
||
snippetsEditTitle: "Editar fragmento",
|
||
syncWebDavTitle: "Sincronización WebDAV",
|
||
syncWebDavDescription: "Sube o restaura una instantánea de DBX, incluida la biblioteca SQL guardada, desde almacenamiento compatible con WebDAV.",
|
||
syncEndpoint: "URL WebDAV",
|
||
syncUsername: "Usuario",
|
||
syncPassword: "Contraseña",
|
||
syncPasswordPlaceholder: "Introduce la contraseña",
|
||
syncClearSavedPassword: "Borrar contraseña guardada",
|
||
syncRememberWebDavPassword: "Recordar contraseña de app WebDAV",
|
||
syncSavedPassword: "(guardada)",
|
||
syncRememberWebDavPasswordDescription: "La contraseña se cifra y se guarda solo en este dispositivo. No se sincroniza a WebDAV ni reemplaza la contraseña de sync.",
|
||
syncRemotePath: "Ruta remota",
|
||
syncRemotePathDescription: "DBX creará las carpetas padre faltantes al subir.",
|
||
syncSecretNotice: "De forma predeterminada, DBX solo sincroniza detalles de conexión y ajustes. Las contraseñas de base de datos, SSH, proxy, cadenas de conexión y API keys de IA quedan locales.",
|
||
syncSecrets: "Sincronizar secretos cifrados",
|
||
syncSecretsDescription: "Al activarlo, DBX cifra contraseñas de base de datos, contraseñas SSH y API keys de IA antes de subirlas a WebDAV.",
|
||
syncSecretsPassphrase: "Contraseña de sync",
|
||
syncSecretsPassphraseDescription: "Esta contraseña solo se usa para cifrar y restaurar datos sensibles. DBX no la guarda; tendrás que ingresarla en cada dispositivo.",
|
||
syncTest: "Probar",
|
||
syncUpload: "Subir",
|
||
syncDownload: "Descargar",
|
||
syncTestSuccess: "El destino WebDAV está disponible.",
|
||
syncUploadSuccess: "Se subieron {bytes} bytes a {path}.",
|
||
syncAutoUpload: "Subir instantáneas automáticamente",
|
||
syncAutoUploadInterval: "Cada",
|
||
syncAutoUploadMinutes: "minutos",
|
||
syncAutoUploadDescription: "Se ejecuta mientras DBX está abierto. Las descargas aún requieren confirmación manual para evitar reemplazar SQL guardado localmente.",
|
||
syncAutoUploadSuccess: "Se subieron automáticamente {bytes} bytes a {path}.",
|
||
syncDownloadSuccess: "Se descargaron y aplicaron {bytes} bytes desde {path}.",
|
||
syncSecretsApplied: "Los secretos cifrados fueron restaurados.",
|
||
syncSecretsSkipped: "Había secretos cifrados, pero no fueron restaurados.",
|
||
syncDownloadConfirm: "¿Descargar y aplicar la instantánea remota de DBX? Se reemplazarán metadatos locales y SQL guardado.",
|
||
apply: "Aplicar",
|
||
applyAndClose: "Aplicar y cerrar",
|
||
reset: "Restablecer",
|
||
resetDefaults: "Restablecer valores por defecto",
|
||
resetAllDefaults: "Restablecer todos los valores por defecto",
|
||
save: "Guardar",
|
||
cancel: "Cancelar",
|
||
executeMode: "Modo de ejecución (Cmd+Enter)",
|
||
executeModeAll: "Ejecutar todo el SQL",
|
||
executeModeCurrent: "Ejecutar sentencia en el cursor",
|
||
showExecutionTargetPicker: "Mostrar selector de objetivo",
|
||
showExecutionTargetPickerDescription: "Al activarlo, ejecutar sin selección permite elegir entre la sentencia actual y todo el SQL.",
|
||
wordWrap: "Ajuste de línea",
|
||
wordWrapDescription: "Ajustar las líneas largas de SQL al ancho del editor",
|
||
confirmDangerousSqlExecution: "Confirmar antes de SQL peligroso",
|
||
confirmDangerousSqlExecutionDescription: "Cuando se desactiva, ALTER, DROP, DELETE, TRUNCATE y otras sentencias peligrosas se ejecutan sin el diálogo de advertencia.",
|
||
autoAliasTables: "Agregar alias de tabla automáticamente",
|
||
autoAliasTablesDescription: "Al seleccionar una tabla en FROM o JOIN, inserta un alias generado como order_items AS oi.",
|
||
redisScanPageSize: "Cantidad de escaneo Redis",
|
||
redisScanPageSizeDescription: "Claves solicitadas por página SCAN al explorar claves Redis.",
|
||
redisScanPageSizeOption: "{count} claves",
|
||
exportBatchSize: "Tamaño de lote de exportación",
|
||
exportBatchSizeDescription: "Filas obtenidas por lote al exportar datos de tabla (100-100000).",
|
||
exportRowLimitEnabled: "Limitar filas exportadas",
|
||
exportRowLimitEnabledDescription: "Cuando está activado, las exportaciones de resultados de consultas y datos de tabla se detienen en el límite de filas indicado abajo.",
|
||
exportRowLimit: "Límite de filas de exportación",
|
||
exportRowLimitDescription: "Máximo de filas para exportaciones de resultados de consultas y datos de tabla.",
|
||
exportRowLimitUnlimited: "Sin límite",
|
||
queryExportKeysetOptimizationEnabled: "Intentar optimización keyset",
|
||
queryExportKeysetOptimizationEnabledDescription: "Solo aplica a consultas de una sola tabla reconocidas de forma segura; las consultas complejas usan el método estándar automáticamente.",
|
||
exportSection: "Exportar",
|
||
shortcutExecuteSql: "Ejecutar SQL",
|
||
shortcutFind: "Buscar",
|
||
shortcutReplace: "Reemplazar",
|
||
shortcutSaveSql: "Guardar SQL",
|
||
shortcutAcceptCompletion: "Aceptar completado",
|
||
shortcutFormatSql: "Formatear SQL",
|
||
shortcutIndentMore: "Aumentar sangría",
|
||
shortcutIndentLess: "Reducir sangría",
|
||
shortcutDuplicateLine: "Duplicar línea actual",
|
||
shortcutDeleteLine: "Eliminar línea actual",
|
||
shortcutMoveLineUp: "Mover línea arriba",
|
||
shortcutMoveLineDown: "Mover línea abajo",
|
||
shortcutCopyLineUp: "Copiar línea arriba",
|
||
shortcutCopyLineDown: "Copiar línea abajo",
|
||
shortcutUndo: "Deshacer",
|
||
shortcutRedo: "Rehacer",
|
||
shortcutSelectAll: "Seleccionar todo",
|
||
shortcutCopyCurrentRow: "Copiar fila de datos actual",
|
||
shortcutDeleteCurrentRow: "Eliminar fila de datos actual",
|
||
shortcutNewQuery: "Nueva consulta",
|
||
shortcutOpenSettings: "Abrir configuración",
|
||
shortcutCloseTab: "Cerrar pestaña",
|
||
shortcutToggleSidebar: "Alternar barra lateral",
|
||
shortcutFocusSearch: "Enfocar búsqueda",
|
||
shortcutQuickOpen: "Abrir rápido (buscar todos los objetos de base de datos)",
|
||
shortcutSwitchToPreviousTab: "Cambiar a la pestaña anterior",
|
||
shortcutSwitchToNextTab: "Cambiar a la pestaña siguiente",
|
||
shortcutSwitchToTab1: "Cambiar a la pestaña 1",
|
||
shortcutSwitchToTab2: "Cambiar a la pestaña 2",
|
||
shortcutSwitchToTab3: "Cambiar a la pestaña 3",
|
||
shortcutSwitchToTab4: "Cambiar a la pestaña 4",
|
||
shortcutSwitchToTab5: "Cambiar a la pestaña 5",
|
||
shortcutSwitchToTab6: "Cambiar a la pestaña 6",
|
||
shortcutSwitchToTab7: "Cambiar a la pestaña 7",
|
||
shortcutSwitchToTab8: "Cambiar a la pestaña 8",
|
||
shortcutSwitchToTab9: "Cambiar a la pestaña 9",
|
||
shortcutZoomInUi: "Ampliar interfaz",
|
||
shortcutZoomOutUi: "Reducir interfaz",
|
||
shortcutResetUiZoom: "Restablecer zoom de interfaz",
|
||
shortcutRefreshData: "Actualizar datos",
|
||
shortcutToggleTranspose: "Alternar vista transpuesta",
|
||
shortcutCancelSearch: "Cancelar búsqueda",
|
||
shortcutScopeGlobal: "Global",
|
||
shortcutScopeEditor: "Editor SQL",
|
||
shortcutScopeGrid: "Cuadrícula de datos",
|
||
shortcutScopeSearch: "Campos de búsqueda",
|
||
shortcutPressShortcut: "Presiona un atajo",
|
||
shortcutConflict: "Este atajo entra en conflicto con otra acción del mismo ámbito.",
|
||
shortcutClear: "Borrar atajo",
|
||
preview: "Vista previa en tiempo real",
|
||
customTheme: "Tema personalizado",
|
||
customThemeConfigure: "Configurar tema personalizado",
|
||
customThemeTitle: "Configuración de tema personalizado",
|
||
customThemeMyThemes: "Mis temas",
|
||
customThemeNewTheme: "Nuevo tema",
|
||
customThemeVisualEdit: "Editor visual",
|
||
customThemeJsonConfig: "Configuración JSON",
|
||
customThemeLivePreview: "Vista previa en tiempo real",
|
||
customThemePreviewExample: "Ejemplo de consulta",
|
||
customThemePreset: "Tema predefinido",
|
||
customThemeSelectPreset: "Seleccionar tema predefinido...",
|
||
customThemeApply: "Aplicar",
|
||
customThemePasteImport: "Importar desde portapapeles",
|
||
customThemeExportJson: "Exportar JSON",
|
||
customThemeSaveAndApply: "Guardar y aplicar",
|
||
customThemeKeyword: "Palabra clave",
|
||
customThemeField: "Campo/Variable",
|
||
customThemeFunction: "Función",
|
||
customThemeString: "Cadena",
|
||
customThemeNumber: "Número",
|
||
customThemeComment: "Comentario",
|
||
customThemeTable: "Tabla",
|
||
customThemeOperator: "Operador",
|
||
customThemeType: "Tipo",
|
||
customThemeBuiltin: "Variable integrada",
|
||
customThemeBackground: "Color de fondo",
|
||
customThemeForeground: "Color de primer plano",
|
||
customThemeDefaultName: "Tema personalizado",
|
||
customThemeCopySuffix: " Copia",
|
||
customThemeApplied: 'Esquema de color "{name}" aplicado',
|
||
customThemeKeepOne: "Mantener al menos un tema",
|
||
customThemeJsonError: "Formato JSON inválido, por favor verifique",
|
||
jdbcPlugin: "Plugin JDBC de DBX",
|
||
jdbcPluginInstall: "Instalar plugin JDBC",
|
||
jdbcPluginInstallSuccess: "Plugin JDBC instalado",
|
||
jdbcPluginUpdate: "Actualizar",
|
||
jdbcPluginUninstall: "Desinstalar",
|
||
jdbcPluginUninstallSuccess: "Plugin JDBC desinstalado",
|
||
jdbcPluginInstalled: "Instalado: v{version}",
|
||
jdbcPluginIncompatible: "Protocolo incompatible",
|
||
jdbcPluginNotInstalled: "No instalado",
|
||
jdbcDrivers: "JARs de drivers JDBC",
|
||
jdbcImport: "Importar JAR",
|
||
jdbcImportPath: "Ruta de importación",
|
||
jdbcDriverPathPlaceholder: "/ruta/al/driver.jar",
|
||
jdbcImportSuccess: "Se importaron {count} archivo(s) de driver",
|
||
jdbcDeleteSuccess: "Driver eliminado",
|
||
jdbcNoDrivers: "Aún no se han importado drivers JDBC.",
|
||
mcpTitle: "MCP Server",
|
||
mcpDescription: "Comprueba la instalación y versión de DBX MCP Server para Claude Code, Cursor y otros agentes.",
|
||
mcpChecking: "Comprobando",
|
||
mcpStatusUnknown: "Sin comprobar",
|
||
mcpStatusError: "Error al comprobar",
|
||
mcpReady: "Listo",
|
||
mcpNotInstalled: "No instalado",
|
||
mcpUpdateAvailable: "Actualización disponible",
|
||
mcpCurrent: "Versión actual",
|
||
mcpLatest: "Última versión",
|
||
mcpVersionMissing: "No se detectó instalación global",
|
||
mcpVersionUnknown: "Desconocida",
|
||
mcpAvailable: "Disponible",
|
||
mcpUnavailable: "No disponible",
|
||
mcpBinPath: "Ruta del comando",
|
||
mcpInstallCommand: "Comando de instalación",
|
||
mcpUpdateCommand: "Comando de actualización",
|
||
mcpInstallButton: "Instalar",
|
||
mcpUpdateButton: "Actualizar",
|
||
mcpUpToDate: "Actualizado",
|
||
mcpInstalling: "Instalando...",
|
||
mcpInstallSuccess: "Instalación exitosa",
|
||
mcpInstallFailed: "Error de instalación",
|
||
mcpConfig: "Configuración de MCP",
|
||
mcpCodexConfig: "Configuración de Codex",
|
||
mcpCodexConfigPath: "Codex puede usar ~/.codex/config.toml o .codex/config.toml dentro del proyecto.",
|
||
mcpCursorConfigPath: "Cursor puede usar .cursor/mcp.json en el proyecto o ~/.cursor/mcp.json globalmente.",
|
||
mcpTraeConfigPath: "TRAE: Configuración > MCP > Agregar > Agregar manualmente; luego pega la configuración JSON.",
|
||
mcpVsCodeConfigPath: "VS Code/Copilot puede usar .vscode/mcp.json en el espacio de trabajo o mcp.json en el perfil de usuario.",
|
||
mcpWindsurfConfigPath: "Windsurf puede usar ~/.codeium/windsurf/mcp_config.json.",
|
||
mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json global, o opencode.json a nivel de proyecto.",
|
||
mcpReadonlyMode: "Modo solo lectura",
|
||
mcpReadonlyModeDescription: "Añade DBX_MCP_ALLOW_WRITES=0 al ejemplo de configuración para que la sesión MCP solo permita consultas.",
|
||
mcpAllowDangerous: "Permitir SQL peligroso",
|
||
mcpAllowDangerousDescription: "Añade DBX_MCP_ALLOW_DANGEROUS_SQL=1 al ejemplo de configuración para permitir DROP, TRUNCATE, ALTER y sentencias similares.",
|
||
mcpDetectionTiming: "DBX comprueba automáticamente al abrir esta página; usa Comprobar de nuevo para actualizar.",
|
||
mcpNpmBoundary: "DBX solo comprueba y explica el estado de MCP; la instalación y actualización siguen usando npm.",
|
||
mcpRefresh: "Comprobar de nuevo",
|
||
mcpGuide: "Guía MCP",
|
||
aboutDescription: "Una herramienta de administración de bases de datos liviana y de código abierto.",
|
||
community: "Comunidad",
|
||
qqGroup: "Grupo QQ",
|
||
wechatGroup: "Grupo WeChat",
|
||
wechatGroupInvite: "Invitación de Tencent Docs",
|
||
project: "Proyecto",
|
||
openSource: "Repositorio de código abierto",
|
||
officialDocs: "Documentación oficial",
|
||
},
|
||
driverStore: {
|
||
progressJreExtract: "Extrayendo JRE...",
|
||
progressDownloadJre: "Descargando JRE",
|
||
progressDownloadDriver: "Descargando driver",
|
||
progressDownloadJdbcPlugin: "Descargando plugin JDBC",
|
||
progressJdbcPluginExtract: "Instalando plugin JDBC...",
|
||
usageTitle: "Uso de almacenamiento",
|
||
usageTotal: "Total {size}",
|
||
usageTotalLabel: "Total",
|
||
calculating: "Calculando...",
|
||
usageManagedJre: "JRE administrado",
|
||
usageAgentDrivers: "Agentes de driver integrados",
|
||
usageJdbcPlugin: "Plugin JDBC",
|
||
usageJdbcDriverJars: "JARs de driver JDBC",
|
||
offlineDownloadHint: "Para entornos sin conexión a internet, descarga los paquetes de drivers offline en una máquina con conexión, luego impórtalos aquí.",
|
||
offlineDownloadLink: "Descargas de drivers offline",
|
||
searchDrivers: "Buscar nombre de driver, tipo, versión...",
|
||
searchJdbcDrivers: "Buscar nombre o ruta del driver JDBC...",
|
||
jdbcMavenCoordinatePlaceholder: "Coordenada Maven, ej. org.postgresql:postgresql:42.7.7",
|
||
jdbcMavenInstall: "Instalar desde Maven",
|
||
jdbcMavenInstallSuccess: "Driver JDBC Maven instalado",
|
||
jdbcSourceMaven: "Maven",
|
||
jdbcSourceManual: "Manual",
|
||
noMatchingDrivers: "Sin coincidencias.",
|
||
javaRuntimeSaved: "Ajustes de Java guardados",
|
||
javaRuntimeSaveFailed: "Error al guardar los ajustes de Java: {error}",
|
||
chooseJavaExecutable: "Seleccionar ejecutable Java",
|
||
driverInstallSuccess: "Driver {label} instalado",
|
||
driverInstallFailed: "Error al instalar el driver {label}: {error}",
|
||
driverUpdateBlocked: "Cierra estas conexiones de base de datos antes de actualizar drivers: {labels}",
|
||
upgradeAllSuccess: "{count} driver(s) actualizados",
|
||
upgradeAllPartial: "{count} driver(s) actualizados. Omitidos: {failed}",
|
||
upgradeAllFailed: "Error al actualizar en lote: {error}",
|
||
driverUninstallSuccess: "Driver {label} desinstalado",
|
||
driverUninstallFailed: "Error al desinstalar el driver {label}: {error}",
|
||
chooseOfflineDriverPackage: "Seleccionar paquete offline de drivers",
|
||
offlineImportSuccess: "Importación offline completada. Se instalaron {count} driver(s).",
|
||
offlineImportFailed: "Error en la importación offline: {error}",
|
||
driverImportSuccess: "Driver {label} importado",
|
||
driverImportFailed: "Error al importar el driver {label}: {error}",
|
||
chooseDriverJar: "Seleccionar archivo JAR del driver",
|
||
jreReinstallSuccess: "JRE {jre} reinstalado",
|
||
jreReinstallFailed: "Error al reinstalar JRE {jre}: {error}",
|
||
jreUninstallSuccess: "JRE {jre} desinstalado",
|
||
chooseJdbcPluginZip: "Seleccionar zip del plugin JDBC",
|
||
agentDrivers: "Drivers integrados",
|
||
jdbcDrivers: "Drivers JDBC",
|
||
importing: "Importando...",
|
||
importOfflinePackage: "Importar paquete offline",
|
||
refresh: "Actualizar",
|
||
javaRuntime: "Runtime Java",
|
||
javaRuntimeManaged: "JRE administrado por DBX",
|
||
javaRuntimeSystem: "java del sistema",
|
||
javaRuntimeCustom: "Ruta personalizada",
|
||
saving: "Guardando...",
|
||
customJavaPathPlaceholder: "/ruta/a/java o /ruta/a/jdk",
|
||
choose: "Seleccionar",
|
||
systemJavaHint: "Usa java del PATH actual.",
|
||
jreRuntimeTitle: "Runtime JRE {jre}",
|
||
notInstalled: "No instalado",
|
||
reinstalling: "Reinstalando",
|
||
installing: "Instalando",
|
||
install: "Instalar",
|
||
reinstall: "Reinstalar",
|
||
uninstall: "Desinstalar",
|
||
jreRuntime: "Runtime JRE",
|
||
jreRuntimeAutoDownloadHint: "Se descarga automáticamente al instalar un driver por primera vez",
|
||
driversUpdatable: "{count} driver(s) pueden actualizarse",
|
||
upgradingProgress: "Actualizando ({current}/{total})",
|
||
upgradeAll: "Actualizar todo",
|
||
queued: "En cola",
|
||
importLocalJar: "Importar JAR local",
|
||
updating: "Actualizando",
|
||
update: "Actualizar",
|
||
localInstall: "Instalación local",
|
||
runtimeDrivers: "Runtime",
|
||
storageTab: "Almacenamiento",
|
||
runtimeTitle: "Runtime de drivers",
|
||
runtimeHint: "Las métricas de runtime se recopilan solo mientras este panel está abierto.",
|
||
runtimeRunning: "En ejecución",
|
||
runtimeMemory: "Memoria",
|
||
runtimeHealth: "Salud",
|
||
runtimeHealth_healthy: "Correcto",
|
||
runtimeHealth_warning: "Advertencia",
|
||
runtimeHealth_error: "Error",
|
||
runtimeLastError: "Último error",
|
||
runtimeEmpty: "Aún no hay runtimes de drivers. Abre una conexión con driver Agent para iniciar uno.",
|
||
runtimeKindAgent: "Agent",
|
||
runtimeKindPlugin: "Plugin",
|
||
runtimeSourceDaemon: "Daemon",
|
||
runtimeSourceConnection: "Conexión",
|
||
runtimeStatus_running: "En ejecución",
|
||
runtimeStatus_stopped: "Detenido",
|
||
runtimeStatus_error: "Error",
|
||
runtimeStatus_unknown: "Desconocido",
|
||
runtimePid: "PID",
|
||
runtimeUptime: "Tiempo activo",
|
||
runtimeActions: "Acciones",
|
||
runtimeStop: "Detener",
|
||
runtimeRestart: "Reiniciar",
|
||
runtimeControlConnectionOwned: "Cierra la conexión de base de datos para detener este runtime.",
|
||
runtimeStopSuccess: "Runtime de {label} detenido",
|
||
runtimeStopFailed: "Error al detener {label}: {error}",
|
||
runtimeRestartSuccess: "Runtime de {label} reiniciado",
|
||
runtimeRestartFailed: "Error al reiniciar {label}: {error}",
|
||
driverStoreDir: "Ruta de almacenamiento de controladores",
|
||
driverStoreDirDescription: "Configura ubicaciones separadas para el plugin JDBC y los datos de Agent/JRE. La aplicación se reiniciará automáticamente después de la migración.",
|
||
pluginStoreDir: "Directorio del plugin JDBC",
|
||
pluginStoreDirDescription: "Almacena el plugin JDBC, Maven resolver y los jars de controladores JDBC.",
|
||
agentStoreDir: "Directorio Agent / JRE",
|
||
agentStoreDirDescription: "Almacena paquetes de controladores Agent, JRE gestionados y caché de runtime.",
|
||
driverStoreDirDefault: "Predeterminado (directorio de instalación)",
|
||
driverStoreDirChange: "Cambiar",
|
||
driverStoreDirReset: "Restablecer",
|
||
driverStoreDirMigrating: "Migrando {target}…",
|
||
driverStoreDirConfirm: "Cambiar {target} migrará los datos relacionados a la nueva ubicación. Las conexiones relacionadas pueden desconectarse durante la migración. La aplicación se reiniciará automáticamente después. ¿Continuar?",
|
||
driverStoreDirMigrationFailed: "Error en la migración de controladores: {error}",
|
||
driverStoreDirDialogTitle: "Seleccionar {target}",
|
||
driverStoreDirSuccess: "{target} cambiado, reiniciando…",
|
||
},
|
||
databaseExport: {
|
||
title: "Exportar base de datos",
|
||
options: "Opciones",
|
||
includeStructure: "Estructura de tablas (DDL)",
|
||
dropTableIfExists: "Agregar DROP TABLE IF EXISTS antes del DDL",
|
||
includeData: "Datos de tablas (INSERT)",
|
||
includeObjects: "Vistas / Procedimientos / Funciones / Secuencias",
|
||
tableSelection: "Tablas",
|
||
selectedTables: "{selected}/{total} seleccionadas",
|
||
selectAllTables: "Seleccionar todo",
|
||
clearTables: "Limpiar",
|
||
loadingTables: "Cargando tablas...",
|
||
tableLoadError: "Error al cargar tablas: {error}",
|
||
noTables: "No se encontraron tablas",
|
||
export: "Exportar",
|
||
exporting: "Exportando...",
|
||
currentTable: "Actual: {table} ({current}/{total})",
|
||
rowsExported: "{count} filas exportadas",
|
||
exportSuccess: "Base de datos exportada exitosamente",
|
||
exportError: "Error al exportar: {error}",
|
||
exportCancelled: "Exportación cancelada",
|
||
filterTables: "Buscar tablas...",
|
||
runInBackground: "Ejecutar en segundo plano",
|
||
},
|
||
nacos: {
|
||
configs: "Configuraciones",
|
||
services: "Servicios",
|
||
raw: "Raw",
|
||
namespace: "Namespace",
|
||
createNamespace: "Crear Namespace",
|
||
editNamespace: "Editar Namespace",
|
||
creatingNamespace: "Creando...",
|
||
updatingNamespace: "Actualizando...",
|
||
namespaceCreated: 'Namespace "{name}" creado',
|
||
namespaceUpdated: 'Namespace "{name}" actualizado',
|
||
namespaceId: "ID del Namespace",
|
||
namespaceIdPlaceholder: "Déjalo vacío para que Nacos lo genere",
|
||
namespaceName: "Nombre del Namespace",
|
||
namespaceNamePlaceholder: "Ingresa un nombre de namespace",
|
||
namespaceDesc: "Descripción",
|
||
namespaceDescPlaceholder: "Por defecto, el nombre del namespace",
|
||
dataId: "Data ID",
|
||
group: "Grupo",
|
||
format: "Formato",
|
||
content: "Contenido",
|
||
tags: "Etiquetas",
|
||
application: "Aplicación",
|
||
description: "Descripción",
|
||
advanced: "Avanzado",
|
||
collapse: "Contraer",
|
||
load: "Cargar",
|
||
save: "Guardar",
|
||
saveAs: "Guardar como",
|
||
saving: "Guardando...",
|
||
saved: "Configuración guardada",
|
||
createdAndLoaded: "{dataId} creado y cargado",
|
||
savedAndLoaded: "{dataId} guardado y actualizado",
|
||
deleted: "Configuración eliminada",
|
||
delete: "Eliminar",
|
||
copy: "Copiar",
|
||
copied: "Copiado",
|
||
copyVerifyFailed: "La verificación del portapapeles falló después de escribir",
|
||
export: "Exportar",
|
||
exported: "Exportado",
|
||
exportedTo: "Exportado a {path}",
|
||
exportFailed: "Error al exportar: {message}",
|
||
history: "History",
|
||
configHistory: "Config history",
|
||
historyDetail: "History detail",
|
||
historyCompareTitle: "History Version Compare",
|
||
currentPublishedContent: "Current published content:",
|
||
historyVersionContent: "History version content:",
|
||
updatedAt: "Updated at",
|
||
operationType: "Operation",
|
||
operator: "Operator",
|
||
view: "View",
|
||
compare: "Compare",
|
||
rollback: "Rollback",
|
||
loadingHistory: "Loading history...",
|
||
noHistory: "No history versions",
|
||
noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
|
||
historyCreate: "Create",
|
||
historyUpdate: "Update",
|
||
historyDelete: "Delete",
|
||
historyRollback: "Rollback",
|
||
confirmRollbackTitle: "Rollback Nacos config",
|
||
confirmRollbackMessage: "This will roll the current config back to the selected history version.",
|
||
rollbackSuccess: "Config rolled back",
|
||
publish: "Publicar",
|
||
dataIdRequired: "Data ID es obligatorio",
|
||
allGroups: "Todos los grupos",
|
||
noConfigs: "Sin configuraciones",
|
||
selectConfig: "Selecciona o crea una configuración",
|
||
noServices: "Sin servicios",
|
||
selectService: "Selecciona un servicio",
|
||
service: "Servicio",
|
||
instances: "Instancias",
|
||
instanceCount: "{count} instancias",
|
||
refresh: "Actualizar",
|
||
address: "Dirección",
|
||
cluster: "Clúster",
|
||
weight: "Peso",
|
||
state: "Estado",
|
||
actions: "Acciones",
|
||
query: "Consulta",
|
||
body: "Cuerpo",
|
||
response: "Respuesta",
|
||
template: "Plantilla",
|
||
configDiffTitle: "Comparar contenido de configuración",
|
||
inlineCompare: "Comparación en línea",
|
||
currentVersionContent: "Versión oficial actual:",
|
||
publishVersionContent: "Contenido de esta publicación:",
|
||
confirmSaveTitle: "Revisar cambios de configuración Nacos",
|
||
confirmSaveMessage: "¿Guardar este cambio? +{added} / -{removed} líneas.",
|
||
confirmDeleteTitle: "Eliminar configuración Nacos",
|
||
confirmDeleteMessage: "Esto elimina la configuración seleccionada de Nacos.",
|
||
confirmInstanceTitle: "Actualizar instancia Nacos",
|
||
confirmInstanceMessage: "Confirma el estado objetivo de la instancia.",
|
||
confirmRawTitle: "Enviar solicitud Raw API modificadora",
|
||
confirmRawMessage: "Esta solicitud Raw API puede modificar el estado de Nacos.",
|
||
rawTemplate: {
|
||
serverState: "Estado del servidor",
|
||
namespaceList: "Lista de namespaces",
|
||
configDetail: "Detalle de configuración",
|
||
serviceList: "Lista de servicios",
|
||
instanceList: "Lista de instancias",
|
||
},
|
||
healthy: "Saludable",
|
||
unhealthy: "No saludable",
|
||
enabled: "Habilitado",
|
||
offline: "Offline",
|
||
ephemeral: "Efímera",
|
||
persistent: "Persistente",
|
||
enable: "Habilitar",
|
||
disable: "Deshabilitar",
|
||
markHealthy: "Marcar saludable",
|
||
markUnhealthy: "Marcar no saludable",
|
||
send: "Enviar",
|
||
total: "{count} en total",
|
||
prev: "Anterior",
|
||
next: "Siguiente",
|
||
test: "Probar",
|
||
readOnly: "Solo lectura",
|
||
},
|
||
});
|