+Ente is a simple app to automatically backup and organize your photos and videos.
+
+If you've been looking for a privacy-friendly alternative to preserve your memories, you've come to the right place. With Ente, they are stored end-to-end encrypted (e2ee). This means that only you can view them.
+
+We have apps across all platforms, and your photos will seamlessly sync between all your devices in an end-to-end encrypted (e2ee) manner.
+
+Ente also makes it simple to share your albums with your loved ones. You can either share them directly with other Ente users, end-to-end encrypted; or with publicly viewable links.
+
+Your encrypted data is stored across multiple locations, including a fall-out shelter in Paris. We take posterity seriously and make it easy to ensure that your memories outlive you.
+
+We are here to make the safest photos app ever, come join our journey!
+
+FEATURES
+- Original quality backups, because every pixel is important
+- Family plans, so you can share storage with your family
+- Shared folders, in case you want your partner to enjoy your "Camera" clicks
+- Album links, that can be protected with a password and set to expire
+- Ability to free up space, by removing files that have been safely backed up
+- Image editor, to add finishing touches
+- Favorite, hide and relive your memories, for they are precious
+- One-click import from all major storage providers
+- Dark theme, because your photos look good in it
+- 2FA, 3FA, biometric auth
+- and a LOT more!
+
+PRICING
+We don't offer forever free plans, because it is important to us that we remain sustainable and withstand the test of time. Instead we offer affordable plans that you can freely share with your family. You can find more information at ente.io.
+
+SUPPORT
+We take pride in offering human support. If you are our paid customer, you can reach out to team@ente.io and expect a response from our team within 24 hours.
+Ente es una aplicación simple que guarda automáticamente copias de segurida y organiza tus fotos y vídeos.
+
+Si has estado buscando una alternativa pro-privacidad para guardar tus recuerdos, has llegado al sitio adecuado. Con Ente, se almacenan cifradas de extremo a extremo (e2ee). Esto significa que solo tú puedes verlas.
+
+Tenemos aplicaciones en todas las plataformas, y tus fotos se sincronizarán perfectamente entre todos tus dispositivos encriptadas de extremo a extremo (e2ee).
+
+Ente también facitila compartir tus álbumes con tus seres queridos. También puedes compartirlos directamente con otros usuarios de Ente cifrados de extremo a extremo, o publicarlos en enlaces visibles.
+
+Tus datos encriptados se almacenan en varias ubicaciones, incluyendo un refugio antiaréreo en París. Nos tomamos en serio la posternidad y hacemos posible asegurar que tus memorias te sobreviven.
+
+Estamos aquí para hacer la aplicación de fotos más segura de todas.
+
+CARACTERÍSTICAS
+- Copias de seguridad de calidad original, porque cada píxel es importante
+- Planes familiares, para que puedas compartir el almacenamiento con tu familia
+- Carpetas compartidas, por si quieres que tu pareja disfrute de tus 'clicks'
+- Enlaces al álbum, que se pueden proteger con una contraseña y programar para que expiren
+- Capacidad para liberar espacio, eliminando archivos de los que ya tienes una copia de seguridad
+- Editor de imagen, para añadir retoques finales
+- Marca como favoritos, oculta y revive tus recuerdos, porque son preciosos
+- Importa en un click desde todos los proveedores de almacenamiento principales
+- Tema oscuro, porque tus fotos quedan bien con él
+- 2FA, 3FA, autenticación biométrica
+- ¡Y mucho más!
+
+PRECIOS
+No ofrecemos planes gratis para siempre, porque es importante para nosotros seguir siendo sostenibles y resistir a la prueba del tiempo. En su lugar, ofrecemos planes asequibles que puedes compartir libremente con tu familia. Puedes encontrar más información en ente.io.
+
+SOPORTE
+Estamos orgullosos de ofrecer apoyo humano. Si eres un cliente de pago, puedes contactar con team@ente.io y esperar una respuesta de nuestro equipo en 24 horas.
+Ente is een eenvoudige app om jouw foto's en video's automatisch te back-uppen en organiseren.
+
+Als je op zoek bent naar een privacy-vriendelijk alternatief om je herinneringen te bewaren, dan ben je op de juiste plaats. Bij ente worden ze end-to-end encrypted (e2ee). Dit betekent dat alleen jij ze kunt bekijken.
+
+We hebben apps op alle platformen, en je foto's zullen naadloos synchroniseren tussen al je apparaten op een end-to-end versleutelde (e2ee) manier.
+
+Ente maakt het ook eenvoudig om je albums te delen met je dierbaren. Je kunt ze direct delen met andere Ente gebruikers, end-to-end versleuteld; of met openbaar zichtbare links.
+
+Jouw versleutelde gegevens worden over meerdere locaties opgeslagen, waaronder een kernbunker in Parijs. Wij nemen opslag voor de lange termijn serieus, en zorgen ervoor dat je herinneringen minstens je hele leven bewaard worden.
+
+Ons doel is om de veiligste foto app ooit te maken, sluit je bij ons aan!
+
+FUNCTIES
+- Backups van originele kwaliteit, omdat elke pixel belangrijk is
+- Familieplannen, zodat je de opslag kunt delen met je familie
+- Gedeelde mappen, voor het geval je jouw partner wilt laten meegenieten van jouw "Camera" klikjes
+- Album links, die met een wachtwoord en vervaldatum beschermd kunnen worden
+- Mogelijkheid om ruimte vrij te maken op je apparaat, door bestanden die veilig zijn geback-upt te verwijderen
+- Fotobewerker om de laatste finishing touches toe te voegen
+- Favorieten, verbergen en herleven van je herinneringen, want ze zijn kostbaar
+- Met één klik importeren vanuit alle belangrijke opslagdiensten
+- Donker thema, omdat je foto's er goed in uit zien
+- 2FA, 3FA, biometrische authenticatie
+- en nog veel meer!
+
+PRIJZEN
+We bieden geen oneindig gratis plannen aan, omdat het voor ons belangrijk is dat we duurzaam blijven en de tand des tijds weerstaan. In plaats daarvan bieden we betaalbare plannen aan die je vrij kunt delen met je familie. Je kunt meer informatie vinden op ente.io.
+
+ONDERSTEUNING
+Wij zijn trots op het bieden van menselijke klantenservice. Als je een betaalde klant bent, kun je contact opnemen met team@ente.io en binnen 24 uur een antwoord van ons verwachten.
+Ente is a simple app to automatically backup and organize your photos and videos.
+
+If you've been looking for a privacy-friendly alternative to preserve your memories, you've come to the right place. With Ente, they are stored end-to-end encrypted (e2ee). This means that only you can view them.
+
+We have apps across Android, iOS, web and Desktop, and your photos will seamlessly sync between all your devices in an end-to-end encrypted (e2ee) manner.
+
+Ente also makes it simple to share your albums with your loved ones. You can either share them directly with other Ente users, end-to-end encrypted; or with publicly viewable links.
+
+Your encrypted data is stored across multiple locations, including a fall-out shelter in Paris. We take posterity seriously and make it easy to ensure that your memories outlive you.
+
+We are here to make the safest photos app ever, come join our journey!
+
+✨ FEATURES
+- Original quality backups, because every pixel is important
+- Family plans, so you can share storage with your family
+- Shared folders, in case you want your partner to enjoy your "Camera" clicks
+- Album links, that can be protected with a password and set to expire
+- Ability to free up space, by removing files that have been safely backed up
+- Image editor, to add finishing touches
+- Favorite, hide and relive your memories, for they are precious
+- One-click import from Google, Apple, your hard drive and more
+- Dark theme, because your photos look good in it
+- 2FA, 3FA, biometric auth
+- and a LOT more!
+
+💲 PRICING
+We don't offer forever free plans, because it is important to us that we remain sustainable and withstand the test of time. Instead we offer affordable plans that you can freely share with your family. You can find more information at ente.io.
+
+🙋 SUPPORT
+We take pride in offering human support. If you are our paid customer, you can reach out to team@ente.io and expect a response from our team within 24 hours.
+Ente es una aplicación simple que guarda automáticamente copias de segurida y organiza tus fotos y vídeos.
+
+Si has estado buscando una alternativa pro-privacidad para guardar tus recuerdos, has llegado al sitio adecuado. Con Ente, se almacenan cifradas de extremo a extremo (e2ee). Esto significa que solo tú puedes verlas.
+
+Tenemos aplicaciones en Android, iOS, web y escritorio, y tus fotos se sincronizarán perfectamente entre todos tus dispositivos encriptadas de extremo a extremo (e2ee).
+
+Ente también facitila compartir tus álbumes con tus seres queridos. También puedes compartirlos directamente con otros usuarios de Ente cifrados de extremo a extremo, o publicarlos en enlaces visibles.
+
+Tus datos encriptados se almacenan en varias ubicaciones, incluyendo un refugio antiaréreo en París. Nos tomamos en serio la posternidad y hacemos posible asegurar que tus memorias te sobreviven.
+
+Estamos aquí para hacer la aplicación de fotos más segura de todas.
+
+✨ CARACTERÍSTICAS
+- Copias de seguridad de calidad original, porque cada píxel es importante
+- Planes familiares, para que puedas compartir el almacenamiento con tu familia
+- Carpetas compartidas, por si quieres que tu pareja disfrute de tus 'clicks'
+- Enlaces al álbum, que se pueden proteger con una contraseña y programar para que expiren
+- Capacidad para liberar espacio, eliminando archivos de los que ya tienes una copia de seguridad
+- Editor de imagen, para añadir retoques finales
+- Marca como favoritos, oculta y revive tus recuerdos, porque son preciosos
+- Importa en un click desde Google, Apple, tu disco duro y más
+- Tema oscuro, porque tus fotos quedan bien con él
+- 2FA, 3FA, autenticación biométrica
+- ¡Y mucho más!
+
+💲 PRECIOS
+No ofrecemos planes gratis para siempre, porque es importante para nosotros seguir siendo sostenibles y resistir a la prueba del tiempo. En su lugar, ofrecemos planes asequibles que puedes compartir libremente con tu familia. Puedes encontrar más información en ente.io.
+
+🙋 SOPORTE
+Estamos orgullosos de ofrecer apoyo humano. Si eres un cliente de pago, puedes contactar con team@ente.io y esperar una respuesta de nuestro equipo en 24 horas.
+Ente is een eenvoudige app om jouw foto's en video's automatisch te back-uppen en organiseren.
+
+Als je op zoek bent naar een privacy-vriendelijk alternatief om je herinneringen te bewaren, dan ben je op de juiste plaats. Bij ente worden ze end-to-end encrypted (e2ee). Dit betekent dat alleen jij ze kunt bekijken.
+
+We hebben apps op Android, iOS, web en Desktop, en je foto's zullen naadloos synchroniseren tussen al je apparaten op een end-to-end versleutelde (e2ee) manier.
+
+Ente maakt het ook eenvoudig om je albums te delen met je dierbaren. Je kunt ze direct delen met andere Ente gebruikers, end-to-end versleuteld; of met openbaar zichtbare links.
+
+Jouw versleutelde gegevens worden over meerdere locaties opgeslagen, waaronder een kernbunker in Parijs. Wij nemen opslag voor de lange termijn serieus, en zorgen ervoor dat je herinneringen minstens je hele leven bewaard worden.
+
+Ons doel is om de veiligste foto app ooit te maken, sluit je bij ons aan!
+
+✨ FUNCTIES
+- Backups van originele kwaliteit, omdat elke pixel belangrijk is
+- Familieplannen, zodat je de opslag kunt delen met je familie
+- Gedeelde mappen, voor het geval u uw partner wilt laten meegenieten van uw "Camera" klikjes
+- Album links, die met een wachtwoord en vervaldatum beschermd kunnen worden
+- Mogelijkheid om ruimte vrij te maken op je apparaat, door bestanden die veilig zijn geback-upt te verwijderen
+- Fotobewerker om de laatste finishing touches toe te voegen
+- Favorieten, verbergen en herleven van je herinneringen, want ze zijn kostbaar
+- Met één klik importeren vanuit Google, Apple, je harde schijf en meer
+- Donker thema, omdat je foto's er goed in uit zien
+- 2FA, 3FA, biometrische authenticatie
+- en nog veel meer!
+
+💲 PRIJZEN
+We bieden geen oneindig gratis plannen aan, omdat het voor ons belangrijk is dat we duurzaam blijven en de tand des tijds weerstaan. In plaats daarvan bieden we betaalbare plannen aan die je vrij kunt delen met je familie. Je kunt meer informatie vinden op ente.io.
+
+🙋 SUPPORT
+Wij zijn trots op het bieden van menselijke klantenondersteuning. Als je een betaalde klant bent, kun je contact opnemen met team@ente.io en binnen 24 uur een antwoord van ons verwachten.
- ? '$columnLatitude IS NOT NULL AND $columnLongitude IS NOT NULL AND ($columnLatitude IS NOT 0 OR $columnLongitude IS NOT 0)'
- 'AND $columnCreationTime >= ? AND $columnCreationTime <= ? AND ($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1)'
- 'AND $columnMMdVisibility = ?'
- : '$columnCreationTime >= ? AND $columnCreationTime <= ? AND ($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1)'
- ' AND $columnMMdVisibility = ?',
+ where:
+ '$columnCreationTime >= ? AND $columnCreationTime <= ? AND ($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1)'
- ? '$columnLatitude IS NOT NULL AND $columnLongitude IS NOT NULL AND ($columnLatitude IS NOT 0 OR $columnLongitude IS NOT 0)'
- ' AND $columnCreationTime >= ? AND $columnCreationTime <= ? AND '
- '($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnMMdVisibility IS NULL OR $columnMMdVisibility = ?)'
- ' AND ($columnLocalID IS NOT NULL OR ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1))'
- : '$columnCreationTime >= ? AND $columnCreationTime <= ? AND ($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnMMdVisibility IS NULL OR $columnMMdVisibility = ?)'
- ' AND ($columnLocalID IS NOT NULL OR ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1))',
+ where:
+ '$columnCreationTime >= ? AND $columnCreationTime <= ? AND ($columnOwnerID IS NULL OR $columnOwnerID = ?) AND ($columnMMdVisibility IS NULL OR $columnMMdVisibility = ?)'
+ ' AND ($columnLocalID IS NOT NULL OR ($columnCollectionID IS NOT NULL AND $columnCollectionID IS NOT -1))',
+ "Bitte kündigen Sie Ihr aktuelles Abo über ${paymentProvider} zuerst";
+
+ static String m1(user) =>
+ "Der Nutzer \"${user}\" wird keine weiteren Fotos zum Album hinzufügen können.\n\nJedoch kann er weiterhin vorhandene Bilder, welche durch ihn hinzugefügt worden sind, wieder entfernen";
+ "ente Weiterempfehlungs-Code: ${referralCode} \n\nEinlösen unter Einstellungen → Allgemein → Weiterempfehlungen, um ${referralStorageInGB} GB kostenlos zu erhalten, sobald Sie einen kostenpflichtigen Tarif abgeschlossen haben\n\nhttps://ente.io";
+
+ static String m27(numberOfPeople) =>
+ "${Intl.plural(numberOfPeople, zero: 'Teile mit bestimmten Personen', one: 'Teilen mit 1 Person', other: 'Teilen mit ${numberOfPeople} Personen')}";
+
+ static String m28(emailIDs) => "Geteilt mit ${emailIDs}";
+
+ static String m29(fileType) =>
+ "Dieses ${fileType} wird von deinem Gerät gelöscht.";
+
+ static String m30(fileType) =>
+ "Dieses ${fileType} existiert auf ente.io und deinem Gerät.";
+
+ static String m31(fileType) =>
+ "Dieses ${fileType} wird auf ente.io gelöscht.";
+ "Ihr ${id} ist bereits mit einem anderen \'ente\'-Konto verknüpft.\nWenn Sie Ihre ${id} mit diesem Konto verwenden möchten, kontaktieren Sie bitte unseren Support\'";
+
+ static String m34(endDate) => "Ihr Abo endet am ${endDate}";
+ "Ich verstehe, dass ich meine Daten verlieren kann, wenn ich mein Passwort vergesse, da meine Daten <underline>Ende-zu-Ende-verschlüsselt</underline> sind."),
+ "Erstelle einen Link, um anderen zu ermöglichen, Fotos in deinem geteilten Album hinzuzufügen und zu sehen - ohne dass diese ein Konto von ente.io oder die App benötigen. Ideal, um Fotos von Events zu sammeln."),
+ "Das Entwicklerkonto, das wir verwenden, um ente im App Store zu veröffentlichen, hat sich geändert. Aus diesem Grund musst du dich erneut anmelden.\n\nWir entschuldigen uns für die Unannehmlichkeiten, aber das war unvermeidlich."),
+ "Das Sperren des Gerätes verhindern, solange \'ente\' im Vordergrund geöffnet ist und eine Sicherung läuft. \nDies wird für gewöhnlich nicht benötigt, kann aber dabei helfen große Transfers schneller durchzuführen."),
+ "Bitte sie, auf den Einstellungs Bildschirm ihre E-Mail-Adresse lange anzuklicken und zu überprüfen, dass die IDs auf beiden Geräten übereinstimmen."),
+ "Der von Ihnen eingegebene Wiederherstellungsschlüssel ist nicht gültig. Bitte stellen Sie sicher das aus 24 Wörtern zusammen gesetzt ist und jedes dieser Worte richtig geschrieben wurde.\n\nSollten Sie den Wiederherstellungscode eingegeben haben, stellen Sie bitte sicher, dass dieser 64 Worte lang ist und ebenfall richtig geschrieben wurde."),
+ "Aufgrund unseres Ende-zu-Ende-Verschlüsselungsprotokolls können deine Daten nicht ohne dein Passwort oder deinen Wiederherstellungs-Schlüssel entschlüsselt werden"),
+ "Sehr gut! Ihr Wiederherstellungsschlüssel ist gültig. Vielen Dank für die Verifizierung.\n\nBitte vergessen Sie nicht eine Kopie Ihres Wiederherstellungsschlüssels sicher aufzubewahren."),
+ "Ihr Wiederherstellungsschlüssel ist die einzige Möglichkeit Ihre Fotos wieder herzustellen, sollten Sie Ihr Passwort vergessen haben. Sie können diesen unter \"Einstellungen\" und dann \"Konto\" wieder finden.\n\nBitte geben Sie unten Ihren Wiederherstellungsschlüssel ein um sicher zu stellen, dass Sie ihn korrekt hinterlegt haben."),
+ "Das aktuelle Gerät ist nicht leistungsfähig genug, um dein Passwort zu verifizieren, aber wir können es neu erstellen, damit es auf allen Geräten funktioniert.\n\nBitte melde dich mit deinem Wiederherstellungs-Schlüssel an und erstelle dein Passwort neu (Wenn du willst, kannst du dasselbe erneut verwenden)."),
+ "Der verwendbare Speicherplatz ist von deinem aktuellen Abonnement eingeschränkt. Überschüssiger, beanspruchter Speicherplatz wird automatisch verwendbar werden, wenn du ein höheres Abonnement buchst."),
+ "usePublicLinksForPeopleNotOnEnte":
+ MessageLookupByLibrary.simpleMessage(
+ "Nutze öffentliche Links für Personen ohne ente.io Konto"),
+ "This will remove the public link for accessing \"${albumName}\".";
+
+ static String m6(supportEmail) =>
+ "Please drop an email to ${supportEmail} from your registered email address";
+
+ static String m7(count, storageSaved) =>
+ "Your have cleaned up ${Intl.plural(count, one: '${count} duplicate file', other: '${count} duplicate files')}, saving (${storageSaved}!)";
+
+ static String m47(newEmail) => "Email changed to ${newEmail}";
+
+ static String m8(email) =>
+ "${email} does not have an ente account.\n\nSend them an invite to share photos.";
+
+ static String m48(count, formattedNumber) =>
+ "${Intl.plural(count, one: '1 file', other: '${formattedNumber} files')} on this device have been backed up safely";
+
+ static String m49(count, formattedNumber) =>
+ "${Intl.plural(count, one: '1 file', other: '${formattedNumber} files')} in this album has been backed up safely";
+
+ static String m9(storageAmountInGB) =>
+ "${storageAmountInGB} GB each time someone signs up for a paid plan and applies your code";
+
+ static String m10(endDate) => "Free trial valid till ${endDate}";
+
+ static String m50(count) =>
+ "You can still access ${Intl.plural(count, one: 'it', other: 'them')} on ente as long as you have an active subscription";
+
+ static String m51(sizeInMBorGB) => "Free up ${sizeInMBorGB}";
+
+ static String m52(count, formattedSize) =>
+ "${Intl.plural(count, one: 'It can be deleted from the device to free up ${formattedSize}', other: 'They can be deleted from the device to free up ${formattedSize}')}";
+ "ente referral code: ${referralCode} \n\nApply it in Settings → General → Referrals to get ${referralStorageInGB} GB free after you signup for a paid plan\n\nhttps://ente.io";
+
+ static String m27(numberOfPeople) =>
+ "${Intl.plural(numberOfPeople, zero: 'Share with specific people', one: 'Shared with 1 person', other: 'Shared with ${numberOfPeople} people')}";
+
+ static String m28(emailIDs) => "Shared with ${emailIDs}";
+
+ static String m29(fileType) =>
+ "This ${fileType} will be deleted from your device.";
+
+ static String m30(fileType) =>
+ "This ${fileType} is in both ente and your device.";
+
+ static String m31(fileType) => "This ${fileType} will be deleted from ente.";
+ "Create a link to allow people to add and view photos in your shared album without needing an ente app or account. Great for collecting event photos."),
+ "The developer account we use to publish ente on App Store has changed. Because of this, you will need to login again.\n\nOur apologies for the inconvenience, but this was unavoidable."),
+ "Disable the device screen lock when ente is in the foreground and there is a backup in progress. This is normally not needed, but may help big uploads and initial imports of large libraries complete faster."),
+ "didYouKnow": MessageLookupByLibrary.simpleMessage("Did you know?"),
+ "disableAutoLock":
+ MessageLookupByLibrary.simpleMessage("Disable auto lock"),
+ "The recovery key you entered is not valid. Please make sure it contains 24 words, and check the spelling of each.\n\nIf you entered an older recovery code, make sure it is 64 characters long, and check each of them."),
+ "Your recovery key is the only way to recover your photos if you forget your password. You can find your recovery key in Settings > Account.\n\nPlease enter your recovery key here to verify that you have saved it correctly."),
+ "The current device is not powerful enough to verify your password, but we can regenerate in a way that works with all devices.\n\nPlease login using your recovery key and regenerate your password (you can use the same one again if you wish)."),
+ "${Intl.plural(count, one: 'Se puede eliminar del dispositivo para liberar ${formattedSize}', other: 'Se pueden eliminar del dispositivo para liberar ${formattedSize}')}";
+ static String m12(expiryTime) => "El enlace caducará en ${expiryTime}";
+
+ static String m13(maxValue) =>
+ "Cuando se establece al máximo (${maxValue}), el límite del dispositivo se relajará para permitir picos temporales de un gran número de espectadores.";
+ "ente código de referencia: ${referralCode} \n\nAplicarlo en Ajustes → General → Referencias para obtener ${referralStorageInGB} GB gratis después de registrarse en un plan de pago\n\nhttps://ente.io";
+
+ static String m27(numberOfPeople) =>
+ "${Intl.plural(numberOfPeople, zero: 'Compartir con personas específicas', one: 'Compartido con 1 persona', other: 'Compartido con ${numberOfPeople} personas')}";
+
+ static String m28(emailIDs) => "Compartido con ${emailIDs}";
+
+ static String m29(fileType) =>
+ "Este ${fileType} se eliminará de tu dispositivo.";
+
+ static String m30(fileType) =>
+ "Este ${fileType} está tanto en ente como en tu dispositivo.";
+
+ static String m31(fileType) => "Este ${fileType} se eliminará de ente.";
+ "Su ${id} ya está vinculado a otra cuenta ente.\nSi desea utilizar su ${id} con esta cuenta, póngase en contacto con nuestro servicio de asistencia\'\'";
+
+ static String m34(endDate) => "Tu suscripción se cancelará el ${endDate}";
+
+ static String m35(completed, total) =>
+ "${completed}/${total} recuerdos conservados";
+
+ static String m36(storageAmountInGB) =>
+ "También obtienen ${storageAmountInGB} GB";
+
+ static String m37(email) => "Este es el ID de verificación de ${email}";
+ "Crea un enlace para que la gente pueda añadir y ver fotos en tu álbum compartido sin necesidad de la aplicación ente o una cuenta. Genial para recolectar fotos de eventos."),
+ "La cuenta de desarrollador que utilizamos para publicar ente en la App Store ha cambiado. Por eso, tendrás que iniciar sesión de nuevo.\n\nNuestras disculpas por las molestias, pero esto era inevitable."),
+ "Deshabilita el bloqueo de pantalla del dispositivo cuando ente está en primer plano y hay una copia de seguridad en curso. Normalmente esto no es necesario, pero puede ayudar a que las grandes cargas y las importaciones iniciales de grandes bibliotecas se completen más rápido."),
+ "Por favor, pídeles que mantengan presionada su dirección de correo electrónico en la pantalla de ajustes, y verifique que los IDs de ambos dispositivos coincidan."),
+ "La clave de recuperación introducida no es válida. Por favor, asegúrese de que contiene 24 palabras y compruebe la ortografía de cada una.\n\nSi ha introducido un código de recuperación antiguo, asegúrese de que tiene 64 caracteres de largo y compruebe cada uno de ellos."),
+ "Parece que algo salió mal. Por favor, vuelve a intentarlo después de algún tiempo. Si el error persiste, ponte en contacto con nuestro equipo de soporte."),
+ "Para activar la pantalla de bloqueo, por favor configure el código de acceso del dispositivo o el bloqueo de pantalla en los ajustes de su sistema."),
+ "lockscreen":
+ MessageLookupByLibrary.simpleMessage("Pantalla de bloqueo"),
+ "Esto enviará registros para ayudarnos a depurar su problema. Tenga en cuenta que los nombres de los archivos se incluirán para ayudar a rastrear problemas con archivos específicos."),
+ "Debido a la naturaleza de nuestro protocolo de cifrado de extremo a extremo, sus datos no pueden ser descifrados sin su contraseña o clave de recuperación"),
+ "Su clave de recuperación es la única forma de recuperar sus fotos si olvida su contraseña. Puede encontrar su clave de recuperación en Ajustes > Cuenta.\n\nPor favor, introduzca su clave de recuperación aquí para verificar que la ha guardado correctamente."),
+ "El dispositivo actual no es lo suficientemente potente para verificar su contraseña, pero podemos regenerarla de una manera que funcione con todos los dispositivos.\n\nPor favor inicie sesión usando su clave de recuperación y regenere su contraseña (puede volver a utilizar la misma si lo desea)."),
+ "Parece que algo salió mal. Por favor, vuelve a intentarlo después de algún tiempo. Si el error persiste, ponte en contacto con nuestro equipo de soporte."),
+ "El almacenamiento utilizable está limitado por su plan actual. El exceso de almacenamiento reclamado se volverá automáticamente utilizable cuando actualice su plan."),
+ "usePublicLinksForPeopleNotOnEnte":
+ MessageLookupByLibrary.simpleMessage(
+ "Usa enlaces públicos para personas que no están en ente"),
+ "useRecoveryKey":
+ MessageLookupByLibrary.simpleMessage("Usar clave de recuperación"),
+ static String m12(expiryTime) => "Le lien expirera le ${expiryTime}";
+
+ static String m13(maxValue) =>
+ "Lorsqu\'elle est définie au maximum (${maxValue}), la limite de l\'appareil sera assouplie pour permettre des pointes temporaires d\'un grand nombre de téléspectateurs.";
+ "code de parrainage ente : ${referralCode} \n\nAppliquez le dans Paramètres → Général → Références pour obtenir ${referralStorageInGB} Go gratuitement après votre inscription à un plan payant\n\nhttps://ente.io";
+
+ static String m27(numberOfPeople) =>
+ "${Intl.plural(numberOfPeople, zero: 'Partagez avec des personnes spécifiques', one: 'Partagé avec 1 personne', other: 'Partagé avec ${numberOfPeople} des gens')}";
+
+ static String m28(emailIDs) => "Partagé avec ${emailIDs}";
+
+ static String m29(fileType) =>
+ "Ce ${fileType} sera supprimé de votre appareil.";
+
+ static String m30(fileType) =>
+ "Ce ${fileType} est à la fois dans ente et votre appareil.";
+
+ static String m31(fileType) => "Ce ${fileType} sera supprimé de ente.";
+ "Je comprends que si je perds mon mot de passe, je risque de perdre mes données puisque mes données sont <underline>chiffrées de bout en bout</underline>."),
+ "Créez un lien pour permettre aux gens d\'ajouter et de voir des photos dans votre album partagé sans avoir besoin d\'une application ente ou d\'un compte. Idéal pour collecter des photos d\'événement."),
+ "Désactiver le verrouillage de l\'écran de l\'appareil lorsque ente est au premier plan et il y a une sauvegarde en cours. Ce n\'est normalement pas nécessaire, mais peut aider les gros téléchargements et les premières importations de grandes bibliothèques plus rapidement."),
+ "Demandez-leur d\'appuyer longuement sur leur adresse e-mail sur l\'écran des paramètres et de vérifier que les identifiants des deux appareils correspondent."),
+ "Il semble qu\'une erreur s\'est produite. Veuillez réessayer après un certain temps. Si l\'erreur persiste, veuillez contacter notre équipe d\'assistance."),
+ "Pour activer l\'écran de verrouillage, veuillez configurer le code d\'accès de l\'appareil ou le verrouillage de l\'écran dans les paramètres de votre système."),
+ "lockscreen":
+ MessageLookupByLibrary.simpleMessage("Ecran de vérouillage"),
+ "Cela enverra des logs pour nous aider à déboguer votre problème. Veuillez noter que les noms de fichiers seront inclus pour aider à suivre les problèmes avec des fichiers spécifiques."),
+ "En raison de notre protocole de chiffrement de bout en bout, vos données ne peuvent pas être déchiffré sans votre mot de passe ou clé de récupération"),
+ "Votre clé de récupération est la seule façon de récupérer vos photos si vous oubliez votre mot de passe. Vous pouvez trouver votre clé de récupération dans Paramètres > Compte.\n\nVeuillez entrer votre clé de récupération ici pour vous assurer que vous l\'avez enregistrée correctement."),
+ "L\'appareil actuel n\'est pas assez puissant pour vérifier votre mot de passe, mais nous pouvons régénérer d\'une manière qui fonctionne avec tous les appareils.\n\nVeuillez vous connecter à l\'aide de votre clé de récupération et régénérer votre mot de passe (vous pouvez réutiliser le même si vous le souhaitez)."),
+ "recreatePasswordTitle":
+ MessageLookupByLibrary.simpleMessage("Recréer le mot de passe"),
+ "Certains éléments sont à la fois dans ente et votre appareil."),
+ "someOfTheFilesYouAreTryingToDeleteAre":
+ MessageLookupByLibrary.simpleMessage(
+ "Certains des fichiers que vous essayez de supprimer ne sont disponibles que sur votre appareil et ne peuvent pas être récupérés s\'ils sont supprimés"),
+ "Il semble qu\'une erreur s\'est produite. Veuillez réessayer après un certain temps. Si l\'erreur persiste, veuillez contacter notre équipe d\'assistance."),
+ "Le stockage utilisable est limité par votre offre actuelle. Le stockage excédentaire deviendra automatiquement utilisable lorsque vous mettez à niveau votre offre."),
+ static String m43(emailOrName) => "Toegevoegd door ${emailOrName}";
+
+ static String m44(albumName) => "Succesvol toegevoegd aan ${albumName}";
+
+ static String m0(paymentProvider) =>
+ "Annuleer eerst uw bestaande abonnement bij ${paymentProvider}";
+
+ static String m1(user) =>
+ "${user} zal geen foto\'s meer kunnen toevoegen aan dit album\n\nDe gebruiker zal nog steeds bestaande foto\'s kunnen verwijderen die door hen zijn toegevoegd";
+ "${Intl.plural(count, one: 'Het kan verwijderd worden van het apparaat om ${formattedSize} vrij te maken', other: 'Ze kunnen verwijderd worden van het apparaat om ${formattedSize} vrij te maken')}";
+ static String m12(expiryTime) => "Link vervalt op ${expiryTime}";
+
+ static String m13(maxValue) =>
+ "Wanneer ingesteld op het maximum (${maxValue}), wordt het apparaatlimiet versoepeld om tijdelijke pieken van grote aantallen kijkers mogelijk te maken.";
+ "ente verwijzingscode: ${referralCode} \n\nPas het toe bij Instellingen → Algemeen → Verwijzingen om ${referralStorageInGB} GB gratis te krijgen nadat je je hebt aangemeld voor een betaald abonnement\n\nhttps://ente.io";
+
+ static String m27(numberOfPeople) =>
+ "${Intl.plural(numberOfPeople, zero: 'Deel met specifieke mensen', one: 'Gedeeld met 1 persoon', other: 'Gedeeld met ${numberOfPeople} mensen')}";
+
+ static String m28(emailIDs) => "Gedeeld met ${emailIDs}";
+
+ static String m29(fileType) =>
+ "Dit ${fileType} zal worden verwijderd van jouw apparaat.";
+
+ static String m30(fileType) =>
+ "Dit ${fileType} staat zowel in ente als in jouw apparaat.";
+
+ static String m31(fileType) =>
+ "Dit ${fileType} zal worden verwijderd uit ente.";
+ "Ik begrijp dat als ik mijn wachtwoord verlies, ik mijn gegevens kan verliezen omdat mijn gegevens <underline>end-to-end versleuteld</underline> zijn."),
+ "Maak een link waarmee mensen foto\'s in jouw gedeelde album kunnen toevoegen en bekijken zonder dat ze daarvoor een ente app of account nodig hebben. Handig voor het verzamelen van foto\'s van evenementen."),
+ "Het ontwikkelaarsaccount dat we gebruiken om te publiceren in de App Store is veranderd. Daarom moet je opnieuw inloggen.\n\nOnze excuses voor het ongemak, helaas was dit onvermijdelijk."),
+ "Schakel de schermvergrendeling van het apparaat uit wanneer ente op de voorgrond is en er een back-up aan de gang is. Dit is normaal gesproken niet nodig, maar kan grote uploads en initiële imports van grote mappen sneller laten verlopen."),
+ "didYouKnow": MessageLookupByLibrary.simpleMessage("Wist u dat?"),
+ "De herstelsleutel die je hebt ingevoerd is niet geldig. Zorg ervoor dat deze 24 woorden bevat en controleer de spelling van elk van deze woorden.\n\nAls je een oudere herstelcode hebt ingevoerd, zorg ervoor dat deze 64 tekens lang is, en controleer ze allemaal."),
+ "Dit zal logboeken verzenden om ons te helpen uw probleem op te lossen. Houd er rekening mee dat bestandsnamen zullen worden meegenomen om problemen met specifieke bestanden bij te houden."),
+ "Je herstelsleutel is de enige manier om je foto\'s te herstellen als je je wachtwoord bent vergeten. Je vindt je herstelsleutel in Instellingen > Account.\n\nVoer hier je herstelsleutel in om te controleren of je hem correct hebt opgeslagen."),
+ "Het huidige apparaat is niet krachtig genoeg om je wachtwoord te verifiëren, dus moeten we de code een keer opnieuw genereren op een manier die met alle apparaten werkt.\n\nLog in met behulp van uw herstelcode en genereer opnieuw uw wachtwoord (je kunt dezelfde indien gewenst opnieuw gebruiken)."),
+ "Bruikbare opslag is beperkt door je huidige abonnement. Buitensporige geclaimde opslag zal automatisch bruikbaar worden wanneer je je abonnement upgrade."),
+ "usePublicLinksForPeopleNotOnEnte":
+ MessageLookupByLibrary.simpleMessage(
+ "Gebruik publieke links voor mensen die niet op ente zitten"),
+ "Código de referência do ente: ${referralCode} \n\nAplique em Configurações → Geral → Indicações para obter ${referralStorageInGB} GB gratuitamente após a sua inscrição em um plano pago\n\nhttps://ente.io";
+ "A chave de recuperação que você digitou não é válida. Certifique-se de que contém 24 palavras e verifique a ortografia de cada uma.\n\nSe você inseriu um código de recuperação mais antigo, verifique se ele tem 64 caracteres e verifique cada um deles."),
+ "inviteToEnte":
+ MessageLookupByLibrary.simpleMessage("Convidar para o ente"),
+ "inviteYourFriends":
+ MessageLookupByLibrary.simpleMessage("Convide seus amigos"),
+ "Devido à natureza do nosso protocolo de criptografia de ponta a ponta, seus dados não podem ser descriptografados sem sua senha ou chave de recuperação"),
+ "Sua chave de recuperação é a única maneira de recuperar suas fotos se você esquecer sua senha. Você pode encontrar sua chave de recuperação em Configurações > Conta.\n\nDigite sua chave de recuperação aqui para verificar se você a salvou corretamente."),
+ "recoverySuccessful":
+ MessageLookupByLibrary.simpleMessage("Recuperação bem sucedida!"),
+ "O dispositivo atual não é poderoso o suficiente para verificar sua senha, mas podemos regenerar de uma forma que funcione com todos os dispositivos.\n\nPor favor, faça o login usando sua chave de recuperação e recrie sua senha (você pode usar o mesmo novamente se desejar)."),
+ "recreatePasswordTitle":
+ MessageLookupByLibrary.simpleMessage("Restabeleça sua senha"),
+ "Armazenamento utilizável é limitado pelo seu plano atual. O armazenamento reivindicado em excesso se tornará utilizável automaticamente quando você fizer a melhoria do seu plano."),
+ "useRecoveryKey":
+ MessageLookupByLibrary.simpleMessage("Usar chave de recuperação"),
+ /// `I understand that if I lose my password, I may lose my data since my data is <underline>end-to-end encrypted</underline>.`
+ String get ackPasswordLostWarning {
+ return Intl.message(
+ 'I understand that if I lose my password, I may lose my data since my data is <underline>end-to-end encrypted</underline>.',
+ name: 'ackPasswordLostWarning',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Privacy Policy`
+ String get privacyPolicyTitle {
+ return Intl.message(
+ 'Privacy Policy',
+ name: 'privacyPolicyTitle',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Terms`
+ String get termsOfServicesTitle {
+ return Intl.message(
+ 'Terms',
+ name: 'termsOfServicesTitle',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `I agree to the <u-terms>terms of service</u-terms> and <u-policy>privacy policy</u-policy>`
+ String get signUpTerms {
+ return Intl.message(
+ 'I agree to the <u-terms>terms of service</u-terms> and <u-policy>privacy policy</u-policy>',
+ name: 'signUpTerms',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Log in`
+ String get logInLabel {
+ return Intl.message(
+ 'Log in',
+ name: 'logInLabel',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `By clicking log in, I agree to the <u-terms>terms of service</u-terms> and <u-policy>privacy policy</u-policy>`
+ String get loginTerms {
+ return Intl.message(
+ 'By clicking log in, I agree to the <u-terms>terms of service</u-terms> and <u-policy>privacy policy</u-policy>',
+ name: 'loginTerms',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Change email`
+ String get changeEmail {
+ return Intl.message(
+ 'Change email',
+ name: 'changeEmail',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Enter your password`
+ String get enterYourPassword {
+ return Intl.message(
+ 'Enter your password',
+ name: 'enterYourPassword',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Welcome back!`
+ String get welcomeBack {
+ return Intl.message(
+ 'Welcome back!',
+ name: 'welcomeBack',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Contact support`
+ String get contactSupport {
+ return Intl.message(
+ 'Contact support',
+ name: 'contactSupport',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Incorrect password`
+ String get incorrectPasswordTitle {
+ return Intl.message(
+ 'Incorrect password',
+ name: 'incorrectPasswordTitle',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please try again`
+ String get pleaseTryAgain {
+ return Intl.message(
+ 'Please try again',
+ name: 'pleaseTryAgain',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recreate password`
+ String get recreatePasswordTitle {
+ return Intl.message(
+ 'Recreate password',
+ name: 'recreatePasswordTitle',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Use recovery key`
+ String get useRecoveryKey {
+ return Intl.message(
+ 'Use recovery key',
+ name: 'useRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `The current device is not powerful enough to verify your password, but we can regenerate in a way that works with all devices.\n\nPlease login using your recovery key and regenerate your password (you can use the same one again if you wish).`
+ String get recreatePasswordBody {
+ return Intl.message(
+ 'The current device is not powerful enough to verify your password, but we can regenerate in a way that works with all devices.\n\nPlease login using your recovery key and regenerate your password (you can use the same one again if you wish).',
+ name: 'recreatePasswordBody',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Verify password`
+ String get verifyPassword {
+ return Intl.message(
+ 'Verify password',
+ name: 'verifyPassword',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recovery key`
+ String get recoveryKey {
+ return Intl.message(
+ 'Recovery key',
+ name: 'recoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `If you forget your password, the only way you can recover your data is with this key.`
+ String get recoveryKeyOnForgotPassword {
+ return Intl.message(
+ 'If you forget your password, the only way you can recover your data is with this key.',
+ name: 'recoveryKeyOnForgotPassword',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `We don't store this key, please save this 24 word key in a safe place.`
+ String get recoveryKeySaveDescription {
+ return Intl.message(
+ 'We don\'t store this key, please save this 24 word key in a safe place.',
+ name: 'recoveryKeySaveDescription',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Do this later`
+ String get doThisLater {
+ return Intl.message(
+ 'Do this later',
+ name: 'doThisLater',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Save key`
+ String get saveKey {
+ return Intl.message(
+ 'Save key',
+ name: 'saveKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recovery key copied to clipboard`
+ String get recoveryKeyCopiedToClipboard {
+ return Intl.message(
+ 'Recovery key copied to clipboard',
+ name: 'recoveryKeyCopiedToClipboard',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recover account`
+ String get recoverAccount {
+ return Intl.message(
+ 'Recover account',
+ name: 'recoverAccount',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recover`
+ String get recover {
+ return Intl.message(
+ 'Recover',
+ name: 'recover',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please drop an email to {supportEmail} from your registered email address`
+ String dropSupportEmail(String supportEmail) {
+ return Intl.message(
+ 'Please drop an email to $supportEmail from your registered email address',
+ name: 'dropSupportEmail',
+ desc: '',
+ args: [supportEmail],
+ );
+ }
+
+ /// `Two-factor setup`
+ String get twofactorSetup {
+ return Intl.message(
+ 'Two-factor setup',
+ name: 'twofactorSetup',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Enter code`
+ String get enterCode {
+ return Intl.message(
+ 'Enter code',
+ name: 'enterCode',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Scan code`
+ String get scanCode {
+ return Intl.message(
+ 'Scan code',
+ name: 'scanCode',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Code copied to clipboard`
+ String get codeCopiedToClipboard {
+ return Intl.message(
+ 'Code copied to clipboard',
+ name: 'codeCopiedToClipboard',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Copy-paste this code\nto your authenticator app`
+ String get copypasteThisCodentoYourAuthenticatorApp {
+ return Intl.message(
+ 'Copy-paste this code\nto your authenticator app',
+ /// `Save your recovery key if you haven't already`
+ String get saveYourRecoveryKeyIfYouHaventAlready {
+ return Intl.message(
+ 'Save your recovery key if you haven\'t already',
+ name: 'saveYourRecoveryKeyIfYouHaventAlready',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `This can be used to recover your account if you lose your second factor`
+ String get thisCanBeUsedToRecoverYourAccountIfYou {
+ return Intl.message(
+ 'This can be used to recover your account if you lose your second factor',
+ name: 'thisCanBeUsedToRecoverYourAccountIfYou',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Two-factor authentication`
+ String get twofactorAuthenticationPageTitle {
+ return Intl.message(
+ 'Two-factor authentication',
+ name: 'twofactorAuthenticationPageTitle',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Lost device?`
+ String get lostDevice {
+ return Intl.message(
+ 'Lost device?',
+ name: 'lostDevice',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Verifying recovery key...`
+ String get verifyingRecoveryKey {
+ return Intl.message(
+ 'Verifying recovery key...',
+ name: 'verifyingRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Recovery key verified`
+ String get recoveryKeyVerified {
+ return Intl.message(
+ 'Recovery key verified',
+ name: 'recoveryKeyVerified',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Great! Your recovery key is valid. Thank you for verifying.\n\nPlease remember to keep your recovery key safely backed up.`
+ String get recoveryKeySuccessBody {
+ return Intl.message(
+ 'Great! Your recovery key is valid. Thank you for verifying.\n\nPlease remember to keep your recovery key safely backed up.',
+ name: 'recoveryKeySuccessBody',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `The recovery key you entered is not valid. Please make sure it contains 24 words, and check the spelling of each.\n\nIf you entered an older recovery code, make sure it is 64 characters long, and check each of them.`
+ String get invalidRecoveryKey {
+ return Intl.message(
+ 'The recovery key you entered is not valid. Please make sure it contains 24 words, and check the spelling of each.\n\nIf you entered an older recovery code, make sure it is 64 characters long, and check each of them.',
+ name: 'invalidRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Invalid key`
+ String get invalidKey {
+ return Intl.message(
+ 'Invalid key',
+ name: 'invalidKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Try again`
+ String get tryAgain {
+ return Intl.message(
+ 'Try again',
+ name: 'tryAgain',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `View recovery key`
+ String get viewRecoveryKey {
+ return Intl.message(
+ 'View recovery key',
+ name: 'viewRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Confirm recovery key`
+ String get confirmRecoveryKey {
+ return Intl.message(
+ 'Confirm recovery key',
+ name: 'confirmRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Your recovery key is the only way to recover your photos if you forget your password. You can find your recovery key in Settings > Account.\n\nPlease enter your recovery key here to verify that you have saved it correctly.`
+ String get recoveryKeyVerifyReason {
+ return Intl.message(
+ 'Your recovery key is the only way to recover your photos if you forget your password. You can find your recovery key in Settings > Account.\n\nPlease enter your recovery key here to verify that you have saved it correctly.',
+ name: 'recoveryKeyVerifyReason',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Confirm your recovery key`
+ String get confirmYourRecoveryKey {
+ return Intl.message(
+ 'Confirm your recovery key',
+ name: 'confirmYourRecoveryKey',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Add viewer`
+ String get addViewer {
+ return Intl.message(
+ 'Add viewer',
+ name: 'addViewer',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Add collaborator`
+ String get addCollaborator {
+ return Intl.message(
+ 'Add collaborator',
+ name: 'addCollaborator',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Add a new email`
+ String get addANewEmail {
+ return Intl.message(
+ 'Add a new email',
+ name: 'addANewEmail',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Or pick an existing one`
+ String get orPickAnExistingOne {
+ return Intl.message(
+ 'Or pick an existing one',
+ name: 'orPickAnExistingOne',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Collaborators can add photos and videos to the shared album.`
+ String get collaboratorsCanAddPhotosAndVideosToTheSharedAlbum {
+ return Intl.message(
+ 'Collaborators can add photos and videos to the shared album.',
+ 'When set to the maximum ($maxValue), the device limit will be relaxed to allow for temporary spikes of large number of viewers.',
+ name: 'maxDeviceLimitSpikeHandling',
+ desc: '',
+ args: [maxValue],
+ );
+ }
+
+ /// `Never`
+ String get never {
+ return Intl.message(
+ 'Never',
+ name: 'never',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Custom`
+ String get custom {
+ return Intl.message(
+ 'Custom',
+ name: 'custom',
+ desc: 'Label for setting custom value for link expiry',
+ args: [],
+ );
+ }
+
+ /// `After 1 hour`
+ String get after1Hour {
+ return Intl.message(
+ 'After 1 hour',
+ name: 'after1Hour',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `After 1 day`
+ String get after1Day {
+ return Intl.message(
+ 'After 1 day',
+ name: 'after1Day',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `After 1 week`
+ String get after1Week {
+ return Intl.message(
+ 'After 1 week',
+ name: 'after1Week',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `After 1 month`
+ String get after1Month {
+ return Intl.message(
+ 'After 1 month',
+ name: 'after1Month',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `After 1 year`
+ String get after1Year {
+ return Intl.message(
+ 'After 1 year',
+ name: 'after1Year',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Manage`
+ String get manageParticipants {
+ return Intl.message(
+ 'Manage',
+ name: 'manageParticipants',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Create a link to allow people to add and view photos in your shared album without needing an ente app or account. Great for collecting event photos.`
+ String get collabLinkSectionDescription {
+ return Intl.message(
+ 'Create a link to allow people to add and view photos in your shared album without needing an ente app or account. Great for collecting event photos.',
+ name: 'collabLinkSectionDescription',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Collect photos`
+ String get collectPhotos {
+ return Intl.message(
+ 'Collect photos',
+ name: 'collectPhotos',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Collaborative link`
+ String get collaborativeLink {
+ return Intl.message(
+ 'Collaborative link',
+ name: 'collaborativeLink',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Share with non-ente users`
+ String get shareWithNonenteUsers {
+ return Intl.message(
+ 'Share with non-ente users',
+ name: 'shareWithNonenteUsers',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Create public link`
+ String get createPublicLink {
+ return Intl.message(
+ 'Create public link',
+ name: 'createPublicLink',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Send link`
+ String get sendLink {
+ return Intl.message(
+ 'Send link',
+ name: 'sendLink',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Copy link`
+ String get copyLink {
+ return Intl.message(
+ 'Copy link',
+ name: 'copyLink',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Link has expired`
+ String get linkHasExpired {
+ return Intl.message(
+ 'Link has expired',
+ name: 'linkHasExpired',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Public link enabled`
+ String get publicLinkEnabled {
+ return Intl.message(
+ 'Public link enabled',
+ name: 'publicLinkEnabled',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Share a link`
+ String get shareALink {
+ return Intl.message(
+ 'Share a link',
+ name: 'shareALink',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Create shared and collaborative albums with other ente users, including users on free plans.`
+ String get sharedAlbumSectionDescription {
+ return Intl.message(
+ 'Create shared and collaborative albums with other ente users, including users on free plans.',
+ name: 'sharedAlbumSectionDescription',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `{numberOfPeople, plural, =0 {Share with specific people} =1 {Shared with 1 person} other {Shared with {numberOfPeople} people}}`
+ '$storageAmountInGB GB each time someone signs up for a paid plan and applies your code',
+ name: 'freeStorageOnReferralSuccess',
+ desc: '',
+ args: [storageAmountInGB],
+ );
+ }
+
+ /// `ente referral code: {referralCode} \n\nApply it in Settings → General → Referrals to get {referralStorageInGB} GB free after you signup for a paid plan\n\nhttps://ente.io`
+ 'ente referral code: $referralCode \n\nApply it in Settings → General → Referrals to get $referralStorageInGB GB free after you signup for a paid plan\n\nhttps://ente.io',
+ name: 'shareTextReferralCode',
+ desc: '',
+ args: [referralCode, referralStorageInGB],
+ );
+ }
+
+ /// `Claim free storage`
+ String get claimFreeStorage {
+ return Intl.message(
+ 'Claim free storage',
+ name: 'claimFreeStorage',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Invite your friends`
+ String get inviteYourFriends {
+ return Intl.message(
+ 'Invite your friends',
+ name: 'inviteYourFriends',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Unable to fetch referral details. Please try again later.`
+ String get failedToFetchReferralDetails {
+ return Intl.message(
+ 'Unable to fetch referral details. Please try again later.',
+ name: 'failedToFetchReferralDetails',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `1. Give this code to your friends`
+ String get referralStep1 {
+ return Intl.message(
+ '1. Give this code to your friends',
+ name: 'referralStep1',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `2. They sign up for a paid plan`
+ String get referralStep2 {
+ return Intl.message(
+ '2. They sign up for a paid plan',
+ name: 'referralStep2',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `3. Both of you get {storageInGB} GB* free`
+ String referralStep3(Object storageInGB) {
+ return Intl.message(
+ '3. Both of you get $storageInGB GB* free',
+ name: 'referralStep3',
+ desc: '',
+ args: [storageInGB],
+ );
+ }
+
+ /// `Referrals are currently paused`
+ String get referralsAreCurrentlyPaused {
+ return Intl.message(
+ 'Referrals are currently paused',
+ name: 'referralsAreCurrentlyPaused',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `* You can at max double your storage`
+ String get youCanAtMaxDoubleYourStorage {
+ return Intl.message(
+ '* You can at max double your storage',
+ name: 'youCanAtMaxDoubleYourStorage',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `{isFamilyMember, select, true {Your family has claimed {storageAmountInGb} Gb so far} false {You have claimed {storageAmountInGb} Gb so far} other {You have claimed {storageAmountInGb} Gb so far!}}`
+ String claimedStorageSoFar(String isFamilyMember, int storageAmountInGb) {
+ return Intl.select(
+ isFamilyMember,
+ {
+ 'true': 'Your family has claimed $storageAmountInGb Gb so far',
+ 'false': 'You have claimed $storageAmountInGb Gb so far',
+ 'other': 'You have claimed $storageAmountInGb Gb so far!',
+ },
+ name: 'claimedStorageSoFar',
+ desc: '',
+ args: [isFamilyMember, storageAmountInGb],
+ );
+ }
+
+ /// `This is my name: {nameValue}, my age is {ageValue}`
+ /// `{count, plural, one{{count} year ago} other{{count} years ago}}`
+ String yearsAgo(num count) {
+ return Intl.plural(
+ count,
+ one: '$count year ago',
+ other: '$count years ago',
+ name: 'yearsAgo',
+ desc: '',
+ args: [count],
+ );
+ }
+
+ /// `Backup settings`
+ String get backupSettings {
+ return Intl.message(
+ 'Backup settings',
+ name: 'backupSettings',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Backup over mobile data`
+ String get backupOverMobileData {
+ return Intl.message(
+ 'Backup over mobile data',
+ name: 'backupOverMobileData',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Backup videos`
+ String get backupVideos {
+ return Intl.message(
+ 'Backup videos',
+ name: 'backupVideos',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Disable auto lock`
+ String get disableAutoLock {
+ return Intl.message(
+ 'Disable auto lock',
+ name: 'disableAutoLock',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Disable the device screen lock when ente is in the foreground and there is a backup in progress. This is normally not needed, but may help big uploads and initial imports of large libraries complete faster.`
+ String get deviceLockExplanation {
+ return Intl.message(
+ 'Disable the device screen lock when ente is in the foreground and there is a backup in progress. This is normally not needed, but may help big uploads and initial imports of large libraries complete faster.',
+ name: 'deviceLockExplanation',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `About`
+ String get about {
+ return Intl.message(
+ 'About',
+ name: 'about',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `We are open source!`
+ String get weAreOpenSource {
+ return Intl.message(
+ 'We are open source!',
+ name: 'weAreOpenSource',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Privacy`
+ String get privacy {
+ return Intl.message(
+ 'Privacy',
+ name: 'privacy',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Terms`
+ String get terms {
+ return Intl.message(
+ 'Terms',
+ name: 'terms',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Check for updates`
+ String get checkForUpdates {
+ return Intl.message(
+ 'Check for updates',
+ name: 'checkForUpdates',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Checking...`
+ String get checking {
+ return Intl.message(
+ 'Checking...',
+ name: 'checking',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `You are on the latest version`
+ String get youAreOnTheLatestVersion {
+ return Intl.message(
+ 'You are on the latest version',
+ name: 'youAreOnTheLatestVersion',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Account`
+ String get account {
+ return Intl.message(
+ 'Account',
+ name: 'account',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Manage subscription`
+ String get manageSubscription {
+ return Intl.message(
+ 'Manage subscription',
+ name: 'manageSubscription',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please authenticate to change your email`
+ String get authToChangeYourEmail {
+ return Intl.message(
+ 'Please authenticate to change your email',
+ name: 'authToChangeYourEmail',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Change password`
+ String get changePassword {
+ return Intl.message(
+ 'Change password',
+ name: 'changePassword',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please authenticate to change your password`
+ String get authToChangeYourPassword {
+ return Intl.message(
+ 'Please authenticate to change your password',
+ name: 'authToChangeYourPassword',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Export your data`
+ String get exportYourData {
+ return Intl.message(
+ 'Export your data',
+ name: 'exportYourData',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Logout`
+ String get logout {
+ return Intl.message(
+ 'Logout',
+ name: 'logout',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please authenticate to initiate account deletion`
+ String get authToInitiateAccountDeletion {
+ return Intl.message(
+ 'Please authenticate to initiate account deletion',
+ name: 'authToInitiateAccountDeletion',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Are you sure you want to logout?`
+ String get areYouSureYouWantToLogout {
+ return Intl.message(
+ 'Are you sure you want to logout?',
+ name: 'areYouSureYouWantToLogout',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Yes, logout`
+ String get yesLogout {
+ return Intl.message(
+ 'Yes, logout',
+ name: 'yesLogout',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `A new version of ente is available.`
+ String get aNewVersionOfEnteIsAvailable {
+ return Intl.message(
+ 'A new version of ente is available.',
+ name: 'aNewVersionOfEnteIsAvailable',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Update`
+ String get update {
+ return Intl.message(
+ 'Update',
+ name: 'update',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Install manually`
+ String get installManually {
+ return Intl.message(
+ 'Install manually',
+ name: 'installManually',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Critical update available`
+ String get criticalUpdateAvailable {
+ return Intl.message(
+ 'Critical update available',
+ name: 'criticalUpdateAvailable',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Update available`
+ String get updateAvailable {
+ return Intl.message(
+ 'Update available',
+ name: 'updateAvailable',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Downloading...`
+ String get downloading {
+ return Intl.message(
+ 'Downloading...',
+ name: 'downloading',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `The download could not be completed`
+ String get theDownloadCouldNotBeCompleted {
+ return Intl.message(
+ 'The download could not be completed',
+ name: 'theDownloadCouldNotBeCompleted',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Retry`
+ String get retry {
+ return Intl.message(
+ 'Retry',
+ name: 'retry',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Backed up folders`
+ String get backedUpFolders {
+ return Intl.message(
+ 'Backed up folders',
+ name: 'backedUpFolders',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Backup`
+ String get backup {
+ return Intl.message(
+ 'Backup',
+ name: 'backup',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Free up device space`
+ String get freeUpDeviceSpace {
+ return Intl.message(
+ 'Free up device space',
+ name: 'freeUpDeviceSpace',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `✨ All clear`
+ String get allClear {
+ return Intl.message(
+ '✨ All clear',
+ name: 'allClear',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `You've no files on this device that can be deleted`
+ String get noDeviceThatCanBeDeleted {
+ return Intl.message(
+ 'You\'ve no files on this device that can be deleted',
+ name: 'noDeviceThatCanBeDeleted',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Remove duplicates`
+ String get removeDuplicates {
+ return Intl.message(
+ 'Remove duplicates',
+ name: 'removeDuplicates',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `✨ No duplicates`
+ String get noDuplicates {
+ return Intl.message(
+ '✨ No duplicates',
+ name: 'noDuplicates',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `You've no duplicate files that can be cleared`
+ String get youveNoDuplicateFilesThatCanBeCleared {
+ return Intl.message(
+ 'You\'ve no duplicate files that can be cleared',
+ name: 'youveNoDuplicateFilesThatCanBeCleared',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Success`
+ String get success {
+ return Intl.message(
+ 'Success',
+ name: 'success',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Rate us`
+ String get rateUs {
+ return Intl.message(
+ 'Rate us',
+ name: 'rateUs',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Also empty "Recently Deleted" from "Settings" -> "Storage" to claim the freed space`
+ String get remindToEmptyDeviceTrash {
+ return Intl.message(
+ 'Also empty "Recently Deleted" from "Settings" -> "Storage" to claim the freed space',
+ name: 'remindToEmptyDeviceTrash',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `You have successfully freed up {storageSaved}!`
+ 'Please contact <green>$familyAdminEmail</green> to manage your subscription',
+ name: 'contactFamilyAdmin',
+ desc: '',
+ args: [familyAdminEmail],
+ );
+ }
+
+ /// `Leave family`
+ String get leaveFamily {
+ return Intl.message(
+ 'Leave family',
+ name: 'leaveFamily',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Are you sure that you want to leave the family plan?`
+ String get areYouSureThatYouWantToLeaveTheFamily {
+ return Intl.message(
+ 'Are you sure that you want to leave the family plan?',
+ name: 'areYouSureThatYouWantToLeaveTheFamily',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Leave`
+ String get leave {
+ return Intl.message(
+ 'Leave',
+ name: 'leave',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Rate the app`
+ String get rateTheApp {
+ return Intl.message(
+ 'Rate the app',
+ name: 'rateTheApp',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Start backup`
+ String get startBackup {
+ return Intl.message(
+ 'Start backup',
+ name: 'startBackup',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `No photos are being backed up right now`
+ String get noPhotosAreBeingBackedUpRightNow {
+ return Intl.message(
+ 'No photos are being backed up right now',
+ name: 'noPhotosAreBeingBackedUpRightNow',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Preserve more`
+ String get preserveMore {
+ return Intl.message(
+ 'Preserve more',
+ name: 'preserveMore',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Existing user`
+ String get existingUser {
+ return Intl.message(
+ 'Existing user',
+ name: 'existingUser',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Private backups`
+ String get privateBackups {
+ return Intl.message(
+ 'Private backups',
+ name: 'privateBackups',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `for your memories`
+ String get forYourMemories {
+ return Intl.message(
+ 'for your memories',
+ name: 'forYourMemories',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `End-to-end encrypted by default`
+ String get endtoendEncryptedByDefault {
+ return Intl.message(
+ 'End-to-end encrypted by default',
+ name: 'endtoendEncryptedByDefault',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Safely stored`
+ String get safelyStored {
+ return Intl.message(
+ 'Safely stored',
+ name: 'safelyStored',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `at a fallout shelter`
+ String get atAFalloutShelter {
+ return Intl.message(
+ 'at a fallout shelter',
+ name: 'atAFalloutShelter',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Designed to outlive`
+ String get designedToOutlive {
+ return Intl.message(
+ 'Designed to outlive',
+ name: 'designedToOutlive',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Available`
+ String get available {
+ return Intl.message(
+ 'Available',
+ name: 'available',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `everywhere`
+ String get everywhere {
+ return Intl.message(
+ 'everywhere',
+ name: 'everywhere',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Android, iOS, Web, Desktop`
+ String get androidIosWebDesktop {
+ return Intl.message(
+ 'Android, iOS, Web, Desktop',
+ name: 'androidIosWebDesktop',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Mobile, Web, Desktop`
+ String get mobileWebDesktop {
+ return Intl.message(
+ 'Mobile, Web, Desktop',
+ name: 'mobileWebDesktop',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `New to ente`
+ String get newToEnte {
+ return Intl.message(
+ 'New to ente',
+ name: 'newToEnte',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please login again`
+ String get pleaseLoginAgain {
+ return Intl.message(
+ 'Please login again',
+ name: 'pleaseLoginAgain',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `The developer account we use to publish ente on App Store has changed. Because of this, you will need to login again.\n\nOur apologies for the inconvenience, but this was unavoidable.`
+ String get devAccountChanged {
+ return Intl.message(
+ 'The developer account we use to publish ente on App Store has changed. Because of this, you will need to login again.\n\nOur apologies for the inconvenience, but this was unavoidable.',
+ name: 'devAccountChanged',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Your subscription has expired`
+ String get yourSubscriptionHasExpired {
+ return Intl.message(
+ 'Your subscription has expired',
+ name: 'yourSubscriptionHasExpired',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Storage limit exceeded`
+ String get storageLimitExceeded {
+ return Intl.message(
+ 'Storage limit exceeded',
+ name: 'storageLimitExceeded',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Upgrade`
+ String get upgrade {
+ return Intl.message(
+ 'Upgrade',
+ name: 'upgrade',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Raise ticket`
+ String get raiseTicket {
+ return Intl.message(
+ 'Raise ticket',
+ name: 'raiseTicket',
+ desc:
+ 'Button text for raising a support tickets in case of unhandled errors during backup',
+ args: [],
+ );
+ }
+
+ /// `Backup failed`
+ String get backupFailed {
+ return Intl.message(
+ 'Backup failed',
+ name: 'backupFailed',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `We could not backup your data.\nWe will retry later.`
+ String get couldNotBackUpTryLater {
+ return Intl.message(
+ 'We could not backup your data.\nWe will retry later.',
+ name: 'couldNotBackUpTryLater',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `ente can encrypt and preserve files only if you grant access to them`
+ String get enteCanEncryptAndPreserveFilesOnlyIfYouGrant {
+ return Intl.message(
+ 'ente can encrypt and preserve files only if you grant access to them',
+ /// `Please review and delete the items you believe are duplicates.`
+ String get reviewDeduplicateItems {
+ return Intl.message(
+ 'Please review and delete the items you believe are duplicates.',
+ name: 'reviewDeduplicateItems',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Club by capture time`
+ String get clubByCaptureTime {
+ return Intl.message(
+ 'Club by capture time',
+ name: 'clubByCaptureTime',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Count`
+ String get count {
+ return Intl.message(
+ 'Count',
+ name: 'count',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Total size`
+ String get totalSize {
+ return Intl.message(
+ 'Total size',
+ name: 'totalSize',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Time`
+ String get time {
+ return Intl.message(
+ 'Time',
+ name: 'time',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Long-press on an item to view in full-screen`
+ String get longpressOnAnItemToViewInFullscreen {
+ return Intl.message(
+ 'Long-press on an item to view in full-screen',
+ name: 'longpressOnAnItemToViewInFullscreen',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Decrypting video...`
+ String get decryptingVideo {
+ return Intl.message(
+ 'Decrypting video...',
+ name: 'decryptingVideo',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Please authenticate to view your memories`
+ String get authToViewYourMemories {
+ return Intl.message(
+ 'Please authenticate to view your memories',
+ name: 'authToViewYourMemories',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Unlock`
+ String get unlock {
+ return Intl.message(
+ 'Unlock',
+ name: 'unlock',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `Free up space`
+ String get freeUpSpace {
+ return Intl.message(
+ 'Free up space',
+ name: 'freeUpSpace',
+ desc: '',
+ args: [],
+ );
+ }
+
+ /// `{count, plural, one {It can be deleted from the device to free up {formattedSize}} other {They can be deleted from the device to free up {formattedSize}}}`
+ "enterValidEmail": "Bitte gib eine gültige E-Mail-Adresse ein.",
"deleteAccount": "Konto löschen",
+ "askDeleteReason": "Was ist der Hauptgrund für die Löschung deines Kontos?",
+ "deleteAccountFeedbackPrompt": "Wir bedauern sehr, dass du dein Konto löschen möchtest. Du würdest uns sehr helfen, wenn du uns kurz einige Gründe hierfür nennen könntest.",
"feedback": "Rückmeldung",
+ "kindlyHelpUsWithThisInformation": "Bitte gib diese Daten ein",
+ "confirmDeletePrompt": "Ja, ich möchte dieses Konto und alle enthaltenen Daten endgültig und unwiderruflich löschen.",
+ "noRecoveryKeyNoDecryption": "Aufgrund unseres Ende-zu-Ende-Verschlüsselungsprotokolls können deine Daten nicht ohne dein Passwort oder deinen Wiederherstellungs-Schlüssel entschlüsselt werden",
+ "verifyEmail": "E-Mail-Adresse verifizieren",
+ "checkInboxAndSpamFolder": "Bitte überprüfe deinen E-Mail-Posteingang (und Spam), um die Verifizierung abzuschließen",
+ "tapToEnterCode": "Antippen, um den Code einzugeben",
+ "resendEmail": "E-Mail erneut senden",
+ "weHaveSendEmailTo": "Wir haben eine E-Mail an <green>{email}</green> gesendet",
+ "@weHaveSendEmailTo": {
+ "description": "Text to indicate that we have sent a mail to the user",
+ "placeholders": {
+ "email": {
+ "description": "The email address of the user",
+ "type": "String",
+ "example": "example@ente.io"
+ }
+ }
+ },
+ "setPasswordTitle": "Passwort festlegen",
+ "changePasswordTitle": "Passwort ändern",
+ "resetPasswordTitle": "Passwort zurücksetzen",
+ "encryptionKeys": "Verschlüsselungscode",
+ "passwordWarning": "Wir speichern dieses Passwort nicht. Wenn du es vergisst, <underline>können wir deine Daten nicht entschlüsseln</underline>",
+ "enterPasswordToEncrypt": "Gib ein Passwort ein, mit dem wir deine Daten verschlüsseln können",
+ "enterNewPasswordToEncrypt": "Gib ein neues Passwort ein, mit dem wir deine Daten verschlüsseln können",
+ "generatingEncryptionKeys": "Generierung von Verschlüsselungscodes...",
+ "pleaseWait": "Bitte warten...",
+ "continueLabel": "Weiter",
+ "insecureDevice": "Unsicheres Gerät",
+ "sorryWeCouldNotGenerateSecureKeysOnThisDevicennplease": "Es tut uns leid, wir konnten keine sicheren Schlüssel auf diesem Gerät generieren.\n\nBitte starte die Registrierung auf einem anderen Gerät.",
+ "howItWorks": "So funktioniert's",
+ "encryption": "Verschlüsselung",
+ "ackPasswordLostWarning": "Ich verstehe, dass ich meine Daten verlieren kann, wenn ich mein Passwort vergesse, da meine Daten <underline>Ende-zu-Ende-verschlüsselt</underline> sind.",
+ "privacyPolicyTitle": "Datenschutzerklärung",
+ "termsOfServicesTitle": "Nutzungsbedingungen",
+ "signUpTerms": "Ich stimme den <u-terms>Nutzungsbedingungen</u-terms> und der <u-policy>Datenschutzerklärung</u-policy> zu",
+ "logInLabel": "Anmelden",
+ "loginTerms": "Mit dem Klick auf \"Anmelden\" stimme ich den <u-terms>Nutzungsbedingungen</u-terms> und der <u-policy>Datenschutzerklärung</u-policy> zu",
+ "recreatePasswordBody": "Das aktuelle Gerät ist nicht leistungsfähig genug, um dein Passwort zu verifizieren, aber wir können es neu erstellen, damit es auf allen Geräten funktioniert.\n\nBitte melde dich mit deinem Wiederherstellungs-Schlüssel an und erstelle dein Passwort neu (Wenn du willst, kannst du dasselbe erneut verwenden).",
+ "verifyPassword": "Passwort überprüfen",
+ "recoveryKey": "Wiederherstellungs-Schlüssel",
+ "recoveryKeyOnForgotPassword": "Falls du dein Passwort vergisst, kannst du deine Daten allein mit diesem Schlüssel wiederherstellen.",
+ "recoveryKeySaveDescription": "Wir speichern diesen Schlüssel nicht. Bitte speichere diese Schlüssel aus 24 Wörtern an einem sicheren Ort.",
+ "doThisLater": "Später machen",
+ "saveKey": "Schlüssel speichern",
+ "recoveryKeyCopiedToClipboard": "Wiederherstellungs-Schlüssel in die Zwischenablage kopiert",
+ "recoverAccount": "Konto wiederherstellen",
+ "recover": "Wiederherstellen",
+ "dropSupportEmail": "Bitte sende eine E-Mail an {supportEmail} von deiner registrierten E-Mail-Adresse",
+ "codeCopiedToClipboard": "Code in Zwischenablage kopiert",
+ "copypasteThisCodentoYourAuthenticatorApp": "Kopiere diesen Code\nin deine Authentifizierungs-App",
+ "tapToCopy": "zum Kopieren antippen",
+ "scanThisBarcodeWithnyourAuthenticatorApp": "Scanne diesen Code mit \ndeiner Authentifizierungs-App",
+ "enterThe6digitCodeFromnyourAuthenticatorApp": "Gib den 6-stelligen Code aus\ndeiner Authentifizierungs-App ein",
+ "confirm": "Bestätigen",
+ "setupComplete": "Einrichtung abgeschlossen",
+ "saveYourRecoveryKeyIfYouHaventAlready": "Sichere deinen Wiederherstellungs-Schlüssel, falls noch nicht geschehen",
+ "thisCanBeUsedToRecoverYourAccountIfYou": "Dies kann verwendet werden, um dein Konto wiederherzustellen, wenn du deinen zweiten Faktor (2FA) verlierst",
+ "recoveryKeySuccessBody": "Sehr gut! Ihr Wiederherstellungsschlüssel ist gültig. Vielen Dank für die Verifizierung.\n\nBitte vergessen Sie nicht eine Kopie Ihres Wiederherstellungsschlüssels sicher aufzubewahren.",
+ "invalidRecoveryKey": "Der von Ihnen eingegebene Wiederherstellungsschlüssel ist nicht gültig. Bitte stellen Sie sicher das aus 24 Wörtern zusammen gesetzt ist und jedes dieser Worte richtig geschrieben wurde.\n\nSollten Sie den Wiederherstellungscode eingegeben haben, stellen Sie bitte sicher, dass dieser 64 Worte lang ist und ebenfall richtig geschrieben wurde.",
+ "recoveryKeyVerifyReason": "Ihr Wiederherstellungsschlüssel ist die einzige Möglichkeit Ihre Fotos wieder herzustellen, sollten Sie Ihr Passwort vergessen haben. Sie können diesen unter \"Einstellungen\" und dann \"Konto\" wieder finden.\n\nBitte geben Sie unten Ihren Wiederherstellungsschlüssel ein um sicher zu stellen, dass Sie ihn korrekt hinterlegt haben.",
+ "confirmYourRecoveryKey": "Bestätigen Sie ihren Wiederherstellungsschlüssel",
+ "orPickAnExistingOne": "Oder eine Vorherige auswählen",
+ "collaboratorsCanAddPhotosAndVideosToTheSharedAlbum": "Bearbeiter können Fotos & Videos zu dem geteilten Album hinzufügen.",
+ "enterEmail": "E-Mail eingeben",
+ "albumOwner": "Besitzer",
+ "@albumOwner": {
+ "description": "Role of the album owner"
+ },
+ "you": "Sie",
+ "collaborator": "Bearbeiter",
+ "addMore": "Mehr hinzufügen",
+ "@addMore": {
+ "description": "Button text to add more collaborators/viewers"
+ },
+ "viewer": "Zuschauer",
+ "remove": "Entfernen",
+ "removeParticipant": "Teilnehmer entfernen",
+ "@removeParticipant": {
+ "description": "menuSectionTitle for removing a participant"
+ },
+ "manage": "Verwalten",
+ "addedAs": "Hinzugefügt als",
+ "changePermissions": "Berechtigungen ändern?",
+ "yesConvertToViewer": "Ja, zu \"Beobachter\" ändern",
+ "cannotAddMorePhotosAfterBecomingViewer": "Der Nutzer \"{user}\" wird keine weiteren Fotos zum Album hinzufügen können.\n\nJedoch kann er weiterhin vorhandene Bilder, welche durch ihn hinzugefügt worden sind, wieder entfernen",
+ "allowAddingPhotos": "Hinzufügen von Fotos erlauben",
+ "@allowAddingPhotos": {
+ "description": "Switch button to enable uploading photos to a public link"
+ },
+ "allowAddPhotosDescription": "Erlaube Nutzern mit diesem Link ebenfalls Fotos zu diesem geteilten Album hinzuzufügen.",
+ "disableDownloadWarningBody": "Zuschauer können weiterhin Screenshots oder mit anderen externen Programmen Kopien der Bilder machen.",
+ "allowDownloads": "Downloads erlauben",
+ "linkDeviceLimit": "Geräte Limit",
+ "linkExpiry": "Ablaufdatum des Links",
+ "linkExpired": "Abgelaufen",
+ "linkEnabled": "Aktiviert",
+ "linkNeverExpires": "Niemals",
+ "expiredLinkInfo": "Dieser Link ist abgelaufen. Bitte wählen Sie ein neues Ablaufdatum oder deaktivieren Sie das Ablaufdatum des Links.",
+ "setAPassword": "Passwort setzen",
+ "lockButtonLabel": "Sperren",
+ "enterPassword": "Passwort eingeben",
+ "removeLink": "Link entfernen",
+ "manageLink": "Link verwalten",
+ "linkExpiresOn": "Link läuft am {expiryTime} ab",
+ "albumUpdated": "Album aktualisiert",
+ "maxDeviceLimitSpikeHandling": "Wenn auf den Höchstwert von {maxValue} gesetzt, dann wird das Limit gelockert um potenzielle Höchstlasten unterstützen zu können.",
+ "@maxDeviceLimitSpikeHandling": {
+ "placeholders": {
+ "maxValue": {
+ "type": "int",
+ "example": "100"
+ }
+ }
+ },
+ "never": "Niemals",
+ "custom": "Benutzerdefiniert",
+ "@custom": {
+ "description": "Label for setting custom value for link expiry"
+ },
+ "after1Hour": "Nach 1. Stunde",
+ "after1Day": "Nach einem Tag",
+ "after1Week": "Nach 1 Woche",
+ "after1Month": "Nach 1 Monat",
+ "after1Year": "Nach 1 Jahr",
+ "manageParticipants": "Verwalten",
+ "collabLinkSectionDescription": "Erstelle einen Link, um anderen zu ermöglichen, Fotos in deinem geteilten Album hinzuzufügen und zu sehen - ohne dass diese ein Konto von ente.io oder die App benötigen. Ideal, um Fotos von Events zu sammeln.",
+ "createPublicLink": "Öffentlichen Link erstellen",
+ "sendLink": "Link senden",
+ "copyLink": "Link kopieren",
+ "linkHasExpired": "Link ist abgelaufen",
+ "publicLinkEnabled": "Öffentlicher Link aktiviert",
+ "shareALink": "Einen Link teilen",
+ "sharedAlbumSectionDescription": "Erstelle gemeinsame Alben mit anderen ente Benutzern, einschließlich solchen im kostenlosen Tarif.",
+ "shareWithPeopleSectionTitle": "{numberOfPeople, plural, =0 {Teile mit bestimmten Personen} =1 {Teilen mit 1 Person} other {Teilen mit {numberOfPeople} Personen}}",
+ "@shareWithPeopleSectionTitle": {
+ "placeholders": {
+ "numberOfPeople": {
+ "type": "int",
+ "example": "2"
+ }
+ }
+ },
+ "thisIsYourVerificationId": "Dies ist deine Verifizierungs-ID",
+ "someoneSharingAlbumsWithYouShouldSeeTheSameId": "Jemand, der Alben mit dir teilt, sollte die gleiche ID auf seinem Gerät sehen.",
+ "howToViewShareeVerificationID": "Bitte sie, auf den Einstellungs Bildschirm ihre E-Mail-Adresse lange anzuklicken und zu überprüfen, dass die IDs auf beiden Geräten übereinstimmen.",
+ "thisIsPersonVerificationId": "Dies ist {email}s Verifizierungs-ID",
+ "@thisIsPersonVerificationId": {
+ "placeholders": {
+ "email": {
+ "type": "String",
+ "example": "someone@ente.io"
+ }
+ }
+ },
+ "verificationId": "Verifizierungs-ID",
+ "verifyEmailID": "Verifiziere {email}",
+ "emailNoEnteAccount": "{email} hat kein Ente-Konto.\n\nSenden Sie eine Einladung, um Fotos zu teilen.",
+ "shareMyVerificationID": "Hier ist meine Verifizierungs-ID: {verificationID} für ente.io.",
+ "shareTextConfirmOthersVerificationID": "Hey, kannst du bestätigen, dass dies deine ente.io Verifizierungs-ID ist: {verificationID}",
+ "somethingWentWrong": "Irgendetwas ging schief",
+ "sendInvite": "Einladung senden",
+ "shareTextRecommendUsingEnte": "Lade ente herunter, damit wir einfach Fotos und Videos in höchster Qualität teilen können\n\nhttps://ente.io/#download",
+ "done": "Fertig",
+ "applyCodeTitle": "Code nutzen",
+ "enterCodeDescription": "Gib den Code deines Freundes ein, damit sie beide kostenlosen Speicherplatz erhalten",
+ "apply": "Anwenden",
+ "failedToApplyCode": "Der Code konnte nicht aktiviert werden",
+ "enterReferralCode": "Gib den Weiterempfehlungs-Code ein",
+ "codeAppliedPageTitle": "Code eingelöst",
+ "storageInGB": "{storageAmountInGB} GB",
+ "claimed": "Eingelöst",
+ "@claimed": {
+ "description": "Used to indicate storage claimed, like 10GB Claimed"
+ },
+ "details": "Details",
+ "claimMore": "Mehr einlösen!",
+ "theyAlsoGetXGb": "Diese erhalten auch {storageAmountInGB} GB",
+ "freeStorageOnReferralSuccess": "{storageAmountInGB} GB jedes Mal, wenn sich jemand mit deinem Code für einen bezahlten Tarif anmeldet",
+ "shareTextReferralCode": "ente Weiterempfehlungs-Code: {referralCode} \n\nEinlösen unter Einstellungen → Allgemein → Weiterempfehlungen, um {referralStorageInGB} GB kostenlos zu erhalten, sobald Sie einen kostenpflichtigen Tarif abgeschlossen haben\n\nhttps://ente.io",
+ "claimFreeStorage": "Freien Speicher einlösen",
+ "inviteYourFriends": "Lade deine Freunde ein",
+ "failedToFetchReferralDetails": "Die Weiterempfehlungs-Details können nicht abgerufen werden. Bitte versuche es später erneut.",
+ "referralStep1": "1. Gib diesen Code an deine Freunde",
+ "referralStep2": "2. Sie schließen ein bezahltes Abo ab",
+ "referralStep3": "3. Ihr beide erhaltet {storageInGB} GB* kostenlos",
+ "referralsAreCurrentlyPaused": "Einlösungen sind derzeit pausiert",
+ "youCanAtMaxDoubleYourStorage": "* Du kannst deinen Speicher maximal verdoppeln",
+ "claimedStorageSoFar": "{isFamilyMember, select, true {Deine Familiengruppe hat bereits {storageAmountInGb} GB erhalten} false {Du hast bereits {storageAmountInGb} GB erhalten} other {Du hast bereits {storageAmountInGb} Gb erhalten!}}",
+ "@claimedStorageSoFar": {
+ "placeholders": {
+ "isFamilyMember": {
+ "type": "String",
+ "example": "true"
+ },
+ "storageAmountInGb": {
+ "type": "int",
+ "example": "10"
+ }
+ }
+ },
+ "faq": "Häufig gestellte Fragen",
+ "oopsSomethingWentWrong": "Ups. Leider ist ein Fehler aufgetreten",
+ "peopleUsingYourCode": "Leute, die deinen Code verwenden",
+ "usableReferralStorageInfo": "Der verwendbare Speicherplatz ist von deinem aktuellen Abonnement eingeschränkt. Überschüssiger, beanspruchter Speicherplatz wird automatisch verwendbar werden, wenn du ein höheres Abonnement buchst.",
+ "removeFromAlbumTitle": "Aus Album entfernen?",
+ "removeFromAlbum": "Aus Album entfernen",
+ "itemsWillBeRemovedFromAlbum": "Ausgewählte Elemente werden aus diesem Album entfernt",
+ "removeShareItemsWarning": "Einige der Elemente, die du entfernst, wurden von anderen Nutzern hinzugefügt und du wirst den Zugriff auf sie verlieren",
+ "addingToFavorites": "Wird zu Favoriten hinzugefügt...",
+ "removingFromFavorites": "Wird aus Favoriten entfernt...",
+ "sorryCouldNotAddToFavorites": "Konnte leider nicht zu den Favoriten hinzugefügt werden!",
+ "sorryCouldNotRemoveFromFavorites": "Konnte leider nicht aus den Favoriten entfernt werden!",
+ "subscribeToEnableSharing": "Sieht aus, als sei dein Abonnement abgelaufen. Bitte abonniere, um das Teilen zu aktivieren.",
+ "subscribe": "Abonnieren",
+ "canOnlyRemoveFilesOwnedByYou": "Du kannst nur Dateien entfernen, die dir gehören",
+ "deleteSharedAlbum": "Geteiltes Album löschen?",
+ "deleteAlbum": "Album löschen",
+ "deleteAlbumDialog": "Auch die Fotos (und Videos) in diesem Album aus <bold>allen</bold> anderen Alben löschen, die sie enthalten?",
+ "deleteSharedAlbumDialogBody": "Dieses Album wird für alle gelöscht\n\nDu wirst den Zugriff auf geteilte Fotos in diesem Album, die anderen gehören, verlieren",
+ "yesRemove": "Ja, entfernen",
+ "creatingLink": "Erstelle Link...",
+ "removeWithQuestionMark": "Entfernen?",
+ "removeParticipantBody": "{userEmail} wird aus diesem geteilten Album entfernt\n\nAlle von ihnen hinzugefügte Fotos werden ebenfalls aus dem Album entfernt",
+ "keepPhotos": "Fotos behalten",
+ "deletePhotos": "Fotos löschen",
+ "inviteToEnte": "Zu ente einladen",
+ "removePublicLink": "Öffentlichen Link entfernen",
+ "disableLinkMessage": "Der öffentliche Link zum Zugriff auf \"{albumName}\" wird entfernt.",
+ "sharing": "Teilt...",
+ "youCannotShareWithYourself": "Du kannst nicht mit dir selbst teilen",
+ "archive": "Archiv",
+ "createAlbumActionHint": "Drücke lange um Fotos auszuwählen und klicke + um ein Album zu erstellen",
+ "importing": "Importiert....",
+ "failedToLoadAlbums": "Laden der Alben fehlgeschlagen",
+ "hidden": "Versteckt",
+ "authToViewYourHiddenFiles": "Bitte authentifizieren, um die versteckten Dateien anzusehen",
+ "trash": "Papierkorb",
+ "uncategorized": "Unkategorisiert",
+ "videoSmallCase": "Video",
+ "photoSmallCase": "Foto",
+ "singleFileDeleteHighlight": "Es wird aus allen Alben gelöscht.",
+ "singleFileInBothLocalAndRemote": "Dieses {fileType} existiert auf ente.io und deinem Gerät.",
+ "singleFileInRemoteOnly": "Dieses {fileType} wird auf ente.io gelöscht.",
+ "singleFileDeleteFromDevice": "Dieses {fileType} wird von deinem Gerät gelöscht.",
+ "deviceLockExplanation": "Das Sperren des Gerätes verhindern, solange 'ente' im Vordergrund geöffnet ist und eine Sicherung läuft. \nDies wird für gewöhnlich nicht benötigt, kann aber dabei helfen große Transfers schneller durchzuführen.",
+ "about": "Allgemeine Informationen",
+ "weAreOpenSource": "Unser Quellcode ist offen einsehbar!",
+ "description": "The text to display when the user has successfully cleaned up duplicate files",
+ "type": "text",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "storageSaved": {
+ "example": "1.2 GB",
+ "type": "String"
+ }
+ }
+ },
+ "familyPlans": "Familientarif",
+ "referrals": "Weiterempfehlungen",
+ "advanced": "Erweitert",
+ "general": "Allgemein",
+ "security": "Sicherheit",
+ "authToViewYourRecoveryKey": "Bitte authentifizieren, um deinen Wiederherstellungs-Schlüssel anzusehen",
+ "twofactor": "Zwei-Faktor",
+ "authToConfigureTwofactorAuthentication": "Bitte authentifizieren, um Zwei-Faktor-Authentifizierung zu konfigurieren",
+ "lockscreen": "Sperrbildschirm",
+ "authToChangeLockscreenSetting": "Bitte authentifizieren, um die Sperrbildschirm-Einstellung zu ändern",
+ "lockScreenEnablePreSteps": "Um den Sperrbildschirm zu aktivieren, legen Sie bitte den Geräte-Passcode oder die Bildschirmsperre in den Systemeinstellungen fest.",
+ "confirm2FADisable": "Bist du sicher, dass du die Zwei-Faktor-Authentifizierung (2FA) deaktivieren willst?",
+ "no": "Nein",
+ "yes": "Ja",
+ "social": "Social Media",
+ "rateUsOnStore": "Bewerte uns auf {storeName}",
+ "blog": "Blog",
+ "merchandise": "Merchandise",
+ "twitter": "Twitter",
+ "mastodon": "Mastodon",
+ "matrix": "Matrix",
+ "discord": "Discord",
+ "reddit": "Reddit",
+ "yourStorageDetailsCouldNotBeFetched": "Details zum Speicherplatz konnten nicht abgerufen werden",
+ "reportABug": "Fehler melden",
+ "reportBug": "Fehler melden",
+ "suggestFeatures": "Verbesserung vorschlagen",
+ "support": "Support",
+ "theme": "Theme",
+ "lightTheme": "Hell",
+ "darkTheme": "Dunkel",
+ "systemTheme": "System",
+ "freeTrial": "Kostenlose Testphase",
+ "selectYourPlan": "Wähle dein Abo aus",
+ "enteSubscriptionPitch": "ente sichert deine Erinnerungsstücke, sodass sie immer für dich verfügbar sind, auch wenn du dein Gerät verlieren solltest.",
+ "enteSubscriptionShareWithFamily": "Deine Familie kann zu deinem Abo hinzugefügt werden.",
+ "currentUsageIs": "Aktuell genutzt werden ",
+ "@currentUsageIs": {
+ "description": "This text is followed by storage usaged",
+ "examples": {
+ "0": "Current usage is 1.2 GB"
+ },
+ "type": "text"
+ },
+ "faqs": "FAQs",
+ "renewsOn": "Erneuert am {endDate}",
+ "freeTrialValidTill": "Kostenlose Demo verfügbar bis zum {endDate}",
+ "subWillBeCancelledOn": "Ihr Abo endet am {endDate}",
+ "subscription": "Abonnement",
+ "paymentDetails": "Zahlungsdetails",
+ "manageFamily": "Familiengruppe verwalten",
+ "contactToManageSubscription": "Bitte kontaktieren Sie uns über support@ente.io, um Ihr {provider} Abo zu verwalten.",
+ "renewSubscription": "Abonnement erneuern",
+ "cancelSubscription": "Abonnement kündigen",
+ "areYouSureYouWantToRenew": "Bist du sicher, dass du verlängern möchtest?",
+ "yesRenew": "Ja, erneuern",
+ "areYouSureYouWantToCancel": "Bist du sicher, dass du kündigen willst?",
+ "yesCancel": "Ja, kündigen",
+ "failedToRenew": "Erneuern fehlgeschlagen",
+ "failedToCancel": "Kündigung fehlgeschlagen",
+ "twoMonthsFreeOnYearlyPlans": "2 Monate kostenlos beim jährlichen Bezahlen",
+ "monthly": "Monatlich",
+ "@monthly": {
+ "description": "The text to display for monthly plans",
+ "type": "text"
+ },
+ "yearly": "Jährlich",
+ "@yearly": {
+ "description": "The text to display for yearly plans",
+ "yourPurchaseWasSuccessful": "Ihr Einkauf war erfolgreich!",
+ "yourPlanWasSuccessfullyUpgraded": "Ihr Abo wurde erfolgreich aufgestuft",
+ "yourPlanWasSuccessfullyDowngraded": "Ihr Tarif wurde erfolgreich heruntergestuft",
+ "yourSubscriptionWasUpdatedSuccessfully": "Dein Abonnement wurde erfolgreich aktualisiert.",
+ "googlePlayId": "Google Play ID",
+ "appleId": "Apple ID",
+ "playstoreSubscription": "PlayStore Abo",
+ "appstoreSubscription": "AppStore Abo",
+ "subAlreadyLinkedErrMessage": "Ihr {id} ist bereits mit einem anderen 'ente'-Konto verknüpft.\nWenn Sie Ihre {id} mit diesem Konto verwenden möchten, kontaktieren Sie bitte unseren Support'",
+ "visitWebToManage": "Bitte rufen Sie \"web.ente.io\" auf um ihr Abo zu verwalten",
+ "couldNotUpdateSubscription": "Abo konnte nicht aktualisiert werden",
+ "pleaseContactSupportAndWeWillBeHappyToHelp": "Bitte kontaktieren Sie uns über support@ente.io wo wir Ihnen gerne weiterhelfen.",
+ "paymentFailed": "Zahlung fehlgeschlagen",
+ "paymentFailedTalkToProvider": "Bitte kontaktiere den Support von {providerName}, falls etwas abgebucht wurde",
+ "@paymentFailedTalkToProvider": {
+ "description": "The text to display when the payment failed",
+ "pleaseLoginAgain": "Bitte logge dich erneut ein",
+ "devAccountChanged": "Das Entwicklerkonto, das wir verwenden, um ente im App Store zu veröffentlichen, hat sich geändert. Aus diesem Grund musst du dich erneut anmelden.\n\nWir entschuldigen uns für die Unannehmlichkeiten, aber das war unvermeidlich.",
+ "yourSubscriptionHasExpired": "Dein Abonnement ist abgelaufen",
+ "deleteAlbumsDialogBody": "Damit werden alle leeren Alben gelöscht. Dies ist nützlich, wenn du das Durcheinander in deiner Albenliste verringern möchtest.",
+ "restore": "Wiederherstellen",
+ "@restore": {
+ "description": "Display text for an action which triggers a restore of item from trash",
+ "type": "text"
+ },
+ "moveToAlbum": "Zum Album verschieben",
+ "unarchive": "Dearchivieren",
+ "favorite": "Favorit",
+ "shareLink": "Link teilen",
+ "addToEnte": "Zu ente hinzufügen",
+ "addToAlbum": "Zum Album hinzufügen",
+ "delete": "Löschen",
+ "share": "Teilen",
+ "searchByAlbumNameHint": "Name des Albums",
+ "albumTitle": "Albumtitel",
+ "enterAlbumName": "Albumname eingeben",
+ "restoringFiles": "Dateien werden wiederhergestellt...",
+ "invite": "Einladen",
+ "shareYourFirstAlbum": "Teile dein erstes Album",
+ "enterYourEmailAddress": "Escribe tu correo electrónico",
+ "accountWelcomeBack": "¡Bienvenido de nuevo!",
+ "email": "Correo electrónico",
+ "cancel": "Cancelar",
+ "verify": "Verificar",
+ "invalidEmailAddress": "Dirección de correo electrónico no válida",
+ "enterValidEmail": "Por favor, introduzca una dirección de correo electrónico válida.",
+ "deleteAccount": "Eliminar cuenta",
+ "askDeleteReason": "¿Cuál es la razón principal por la que eliminas tu cuenta?",
+ "deleteAccountFeedbackPrompt": "Lamentamos que te vayas. Por favor, explícanos el motivo para ayudarnos a mejorar.",
+ "feedback": "Sugerencias",
+ "kindlyHelpUsWithThisInformation": "Por favor ayúdanos con esta información",
+ "confirmDeletePrompt": "Sí, quiero eliminar permanentemente esta cuenta y todos sus datos.",
+ "confirmAccountDeletion": "Corfirmar borrado de cuenta",
+ "deleteConfirmDialogBody": "Está a punto de eliminar permanentemente su cuenta y todos sus datos.\nEsta acción es irreversible.",
+ "deleteAccountPermanentlyButton": "Eliminar Cuenta Permanentemente",
+ "yourAccountHasBeenDeleted": "Su cuenta ha sido eliminada",
+ "selectReason": "Seleccionar motivo",
+ "deleteReason1": "Falta una característica clave que necesito",
+ "deleteReason2": "La aplicación o una característica determinada no \nse comporta como creo que debería",
+ "deleteReason3": "He encontrado otro servicio que me gusta más",
+ "deleteReason4": "Mi motivo no se encuentra en la lista",
+ "sendEmail": "Enviar correo electrónico",
+ "deleteRequestSLAText": "Su solicitud será procesada dentro de 72 horas.",
+ "deleteEmailRequest": "Por favor, envíe un correo electrónico a <warning>account-deletion@ente.io</warning> desde su dirección de correo electrónico registrada.",
+ "ok": "Aceptar",
+ "createAccount": "Crear cuenta",
+ "createNewAccount": "Crear nueva cuenta",
+ "password": "Contraseña",
+ "confirmPassword": "Confirmar contraseña",
+ "activeSessions": "Sesiónes activas",
+ "oops": "Ups",
+ "somethingWentWrongPleaseTryAgain": "Algo salió mal, por favor inténtalo de nuevo",
+ "thisWillLogYouOutOfThisDevice": "¡Esto cerrará la sesión de este dispositivo!",
+ "thisWillLogYouOutOfTheFollowingDevice": "Esto cerrará la sesión del siguiente dispositivo:",
+ "terminateSession": "¿Terminar sesión?",
+ "terminate": "Terminar",
+ "thisDevice": "Este dispositivo",
+ "recoverButton": "Recuperar",
+ "recoverySuccessful": "¡Recuperación exitosa!",
+ "decrypting": "Descifrando...",
+ "incorrectRecoveryKeyTitle": "Clave de recuperación incorrecta",
+ "incorrectRecoveryKeyBody": "La clave de recuperación introducida es incorrecta",
+ "forgotPassword": "Olvidé mi contraseña",
+ "enterYourRecoveryKey": "Introduzca su clave de recuperación",
+ "noRecoveryKey": "¿Sin clave de recuperación?",
+ "sorry": "Lo sentimos",
+ "noRecoveryKeyNoDecryption": "Debido a la naturaleza de nuestro protocolo de cifrado de extremo a extremo, sus datos no pueden ser descifrados sin su contraseña o clave de recuperación",
+ "verifyEmail": "Verificar correo electrónico",
+ "checkInboxAndSpamFolder": "Revisa tu bandeja de entrada (y spam) para completar la verificación",
+ "tapToEnterCode": "Toca para introducir el código",
+ "resendEmail": "Reenviar correo electrónico",
+ "weHaveSendEmailTo": "Hemos enviado un correo a <green>{email}</green>",
+ "@weHaveSendEmailTo": {
+ "description": "Text to indicate that we have sent a mail to the user",
+ "placeholders": {
+ "email": {
+ "description": "The email address of the user",
+ "type": "String",
+ "example": "example@ente.io"
+ }
+ }
+ },
+ "setPasswordTitle": "Establecer contraseña",
+ "changePasswordTitle": "Cambiar contraseña",
+ "resetPasswordTitle": "Restablecer contraseña",
+ "encryptionKeys": "Claves de cifrado",
+ "passwordWarning": "No almacenamos esta contraseña, así que si la olvidas, <underline>no podemos descifrar tus datos</underline>",
+ "enterPasswordToEncrypt": "Introduzca una contraseña que podamos usar para cifrar sus datos",
+ "enterNewPasswordToEncrypt": "Introduzca una nueva contraseña que podamos usar para cifrar sus datos",
+ "weakStrength": "Poco segura",
+ "strongStrength": "Segura",
+ "moderateStrength": "Moderada",
+ "passwordStrength": "Seguridad de la contraseña : {passwordStrengthValue}",
+ "@passwordStrength": {
+ "description": "Text to indicate the password strength",
+ "placeholders": {
+ "passwordStrengthValue": {
+ "description": "The strength of the password as a string",
+ "generatingEncryptionKeys": "Generando claves de encriptación...",
+ "pleaseWait": "Por favor, espere...",
+ "continueLabel": "Continuar",
+ "insecureDevice": "Dispositivo inseguro",
+ "sorryWeCouldNotGenerateSecureKeysOnThisDevicennplease": "Lo sentimos, no hemos podido generar claves seguras en este dispositivo.\n\nRegístrate desde un dispositivo diferente.",
+ "howItWorks": "Cómo funciona",
+ "encryption": "Cifrado",
+ "ackPasswordLostWarning": "Entiendo que si pierdo mi contraseña podría perder mis datos, ya que mis datos están <underline>cifrados de extremo a extremo</underline>.",
+ "privacyPolicyTitle": "Política de Privacidad",
+ "termsOfServicesTitle": "Términos",
+ "signUpTerms": "Estoy de acuerdo con los <u-terms>términos del servicio</u-terms> y <u-policy> la política de privacidad</u-policy>",
+ "logInLabel": "Iniciar sesión",
+ "loginTerms": "Al hacer clic en iniciar sesión, acepto los <u-terms>términos de servicio</u-terms> y <u-policy>la política de privacidad</u-policy>",
+ "recreatePasswordBody": "El dispositivo actual no es lo suficientemente potente para verificar su contraseña, pero podemos regenerarla de una manera que funcione con todos los dispositivos.\n\nPor favor inicie sesión usando su clave de recuperación y regenere su contraseña (puede volver a utilizar la misma si lo desea).",
+ "verifyPassword": "Verificar contraseña",
+ "recoveryKey": "Clave de recuperación",
+ "recoveryKeyOnForgotPassword": "Si olvida su contraseña, la única forma de recuperar sus datos es con esta clave.",
+ "recoveryKeySaveDescription": "Nosotros no almacenamos esta clave, por favor guarde dicha clave de 24 palabras en un lugar seguro.",
+ "doThisLater": "Hacer esto más tarde",
+ "saveKey": "Guardar Clave",
+ "recoveryKeyCopiedToClipboard": "Clave de recuperación copiada al portapapeles",
+ "recoverAccount": "Recuperar cuenta",
+ "recover": "Recuperar",
+ "dropSupportEmail": "Por favor, envíe un email a {supportEmail} desde su dirección de correo electrónico registrada",
+ "@dropSupportEmail": {
+ "placeholders": {
+ "supportEmail": {
+ "description": "The support email address",
+ "type": "String",
+ "example": "support@ente.io"
+ }
+ }
+ },
+ "twofactorSetup": "Configuración de dos pasos",
+ "enterCode": "Introduzca el código",
+ "scanCode": "Escanear código",
+ "codeCopiedToClipboard": "Código copiado al portapapeles",
+ "copypasteThisCodentoYourAuthenticatorApp": "Copiar y pegar este código\na su aplicación de autenticador",
+ "tapToCopy": "toque para copiar",
+ "scanThisBarcodeWithnyourAuthenticatorApp": "Escanea este código QR con tu aplicación de autenticación",
+ "enterThe6digitCodeFromnyourAuthenticatorApp": "Ingrese el código de seis dígitos de su aplicación de autenticación",
+ "confirm": "Confirmar",
+ "setupComplete": "Configuración completa",
+ "saveYourRecoveryKeyIfYouHaventAlready": "Guarda tu clave de recuperación si aún no lo has hecho",
+ "thisCanBeUsedToRecoverYourAccountIfYou": "Esto puede utilizarse para recuperar su cuenta si pierde su segundo factor",
+ "twofactorAuthenticationPageTitle": "Autenticación en dos pasos",
+ "lostDevice": "¿Perdió su dispositivo?",
+ "verifyingRecoveryKey": "Verificando clave de recuperación...",
+ "recoveryKeyVerified": "Clave de recuperación verificada",
+ "recoveryKeySuccessBody": "¡Genial! Su clave de recuperación es válida. Gracias por verificar.\n\nPor favor, recuerde mantener su clave de recuperación segura.",
+ "invalidRecoveryKey": "La clave de recuperación introducida no es válida. Por favor, asegúrese de que contiene 24 palabras y compruebe la ortografía de cada una.\n\nSi ha introducido un código de recuperación antiguo, asegúrese de que tiene 64 caracteres de largo y compruebe cada uno de ellos.",
+ "invalidKey": "Clave inválida",
+ "tryAgain": "Inténtelo de nuevo",
+ "viewRecoveryKey": "Ver código de recuperación",
+ "confirmRecoveryKey": "Confirmar clave de recuperación",
+ "recoveryKeyVerifyReason": "Su clave de recuperación es la única forma de recuperar sus fotos si olvida su contraseña. Puede encontrar su clave de recuperación en Ajustes > Cuenta.\n\nPor favor, introduzca su clave de recuperación aquí para verificar que la ha guardado correctamente.",
+ "confirmYourRecoveryKey": "Confirme su clave de recuperación",
+ "addViewer": "Añadir espectador",
+ "addCollaborator": "Agregar colaborador",
+ "addANewEmail": "Agregar nuevo correo electrónico",
+ "orPickAnExistingOne": "O elige uno existente",
+ "collaboratorsCanAddPhotosAndVideosToTheSharedAlbum": "Colaboradores pueden añadir fotos y videos al álbum compartido.",
+ "enterEmail": "Ingresar correo electrónico ",
+ "albumOwner": "Propietario",
+ "@albumOwner": {
+ "description": "Role of the album owner"
+ },
+ "you": "Usted",
+ "collaborator": "Colaborador",
+ "addMore": "Añadir más",
+ "@addMore": {
+ "description": "Button text to add more collaborators/viewers"
+ },
+ "viewer": "Espectador",
+ "remove": "Quitar",
+ "removeParticipant": "Quitar participante",
+ "@removeParticipant": {
+ "description": "menuSectionTitle for removing a participant"
+ },
+ "manage": "Administrar",
+ "addedAs": "Agregado como",
+ "changePermissions": "¿Cambiar permisos?",
+ "yesConvertToViewer": "Sí, convertir a espectador",
+ "cannotAddMorePhotosAfterBecomingViewer": "{user} no podrá añadir más fotos a este álbum\n\nTodavía podrán eliminar las fotos ya añadidas por ellos",
+ "allowAddingPhotos": "Permitir añadir fotos",
+ "@allowAddingPhotos": {
+ "description": "Switch button to enable uploading photos to a public link"
+ },
+ "allowAddPhotosDescription": "Permitir a las personas con el enlace añadir fotos al álbum compartido.",
+ "passwordLock": "Bloqueo por contraseña",
+ "disableDownloadWarningTitle": "Por favor tenga en cuenta",
+ "disableDownloadWarningBody": "Los espectadores todavía pueden tomar capturas de pantalla o guardar una copia de sus fotos usando herramientas externas",
+ "allowDownloads": "Permitir descargas",
+ "linkDeviceLimit": "Límite del dispositivo",
+ "linkExpiry": "Enlace vence",
+ "linkExpired": "Vencido",
+ "linkEnabled": "Habilitado",
+ "linkNeverExpires": "Nunca",
+ "expiredLinkInfo": "Este enlace ha caducado. Por favor, seleccione una nueva fecha de caducidad o deshabilite la fecha de caducidad.",
+ "setAPassword": "Establecer una contraseña",
+ "lockButtonLabel": "Bloquear",
+ "enterPassword": "Introduzca contraseña",
+ "removeLink": "Eliminar enlace",
+ "manageLink": "Administrar enlace",
+ "linkExpiresOn": "El enlace caducará en {expiryTime}",
+ "albumUpdated": "Álbum actualizado",
+ "maxDeviceLimitSpikeHandling": "Cuando se establece al máximo ({maxValue}), el límite del dispositivo se relajará para permitir picos temporales de un gran número de espectadores.",
+ "@maxDeviceLimitSpikeHandling": {
+ "placeholders": {
+ "maxValue": {
+ "type": "int",
+ "example": "100"
+ }
+ }
+ },
+ "never": "Nunca",
+ "custom": "Personalizado",
+ "@custom": {
+ "description": "Label for setting custom value for link expiry"
+ },
+ "after1Hour": "Después de 1 hora",
+ "after1Day": "Después de un día",
+ "after1Week": "Después de una semana",
+ "after1Month": "Después de un mes",
+ "after1Year": "Después de un año",
+ "manageParticipants": "Administrar",
+ "collabLinkSectionDescription": "Crea un enlace para que la gente pueda añadir y ver fotos en tu álbum compartido sin necesidad de la aplicación ente o una cuenta. Genial para recolectar fotos de eventos.",
+ "collectPhotos": "Recolectar fotos",
+ "collaborativeLink": "Enlace colaborativo",
+ "shareWithNonenteUsers": "Compartir con usuarios no ente",
+ "sharedAlbumSectionDescription": "Crear álbumes compartidos y colaborativos con otros usuarios ente, incluyendo usuarios en planes gratuitos.",
+ "shareWithPeopleSectionTitle": "{numberOfPeople, plural, =0 {Compartir con personas específicas} =1 {Compartido con 1 persona} other {Compartido con {numberOfPeople} personas}}",
+ "@shareWithPeopleSectionTitle": {
+ "placeholders": {
+ "numberOfPeople": {
+ "type": "int",
+ "example": "2"
+ }
+ }
+ },
+ "thisIsYourVerificationId": "Esta es tu ID de verificación",
+ "someoneSharingAlbumsWithYouShouldSeeTheSameId": "Alguien compartiendo álbumes con usted debería ver el mismo ID en su dispositivo.",
+ "howToViewShareeVerificationID": "Por favor, pídeles que mantengan presionada su dirección de correo electrónico en la pantalla de ajustes, y verifique que los IDs de ambos dispositivos coincidan.",
+ "thisIsPersonVerificationId": "Este es el ID de verificación de {email}",
+ "@thisIsPersonVerificationId": {
+ "placeholders": {
+ "email": {
+ "type": "String",
+ "example": "someone@ente.io"
+ }
+ }
+ },
+ "verificationId": "ID de verificación",
+ "verifyEmailID": "Verificar {email}",
+ "emailNoEnteAccount": "{email} no tiene una cuenta ente.\n\nEnvíale una invitación para compartir fotos.",
+ "shareMyVerificationID": "Aquí está mi ID de verificación: {verificationID} para ente.io.",
+ "shareTextConfirmOthersVerificationID": "Hola, ¿puedes confirmar que esta es tu ID de verificación ente.io: {verificationID}?",
+ "somethingWentWrong": "Algo salió mal",
+ "sendInvite": "Enviar invitación",
+ "shareTextRecommendUsingEnte": "Descarga ente para que podamos compartir fácilmente fotos y videos en su calidad original\n\nhttps://ente.io/#download",
+ "done": "Hecho",
+ "applyCodeTitle": "Usar código",
+ "enterCodeDescription": "Introduce el código proporcionado por tu amigo para reclamar almacenamiento gratuito para ambos",
+ "apply": "Aplicar",
+ "failedToApplyCode": "Error al aplicar el código",
+ "enterReferralCode": "Ingresar código de referencia",
+ "codeAppliedPageTitle": "Código aplicado",
+ "storageInGB": "{storageAmountInGB} GB",
+ "claimed": "Reclamado",
+ "@claimed": {
+ "description": "Used to indicate storage claimed, like 10GB Claimed"
+ "freeStorageOnReferralSuccess": "{storageAmountInGB} GB cada vez que alguien se registra en un plan de pago y aplica tu código",
+ "shareTextReferralCode": "ente código de referencia: {referralCode} \n\nAplicarlo en Ajustes → General → Referencias para obtener {referralStorageInGB} GB gratis después de registrarse en un plan de pago\n\nhttps://ente.io",
+ "referralsAreCurrentlyPaused": "Las referencias están actualmente en pausa",
+ "youCanAtMaxDoubleYourStorage": "* Puedes al máximo duplicar tu almacenamiento",
+ "claimedStorageSoFar": "{isFamilyMember, select, true {Su familia ha reclamado {storageAmountInGb} Gb hasta el momento} false {Tú has reclamado {storageAmountInGb} Gb hasta el momento} other {¡Tú has reclamado {storageAmountInGb} Gb hasta el momento!}}",
+ "usableReferralStorageInfo": "El almacenamiento utilizable está limitado por su plan actual. El exceso de almacenamiento reclamado se volverá automáticamente utilizable cuando actualice su plan.",
+ "removeFromAlbumTitle": "¿Quitar del álbum?",
+ "removeFromAlbum": "Quitar del álbum",
+ "itemsWillBeRemovedFromAlbum": "Los elementos seleccionados serán removidos de este álbum",
+ "removeShareItemsWarning": "Algunos de los elementos que estás eliminando fueron añadidos por otras personas, y perderás el acceso a ellos",
+ "addingToFavorites": "Añadiendo a favoritos...",
+ "removingFromFavorites": "Quitando de favoritos...",
+ "sorryCouldNotAddToFavorites": "¡Lo sentimos, no se pudo añadir a favoritos!",
+ "sorryCouldNotRemoveFromFavorites": "¡Lo sentimos, no se pudo quitar de favoritos!",
+ "subscribeToEnableSharing": "Parece que su suscripción ha caducado. Por favor, suscríbase para habilitar el compartir.",
+ "subscribe": "Suscribirse",
+ "canOnlyRemoveFilesOwnedByYou": "Sólo puede eliminar archivos de tu propiedad",
+ "deleteSharedAlbum": "¿Borrar álbum compartido?",
+ "deleteAlbum": "Borrar álbum",
+ "deleteAlbumDialog": "¿También eliminar las fotos (y los vídeos) presentes en este álbum de <bold>todos</bold> los otros álbumes de los que forman parte?",
+ "deleteSharedAlbumDialogBody": "El álbum se eliminará para todos\n\nPerderás el acceso a las fotos compartidas en este álbum que son propiedad de otros",
+ "yesRemove": "Sí, quitar",
+ "creatingLink": "Creando enlace...",
+ "removeWithQuestionMark": "Quitar?",
+ "removeParticipantBody": "{userEmail} será eliminado de este álbum compartido\n\nCualquier foto añadida por ellos también será eliminada del álbum",
+ "keepPhotos": "Conservar las fotos",
+ "deletePhotos": "Borrar las fotos",
+ "inviteToEnte": "Invitar a ente",
+ "removePublicLink": "Quitar enlace público",
+ "disableLinkMessage": "Esto eliminará el enlace público para acceder a \"{albumName}\".",
+ "sharing": "Compartiendo...",
+ "youCannotShareWithYourself": "No puedes compartir contigo mismo",
+ "archive": "Archivo",
+ "createAlbumActionHint": "Mantenga presionado para seleccionar fotos y haga clic en + para crear un álbum",
+ "importing": "Importando....",
+ "failedToLoadAlbums": "Error al cargar álbumes",
+ "hidden": "Oculto",
+ "authToViewYourHiddenFiles": "Por favor, autentifiquese para ver sus archivos ocultos",
+ "trash": "Papelera",
+ "uncategorized": "Sin categorizar",
+ "videoSmallCase": "vídeo",
+ "photoSmallCase": "foto",
+ "singleFileDeleteHighlight": "Se borrará de todos los álbumes.",
+ "singleFileInBothLocalAndRemote": "Este {fileType} está tanto en ente como en tu dispositivo.",
+ "singleFileInRemoteOnly": "Este {fileType} se eliminará de ente.",
+ "singleFileDeleteFromDevice": "Este {fileType} se eliminará de tu dispositivo.",
+ "yearsAgo": "{count, plural, one{{count} hace un año} other{{count} hace años}}",
+ "backupSettings": "Ajustes de copia de seguridad",
+ "backupOverMobileData": "Copia de seguridad usando datos móviles",
+ "backupVideos": "Respaldar vídeos",
+ "disableAutoLock": "Desactivar autobloqueo",
+ "deviceLockExplanation": "Deshabilita el bloqueo de pantalla del dispositivo cuando ente está en primer plano y hay una copia de seguridad en curso. Normalmente esto no es necesario, pero puede ayudar a que las grandes cargas y las importaciones iniciales de grandes bibliotecas se completen más rápido.",
+ "about": "Acerca de",
+ "weAreOpenSource": "¡Somos de código abierto!",
+ "privacy": "Privacidad",
+ "terms": "Términos",
+ "checkForUpdates": "Comprobar actualizaciónes",
+ "checking": "Comprobando...",
+ "youAreOnTheLatestVersion": "Estás usando la última versión",
+ "account": "Cuenta",
+ "manageSubscription": "Administrar tu suscripción",
+ "authToChangeYourEmail": "Por favor, autentifíquese para cambiar su correo electrónico",
+ "changePassword": "Cambiar contraseña",
+ "authToChangeYourPassword": "Por favor, autentifíquese para cambiar su contraseña",
+ "exportYourData": "Exportar tus datos",
+ "logout": "Cerrar sesión",
+ "authToInitiateAccountDeletion": "Por favor, autentifíquese para iniciar la eliminación de la cuenta",
+ "areYouSureYouWantToLogout": "¿Seguro que quiere cerrar la sesión?",
+ "yesLogout": "Sí, cerrar sesión",
+ "aNewVersionOfEnteIsAvailable": "Hay una nueva versión de ente disponible.",
+ "description": "The text to display when the user has successfully cleaned up duplicate files",
+ "type": "text",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "storageSaved": {
+ "example": "1.2 GB",
+ "type": "String"
+ }
+ }
+ },
+ "familyPlans": "Planes familiares",
+ "referrals": "Referidos",
+ "advanced": "Avanzado",
+ "general": "General",
+ "security": "Seguridad",
+ "authToViewYourRecoveryKey": "Por favor, autentifíquese para ver su clave de recuperación",
+ "twofactor": "Dos factores",
+ "authToConfigureTwofactorAuthentication": "Por favor autentificar para configurar autenticación de dos factores",
+ "lockscreen": "Pantalla de bloqueo",
+ "authToChangeLockscreenSetting": "Por favor autentificar para cambiar la configuración de bloqueo de pantalla",
+ "lockScreenEnablePreSteps": "Para activar la pantalla de bloqueo, por favor configure el código de acceso del dispositivo o el bloqueo de pantalla en los ajustes de su sistema.",
+ "viewActiveSessions": "Ver sesiones activas",
+ "authToViewYourActiveSessions": "Por favor, autentifíquese para ver sus sesiones activas",
+ "disableTwofactor": "Deshabilitar dos factores",
+ "confirm2FADisable": "¿Estás seguro de que desea deshabilitar la autenticación de doble factor?",
+ "no": "No",
+ "yes": "Sí",
+ "social": "Social",
+ "rateUsOnStore": "Califícanos en {storeName}",
+ "blog": "Blog",
+ "merchandise": "Mercancías",
+ "twitter": "Twitter",
+ "mastodon": "Mastodon",
+ "matrix": "Matrix",
+ "discord": "Discord",
+ "reddit": "Reddit",
+ "yourStorageDetailsCouldNotBeFetched": "Tus datos de almacenamiento no se han podido obtener",
+ "reportABug": "Reportar un error",
+ "reportBug": "Reportar error",
+ "suggestFeatures": "Sugerir una característica",
+ "support": "Soporte",
+ "theme": "Tema",
+ "lightTheme": "Claro",
+ "darkTheme": "Oscuro",
+ "systemTheme": "Sistema",
+ "freeTrial": "Prueba gratuita",
+ "selectYourPlan": "Elegir tu suscripción",
+ "enteSubscriptionPitch": "ente conserva tus recuerdos, así que siempre están disponibles para ti, incluso si pierdes tu dispositivo.",
+ "enteSubscriptionShareWithFamily": "Tu familia también puede ser agregada a tu plan.",
+ "currentUsageIs": "El uso actual es ",
+ "@currentUsageIs": {
+ "description": "This text is followed by storage usaged",
+ "subWillBeCancelledOn": "Tu suscripción se cancelará el {endDate}",
+ "subscription": "Suscripción",
+ "paymentDetails": "Detalles de pago",
+ "manageFamily": "Administrar familia",
+ "contactToManageSubscription": "Por favor, contáctenos en support@ente.io para gestionar su suscripción a {provider}.",
+ "renewSubscription": "Renovar suscripción",
+ "cancelSubscription": "Cancelar suscripción",
+ "areYouSureYouWantToRenew": "¿Estás seguro de que quieres renovar?",
+ "yesRenew": "Sí, Renovar",
+ "areYouSureYouWantToCancel": "¿Estás seguro de que quieres cancelar?",
+ "yesCancel": "Sí, cancelar",
+ "failedToRenew": "Renovación fallida",
+ "failedToCancel": "Error al cancelar",
+ "twoMonthsFreeOnYearlyPlans": "2 meses gratis en planes anuales",
+ "monthly": "Mensual",
+ "@monthly": {
+ "description": "The text to display for monthly plans",
+ "type": "text"
+ },
+ "yearly": "Anualmente",
+ "@yearly": {
+ "description": "The text to display for yearly plans",
+ "type": "text"
+ },
+ "confirmPlanChange": "Confirmar los cambios en el plan",
+ "areYouSureYouWantToChangeYourPlan": "¿Estás seguro de que quieres cambiar tu plan?",
+ "youCannotDowngradeToThisPlan": "No puedes degradar a este plan",
+ "cancelOtherSubscription": "Por favor, cancele primero su suscripción existente de {paymentProvider}",
+ "@cancelOtherSubscription": {
+ "description": "The text to display when the user has an existing subscription from a different payment provider",
+ "type": "text",
+ "placeholders": {
+ "paymentProvider": {
+ "example": "Apple",
+ "type": "String"
+ }
+ }
+ },
+ "optionalAsShortAsYouLike": "Opcional, tan corto como quieras...",
+ "send": "Enviar",
+ "askCancelReason": "Tu suscripción ha sido cancelada. ¿Quieres compartir el motivo?",
+ "thankYouForSubscribing": "¡Gracias por suscribirte!",
+ "yourPurchaseWasSuccessful": "Tu compra ha sido exitosa",
+ "yourPlanWasSuccessfullyUpgraded": "Tu plan se ha actualizado correctamente",
+ "yourPlanWasSuccessfullyDowngraded": "Tu plan ha sido degradado con éxito",
+ "yourSubscriptionWasUpdatedSuccessfully": "Tu suscripción se ha actualizado con éxito",
+ "googlePlayId": "ID de Google Play",
+ "appleId": "ID de Apple",
+ "playstoreSubscription": "Suscripción en la PlayStore",
+ "appstoreSubscription": "Suscripción en la AppStore",
+ "subAlreadyLinkedErrMessage": "Su {id} ya está vinculado a otra cuenta ente.\nSi desea utilizar su {id} con esta cuenta, póngase en contacto con nuestro servicio de asistencia''",
+ "visitWebToManage": "Por favor visite web.ente.io para administrar su suscripción",
+ "couldNotUpdateSubscription": "No se pudo actualizar la suscripción",
+ "pleaseContactSupportAndWeWillBeHappyToHelp": "¡Por favor, contacta con support@ente.io y estaremos encantados de ayudar!",
+ "paymentFailed": "Pago fallido",
+ "paymentFailedTalkToProvider": "Por favor hable con el soporte de {providerName} si se le cobró",
+ "@paymentFailedTalkToProvider": {
+ "description": "The text to display when the payment failed",
+ "type": "text",
+ "placeholders": {
+ "providerName": {
+ "example": "AppStore|PlayStore",
+ "type": "String"
+ }
+ }
+ },
+ "continueOnFreeTrial": "Continuar con el plan gratuito",
+ "areYouSureYouWantToExit": "¿Seguro que quieres salir?",
+ "thankYou": "Gracias",
+ "failedToVerifyPaymentStatus": "Error al verificar el estado de su pago",
+ "pleaseWaitForSometimeBeforeRetrying": "Por favor espere un momento antes de volver a intentarlo",
+ "paymentFailedWithReason": "Lamentablemente tu pago falló debido a {reason}",
+ "youAreOnAFamilyPlan": "¡Estás en un plan familiar!",
+ "contactFamilyAdmin": "Por favor contacta con <green>{familyAdminEmail}</green> para administrar tu suscripción",
+ "leaveFamily": "Abandonar plan familiar",
+ "areYouSureThatYouWantToLeaveTheFamily": "¿Está seguro de que desea abandonar el plan familiar?",
+ "leave": "Abandonar",
+ "rateTheApp": "Evalúa la aplicación",
+ "startBackup": "Iniciar copia de seguridad",
+ "noPhotosAreBeingBackedUpRightNow": "No se están respaldando fotos ahora mismo",
+ "preserveMore": "Preservar más",
+ "existingUser": "Usuario existente",
+ "privateBackups": "Copias de seguridad privadas",
+ "forYourMemories": "para tus recuerdos",
+ "endtoendEncryptedByDefault": "Encriptado de extremo a extremo por defecto",
+ "safelyStored": "Almacenado con seguridad",
+ "atAFalloutShelter": "en un refugio blindado",
+ "designedToOutlive": "Diseñado para sobrevivir",
+ "pleaseLoginAgain": "Por favor, vuelva a iniciar sesión",
+ "devAccountChanged": "La cuenta de desarrollador que utilizamos para publicar ente en la App Store ha cambiado. Por eso, tendrás que iniciar sesión de nuevo.\n\nNuestras disculpas por las molestias, pero esto era inevitable.",
+ "yourSubscriptionHasExpired": "Tu suscripción ha caducado",
+ "storageLimitExceeded": "Límite de datos excedido",
+ "upgrade": "Mejorar",
+ "raiseTicket": "Generar ticket",
+ "@raiseTicket": {
+ "description": "Button text for raising a support tickets in case of unhandled errors during backup",
+ "type": "text"
+ },
+ "backupFailed": "La copia de seguridad ha fallado",
+ "couldNotBackUpTryLater": "No pudimos hacer una copia de seguridad de tus datos.\nVolveremos a intentarlo más tarde.",
+ "enteCanEncryptAndPreserveFilesOnlyIfYouGrant": "ente puede cifrar y preservar archivos sólo si concede acceso a ellos",
+ "deviceFilesAutoUploading": "Los archivos añadidos a este álbum de dispositivo se subirán automáticamente a ente.",
+ "turnOnBackupForAutoUpload": "Activar la copia de seguridad para subir automáticamente archivos añadidos a la carpeta de este dispositivo hacia ente.",
+ "noHiddenPhotosOrVideos": "No hay fotos ni vídeos ocultos",
+ "toHideAPhotoOrVideo": "Para ocultar una foto o video",
+ "openTheItem": "• Abrir el elemento",
+ "clickOnTheOverflowMenu": "• Haga clic en el menú desbordante",
+ "click": "• Click",
+ "nothingToSeeHere": "¡No hay nada que ver aquí! 👀",
+ "searchHintText": "Álbunes, meses, días, años, ...",
+ "searchByExamples": "• Nombres de álbumes (por ejemplo, \"Cámara\")\n• Tipos de archivos (por ejemplo, \"Videos\", \".gif\")\n• Años y meses (por ejemplo, \"2022\", \"Enero\")\n• Vacaciones (por ejemplo, \"Navidad\")\n• Descripciones fotográficas (por ejemplo, \"#diversión\")",
+ "youCanTrySearchingForADifferentQuery": "Puedes intentar buscar una consulta diferente.",
+ "noResultsFound": "No se han encontrado resultados",
+ "addedBy": "Añadido por {emailOrName}",
+ "loadingExifData": "Cargando datos EXIF...",
+ "viewAllExifData": "Ver todos los datos EXIF",
+ "noExifData": "No hay datos EXIF",
+ "thisImageHasNoExifData": "Esta imagen no tiene datos exif",
+ "exif": "EXIF",
+ "noResults": "Sin resultados",
+ "weDontSupportEditingPhotosAndAlbumsThatYouDont": "No admitimos la edición de fotos y álbunes que aún no son tuyos",
+ "failedToFetchOriginalForEdit": "No se pudo obtener el original para editar",
+ "close": "Cerrar",
+ "setAs": "Establecer como",
+ "fileSavedToGallery": "Archivo guardado en la galería",
+ "download": "Descargar",
+ "pressAndHoldToPlayVideo": "Presiona y mantén presionado para reproducir el video",
+ "downloadFailed": "Descarga fallida",
+ "deduplicateFiles": "Deduplicar archivos",
+ "deselectAll": "Deseleccionar todo",
+ "reviewDeduplicateItems": "Por favor, revise y elimine los elementos que cree que están duplicados.",
+ "clubByCaptureTime": "Agrupar por tiempo de captura",
+ "count": "Cuenta",
+ "totalSize": "Tamaño total",
+ "time": "Tiempo",
+ "longpressOnAnItemToViewInFullscreen": "Pulsación prolongada en un elemento para ver en pantalla completa",
+ "decryptingVideo": "Descifrando video...",
+ "authToViewYourMemories": "Por favor autentifique para ver sus memorias",
+ "unlock": "Desbloquear",
+ "freeUpSpace": "Liberar espacio",
+ "freeUpSpaceSaving": "{count, plural, one {Se puede eliminar del dispositivo para liberar {formattedSize}} other {Se pueden eliminar del dispositivo para liberar {formattedSize}}}",
+ "filesBackedUpInAlbum": "{count, plural, one {1 archivo} other {{formattedNumber} archivos}} en este álbum ha sido respaldado de forma segura",
+ "@filesBackedUpInAlbum": {
+ "description": "Text to tell user how many files have been backed up in the album",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "formattedNumber": {
+ "content": "{formattedNumber}",
+ "example": "1,000",
+ "type": "String"
+ }
+ }
+ },
+ "filesBackedUpFromDevice": "{count, plural, one {1 archivo} other {{formattedNumber} archivos}} en este dispositivo han sido respaldados de forma segura",
+ "@filesBackedUpFromDevice": {
+ "description": "Text to tell user how many files have been backed up from this device",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "formattedNumber": {
+ "content": "{formattedNumber}",
+ "example": "1,000",
+ "type": "String"
+ }
+ }
+ },
+ "@freeUpSpaceSaving": {
+ "description": "Text to tell user how much space they can free up by deleting items from the device"
+ },
+ "freeUpAccessPostDelete": "Aún puedes acceder {count, plural, one {si} other {entonces}} en ente mientras mantengas una suscripción activa",
+ "@freeUpAccessPostDelete": {
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ }
+ }
+ },
+ "freeUpAmount": "Liberar {sizeInMBorGB}",
+ "thisEmailIsAlreadyInUse": "Este correo electrónico ya está en uso",
+ "incorrectCode": "Código incorrecto",
+ "authenticationFailedPleaseTryAgain": "Error de autenticación, por favor inténtalo de nuevo",
+ "verificationFailedPleaseTryAgain": "Verificación fallida, por favor intenta nuevamente",
+ "enterFileName": "Introduzca el nombre del archivo",
+ "filesDeleted": "Archivos eliminados",
+ "selectedFilesAreNotOnEnte": "Los archivos seleccionados no están en ente",
+ "thisActionCannotBeUndone": "Esta acción no se puede deshacer",
+ "emptyTrash": "¿Vaciar la papelera?",
+ "permDeleteWarning": "Todos los elementos de la papelera serán eliminados permanentemente\n\nEsta acción no se puede deshacer",
+ "empty": "Vaciar",
+ "couldNotFreeUpSpace": "No se pudo liberar espacio",
+ "permanentlyDeleteFromDevice": "¿Eliminar permanentemente del dispositivo?",
+ "someOfTheFilesYouAreTryingToDeleteAre": "Algunos de los archivos que estás intentando eliminar sólo están disponibles en tu dispositivo y no se pueden recuperar si se eliminan",
+ "theyWillBeDeletedFromAllAlbums": "Se borrarán de todos los álbumes.",
+ "someItemsAreInBothEnteAndYourDevice": "Algunos elementos están tanto en ente como en tu dispositivo.",
+ "selectedItemsWillBeDeletedFromAllAlbumsAndMoved": "Los archivos seleccionados serán eliminados de todos los álbumes y movidos a la papelera.",
+ "theseItemsWillBeDeletedFromYourDevice": "Estos elementos se eliminarán de tu dispositivo.",
+ "itLooksLikeSomethingWentWrongPleaseRetryAfterSome": "Parece que algo salió mal. Por favor, vuelve a intentarlo después de algún tiempo. Si el error persiste, ponte en contacto con nuestro equipo de soporte.",
+ "error": "Error",
+ "tempErrorContactSupportIfPersists": "Parece que algo salió mal. Por favor, vuelve a intentarlo después de algún tiempo. Si el error persiste, ponte en contacto con nuestro equipo de soporte.",
+ "cachedData": "Datos almacenados en caché",
+ "clearCaches": "Limpiar caché",
+ "remoteImages": "Imágenes remotas",
+ "remoteVideos": "Videos remotos",
+ "remoteThumbnails": "Miniaturas remotas",
+ "pendingSync": "Sincronización pendiente",
+ "localGallery": "Galería local",
+ "todaysLogs": "Registros de hoy",
+ "viewLogs": "Ver Registros",
+ "logsDialogBody": "Esto enviará registros para ayudarnos a depurar su problema. Tenga en cuenta que los nombres de los archivos se incluirán para ayudar a rastrear problemas con archivos específicos.",
+ "preparingLogs": "Preparando registros...",
+ "emailYourLogs": "Envíe sus registros por correo electrónico",
+ "pleaseSendTheLogsTo": "Por favor, envíe los registros a {toEmail}",
+ "copyEmailAddress": "Copiar dirección de correo electrónico",
+ "exportLogs": "Exportar registros",
+ "pleaseEmailUsAt": "Por favor, envíanos un correo electrónico a {toEmail}",
+ "dismiss": "Descartar",
+ "didYouKnow": "¿Sabías que?",
+ "loadingMessage": "Cargando tus fotos...",
+ "loadMessage1": "Puedes compartir tu suscripción con tu familia",
+ "loadMessage2": "Hasta ahora hemos conservado más de 10 millones de recuerdos",
+ "loadMessage3": "Guardamos 3 copias de sus datos, una en un refugio subterráneo",
+ "loadMessage4": "Todas nuestras aplicaciones son de código abierto",
+ "loadMessage5": "Nuestro código fuente y criptografía han sido auditados externamente",
+ "loadMessage6": "Puedes compartir enlaces a tus álbumes con tus seres queridos",
+ "loadMessage7": "Nuestras aplicaciones móviles se ejecutan en segundo plano para cifrar y hacer copias de seguridad de las nuevas fotos que hagas clic",
+ "loadMessage8": "web.ente.io tiene un cargador sofisticado",
+ "loadMessage9": "Utilizamos Xchacha20Poly1305 para cifrar tus datos de forma segura",
+ "language": "Idioma",
+ "selectLanguage": "Seleccionar idioma",
+ "locationName": "Nombre de la ubicación",
+ "addLocation": "Agregar ubicación",
+ "groupNearbyPhotos": "Agrupar fotos cercanas",
+ "location": "Ubicación",
+ "kiloMeterUnit": "km",
+ "addLocationButton": "Añadir",
+ "radius": "Radio",
+ "locationTagFeatureDescription": "Una etiqueta de ubicación agrupa todas las fotos que fueron tomadas dentro de un radio de una foto",
+ "galleryMemoryLimitInfo": "Hasta 1000 memorias mostradas en la galería",
+ "save": "Guardar",
+ "centerPoint": "Punto central",
+ "pickCenterPoint": "Elegir punto central",
+ "useSelectedPhoto": "Usar foto seleccionada",
+ "edit": "Editar",
+ "deleteLocation": "Borrar la ubicación",
+ "rotateLeft": "Girar a la izquierda",
+ "flip": "Voltear",
+ "rotateRight": "Girar a la derecha",
+ "saveCopy": "Guardar copia",
+ "light": "Claro",
+ "color": "Color",
+ "yesDiscardChanges": "Sí, descartar cambios",
+ "doYouWantToDiscardTheEditsYouHaveMade": "¿Quieres descartar las ediciones que has hecho?",
+ "saving": "Saving...",
+ "editsSaved": "Ediciones guardadas",
+ "oopsCouldNotSaveEdits": "Ups, no se pudieron guardar las ediciónes"
"checkInboxAndSpamFolder": "Veuillez consulter votre boîte de courriels (et les indésirables) pour compléter la vérification",
"tapToEnterCode": "Appuyez pour entrer un code",
"resendEmail": "Renvoyer le courriel",
- "weveSentAMailTo": "Nous avons envoyé un email à",
"setPasswordTitle": "Définir le mot de passe",
"changePasswordTitle": "Modifier le mot de passe",
"resetPasswordTitle": "Réinitialiser le mot de passe",
@@ -96,6 +95,7 @@
"pleaseTryAgain": "Veuillez réessayer",
"recreatePasswordTitle": "Recréer le mot de passe",
"useRecoveryKey": "Utiliser la clé de récupération",
+ "recreatePasswordBody": "L'appareil actuel n'est pas assez puissant pour vérifier votre mot de passe, mais nous pouvons régénérer d'une manière qui fonctionne avec tous les appareils.\n\nVeuillez vous connecter à l'aide de votre clé de récupération et régénérer votre mot de passe (vous pouvez réutiliser le même si vous le souhaitez).",
"verifyPassword": "Vérifier le mot de passe",
"recoveryKey": "Clé de récupération",
"recoveryKeyOnForgotPassword": "Si vous oubliez votre mot de passe, la seule façon de récupérer vos données sera grâce à cette clé.",
@@ -182,6 +182,78 @@
"linkNeverExpires": "Jamais",
"expiredLinkInfo": "Ce lien a expiré. Veuillez sélectionner un nouveau délai d'expiration ou désactiver l'expiration du lien.",
"setAPassword": "Définir un mot de passe",
+ "lockButtonLabel": "Verrouiller",
+ "enterPassword": "Saisissez le mot de passe",
+ "removeLink": "Supprimer le lien",
+ "manageLink": "Gérer le lien",
+ "linkExpiresOn": "Le lien expirera le {expiryTime}",
+ "albumUpdated": "Album mis à jour",
+ "maxDeviceLimitSpikeHandling": "Lorsqu'elle est définie au maximum ({maxValue}), la limite de l'appareil sera assouplie pour permettre des pointes temporaires d'un grand nombre de téléspectateurs.",
+ "@maxDeviceLimitSpikeHandling": {
+ "placeholders": {
+ "maxValue": {
+ "type": "int",
+ "example": "100"
+ }
+ }
+ },
+ "never": "Jamais",
+ "custom": "Personnaliser",
+ "@custom": {
+ "description": "Label for setting custom value for link expiry"
+ },
+ "after1Hour": "Après 1 heure",
+ "after1Day": "Après 1 jour",
+ "after1Week": "Après 1 semaine",
+ "after1Month": "Après 1 mois",
+ "after1Year": "Après 1 an",
+ "manageParticipants": "Gérer",
+ "collabLinkSectionDescription": "Créez un lien pour permettre aux gens d'ajouter et de voir des photos dans votre album partagé sans avoir besoin d'une application ente ou d'un compte. Idéal pour collecter des photos d'événement.",
+ "collectPhotos": "Récupérer les photos",
+ "collaborativeLink": "Lien collaboratif",
+ "shareWithNonenteUsers": "Partager avec des utilisateurs non-ente",
+ "createPublicLink": "Créer un lien public",
+ "sendLink": "Envoyer le lien",
+ "copyLink": "Copier le lien",
+ "linkHasExpired": "Le lien a expiré",
+ "publicLinkEnabled": "Lien public activé",
+ "shareALink": "Partager le lien",
+ "sharedAlbumSectionDescription": "Créez des albums partagés et collaboratifs avec d'autres utilisateurs de ente, y compris des utilisateurs sur des plans gratuits.",
+ "shareWithPeopleSectionTitle": "{numberOfPeople, plural, =0 {Partagez avec des personnes spécifiques} =1 {Partagé avec 1 personne} other {Partagé avec {numberOfPeople} des gens}}",
+ "@shareWithPeopleSectionTitle": {
+ "placeholders": {
+ "numberOfPeople": {
+ "type": "int",
+ "example": "2"
+ }
+ }
+ },
+ "thisIsYourVerificationId": "Ceci est votre ID de vérification",
+ "someoneSharingAlbumsWithYouShouldSeeTheSameId": "Quelqu'un qui partage des albums avec vous devrait voir le même ID sur son appareil.",
+ "howToViewShareeVerificationID": "Demandez-leur d'appuyer longuement sur leur adresse e-mail sur l'écran des paramètres et de vérifier que les identifiants des deux appareils correspondent.",
+ "thisIsPersonVerificationId": "Ceci est l'ID de vérification de {email}",
+ "@thisIsPersonVerificationId": {
+ "placeholders": {
+ "email": {
+ "type": "String",
+ "example": "someone@ente.io"
+ }
+ }
+ },
+ "verificationId": "ID de vérification",
+ "verifyEmailID": "Vérifier {email}",
+ "emailNoEnteAccount": "{email} n'a pas de compte ente.\n\nEnvoyez une invitation pour partager des photos.",
+ "shareMyVerificationID": "Voici mon ID de vérification : {verificationID} pour ente.io.",
+ "shareTextConfirmOthersVerificationID": "Hé, pouvez-vous confirmer qu'il s'agit de votre ID de vérification ente.io : {verificationID}",
+ "somethingWentWrong": "Un problème est survenu",
+ "sendInvite": "Envoyer Invitations",
+ "shareTextRecommendUsingEnte": "Téléchargez ente pour que nous puissions facilement partager des photos et des vidéos de qualité originale\n\nhttps://ente.io/#download",
+ "done": "Terminé",
+ "applyCodeTitle": "Utiliser le code",
+ "enterCodeDescription": "Entrez le code fourni par votre ami pour réclamer de l'espace de stockage gratuit pour vous deux",
+ "apply": "Appliquer",
+ "failedToApplyCode": "Impossible d'appliquer le code",
+ "enterReferralCode": "Entrez le code de parrainage",
"codeAppliedPageTitle": "Code appliqué",
"storageInGB": "{storageAmountInGB} Go",
"claimed": "Réclamée",
@@ -195,5 +267,464 @@
"shareTextReferralCode": "code de parrainage ente : {referralCode} \n\nAppliquez le dans Paramètres → Général → Références pour obtenir {referralStorageInGB} Go gratuitement après votre inscription à un plan payant\n\nhttps://ente.io",
"claimFreeStorage": "Réclamer le stockage gratuit",
"inviteYourFriends": "Invite tes ami(e)s",
- "failedToFetchReferralDetails": "Impossible de récupérer les détails du parrainage. Veuillez réessayer plus tard."
+ "failedToFetchReferralDetails": "Impossible de récupérer les détails du parrainage. Veuillez réessayer plus tard.",
+ "referralStep1": "1. Donnez ce code à vos amis",
+ "referralStep2": "2. Ils s'inscrivent à une offre payante",
+ "referralStep3": "3. Vous recevez tous les deux {storageInGB} GB* gratuits",
+ "referralsAreCurrentlyPaused": "Les recommandations sont actuellement en pause",
+ "youCanAtMaxDoubleYourStorage": "* Vous pouvez au maximum doubler votre espace de stockage",
+ "claimedStorageSoFar": "{isFamilyMember, select, true {Votre famille a demandé {storageAmountInGb} Gb jusqu'à présent} false {Vous avez réclamé {storageAmountInGb} Gb jusqu'à présent} other {Vous avez réclamé {storageAmountInGb} Gbjusqu'à présent!}}",
+ "@claimedStorageSoFar": {
+ "placeholders": {
+ "isFamilyMember": {
+ "type": "String",
+ "example": "true"
+ },
+ "storageAmountInGb": {
+ "type": "int",
+ "example": "10"
+ }
+ }
+ },
+ "faq": "FAQ",
+ "oopsSomethingWentWrong": "Oups, une erreur est arrivée",
+ "usableReferralStorageInfo": "Le stockage utilisable est limité par votre offre actuelle. Le stockage excédentaire deviendra automatiquement utilisable lorsque vous mettez à niveau votre offre.",
+ "removeFromAlbumTitle": "Retirer de l'album ?",
+ "removeFromAlbum": "Retirer de l'album",
+ "itemsWillBeRemovedFromAlbum": "Les éléments sélectionnés seront supprimés de cet album",
+ "removeShareItemsWarning": "Certains des objets que vous êtes en train de retirer ont été ajoutés par d'autres personnes, vous perdrez l'accès vers ces objets",
+ "addingToFavorites": "Ajout aux favoris...",
+ "removingFromFavorites": "Suppression des favoris…",
+ "sorryCouldNotAddToFavorites": "Désolé, impossible d'ajouter aux favoris !",
+ "sorryCouldNotRemoveFromFavorites": "Désolé, impossible de supprimer des favoris !",
+ "subscribeToEnableSharing": "Il semble que votre abonnement ait expiré. Veuillez vous abonner pour activer le partage.",
+ "subscribe": "S'abonner",
+ "canOnlyRemoveFilesOwnedByYou": "Vous ne pouvez supprimer que les fichiers que vous possédez",
+ "deleteAlbumDialog": "Supprimer aussi les photos (et vidéos) présentes dans cet album depuis <bold>tous</bold> les autres albums dont ils font partie ?",
+ "deleteSharedAlbumDialogBody": "L'album sera supprimé pour tout le monde\n\nVous perdrez l'accès aux photos partagées dans cet album qui est détenues par d'autres personnes",
+ "yesRemove": "Oui, supprimer",
+ "creatingLink": "Création du lien...",
+ "removeWithQuestionMark": "Enlever?",
+ "removeParticipantBody": "{userEmail} sera retiré de cet album partagé\n\nToutes les photos ajoutées par eux seront également retirées de l'album",
+ "keepPhotos": "Conserver les photos",
+ "deletePhotos": "Supprimer des photos",
+ "inviteToEnte": "Inviter à ente",
+ "removePublicLink": "Supprimer le lien public",
+ "disableLinkMessage": "Cela supprimera le lien public pour accéder à \"{albumName}\".",
+ "sharing": "Partage...",
+ "youCannotShareWithYourself": "Vous ne pouvez pas partager avec vous-même",
+ "archive": "Archiver",
+ "createAlbumActionHint": "Appuyez longuement pour sélectionner des photos et cliquez sur + pour créer un album",
+ "importing": "Importation en cours...",
+ "failedToLoadAlbums": "Impossible de charger les albums",
+ "hidden": "Masqué",
+ "authToViewYourHiddenFiles": "Veuillez vous authentifier pour voir vos fichiers cachés",
+ "trash": "Corbeille",
+ "uncategorized": "Aucune catégorie",
+ "videoSmallCase": "vidéo",
+ "photoSmallCase": "photo",
+ "singleFileDeleteHighlight": "Il sera supprimé de tous les albums.",
+ "singleFileInBothLocalAndRemote": "Ce {fileType} est à la fois dans ente et votre appareil.",
+ "singleFileInRemoteOnly": "Ce {fileType} sera supprimé de ente.",
+ "singleFileDeleteFromDevice": "Ce {fileType} sera supprimé de votre appareil.",
+ "yearsAgo": "{count, plural, one{{count} il y a un an} other{{count} il y a des années}}",
+ "backupSettings": "Paramètres de la sauvegarde",
+ "backupOverMobileData": "Sauvegarde sur données mobiles",
+ "backupVideos": "Sauvegarde des vidéos",
+ "disableAutoLock": "Désactiver le verrouillage automatique",
+ "deviceLockExplanation": "Désactiver le verrouillage de l'écran de l'appareil lorsque ente est au premier plan et il y a une sauvegarde en cours. Ce n'est normalement pas nécessaire, mais peut aider les gros téléchargements et les premières importations de grandes bibliothèques plus rapidement.",
+ "about": "À propos",
+ "weAreOpenSource": "Nous sommes open source !",
+ "privacy": "Confidentialité",
+ "terms": "Conditions",
+ "checkForUpdates": "Vérifier les mises à jour",
+ "checking": "Vérification...",
+ "youAreOnTheLatestVersion": "Vous êtes sur la dernière version",
+ "account": "Compte",
+ "manageSubscription": "Gérer l'abonnement",
+ "authToChangeYourEmail": "Veuillez vous authentifier pour modifier votre adresse e-mail",
+ "changePassword": "Modifier le mot de passe",
+ "authToChangeYourPassword": "Veuillez vous authentifier pour modifier votre mot de passe",
+ "exportYourData": "Exportez vos données",
+ "logout": "Déconnexion",
+ "authToInitiateAccountDeletion": "Veuillez vous authentifier pour débuter la suppression du compte",
+ "description": "The text to display when the user has successfully cleaned up duplicate files",
+ "type": "text",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "storageSaved": {
+ "example": "1.2 GB",
+ "type": "String"
+ }
+ }
+ },
+ "familyPlans": "Forfaits famille",
+ "referrals": "Parrainages",
+ "advanced": "Avancé",
+ "general": "Général",
+ "security": "Sécurité",
+ "authToViewYourRecoveryKey": "Veuillez vous authentifier pour afficher votre clé de récupération",
+ "twofactor": "Double authentification",
+ "authToConfigureTwofactorAuthentication": "Veuillez vous authentifier pour configurer l'authentification à deux facteurs",
+ "lockscreen": "Ecran de vérouillage",
+ "authToChangeLockscreenSetting": "Veuillez vous authentifier pour modifier les paramètres de l'écran de verrouillage",
+ "lockScreenEnablePreSteps": "Pour activer l'écran de verrouillage, veuillez configurer le code d'accès de l'appareil ou le verrouillage de l'écran dans les paramètres de votre système.",
+ "viewActiveSessions": "Afficher les sessions actives",
+ "authToViewYourActiveSessions": "Veuillez vous authentifier pour voir vos sessions actives",
+ "disableTwofactor": "Désactiver la double-authentification",
+ "confirm2FADisable": "Voulez-vous vraiment désactiver l'authentification à deux facteurs ?",
+ "no": "Non",
+ "yes": "Oui",
+ "social": "Réseaux Sociaux",
+ "rateUsOnStore": "Notez-nous sur {storeName}",
+ "blog": "Blog",
+ "merchandise": "Marchandise",
+ "twitter": "Twitter",
+ "mastodon": "Mastodon",
+ "matrix": "Matrix",
+ "discord": "Discord",
+ "reddit": "Reddit",
+ "yourStorageDetailsCouldNotBeFetched": "Vos informations de stockage n'ont pas pu être récupérées",
+ "reportABug": "Signaler un bug",
+ "reportBug": "Signaler un bug",
+ "suggestFeatures": "Suggérer des fonctionnalités",
+ "support": "Support",
+ "theme": "Thème",
+ "lightTheme": "Clair",
+ "darkTheme": "Sombre",
+ "systemTheme": "Système",
+ "freeTrial": "Essai gratuit",
+ "selectYourPlan": "Sélectionner votre offre",
+ "enteSubscriptionPitch": "ente conserve vos souvenirs, donc ils sont toujours disponibles pour vous, même si vous perdez votre appareil.",
+ "enteSubscriptionShareWithFamily": "Vous pouvez également ajouter votre famille à votre forfait.",
+ "currentUsageIs": "L'utilisation actuelle est ",
+ "@currentUsageIs": {
+ "description": "This text is followed by storage usaged",
+ "examples": {
+ "0": "Current usage is 1.2 GB"
+ },
+ "type": "text"
+ },
+ "faqs": "FAQ",
+ "renewsOn": "Renouvellement le {endDate}",
+ "subWillBeCancelledOn": "Votre abonnement sera annulé le {endDate}",
+ "subscription": "Abonnement",
+ "paymentDetails": "Détails de paiement",
+ "manageFamily": "Gérer la famille",
+ "contactToManageSubscription": "Veuillez nous contacter à support@ente.io pour gérer votre abonnement {provider}.",
+ "renewSubscription": "Renouveler l’abonnement",
+ "cancelSubscription": "Annuler l'abonnement",
+ "areYouSureYouWantToRenew": "Êtes-vous sûr de vouloir renouveler ?",
+ "yesRenew": "Oui, renouveler",
+ "areYouSureYouWantToCancel": "Es-tu sûre de vouloir annuler?",
+ "yesCancel": "Oui, annuler",
+ "failedToRenew": "Échec du renouvellement",
+ "failedToCancel": "Échec de l'annulation",
+ "twoMonthsFreeOnYearlyPlans": "2 mois gratuits sur les forfaits annuels",
+ "monthly": "Mensuel",
+ "@monthly": {
+ "description": "The text to display for monthly plans",
+ "type": "text"
+ },
+ "yearly": "Annuel",
+ "@yearly": {
+ "description": "The text to display for yearly plans",
+ "type": "text"
+ },
+ "confirmPlanChange": "Confirmer le changement de l'offre",
+ "areYouSureYouWantToChangeYourPlan": "Êtes-vous certains de vouloir changer d'offre ?",
+ "youCannotDowngradeToThisPlan": "Vous ne pouvez pas rétrograder vers cette offre",
+ "cancelOtherSubscription": "Veuillez d'abord annuler votre abonnement existant de {paymentProvider}",
+ "@cancelOtherSubscription": {
+ "description": "The text to display when the user has an existing subscription from a different payment provider",
+ "type": "text",
+ "placeholders": {
+ "paymentProvider": {
+ "example": "Apple",
+ "type": "String"
+ }
+ }
+ },
+ "optionalAsShortAsYouLike": "Optionnel, aussi court que vous le souhaitez...",
+ "send": "Envoyer",
+ "askCancelReason": "Votre abonnement a été annulé. Souhaitez-vous partager la raison ?",
+ "thankYouForSubscribing": "Merci de vous être abonné !",
+ "yourPurchaseWasSuccessful": "Votre achat a été effectué avec succès",
+ "yourPlanWasSuccessfullyUpgraded": "Votre offre a été mise à jour avec succès",
+ "yourPlanWasSuccessfullyDowngraded": "Votre plan a été rétrogradé avec succès",
+ "yourSubscriptionWasUpdatedSuccessfully": "Votre abonnement a été mis à jour avec succès",
+ "googlePlayId": "Identifiant Google Play",
+ "appleId": "Apple ID",
+ "playstoreSubscription": "Abonnement au PlayStore",
+ "areYouSureYouWantToExit": "Êtes-vous sûr de vouloir quitter ?",
+ "thankYou": "Merci",
+ "pleaseWaitForSometimeBeforeRetrying": "Veuillez attendre quelque temps avant de réessayer",
+ "available": "Disponible",
+ "upgrade": "Améliorer",
+ "usePublicLinksForPeopleNotOnEnte": "Utiliser des liens publics pour les personnes qui ne sont pas sur ente",
+ "allowPeopleToAddPhotos": "Autoriser les personnes à ajouter des photos",
+ "shareAnAlbumNow": "Partagez un album maintenant",
+ "collectEventPhotos": "Collecter des photos de l'événement",
+ "sessionExpired": "Session expirée",
+ "loggingOut": "Deconnexion...",
+ "name": "Nom",
+ "newest": "Le plus récent",
+ "lastUpdated": "Dernière mise à jour",
+ "deleteEmptyAlbums": "Supprimer les albums vides",
+ "deleteEmptyAlbumsWithQuestionMark": "Supprimer les albums vides ?",
+ "deleteAlbumsDialogBody": "Ceci supprimera tous les albums vides. Ceci est utile lorsque vous voulez réduire l'encombrement dans votre liste d'albums.",
+ "deleteProgress": "Suppression de {currentlyDeleting} / {totalCount}",
+ "canOnlyCreateLinkForFilesOwnedByYou": "Ne peut créer de lien que pour les fichiers que vous possédez",
+ "publicLinkCreated": "Lien public créé",
+ "youCanManageYourLinksInTheShareTab": "Vous pouvez gérer vos liens dans l'onglet Partage.",
+ "linkCopiedToClipboard": "Lien copié dans le presse-papiers",
+ "restore": "Restaurer",
+ "@restore": {
+ "description": "Display text for an action which triggers a restore of item from trash",
+ "type": "text"
+ },
+ "moveToAlbum": "Déplacer vers l'album",
+ "unhide": "Dévoiler",
+ "unarchive": "Désarchiver",
+ "favorite": "Favori",
+ "removeFromFavorite": "Retirer des favoris",
+ "shareLink": "Partager le lien",
+ "addToEnte": "Ajouter à ente",
+ "addToAlbum": "Ajouter à l'album",
+ "delete": "Supprimer",
+ "hide": "Masquer",
+ "itemSelectedCount": "{count} sélectionné",
+ "@itemSelectedCount": {
+ "description": "Text to indicate number of items selected",
+ "placeholders": {
+ "count": {
+ "example": "1|2|3",
+ "type": "int"
+ }
+ }
+ },
+ "share": "Partager",
+ "unhideToAlbum": "Afficher dans l'album",
+ "restoreToAlbum": "Restaurer vers l'album",
+ "moveItem": "{count, plural, one {Déplacez l'objet} other {Déplacez des objets}}",
+ "@moveItem": {
+ "description": "Page title while moving one or more items to an album"
+ },
+ "addItem": "{count, plural, one {Ajoutez un objet} other {Ajoutez des objets}}",
+ "@addItem": {
+ "description": "Page title while adding one or more items to album"
+ },
+ "createOrSelectAlbum": "Créer ou sélectionner un album",
+ "selectAlbum": "Sélectionner album",
+ "searchByAlbumNameHint": "Nom de l'album",
+ "albumTitle": "Titre de l'album",
+ "enterAlbumName": "Saisir un nom d'album",
+ "restoringFiles": "Restauration des fichiers...",
+ "movingFilesToAlbum": "Déplacement des fichiers vers l'album...",
+ "unhidingFilesToAlbum": "Démasquage des fichiers vers l'album",
+ "canNotUploadToAlbumsOwnedByOthers": "Impossible de télécharger dans les albums appartenant à d'autres personnes",
+ "uploadingFilesToAlbum": "Envoi des fichiers vers l'album...",
+ "addedSuccessfullyTo": "Ajouté avec succès à {albumName}",
+ "movedSuccessfullyTo": "Déplacé avec succès vers {albumName}",
+ "thisAlbumAlreadyHDACollaborativeLink": "Cet album a déjà un lien collaboratif",
+ "collaborativeLinkCreatedFor": "Lien collaboratif créé pour {albumName}",
+ "askYourLovedOnesToShare": "Demandez à vos proches de partager",
+ "sharedWith": "Partagé avec {emailIDs}",
+ "sharedByMe": "Partagé par moi",
+ "doubleYourStorage": "Doubler votre espace de stockage",
+ "referFriendsAnd2xYourPlan": "Parrainez des amis et 2x votre abonnement",
+ "shareAlbumHint": "Ouvrez un album et appuyez sur le bouton de partage en haut à droite pour le partager.",
+ "itemsShowTheNumberOfDaysRemainingBeforePermanentDeletion": "Les éléments montrent le nombre de jours restants avant la suppression définitive",
+ "deleteAll": "Tout Supprimer",
+ "renameAlbum": "Renommer l'album",
+ "rename": "Renommer",
+ "leaveSharedAlbum": "Quitter l'album partagé?",
+ "leaveAlbum": "Quitter l'album",
+ "photosAddedByYouWillBeRemovedFromTheAlbum": "Les photos ajoutées par vous seront retirées de l'album",
+ "youveNoFilesInThisAlbumThatCanBeDeleted": "Vous n'avez pas de fichiers dans cet album qui peuvent être supprimés",
+ "ignoredFolderUploadReason": "Certains fichiers de cet album sont ignorés parce qu'ils avaient été précédemment supprimés de ente.",
+ "resetIgnoredFiles": "Réinitialiser les fichiers ignorés",
+ "exif": "EXIF",
+ "noResults": "Aucun résultat",
+ "weDontSupportEditingPhotosAndAlbumsThatYouDont": "Nous ne prenons pas en charge l'édition des photos et des albums que vous ne possédez pas encore",
+ "failedToFetchOriginalForEdit": "Impossible de récupérer l'original pour l'édition",
+ "close": "Fermer",
+ "setAs": "Définir comme",
+ "fileSavedToGallery": "Fichier enregistré dans la galerie",
+ "download": "Télécharger",
+ "pressAndHoldToPlayVideo": "Appuyez et maintenez enfoncé pour lire la vidéo",
+ "downloadFailed": "Échec du téléchargement",
+ "deduplicateFiles": "Déduplication de fichiers",
+ "deselectAll": "Tout déselectionner",
+ "reviewDeduplicateItems": "Veuillez vérifier et supprimer les éléments que vous croyez dupliqués.",
+ "clubByCaptureTime": "Durée du Club par capture",
+ "totalSize": "Taille totale",
+ "emailChangedTo": "L'e-mail a été changé en {newEmail}",
+ "verifying": "Validation en cours...",
+ "disablingTwofactorAuthentication": "Désactiver la double-authentification...",
+ "allMemoriesPreserved": "Tous les souvenirs conservés",
+ "loadingGallery": "Chargement de la galerie...",
+ "syncing": "En cours de synchronisation...",
+ "encryptingBackup": "Chiffrement de la sauvegarde...",
+ "description": "Text to tell user how many memories have been preserved",
+ "placeholders": {
+ "completed": {
+ "type": "int"
+ },
+ "total": {
+ "type": "int"
+ }
+ }
+ },
+ "archiving": "Archivage en cours...",
+ "unarchiving": "Désarchivage en cours...",
+ "successfullyArchived": "Archivé avec succès",
+ "successfullyUnarchived": "Désarchivé avec succès",
+ "renameFile": "Renommer le fichier",
+ "enterFileName": "Entrez le nom du fichier",
+ "filesDeleted": "Fichiers supprimés",
+ "selectedFilesAreNotOnEnte": "Les fichiers sélectionnés ne sont pas sur ente",
+ "thisActionCannotBeUndone": "Cette action ne peut pas être annulée",
+ "emptyTrash": "Vider la corbeille ?",
+ "permDeleteWarning": "Tous les éléments de la corbeille seront définitivement supprimés\n\nCette action ne peut pas être annulée",
+ "empty": "Vide",
+ "couldNotFreeUpSpace": "Impossible de libérer de l'espace",
+ "permanentlyDeleteFromDevice": "Supprimer définitivement de l'appareil ?",
+ "someOfTheFilesYouAreTryingToDeleteAre": "Certains des fichiers que vous essayez de supprimer ne sont disponibles que sur votre appareil et ne peuvent pas être récupérés s'ils sont supprimés",
+ "theyWillBeDeletedFromAllAlbums": "Ils seront supprimés de tous les albums.",
+ "someItemsAreInBothEnteAndYourDevice": "Certains éléments sont à la fois dans ente et votre appareil.",
+ "selectedItemsWillBeDeletedFromAllAlbumsAndMoved": "Les éléments sélectionnés seront supprimés de tous les albums et déplacés dans la corbeille.",
+ "theseItemsWillBeDeletedFromYourDevice": "Ces éléments seront supprimés de votre appareil.",
+ "itLooksLikeSomethingWentWrongPleaseRetryAfterSome": "Il semble qu'une erreur s'est produite. Veuillez réessayer après un certain temps. Si l'erreur persiste, veuillez contacter notre équipe d'assistance.",
+ "error": "Erreur",
+ "tempErrorContactSupportIfPersists": "Il semble qu'une erreur s'est produite. Veuillez réessayer après un certain temps. Si l'erreur persiste, veuillez contacter notre équipe d'assistance.",
+ "cachedData": "Données mises en cache",
+ "clearCaches": "Nettoyer le cache",
+ "remoteImages": "Images distantes",
+ "remoteVideos": "Vidéos distantes",
+ "remoteThumbnails": "Miniatures distantes",
+ "pendingSync": "Synchronisation en attente",
+ "localGallery": "Galerie locale",
+ "todaysLogs": "Journaux du jour",
+ "viewLogs": "Afficher les journaux",
+ "logsDialogBody": "Cela enverra des logs pour nous aider à déboguer votre problème. Veuillez noter que les noms de fichiers seront inclus pour aider à suivre les problèmes avec des fichiers spécifiques.",
+ "preparingLogs": "Préparation des journaux...",
+ "emailYourLogs": "Envoyez vos logs par e-mail",
+ "pleaseSendTheLogsTo": "Envoyez les logs à {toEmail}",
+ "copyEmailAddress": "Copier l’adresse e-mail",
+ "exportLogs": "Exporter les logs",
+ "pleaseEmailUsAt": "Merci de nous envoyer un e-mail à {toEmail}",
+ "dismiss": "Rejeter",
+ "didYouKnow": "Le savais-tu ?",
+ "loadingMessage": "Chargement de vos photos...",
"checkInboxAndSpamFolder": "Controleer je inbox (en spam) om verificatie te voltooien",
"tapToEnterCode": "Tik om code in te voeren",
"resendEmail": "E-mail opnieuw versturen",
- "weveSentAMailTo": "We hebben een e-mail gestuurd naar",
+ "weHaveSendEmailTo": "We hebben een e-mail gestuurd naar <green>{email}</green>",
+ "@weHaveSendEmailTo": {
+ "description": "Text to indicate that we have sent a mail to the user",
+ "placeholders": {
+ "email": {
+ "description": "The email address of the user",
+ "type": "String",
+ "example": "example@ente.io"
+ }
+ }
+ },
"setPasswordTitle": "Wachtwoord instellen",
"changePasswordTitle": "Wachtwoord wijzigen",
"resetPasswordTitle": "Wachtwoord resetten",
@@ -96,6 +106,7 @@
"pleaseTryAgain": "Probeer het nog eens",
"recreatePasswordTitle": "Wachtwoord opnieuw instellen",
"useRecoveryKey": "Herstelcode gebruiken",
+ "recreatePasswordBody": "Het huidige apparaat is niet krachtig genoeg om je wachtwoord te verifiëren, dus moeten we de code een keer opnieuw genereren op een manier die met alle apparaten werkt.\n\nLog in met behulp van uw herstelcode en genereer opnieuw uw wachtwoord (je kunt dezelfde indien gewenst opnieuw gebruiken).",
"verifyPassword": "Bevestig wachtwoord",
"recoveryKey": "Herstelsleutel",
"recoveryKeyOnForgotPassword": "Als je je wachtwoord vergeet, kun je alleen met deze sleutel je gegevens herstellen.",
"recoveryKeySuccessBody": "Super! Je herstelsleutel is geldig. Bedankt voor het verifiëren.\n\nVergeet niet om je herstelsleutel veilig te bewaren.",
+ "invalidRecoveryKey": "De herstelsleutel die je hebt ingevoerd is niet geldig. Zorg ervoor dat deze 24 woorden bevat en controleer de spelling van elk van deze woorden.\n\nAls je een oudere herstelcode hebt ingevoerd, zorg ervoor dat deze 64 tekens lang is, en controleer ze allemaal.",
"invalidKey": "Ongeldige sleutel",
"tryAgain": "Probeer opnieuw",
"viewRecoveryKey": "Toon herstelsleutel",
@@ -216,6 +228,87 @@
"copyLink": "Kopieer link",
"linkHasExpired": "Link is vervallen",
"publicLinkEnabled": "Publieke link ingeschakeld",
+ "shareALink": "Deel een link",
+ "sharedAlbumSectionDescription": "Maak gedeelde en collaboratieve albums met andere ente gebruikers, inclusief gebruikers met gratis abonnementen.",
+ "shareWithPeopleSectionTitle": "{numberOfPeople, plural, =0 {Deel met specifieke mensen} =1 {Gedeeld met 1 persoon} other {Gedeeld met {numberOfPeople} mensen}}",
+ "@shareWithPeopleSectionTitle": {
+ "placeholders": {
+ "numberOfPeople": {
+ "type": "int",
+ "example": "2"
+ }
+ }
+ },
+ "thisIsYourVerificationId": "Dit is uw verificatie-ID",
+ "someoneSharingAlbumsWithYouShouldSeeTheSameId": "Iemand die albums met je deelt zou hetzelfde ID op hun apparaat moeten zien.",
+ "howToViewShareeVerificationID": "Vraag hen om hun e-mailadres lang in te drukken op het instellingenscherm en te controleren dat de ID's op beide apparaten overeenkomen.",
+ "thisIsPersonVerificationId": "Dit is de verificatie-ID van {email}",
+ "@thisIsPersonVerificationId": {
+ "placeholders": {
+ "email": {
+ "type": "String",
+ "example": "someone@ente.io"
+ }
+ }
+ },
+ "verificationId": "Verificatie ID",
+ "verifyEmailID": "Verifieer {email}",
+ "emailNoEnteAccount": "{email} heeft geen ente account.\n\nStuur ze een uitnodiging om foto's te delen.",
+ "shareMyVerificationID": "Hier is mijn verificatie-ID: {verificationID} voor ente.io.",
+ "shareTextConfirmOthersVerificationID": "Hey, kunt u bevestigen dat dit uw ente.io verificatie-ID is: {verificationID}",
+ "somethingWentWrong": "Er ging iets mis",
+ "sendInvite": "Stuur een uitnodiging",
+ "shareTextRecommendUsingEnte": "Download ente zodat we gemakkelijk foto's en video's van originele kwaliteit kunnen delen\n\nhttps://ente.io/#download",
+ "done": "Voltooid",
+ "applyCodeTitle": "Code toepassen",
+ "enterCodeDescription": "Voer de code van de vriend in om gratis opslag voor jullie beiden te claimen",
+ "apply": "Toepassen",
+ "failedToApplyCode": "Code toepassen mislukt",
+ "enterReferralCode": "Voer verwijzingscode in",
+ "codeAppliedPageTitle": "Code toegepast",
+ "storageInGB": "{storageAmountInGB} GB",
+ "claimed": "Geclaimd",
+ "@claimed": {
+ "description": "Used to indicate storage claimed, like 10GB Claimed"
+ },
+ "details": "Details",
+ "claimMore": "Claim meer!",
+ "theyAlsoGetXGb": "Zij krijgen ook {storageAmountInGB} GB",
+ "freeStorageOnReferralSuccess": "{storageAmountInGB} GB telkens als iemand zich aanmeldt voor een betaald abonnement en je code toepast",
+ "shareTextReferralCode": "ente verwijzingscode: {referralCode} \n\nPas het toe bij Instellingen → Algemeen → Verwijzingen om {referralStorageInGB} GB gratis te krijgen nadat je je hebt aangemeld voor een betaald abonnement\n\nhttps://ente.io",
+ "claimFreeStorage": "Claim gratis opslag",
+ "inviteYourFriends": "Vrienden uitnodigen",
+ "failedToFetchReferralDetails": "Kan geen verwijzingsgegevens ophalen. Probeer het later nog eens.",
+ "referralStep1": "1. Geef deze code aan je vrienden",
+ "referralStep2": "2. Ze registreren voor een betaald plan",
+ "referralsAreCurrentlyPaused": "Verwijzingen zijn momenteel gepauzeerd",
+ "youCanAtMaxDoubleYourStorage": "* Je kunt maximaal je opslag verdubbelen",
+ "claimedStorageSoFar": "{isFamilyMember, select, true {Jouw familie heeft {storageAmountInGb} Gb geclaimd tot nu toe} false {Je hebt {storageAmountInGb} Gb geclaimd tot nu toe} other {Je hebt {storageAmountInGb} Gb geclaimd tot nu toe!}}",
+ "@claimedStorageSoFar": {
+ "placeholders": {
+ "isFamilyMember": {
+ "type": "String",
+ "example": "true"
+ },
+ "storageAmountInGb": {
+ "type": "int",
+ "example": "10"
+ }
+ }
+ },
+ "faq": "Veelgestelde vragen",
+ "oopsSomethingWentWrong": "Oeps, er is iets misgegaan",
+ "peopleUsingYourCode": "Mensen die jouw code gebruiken",
+ "eligible": "gerechtigd",
+ "total": "totaal",
+ "codeUsedByYou": "Code gebruikt door jou",
+ "freeStorageClaimed": "Gratis opslag geclaimd",
+ "freeStorageUsable": "Gratis opslag bruikbaar",
+ "usableReferralStorageInfo": "Bruikbare opslag is beperkt door je huidige abonnement. Buitensporige geclaimde opslag zal automatisch bruikbaar worden wanneer je je abonnement upgrade.",
+ "removeFromAlbumTitle": "Uit album verwijderen?",
+ "removeFromAlbum": "Verwijder uit album",
+ "itemsWillBeRemovedFromAlbum": "Geselecteerde items zullen worden verwijderd uit dit album",
"removeShareItemsWarning": "Sommige van de items die je verwijdert zijn door andere mensen toegevoegd, en je verliest de toegang daartoe",
"addingToFavorites": "Toevoegen aan favorieten...",
"removingFromFavorites": "Verwijderen uit favorieten...",
@@ -340,5 +433,496 @@
"updateAvailable": "Update beschikbaar",
"downloading": "Downloaden...",
"theDownloadCouldNotBeCompleted": "De download kon niet worden voltooid",
+ "description": "The text to display when the user has successfully cleaned up duplicate files",
+ "type": "text",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "storageSaved": {
+ "example": "1.2 GB",
+ "type": "String"
+ }
+ }
+ },
+ "familyPlans": "Familie abonnement",
+ "referrals": "Referenties",
+ "advanced": "Geavanceerd",
+ "general": "Algemeen",
+ "security": "Beveiliging",
+ "authToViewYourRecoveryKey": "Graag verifiëren om uw herstelsleutel te bekijken",
+ "twofactor": "Tweestapsverificatie",
+ "authToConfigureTwofactorAuthentication": "Graag verifiëren om tweestapsverificatie te configureren",
+ "lockscreen": "Vergrendelscherm",
+ "authToChangeLockscreenSetting": "Graag verifiëren om de vergrendelscherm instellingen te wijzigen",
+ "lockScreenEnablePreSteps": "Om vergrendelscherm in te schakelen, moet u een toegangscode of schermvergrendeling instellen in uw systeeminstellingen.",
+ "subAlreadyLinkedErrMessage": "Uw {id} is al aan een ander ente account gekoppeld.\nAls u uw {id} wilt gebruiken met dit account, neem dan contact op met onze klantenservice",
+ "visitWebToManage": "Bezoek alstublieft web.ente.io om uw abonnement te beheren",
+ "couldNotUpdateSubscription": "Kon abonnement niet wijzigen",
+ "pleaseContactSupportAndWeWillBeHappyToHelp": "Neem alstublieft contact op met support@ente.io en we helpen u graag!",
+ "paymentFailed": "Betaling mislukt",
+ "paymentFailedTalkToProvider": "Praat met {providerName} klantenservice als u in rekening bent gebracht",
+ "@paymentFailedTalkToProvider": {
+ "description": "The text to display when the payment failed",
+ "type": "text",
+ "placeholders": {
+ "providerName": {
+ "example": "AppStore|PlayStore",
+ "type": "String"
+ }
+ }
+ },
+ "continueOnFreeTrial": "Doorgaan met gratis proefversie",
+ "areYouSureYouWantToExit": "Weet u zeker dat u wilt afsluiten?",
+ "devAccountChanged": "Het ontwikkelaarsaccount dat we gebruiken om te publiceren in de App Store is veranderd. Daarom moet je opnieuw inloggen.\n\nOnze excuses voor het ongemak, helaas was dit onvermijdelijk.",
+ "yourSubscriptionHasExpired": "Uw abonnement is verlopen",
+ "reviewDeduplicateItems": "Controleer en verwijder de bestanden die u denkt dat dubbel zijn.",
+ "clubByCaptureTime": "Samenvoegen op tijd",
+ "count": "Aantal",
+ "totalSize": "Totale grootte",
+ "time": "Tijd",
+ "longpressOnAnItemToViewInFullscreen": "Houd een bestand lang ingedrukt om te bekijken op volledig scherm",
+ "decryptingVideo": "Video ontsleutelen...",
+ "authToViewYourMemories": "Graag verifiëren om uw herinneringen te bekijken",
+ "unlock": "Ontgrendelen",
+ "freeUpSpace": "Ruimte vrijmaken",
+ "freeUpSpaceSaving": "{count, plural, one {Het kan verwijderd worden van het apparaat om {formattedSize} vrij te maken} other {Ze kunnen verwijderd worden van het apparaat om {formattedSize} vrij te maken}}",
+ "filesBackedUpInAlbum": "{count, plural, one {1 bestand} other {{formattedNumber} bestanden}} in dit album is veilig geback-upt",
+ "@filesBackedUpInAlbum": {
+ "description": "Text to tell user how many files have been backed up in the album",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "formattedNumber": {
+ "content": "{formattedNumber}",
+ "example": "1,000",
+ "type": "String"
+ }
+ }
+ },
+ "filesBackedUpFromDevice": "{count, plural, one {1 bestand} other {{formattedNumber} bestanden}} in dit album zijn veilig geback-upt",
+ "@filesBackedUpFromDevice": {
+ "description": "Text to tell user how many files have been backed up from this device",
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ },
+ "formattedNumber": {
+ "content": "{formattedNumber}",
+ "example": "1,000",
+ "type": "String"
+ }
+ }
+ },
+ "@freeUpSpaceSaving": {
+ "description": "Text to tell user how much space they can free up by deleting items from the device"
+ },
+ "freeUpAccessPostDelete": "U heeft nog steeds toegang tot {count, plural, one {het} other {ze}} op ente zolang u een actief abonnement heeft",
+ "@freeUpAccessPostDelete": {
+ "placeholders": {
+ "count": {
+ "example": "1",
+ "type": "int"
+ }
+ }
+ },
+ "freeUpAmount": "Maak {sizeInMBorGB} vrij",
+ "thisEmailIsAlreadyInUse": "Dit e-mailadres is al in gebruik",
+ "incorrectCode": "Onjuiste code",
+ "authenticationFailedPleaseTryAgain": "Verificatie mislukt, probeer het opnieuw",
+ "verificationFailedPleaseTryAgain": "Verificatie mislukt, probeer het opnieuw",
+ "successfullyUnarchived": "Succesvol uit archief gehaald",
+ "renameFile": "Bestandsnaam wijzigen",
+ "enterFileName": "Geef bestandsnaam op",
+ "filesDeleted": "Bestanden verwijderd",
+ "selectedFilesAreNotOnEnte": "Geselecteerde bestanden staan niet op ente",
+ "thisActionCannotBeUndone": "Deze actie kan niet ongedaan gemaakt worden",
+ "emptyTrash": "Prullenbak leegmaken?",
+ "permDeleteWarning": "Alle bestanden in de prullenbak zullen permanent worden verwijderd\n\nDeze actie kan niet ongedaan worden gemaakt",
+ "empty": "Leeg",
+ "couldNotFreeUpSpace": "Kon geen ruimte vrijmaken",
+ "permanentlyDeleteFromDevice": "Permanent verwijderen van apparaat?",
+ "someOfTheFilesYouAreTryingToDeleteAre": "Sommige bestanden die u probeert te verwijderen zijn alleen beschikbaar op uw apparaat en kunnen niet hersteld worden als deze verwijderd worden",
+ "theyWillBeDeletedFromAllAlbums": "Ze zullen uit alle albums worden verwijderd.",
+ "someItemsAreInBothEnteAndYourDevice": "Sommige bestanden bevinden zich in zowel ente als op uw apparaat.",
+ "selectedItemsWillBeDeletedFromAllAlbumsAndMoved": "Geselecteerde bestanden worden verwijderd uit alle albums en verplaatst naar de prullenbak.",
+ "theseItemsWillBeDeletedFromYourDevice": "Deze bestanden zullen worden verwijderd van uw apparaat.",
+ "itLooksLikeSomethingWentWrongPleaseRetryAfterSome": "Het lijkt erop dat er iets fout is gegaan. Probeer het later opnieuw. Als de fout zich blijft voordoen, neem dan contact op met ons supportteam.",
+ "error": "Foutmelding",
+ "tempErrorContactSupportIfPersists": "Het lijkt erop dat er iets fout is gegaan. Probeer het later opnieuw. Als de fout zich blijft voordoen, neem dan contact op met ons supportteam.",
+ "cachedData": "Cachegegevens",
+ "clearCaches": "Cache legen",
+ "remoteImages": "Externe afbeeldingen",
+ "remoteVideos": "Externe video's",
+ "remoteThumbnails": "Externe thumbnails",
+ "pendingSync": "Synchronisatie in behandeling",
+ "localGallery": "Lokale galerij",
+ "todaysLogs": "Logboeken van vandaag",
+ "viewLogs": "Logboeken bekijken",
+ "logsDialogBody": "Dit zal logboeken verzenden om ons te helpen uw probleem op te lossen. Houd er rekening mee dat bestandsnamen zullen worden meegenomen om problemen met specifieke bestanden bij te houden.",
+ "preparingLogs": "Logboeken voorbereiden...",
+ "emailYourLogs": "E-mail uw logboeken",
+ "pleaseSendTheLogsTo": "Verstuur de logboeken alstublieft naar {toEmail}",
+ "copyEmailAddress": "E-mailadres kopiëren",
+ "exportLogs": "Logboek exporteren",
+ "pleaseEmailUsAt": "Stuur ons een e-mail op {toEmail}",
+ "dismiss": "Afwijzen",
+ "didYouKnow": "Wist u dat?",
+ "loadingMessage": "Uw foto's laden...",
+ "loadMessage1": "U kunt uw abonnement met uw familie delen",
+ "loadMessage2": "We hebben tot nu toe meer dan tien miljoen herinneringen bewaard",
+ "loadMessage3": "We bewaren 3 kopieën van uw bestanden, één in een ondergrondse kernbunker",
+ "loadMessage4": "Al onze apps zijn open source",
+ "loadMessage5": "Onze broncode en cryptografie zijn extern gecontroleerd en geverifieerd",
+ "loadMessage6": "Je kunt links naar je albums delen met je dierbaren",
+ "loadMessage7": "Onze mobiele apps draaien op de achtergrond om alle nieuwe foto's die je maakt te versleutelen en te back-uppen",
+ "loadMessage8": "web.ente.io heeft een vlotte uploader",
+ "loadMessage9": "We gebruiken Xchacha20Poly1305 om uw gegevens veilig te versleutelen",
+ "language": "Taal",
+ "selectLanguage": "Taal selecteren",
+ "locationName": "Locatie naam",
+ "addLocation": "Locatie toevoegen",
+ "groupNearbyPhotos": "Groep foto's in de buurt",
+ "location": "Locatie",
+ "kiloMeterUnit": "km",
+ "addLocationButton": "Toevoegen",
+ "radius": "Straal",
+ "locationTagFeatureDescription": "Een locatie tag groept alle foto's die binnen een bepaalde straal van een foto zijn genomen",
+ "galleryMemoryLimitInfo": "Tot 1000 herinneringen getoond in de galerij",
+ "incorrectRecoveryKeyBody": "Kod jest nieprawidłowy",
+ "forgotPassword": "Nie pamiętam hasła",
+ "enterYourRecoveryKey": "Wprowadź swój klucz odzyskiwania",
+ "noRecoveryKey": "Brak klucza odzyskiwania?",
+ "sorry": "Przepraszamy",
+ "noRecoveryKeyNoDecryption": "Ze względu na charakter naszego protokołu szyfrowania end-to-end, dane nie mogą być odszyfrowane bez hasła lub klucza odzyskiwania",
+ "verifyEmail": "Zweryfikuj adres e-mail",
+ "checkInboxAndSpamFolder": "Sprawdź swoją skrzynkę odbiorczą (i spam), aby zakończyć weryfikację",
+ "resendEmail": "Wyślij e-mail ponownie",
+ "setPasswordTitle": "Ustaw hasło",
+ "changePasswordTitle": "Zmień hasło",
+ "resetPasswordTitle": "Zresetuj hasło",
+ "passwordWarning": "Nie przechowujemy tego hasła, więc jeśli go zapomnisz, <underline>nie będziemy w stanie odszyfrować Twoich danych</underline>",
+ "enterPasswordToEncrypt": "Wprowadź hasło, którego możemy użyć do zaszyfrowania Twoich danych",
+ "enterNewPasswordToEncrypt": "Wprowadź nowe hasło, którego możemy użyć do zaszyfrowania Twoich danych",
+ "enterYourEmailAddress": "Insira o seu endereço de e-mail",
+ "accountWelcomeBack": "Bem-vindo de volta!",
+ "email": "E-mail",
+ "cancel": "Cancelar",
+ "verify": "Verificar",
+ "invalidEmailAddress": "Endereço de e-mail invalido",
+ "enterValidEmail": "Por, favor insira um endereço de e-mail válido.",
+ "deleteAccount": "Deletar conta",
+ "askDeleteReason": "Qual é o principal motivo para você excluir sua conta?",
+ "deleteAccountFeedbackPrompt": "Lamentamos ver você partir. Por favor, compartilhe seus comentários para nos ajudar a melhorar.",
+ "feedback": "Opinião",
+ "kindlyHelpUsWithThisInformation": "Ajude-nos com esta informação",
+ "confirmDeletePrompt": "Sim, desejo excluir permanentemente esta conta e todos os seus dados.",
+ "confirmAccountDeletion": "Confirmar exclusão da conta",
+ "deleteConfirmDialogBody": "Você está prestes a excluir permanentemente sua conta e todos os seus dados.\nEsta ação é irreversível.",
+ "deleteAccountPermanentlyButton": "Excluir conta permanentemente",
+ "yourAccountHasBeenDeleted": "Sua conta foi deletada",
+ "selectReason": "Selecione o motivo",
+ "deleteReason1": "Está faltando um recurso-chave que eu preciso",
+ "deleteReason2": "O aplicativo ou um determinado recurso não\nestá funcionando como eu acredito que deveria",
+ "deleteReason3": "Encontrei outro serviço que gosto mais",
+ "deleteReason4": "Meu motivo não está listado",
+ "sendEmail": "Enviar e-mail",
+ "deleteRequestSLAText": "Sua solicitação será processada em até 72 horas.",
+ "deleteEmailRequest": "Por favor, envie um e-mail para <warning>account-deletion@ente.io</warning> a partir do seu endereço de e-mail registrado.",
+ "ok": "Ok",
+ "createAccount": "Criar uma conta",
+ "createNewAccount": "Criar nova conta",
+ "password": "Senha",
+ "confirmPassword": "Confirme sua senha",
+ "activeSessions": "Sessões ativas",
+ "oops": "Ops",
+ "somethingWentWrongPleaseTryAgain": "Algo deu errado. Por favor, tente outra vez",
+ "thisWillLogYouOutOfThisDevice": "Isso fará com que você saia deste dispositivo!",
+ "thisWillLogYouOutOfTheFollowingDevice": "Isso fará com que você saia do seguinte dispositivo:",
+ "terminateSession": "Encerrar sessão?",
+ "terminate": "Terminar",
+ "thisDevice": "Este aparelho",
+ "recoverButton": "Recuperar",
+ "recoverySuccessful": "Recuperação bem sucedida!",
+ "decrypting": "Descriptografando...",
+ "incorrectRecoveryKeyTitle": "Chave de recuperação incorreta",
+ "incorrectRecoveryKeyBody": "A chave de recuperação que você digitou está incorreta",
+ "forgotPassword": "Esqueceu sua senha",
+ "enterYourRecoveryKey": "Digite sua chave de recuperação",
+ "noRecoveryKey": "Nenhuma chave de recuperação?",
+ "sorry": "Desculpe",
+ "noRecoveryKeyNoDecryption": "Devido à natureza do nosso protocolo de criptografia de ponta a ponta, seus dados não podem ser descriptografados sem sua senha ou chave de recuperação",
+ "verifyEmail": "Verificar email",
+ "checkInboxAndSpamFolder": "Verifique sua caixa de entrada (e ‘spam’) para concluir a verificação",
+ "tapToEnterCode": "Clica para inserir código",
+ "resendEmail": "Reenviar e-mail",
+ "weHaveSendEmailTo": "Enviamos um e-mail à <green>{email}</green>",
+ "@weHaveSendEmailTo": {
+ "description": "Text to indicate that we have sent a mail to the user",
+ "passwordChangedSuccessfully": "Senha alterada com sucesso",
+ "generatingEncryptionKeys": "Gerando chaves de criptografia...",
+ "pleaseWait": "Por favor, aguarde...",
+ "continueLabel": "Continuar",
+ "insecureDevice": "Dispositivo não seguro",
+ "sorryWeCouldNotGenerateSecureKeysOnThisDevicennplease": "Desculpe, não foi possível gerar chaves seguras neste dispositivo.\n\npor favor, faça o login com um dispositivo diferente.",
+ "howItWorks": "Como funciona",
+ "encryption": "Criptografia",
+ "ackPasswordLostWarning": "Eu entendo que se eu perder minha senha, posso perder meus dados, já que meus dados são <underline>criptografados de ponta a ponta</underline>.",
+ "privacyPolicyTitle": "Política de Privacidade",
+ "termsOfServicesTitle": "Termos",
+ "signUpTerms": "Eu concordo com os <u-terms>termos de serviço</u-terms> e a <u-policy>política de privacidade</u-policy>",
+ "logInLabel": "Login",
+ "loginTerms": "Ao clicar em login, eu concordo com os <u-terms>termos de serviço</u-terms> e a <u-policy>política de privacidade</u-policy>",
+ "changeEmail": "Mudar e-mail",
+ "enterYourPassword": "Insira sua senha",
+ "welcomeBack": "Bem-vindo de volta!",
+ "contactSupport": "Falar com o suporte",
+ "incorrectPasswordTitle": "Senha incorreta",
+ "pleaseTryAgain": "Por favor, tente novamente",
+ "recreatePasswordTitle": "Restabeleça sua senha",
+ "useRecoveryKey": "Usar chave de recuperação",
+ "recreatePasswordBody": "O dispositivo atual não é poderoso o suficiente para verificar sua senha, mas podemos regenerar de uma forma que funcione com todos os dispositivos.\n\nPor favor, faça o login usando sua chave de recuperação e recrie sua senha (você pode usar o mesmo novamente se desejar).",
+ "verifyPassword": "Verificar senha",
+ "recoveryKey": "Chave de recuperação",
+ "recoveryKeyOnForgotPassword": "Caso você esqueça sua senha, a única maneira de recuperar seus dados é com essa chave.",
+ "recoveryKeySaveDescription": "Não armazenamos essa chave, por favor, salve essa chave de 24 palavras em um lugar seguro.",
+ "doThisLater": "Fazer isso mais tarde",
+ "saveKey": "Salvar chave",
+ "recoveryKeyCopiedToClipboard": "Chaves de recuperação foram copiadas para a área de transferência",
+ "recoverAccount": "Recuperar conta",
+ "recover": "Recuperar",
+ "dropSupportEmail": "Por favor, envie um e-mail para {supportEmail} a partir do seu endereço de e-mail registrado",
+ "@dropSupportEmail": {
+ "placeholders": {
+ "supportEmail": {
+ "description": "The support email address",
+ "type": "String",
+ "example": "support@ente.io"
+ }
+ }
+ },
+ "twofactorSetup": "Autenticação de dois fatores",
+ "enterCode": "Coloque o código",
+ "scanCode": "Escanear código",
+ "codeCopiedToClipboard": "Código copiado para a área de transferência",
+ "copypasteThisCodentoYourAuthenticatorApp": "Copie e cole este código\npara seu aplicativo autenticador",
+ "tapToCopy": "toque para copiar",
+ "scanThisBarcodeWithnyourAuthenticatorApp": "Escaneie este código de barras com\nseu aplicativo autenticador",
+ "enterThe6digitCodeFromnyourAuthenticatorApp": "Digite o código de 6 dígitos de\nseu aplicativo autenticador",
+ "confirm": "Confirme",
+ "setupComplete": "Configuração concluída",
+ "saveYourRecoveryKeyIfYouHaventAlready": "Salve sua chave de recuperação, caso ainda não o tenha feito",
+ "thisCanBeUsedToRecoverYourAccountIfYou": "Isso pode ser usado para recuperar sua conta se você perder seu segundo fator",
+ "twofactorAuthenticationPageTitle": "Autenticação de dois fatores",
+ "lostDevice": "Dispositivo perdido?",
+ "verifyingRecoveryKey": "Verificando chave de recuperação...",
+ "recoveryKeyVerified": "Chave de recuperação verificada",
+ "recoveryKeySuccessBody": "Ótimo! Sua chave de recuperação é válida. Obrigado por verificar.\n\nLembre-se de manter o backup seguro de sua chave de recuperação.",
+ "invalidRecoveryKey": "A chave de recuperação que você digitou não é válida. Certifique-se de que contém 24 palavras e verifique a ortografia de cada uma.\n\nSe você inseriu um código de recuperação mais antigo, verifique se ele tem 64 caracteres e verifique cada um deles.",
+ "invalidKey": "Chave inválida",
+ "tryAgain": "Tente novamente",
+ "viewRecoveryKey": "Ver chave de recuperação",
+ "confirmRecoveryKey": "Confirme a chave de recuperação",
+ "recoveryKeyVerifyReason": "Sua chave de recuperação é a única maneira de recuperar suas fotos se você esquecer sua senha. Você pode encontrar sua chave de recuperação em Configurações > Conta.\n\nDigite sua chave de recuperação aqui para verificar se você a salvou corretamente.",
+ "confirmYourRecoveryKey": "Confirme sua chave de recuperação",
+ "addViewer": "Adicionar visualizador",
+ "addCollaborator": "Adicionar colaborador",
+ "addANewEmail": "Adicionar um novo email",
+ "orPickAnExistingOne": "Ou escolha um existente",
+ "collaboratorsCanAddPhotosAndVideosToTheSharedAlbum": "Os colaboradores podem adicionar fotos e vídeos ao álbum compartilhado.",
+ "enterEmail": "Digite o email",
+ "albumOwner": "Proprietário",
+ "@albumOwner": {
+ "description": "Role of the album owner"
+ },
+ "you": "Você",
+ "collaborator": "Colaborador",
+ "addMore": "Adicione mais",
+ "@addMore": {
+ "description": "Button text to add more collaborators/viewers"
+ },
+ "viewer": "Visualizador",
+ "remove": "Remover",
+ "removeParticipant": "Remover participante",
+ "@removeParticipant": {
+ "description": "menuSectionTitle for removing a participant"
+ },
+ "manage": "Gerenciar",
+ "addedAs": "Adicionado como",
+ "changePermissions": "Alterar permissões?",
+ "yesConvertToViewer": "Sim, converter para visualizador",
+ "cannotAddMorePhotosAfterBecomingViewer": "{user} Não poderá adicionar mais fotos a este álbum\n\nEles ainda poderão remover as fotos existentes adicionadas por eles",
+ "description": "Switch button to enable uploading photos to a public link"
+ },
+ "allowAddPhotosDescription": "Permita que as pessoas com o link também adicionem fotos ao álbum compartilhado.",
+ "passwordLock": "Bloqueio de senha",
+ "disableDownloadWarningTitle": "Observe",
+ "disableDownloadWarningBody": "Os espectadores ainda podem tirar screenshots ou salvar uma cópia de suas fotos usando ferramentas externas",
+ "allowDownloads": "Permitir transferências",
+ "linkDeviceLimit": "Limite do dispositivo",
+ "linkExpiry": "Expiração do link",
+ "linkExpired": "Expirado",
+ "storageInGB": "{storageAmountInGB} GB",
+ "claimed": "Reivindicado",
+ "@claimed": {
+ "description": "Used to indicate storage claimed, like 10GB Claimed"
+ },
+ "details": "Detalhes",
+ "claimMore": "Reivindique mais!",
+ "theyAlsoGetXGb": "Eles também recebem {storageAmountInGB} GB",
+ "freeStorageOnReferralSuccess": "{storageAmountInGB} GB cada vez que alguém se inscrever para um plano pago e aplica o seu código",
+ "shareTextReferralCode": "Código de referência do ente: {referralCode} \n\nAplique em Configurações → Geral → Indicações para obter {referralStorageInGB} GB gratuitamente após a sua inscrição em um plano pago\n\nhttps://ente.io",
+ "usableReferralStorageInfo": "Armazenamento utilizável é limitado pelo seu plano atual. O armazenamento reivindicado em excesso se tornará utilizável automaticamente quando você fizer a melhoria do seu plano.",
+ "removeFromAlbumTitle": "Remover do álbum?",
+ "removeFromAlbum": "Remover do álbum",
+ "itemsWillBeRemovedFromAlbum": "Os itens selecionados serão removidos deste álbum",
+ "removeShareItemsWarning": "Alguns dos itens que você está removendo foram adicionados por outras pessoas, e você perderá o acesso a eles",
+ "addingToFavorites": "Adicionando aos favoritos...",
+ "removingFromFavorites": "Removendo dos favoritos...",
+ "sorryCouldNotAddToFavorites": "Desculpe, não foi possível adicionar aos favoritos!",
+ "sorryCouldNotRemoveFromFavorites": "Desculpe, não foi possível remover dos favoritos!",
+ "subscribeToEnableSharing": "Parece que sua assinatura expirou. Por favor inscreva-se para ativar o compartilhamento.",
+ "subscribe": "Inscrever-se",
+ "canOnlyRemoveFilesOwnedByYou": "Só é possível remover arquivos de sua propriedade",
+ "deleteSharedAlbum": "Excluir álbum compartilhado?",
+ "deleteAlbum": "Excluir álbum",
+ "deleteAlbumDialog": "Também excluir as fotos (e vídeos) presentes neste álbum de <bold>todos os</bold> outros álbuns dos quais eles fazem parte?",
+ "deleteSharedAlbumDialogBody": "O álbum será apagado para todos\n\nVocê perderá o acesso a fotos compartilhadas neste álbum que pertencem aos outros",
+ "yesRemove": "Sim, excluir",
+ "creatingLink": "Criando link...",
+ "removeWithQuestionMark": "Excluir?",
+ "removeParticipantBody": "{userEmail} será removido deste álbum compartilhado\n\nQuaisquer fotos adicionadas por eles também serão removidas do álbum",
+ "keepPhotos": "Manter fotos",
+ "deletePhotos": "Excluir fotos",
+ "inviteToEnte": "Convidar para o ente",
+ "removePublicLink": "Remover link público",
+ "disableLinkMessage": "Isso removerá o link público para acessar \"{albumName}\".",
+ "sharing": "Compartilhando...",
+ "authToChangeYourEmail": "Por favor, autentique-se para alterar seu e-mail",
+ "changePassword": "Mude sua senha",
+ "authToChangeYourPassword": "Por favor, autentique-se para alterar sua senha",
+ "exportYourData": "Exportar seus dados",
+ "logout": "Encerrar sessão",
+ "authToInitiateAccountDeletion": "Por favor, autentique-se para iniciar a exclusão de conta",
+ "areYouSureYouWantToLogout": "Você tem certeza que deseja encerrar a sessão?",
+ "yesLogout": "Sim, terminar sessão",
+ "aNewVersionOfEnteIsAvailable": "Uma nova versão do ente está disponível.",