mirror of
https://github.com/xpipe-io/xpipe.git
synced 2026-10-25 08:10:15 +00:00
2373 lines
165 KiB
Properties
Generated
2373 lines
165 KiB
Properties
Generated
delete=Supprimer
|
||
usedDate=Utilisé $DATE$
|
||
sortLastUsed=Trier par date de dernière utilisation
|
||
sortAlphabetical=Trier par ordre alphabétique selon le nom
|
||
sortManually=Trier manuellement
|
||
restartDescription=Un redémarrage peut souvent être une solution rapide
|
||
reportIssue=Signaler un problème
|
||
reportIssueDescription=Ouvre l'outil de signalement de problèmes intégré
|
||
troubleshootingOptions=Outils de dépannage
|
||
troubleshoot=Dépannage
|
||
save=Enregistrer
|
||
clean=Nettoyer
|
||
#custom
|
||
moveTo=Déplacer vers ...
|
||
browseInternalStorage=Parcourir le stockage interne
|
||
addTunnel=Tunnel...
|
||
addService=Service...
|
||
addScript=Script...
|
||
addHost=Hôte distant...
|
||
addShell=Environnement Shell...
|
||
addCommand=Commande...
|
||
addAutomatically=Recherche automatique...
|
||
addOther=Autres...
|
||
connectionAdd=Ajouter une connexion
|
||
connectionEdit=Modifier la connexion
|
||
scriptAdd=Ajouter un script
|
||
scriptEdit=Modifier le script
|
||
identityAdd=Ajouter une identité
|
||
identityEdit=Modifier l'identité
|
||
new=Nouveau
|
||
name=Nom
|
||
storeIntroHeader=Connection Hub
|
||
storeIntroContent=Ici, tu peux gérer toutes tes connexions locales et distantes depuis un seul et même endroit. Pour commencer, tu peux détecter rapidement et automatiquement les connexions disponibles sur ton système et choisir celles que tu souhaites ajouter.
|
||
storeIntroButton=Importer les connexions locales...
|
||
expand=Développer
|
||
accessSubConnections=Accéder aux sous-connexions
|
||
common=Courant
|
||
color=Couleur
|
||
alwaysConfirmElevation=Confirme toujours l'élévation des droits
|
||
alwaysConfirmElevationDescription=Détermine comment gérer les cas où des droits élevés sont nécessaires pour exécuter une commande sur un système, par exemple avec sudo.\n\nPar défaut, les identifiants sudo sont mis en cache pendant une session et fournis automatiquement quand c'est nécessaire. Si cette option est activée, on te demandera de confirmer l'élévation des droits à chaque fois.
|
||
allow=Autoriser
|
||
ask=Demander
|
||
deny=Refuser
|
||
share=Ajouter au dépôt Git
|
||
unshare=Supprimer du dépôt Git
|
||
remove=Supprimer
|
||
createNewCategory=Nouvelle sous-catégorie
|
||
prompt=Invite
|
||
customCommand=Commande personnalisée
|
||
customCommandValue=Commandes
|
||
customCommandValueDescription=La commande ou le script à exécuter dans le shell local
|
||
other=Autre
|
||
selectConnection=Choisis une connexion
|
||
selectEntry=Sélectionner une entrée
|
||
createLock=Créer une phrase de passe
|
||
changeLock=Modifier la phrase de passe
|
||
test=Test
|
||
finish=Terminer
|
||
error=Une erreur s'est produite
|
||
downloadStageDescription=Déplace les fichiers téléchargés dans le répertoire « Téléchargements » de ton système et l'ouvre.
|
||
ok=Ok
|
||
search=Recherche
|
||
repeatPassword=Confirme ton mot de passe
|
||
#custom
|
||
askpassAlertTitle=Demande de mot de passe
|
||
unsupportedOperation=Opération non prise en charge : $MSG$
|
||
fileConflictAlertTitle=Résoudre un conflit
|
||
fileConflictAlertContent=Un conflit s'est produit. Le fichier $FILE$ existe déjà sur le système cible.\n\nComment veux-tu procéder ?
|
||
fileConflictAlertContentMultiple=Un conflit s'est produit. Le fichier $FILE$ existe déjà.\n\nComment veux-tu procéder ? Il se peut qu'il y ait d'autres conflits que tu peux résoudre automatiquement en choisissant une option qui s'applique à tous.
|
||
moveAlertTitle=Confirmer le déplacement
|
||
moveAlertHeader=Tu veux déplacer les éléments sélectionnés ($COUNT$) vers $TARGET$?
|
||
deleteAlertTitle=Confirmer la suppression
|
||
deleteAlertHeader=Tu veux supprimer les éléments sélectionnés ($COUNT$) ?
|
||
selectedElements=Éléments sélectionnés :
|
||
mustNotBeEmpty=$VALUE$ ne doit pas être vide
|
||
valueMustNotBeEmpty=La valeur ne doit pas être vide
|
||
scopeMustBeAccessible=La portée d'accès doit être accessible à l'utilisateur actuel
|
||
transferDescription=Glisse tes fichiers ici pour les télécharger
|
||
dragLocalFiles=Fais glisser les fichiers depuis ici
|
||
null=$VALUE$ ne doit pas être nul
|
||
roots=Racines
|
||
scripts=Scripts
|
||
searchFilter=Rechercher...
|
||
storeFilterPrompt=Rechercher ou lancer...
|
||
recent=Récents
|
||
shortcut=Raccourci
|
||
browserWelcomeEmptyHeader=Explorateur de fichiers
|
||
browserWelcomeEmptyContent=Tu peux choisir à gauche les systèmes que tu veux ouvrir dans l'explorateur de fichiers. XPipe se souviendra des systèmes et des répertoires auxquels tu as déjà accédé et les affichera à l'avenir dans un menu d'accès rapide ici.
|
||
browserWelcomeEmptyButton=Ouvrir l'explorateur de fichiers local
|
||
browserWelcomeSystems=Tu t'es récemment connecté aux systèmes suivants :
|
||
storeIntroDocsHeader=Documentation
|
||
storeIntroDocsContent=Si tu préfères une approche plus guidée pour te familiariser avec XPipe, jette un œil au site web de la documentation.
|
||
storeIntroDocsButton=Ouvrir la documentation
|
||
hostFeatureUnsupported=$FEATURE$ n'est pas installé sur l'hôte
|
||
missingStore=$NAME$ n'existe pas
|
||
connectionName=Nom de la connexion
|
||
connectionNameDescription=Donne un nom personnalisé à cette connexion
|
||
connectionTemplateNameDescription=Enregistre une copie de ce modèle de connexion sous un nom de ton choix
|
||
openFileTitle=Ouvrir un fichier
|
||
openDirectoryTitle=Ouvrir un répertoire
|
||
saveFileTitle=Enregistrer le fichier
|
||
saveDirectoryTitle=Répertoire d'enregistrement
|
||
unknown=Inconnu
|
||
scanAlertTitle=Ajouter des connexions
|
||
scanAlertChoiceHeader=Cible
|
||
scanAlertChoiceHeaderDescription=Le système permettant de rechercher des sous-connexions disponibles
|
||
scanAlertHeader=Types de connexion
|
||
scanAlertHeaderDescription=Sélectionne les types de connexion que tu veux ajouter au système
|
||
noInformationAvailable=Aucune information disponible
|
||
yes=Oui
|
||
no=Non
|
||
errorOccurred=Une erreur s'est produite
|
||
terminalErrorOccurred=Une erreur fatale s'est produite
|
||
errorTypeOccurred=Une exception de type « $TYPE$ » a été levée
|
||
permissionsAlertTitle=Autorisations requises
|
||
permissionsAlertHeader=Des autorisations supplémentaires sont nécessaires pour effectuer cette opération.
|
||
permissionsAlertContent=Suis les instructions de la fenêtre contextuelle pour accorder à XPipe les autorisations nécessaires dans le menu des paramètres.
|
||
errorDetails=Détails de l'erreur
|
||
updateReadyAlertTitle=Prêt pour la mise à jour
|
||
updateReadyAlertHeader=Une mise à jour vers la version $VERSION$ est prête à être installée
|
||
updateReadyAlertContent=Ça va installer la nouvelle version et redémarrer XPipe une fois l'installation terminée.
|
||
errorNoDetail=Aucun détail sur l'erreur n'est disponible
|
||
errorNoExceptionMessage=Une erreur de type « $TYPE$ » a été générée
|
||
updateAvailableTitle=Mise à jour disponible
|
||
updateAvailableContent=Une mise à jour d'XPipe vers la version $VERSION$ est disponible. Même si XPipe n'a pas pu démarrer, tu peux essayer d'installer la mise à jour pour voir si ça résout le problème.
|
||
clipboardActionDetectedTitle=Action du presse-papiers détectée
|
||
clipboardActionDetectedContent=XPipe a détecté dans ton presse-papiers un contenu qui peut être ouvert. Tu veux l'ouvrir maintenant ? Tu veux importer le contenu de ton presse-papiers ?
|
||
install=Installe...
|
||
ignore=Ignorer
|
||
possibleActions=Actions disponibles
|
||
ignoreError=Ignorer l'erreur
|
||
ignoreErrorDescription=Ignore cette erreur et continue comme si de rien n'était
|
||
provideEmail=Comment on peut te contacter (facultatif, uniquement si tu souhaites recevoir une réponse)
|
||
provideEmailPrompt=Par exemple : adresse e-mail, pseudo Discord, etc.
|
||
emailAnonymous=Ton rapport est anonyme par défaut, même si tu as activé une licence ; tu peux donc indiquer tes coordonnées ici
|
||
additionalErrorInfo=Donne des infos supplémentaires (facultatif)
|
||
describeYourIssue=Décris ton problème (facultatif)
|
||
additionalErrorAttachments=Sélectionne les pièces jointes (facultatif)
|
||
dataHandlingPolicies=Politique de confidentialité
|
||
sendReport=Envoyer un rapport
|
||
errorHandler=Gestionnaire d'erreurs
|
||
reportError=Signaler un problème
|
||
events=Événements
|
||
validate=Valider
|
||
stackTrace=Trace de pile
|
||
select=Sélectionner
|
||
checkOutUpdate=Jette un œil à la mise à jour
|
||
quit=Quitter
|
||
noTerminalSet=Aucune application de terminal n'a été configurée automatiquement. Tu peux le faire manuellement dans le menu des paramètres.
|
||
#custom
|
||
connections=Connexions
|
||
connectionHub=Hub de connexion
|
||
settings=Paramètres
|
||
explorePlans=Licence
|
||
help=Aide
|
||
about=À propos
|
||
developer=Développeur
|
||
browser=Explorateur de fichiers
|
||
links=Liens
|
||
website=Site web
|
||
discordDescription=Rejoins le serveur Discord
|
||
redditDescription=Rejoins le subreddit XPipe
|
||
security=Sécurité
|
||
securityPolicy=Infos sur la sécurité
|
||
securityPolicyDescription=Lis la politique de sécurité détaillée
|
||
privacy=Politique de confidentialité
|
||
privacyDescription=Lis la politique de confidentialité de l'application XPipe
|
||
slackDescription=Rejoins l'espace de travail Slack
|
||
support=Assistance
|
||
#custom
|
||
githubDescription=Va voir le dépôt GitHub
|
||
openSourceNotices=Mentions relatives à l'open source
|
||
checkForUpdates=Vérifier les mises à jour
|
||
checkForUpdatesDescription=Télécharge une mise à jour s'il y en a une
|
||
lastChecked=Dernière vérification
|
||
version=Version
|
||
build=Version de compilation
|
||
runtimeVersion=Version du runtime
|
||
virtualMachine=Machine virtuelle
|
||
updateReady=Installer la mise à jour
|
||
updateReadyPortable=Jette un œil à la mise à jour
|
||
updateReadyDescription=Une mise à jour a été téléchargée et est prête à être installée
|
||
updateReadyDescriptionPortable=Une mise à jour est disponible au téléchargement
|
||
updateRestart=Redémarre pour mettre à jour
|
||
never=Jamais
|
||
updateAvailableTooltip=Mise à jour disponible
|
||
ptbAvailableTooltip=Version de test publique disponible
|
||
visitGithubRepository=Consultez le dépôt GitHub
|
||
updateAvailable=Mise à jour disponible : $VERSION$
|
||
downloadUpdate=Télécharger la mise à jour
|
||
legalAccept=J'accepte le contrat de licence utilisateur final
|
||
confirm=Confirmer
|
||
print=Imprimer
|
||
whatsNew=Nouveautés de la version $VERSION$ ($DATE$)
|
||
antivirusNoticeTitle=Une note sur les programmes antivirus
|
||
updateChangelogAlertTitle=Historique des modifications
|
||
#custom
|
||
greetingsAlertTitle=Bienvenue sur XPipe
|
||
eula=Contrat de licence d'utilisateur final
|
||
introduction=Introduction
|
||
privacyPolicy=Politique de confidentialité
|
||
agree=D'accord
|
||
disagree=Je n'accepte pas
|
||
logFile=Fichier journal
|
||
logFiles=Fichiers journaux
|
||
logFilesAttachment=Fichiers journaux
|
||
#custom
|
||
issueReporter=Outil de signalement de problèmes
|
||
openCurrentLogFile=Fichiers journaux
|
||
openCurrentLogFileDescription=Ouvre le fichier journal de la session en cours
|
||
openLogsDirectory=Ouvrir le répertoire des journaux
|
||
installationFiles=Fichiers d'installation
|
||
openInstallationDirectory=Fichiers d'installation
|
||
openInstallationDirectoryDescription=Ouvre le répertoire d'installation de XPipe
|
||
launchDebugMode=Mode débogage
|
||
launchDebugModeDescription=Redémarre XPipe en mode débogage
|
||
license=Licence
|
||
installRequired=Installation requise
|
||
restore=Restaurer
|
||
restoreAllSessions=Restaurer toutes les sessions
|
||
limitedTouchscreenMode=Mode écran tactile limité
|
||
limitedTouchscreenModeDescription=Si tu utilises cette appli sur une interface tactile un peu particulière, comme l'écran d'un téléphone, certains menus risquent de ne pas fonctionner correctement. Quand cette option est activée, le menu utilise des fonctionnalités plus limitées pour s'adapter aux événements souris/tactiles peu fréquents.
|
||
appearance=Apparence
|
||
display=Affichage
|
||
personalization=Personnalisation
|
||
displayOptions=Options d'affichage
|
||
theme=Thème
|
||
rdpConfiguration=Configuration du bureau à distance
|
||
rdpClient=Client RDP
|
||
rdpClientDescription=Le programme client RDP à appeler lors de l'établissement de connexions RDP.\n\nNote que les différents clients ont des capacités et des niveaux d'intégration variables. Certains clients ne prennent pas en charge la transmission automatique des mots de passe ; tu devras donc les saisir manuellement au moment du lancement.
|
||
localShell=Shell local
|
||
themeDescription=Ton thème d'affichage préféré.
|
||
dontAutomaticallyStartVmSshServer=Ne pas démarrer automatiquement le serveur SSH pour les machines virtuelles quand c'est nécessaire
|
||
dontAutomaticallyStartVmSshServerDescription=Toute connexion shell à une machine virtuelle fonctionnant dans un hyperviseur s'effectue via SSH. XPipe peut démarrer automatiquement le serveur SSH installé quand c'est nécessaire. Si tu ne veux pas ça pour des raisons de sécurité, tu peux simplement désactiver cette fonctionnalité avec cette option.
|
||
confirmGitShareTitle=Synchronisation Git
|
||
confirmGitShareContent=Tu veux ajouter le fichier sélectionné à ton dépôt Git « vault » ? Ça va copier une version chiffrée du fichier dans ton dépôt Git « vault » et valider tes modifications. Tu auras ensuite accès au fichier sur tous les ordinateurs de bureau synchronisés.
|
||
gitShareFileTooltip=Ajoute le fichier au répertoire de données du « git vault » pour qu’il soit automatiquement synchronisé.\n\nCette action ne peut être utilisée que si le « git vault » est activé dans les paramètres.
|
||
performanceMode=Mode Performance
|
||
performanceModeDescription=Désactive tous les effets visuels qui ne sont pas indispensables pour améliorer les performances de l'application.
|
||
dontAcceptNewHostKeys=N'accepte pas automatiquement les nouvelles clés d'hôte SSH
|
||
dontAcceptNewHostKeysDescription=Par défaut, XPipe accepte automatiquement les clés hôtes provenant de systèmes pour lesquels ton client SSH n'a pas encore enregistré de clé hôte connue. Cependant, si une clé hôte connue a changé, il refusera de se connecter tant que tu n'auras pas accepté la nouvelle.\n\nDésactiver ce comportement te permet de vérifier toutes les clés hôtes, même s'il n'y a pas de conflit au départ.
|
||
uiScale=Échelle de l'interface utilisateur
|
||
uiScaleDescription=Une valeur de mise à l'échelle personnalisée que tu peux définir indépendamment de l'échelle d'affichage de ton système. Les valeurs sont exprimées en pourcentage ; par exemple, une valeur de 150 donnera une échelle d'interface utilisateur de 150 %.
|
||
editorProgram=Programme d'édition
|
||
editorProgramDescription=L'éditeur de texte par défaut à utiliser pour modifier n'importe quel type de données textuelles.
|
||
windowOpacity=Opacité de la fenêtre
|
||
windowOpacityDescription=Modifie l'opacité de la fenêtre pour te permettre de suivre ce qui se passe en arrière-plan.
|
||
useSystemFont=Utiliser la police système
|
||
#custom
|
||
openDataDir=Répertoire de données du coffre-fort
|
||
openDataDirButton=Ouvrir le répertoire de données
|
||
openDataDirDescription=Si tu veux synchroniser des fichiers supplémentaires, comme des clés SSH, entre tes différents systèmes via ton dépôt Git, tu peux les placer dans le répertoire de stockage des données. Les chemins d'accès de tous les fichiers qui s'y trouvent seront automatiquement adaptés sur chaque système synchronisé.
|
||
updates=Mises à jour
|
||
selectAll=Tout sélectionner
|
||
advanced=Avancé
|
||
thirdParty=Mentions relatives à l'open source
|
||
eulaDescription=Lis le contrat de licence utilisateur final de l'application XPipe
|
||
thirdPartyDescription=Consulter les licences open source des bibliothèques tierces
|
||
enableGitStorage=Activer la synchronisation
|
||
gitSync=Synchronisation Git
|
||
enableGitStorageDescription=Lorsqu’elle est activée, XPipe initialise un dépôt Git pour le coffre-fort local et y enregistre toutes les modifications. Note que ça nécessite l’installation de Git et que ça peut ralentir les opérations de chargement et d’enregistrement.\n\nToutes les catégories qui doivent être synchronisées doivent être explicitement marquées comme synchronisées.
|
||
storageGitRemote=URL de synchronisation à distance
|
||
storageGitRemoteDescription=Une fois cette option activée, XPipe récupérera automatiquement les modifications lors du chargement et les enverra vers le dépôt distant lors de l'enregistrement.\n\nÇa te permet de partager ton « vault » entre plusieurs installations d'XPipe. Il prend en charge les URL HTTP et SSH, ainsi que les répertoires locaux.
|
||
#custom
|
||
vault=Coffre-fort
|
||
vaultAccess=Accès au coffre-fort
|
||
workspaceLockDescription=Permet de définir un mot de passe personnalisé pour crypter toutes les informations sensibles stockées dans XPipe.\n\nÇa renforce la sécurité, car ça ajoute une couche de cryptage supplémentaire pour tes informations sensibles stockées. On te demandera alors de saisir ce mot de passe au démarrage de XPipe.
|
||
useSystemFontDescription=Permet de choisir entre la police par défaut de ton système et la police « Inter », fournie avec XPipe.
|
||
windowOptions=Options de la fenêtre
|
||
saveWindowLocation=Enregistrer l'emplacement de la fenêtre
|
||
saveWindowLocationDescription=Permet de choisir si les coordonnées de la fenêtre doivent être enregistrées et restaurées au redémarrage.
|
||
startupShutdown=Démarrage / Arrêt
|
||
showChildrenConnectionsInParentCategory=Afficher les sous-catégories dans la catégorie parente
|
||
showChildrenConnectionsInParentCategoryDescription=Permet de choisir s'il faut inclure ou non toutes les connexions situées dans les sous-catégories lorsqu'une catégorie parente donnée est sélectionnée.\n\nSi cette option est désactivée, les catégories se comportent davantage comme des dossiers classiques qui n'affichent que leur contenu direct, sans inclure les sous-dossiers.
|
||
condenseConnectionDisplay=Affichage condensé des connexions
|
||
condenseConnectionDisplayDescription=Fais en sorte que chaque connexion de niveau supérieur prenne moins d'espace vertical pour que la liste des connexions soit plus compacte.
|
||
openConnectionSearchWindowOnConnectionCreation=Ouvrir la fenêtre de recherche de connexion lors de la création d'une connexion
|
||
openConnectionSearchWindowOnConnectionCreationDescription=Définit s'il faut ou non ouvrir automatiquement la fenêtre de recherche des sous-connexions disponibles lors de l'ajout d'une nouvelle connexion shell.
|
||
system=Système
|
||
application=Application
|
||
storage=Stockage
|
||
runOnStartup=Lancer au démarrage
|
||
closeBehaviour=Comportement à la fermeture
|
||
closeBehaviourDescription=Détermine comment XPipe doit se comporter à la fermeture de sa fenêtre principale.
|
||
language=Langue
|
||
languageDescription=La langue d'affichage à utiliser. Les traductions sont améliorées grâce aux contributions de la communauté. Tu peux participer à l'effort de traduction en soumettant des corrections de traduction sur GitHub.
|
||
#custom
|
||
lightTheme=Thème clair
|
||
darkTheme=Thème sombre
|
||
exit=Quitter XPipe
|
||
continueInBackground=Continuer en arrière-plan
|
||
#custom
|
||
minimizeToTray=Réduire dans la zone de notification
|
||
closeBehaviourAlertTitle=Définir le comportement de fermeture
|
||
closeBehaviourAlertTitleHeader=Choisis ce qui doit se passer quand tu fermes la fenêtre. Toutes les connexions actives seront fermées à la fermeture de l'application.
|
||
startupBehaviour=Comportement au démarrage
|
||
startupBehaviourDescription=Définit le comportement par défaut de l'application de bureau au lancement de XPipe.
|
||
clearCachesAlertTitle=Vider le cache
|
||
clearCachesAlertContent=Tu veux vider tous les caches XPipe ? Ça va supprimer toutes les données de cache qui sont stockées pour améliorer l'expérience utilisateur.
|
||
startGui=Lancer l'interface graphique
|
||
startInTray=Démarrer dans la barre d'état
|
||
startInBackground=Démarrer en arrière-plan
|
||
clearCaches=Vider les caches...
|
||
clearCachesDescription=Supprimer toutes les données du cache
|
||
cancel=Annuler
|
||
notAnAbsolutePath=Ce n'est pas un chemin absolu
|
||
notADirectory=Ce n'est pas un répertoire
|
||
notAnEmptyDirectory=Ce n'est pas un répertoire vide
|
||
automaticallyCheckForUpdates=Vérifier les mises à jour
|
||
automaticallyCheckForUpdatesDescription=Quand cette option est activée, les infos sur les nouvelles versions sont automatiquement récupérées au bout d'un certain temps pendant que XPipe est en cours d'exécution. Tu dois quand même valider explicitement l'installation de chaque mise à jour.
|
||
developerMode=Mode développeur
|
||
developerModeDescription=Une fois cette option activée, tu auras accès à toute une série d'options supplémentaires utiles pour le développement.
|
||
editor=Éditeur
|
||
custom=Personnalisé
|
||
passwordManager=Gestionnaire de mots de passe
|
||
externalPasswordManager=Gestionnaire de mots de passe externe
|
||
passwordManagerDescription=Le gestionnaire de mots de passe installé localement avec lequel t'as besoin de t'intégrer.\n\nSi t'as un gestionnaire de mots de passe installé, tu peux configurer XPipe pour qu'il récupère les identifiants depuis celui-ci, comme ça XPipe n'aura pas à les gérer lui-même.
|
||
passwordManagerTest=Tester le gestionnaire de mots de passe
|
||
passwordManagerTestDescription=Vérifie si l'intégration du gestionnaire de mots de passe fonctionne correctement. Assure-toi d'utiliser le bon format d'identifiant pour référencer une entrée dans le gestionnaire de mots de passe.
|
||
preferTerminalTabs=Préfère ouvrir de nouveaux onglets
|
||
preferTerminalTabsDescription=Détermine si XPipe va essayer d'ouvrir de nouveaux onglets dans le terminal de ton choix plutôt que de nouvelles fenêtres. Tous les terminaux ne prennent pas en charge les onglets.
|
||
customRdpClientCommand=Commande personnalisée
|
||
customRdpClientCommandDescription=La commande à exécuter pour lancer le client RDP personnalisé.\n\nLa chaîne de caractères $FILE sera remplacée par le nom absolu du fichier .rdp entre guillemets lors de l'appel. N'oublie pas de mettre entre guillemets le chemin d'accès à ton exécutable s'il contient des espaces.
|
||
customEditorCommand=Commande d'éditeur personnalisée
|
||
customEditorCommandDescription=La commande à exécuter pour lancer l'éditeur personnalisé.\n\nLa chaîne de caractères $FILE sera remplacée par le nom de fichier absolu entre guillemets lors de l'appel. N'oublie pas de mettre entre guillemets le chemin d'accès à l'exécutable de ton éditeur s'il contient des espaces.
|
||
encryptAllVaultData=Chiffrer toutes les données du coffre-fort
|
||
encryptAllVaultDataDescription=Lorsqu’elle est activée, chaque élément des données de connexion au coffre-fort sera chiffré avec ta clé de chiffrement du coffre-fort utilisateur, et non plus uniquement les secrets contenus dans ces données. Ça ajoute une couche de sécurité supplémentaire pour d’autres paramètres comme les noms d’utilisateur, les noms d’hôte, etc., qui ne sont pas chiffrés par défaut dans le coffre-fort.\n\nCette option rendra ton historique Git du coffre-fort et tes diffs inutilisables, car tu ne pourras plus voir les modifications d’origine, mais uniquement les modifications binaires.
|
||
#custom
|
||
vaultSecurity=Sécurité du coffre-fort
|
||
developerDisableUpdateVersionCheck=Désactiver la vérification de la mise à jour
|
||
developerDisableUpdateVersionCheckDescription=Détermine si le vérificateur de mises à jour va ignorer le numéro de version lors de la recherche d'une mise à jour.
|
||
shellCommandTest=Test de commande Shell
|
||
shellCommandTestDescription=Exécute une commande dans la session shell utilisée en interne par XPipe.
|
||
terminal=Terminal
|
||
terminalType=Émulateur de terminal
|
||
terminalConfiguration=Configuration du terminal
|
||
terminalCustomization=Personnalisation du terminal
|
||
editorConfiguration=Configuration de l'éditeur
|
||
defaultApplication=Application par défaut
|
||
initialSetup=Configuration initiale
|
||
terminalTypeDescription=Le terminal par défaut à utiliser pour ouvrir des connexions shell.\n\nLe niveau de prise en charge des fonctionnalités varie selon les terminaux, et chacun est indiqué comme étant soit recommandé, soit non recommandé. Tu profiteras d'une meilleure expérience utilisateur en utilisant un terminal recommandé.
|
||
customTerminalCommand=Commande de terminal personnalisée
|
||
customTerminalCommandDescription=La commande à exécuter pour ouvrir le terminal personnalisé avec une commande donnée.\n\nXPipe va créer un script shell de lancement temporaire que ton terminal devra exécuter. La chaîne de caractères de remplacement $CMD dans la commande que tu fournis sera remplacée par le script de lancement réel lors de son appel. N'oublie pas de mettre entre guillemets le chemin d'accès à l'exécutable de ton terminal s'il contient des espaces.
|
||
#custom
|
||
clearTerminalOnInit=Effacer le terminal au démarrage
|
||
clearTerminalOnInitDescription=Quand cette option est activée, XPipe exécute une commande « clear » après le lancement d'une nouvelle session de terminal pour effacer tout affichage inutile qui aurait pu apparaître au démarrage de la session.
|
||
dontCachePasswords=Ne mets pas en cache les mots de passe demandés
|
||
dontCachePasswordsDescription=Détermine si les mots de passe demandés doivent être mis en cache en interne par XPipe pour que tu n'aies pas à les saisir à nouveau au cours de la session en cours.\n\nSi cette fonctionnalité est désactivée, tu devras ressaisir les identifiants demandés à chaque fois que le système t'y invite.
|
||
denyTempScriptCreation=Refuser la création de fichiers de script temporaires
|
||
denyTempScriptCreationDescription=Pour mettre en œuvre certaines de ses fonctionnalités, XPipe crée parfois des scripts shell temporaires sur un système cible afin de faciliter l'exécution de commandes simples. Ceux-ci ne contiennent aucune information sensible et sont uniquement créés à des fins de mise en œuvre.\n\nSi cette fonctionnalité est désactivée, XPipe ne créera aucun fichier temporaire sur un système distant. Cette option est utile dans les environnements hautement sécurisés où chaque modification du système de fichiers est surveillée. Si elle est désactivée, certaines fonctionnalités, comme les environnements shell et les scripts, ne fonctionneront pas comme prévu.
|
||
disableCertutilUse=Désactiver l'utilisation de certutil sous Windows
|
||
useLocalFallbackShell=Utiliser le shell de secours local
|
||
useLocalFallbackShellDescription=Passe à un autre shell local pour gérer les opérations locales. Il s'agit de PowerShell sous Windows et du shell Bourne sur les autres systèmes.\n\nCette option peut être utilisée si le shell local par défaut est désactivé ou ne fonctionne pas correctement. Certaines fonctionnalités risquent toutefois de ne pas fonctionner comme prévu lorsque cette option est activée.
|
||
disableCertutilUseDescription=À cause de plusieurs lacunes et bugs dans cmd.exe, des scripts shell temporaires sont créés avec certutil en l'utilisant pour décoder les entrées en base64, car cmd.exe plante avec les entrées non-ASCII. XPipe peut aussi utiliser PowerShell pour ça, mais ce sera plus lent.\n\nÇa désactive toute utilisation de certutil sur les systèmes Windows pour mettre en œuvre certaines fonctionnalités et se rabat sur PowerShell à la place. Ça pourrait plaire à certains antivirus, car certains d'entre eux bloquent l'utilisation de certutil.
|
||
more=Plus
|
||
translate=Traductions
|
||
allConnections=Toutes les connexions
|
||
allScripts=Tous les scripts
|
||
allIdentities=Toutes les identités
|
||
synced=Synchronisé
|
||
predefined=Prédéfinis
|
||
samples=Exemples
|
||
goodMorning=Bonjour
|
||
goodAfternoon=Bonjour
|
||
goodEvening=Bonsoir
|
||
addVisual=Visuel...
|
||
addDesktop=Bureau...
|
||
ssh=SSH
|
||
sshConfiguration=Configuration SSH
|
||
size=Taille
|
||
attributes=Attributs
|
||
modified=Modifié
|
||
owner=Propriétaire
|
||
updateReadyTitle=Mise à jour vers la version « $VERSION$ » prête
|
||
templates=Modèles
|
||
retry=Réessayer
|
||
retryAll=Réessayer tout
|
||
replace=Remplacer
|
||
replaceAll=Remplacer tout
|
||
hibernateBehaviour=Comportement en mode veille
|
||
hibernateBehaviourDescription=Définit le comportement de l'application lorsque ton système passe en mode veille prolongée ou en veille.
|
||
overview=Présentation
|
||
#custom
|
||
history=Historique
|
||
skipAll=Tout ignorer
|
||
notes=Notes
|
||
addNotes=Ajouter des notes
|
||
httpServer=Serveur API HTTP
|
||
mcpServer=Serveur MCP
|
||
apiKey=Clé API
|
||
apiKeyDescription=La clé API permettant d'authentifier les requêtes adressées à l'API du démon XPipe. Pour en savoir plus sur l'authentification, consulte la documentation générale de l'API.
|
||
disableApiAuthentication=Désactiver l'authentification API
|
||
disableApiAuthenticationDescription=Désactive toutes les méthodes d'authentification obligatoires pour que toute requête non authentifiée soit traitée.\n\nL'authentification ne doit être désactivée qu'à des fins de développement.
|
||
api=API
|
||
storeIntroImportContent=Tu utilises déjà XPipe sur un autre système ? Synchronise tes connexions existantes entre plusieurs systèmes via un dépôt Git distant. Tu peux aussi les synchroniser plus tard à tout moment si ce n'est pas encore configuré.
|
||
storeIntroImportButton=Synchroniser les connexions...
|
||
storeIntroImportHeader=Importer des connexions
|
||
showNonRunningChildren=Afficher les systèmes qui ne fonctionnent pas
|
||
httpApi=API HTTP
|
||
#custom
|
||
isOnlySupportedLimit=n'est pris en charge qu'avec une licence professionnelle quand tu as plus de $COUNT$ connexions
|
||
#custom
|
||
areOnlySupportedLimit=ne sont pris en charge qu'avec une licence professionnelle quand tu as plus de $COUNT$ connexions
|
||
enabled=Activé
|
||
copyId=Copier l'ID de l'API
|
||
requireDoubleClickForConnections=Exiger un double-clic pour établir les connexions
|
||
requireDoubleClickForConnectionsDescription=Si cette option est activée, tu dois double-cliquer sur les connexions pour les lancer. C'est pratique si tu as l'habitude de double-cliquer sur les éléments.
|
||
clearTransferDescription=Effacer la sélection
|
||
selectTab=Sélectionne l'onglet
|
||
closeTab=Fermer l'onglet
|
||
closeOtherTabs=Fermer les autres onglets
|
||
closeAllTabs=Fermer tous les onglets
|
||
closeLeftTabs=Fermer les onglets à gauche
|
||
closeRightTabs=Fermer les onglets à droite
|
||
addSerial=Série...
|
||
connect=Se connecter
|
||
quickConnect=Connexion rapide
|
||
workspaces=Espaces de travail
|
||
manageWorkspaces=Gérer les espaces de travail
|
||
addWorkspace=Ajouter un espace de travail...
|
||
addWorkspaceDescription=Ouvre la boîte de dialogue de création d'un nouvel espace de travail
|
||
workspaceManagement=Gérer les espaces de travail
|
||
workspaceManagementDescription=Les espaces de travail sont des configurations distinctes permettant d'exécuter XPipe. Chaque espace de travail dispose d'un répertoire de données où toutes les données sont stockées localement. Ça inclut les données de connexion, les paramètres, et bien plus encore.\n\nSi tu utilises la fonctionnalité de synchronisation, tu peux aussi choisir de synchroniser chaque espace de travail avec un dépôt Git différent.
|
||
workspaceName=Nom de l'espace de travail
|
||
workspaceNameDescription=Le nom d'affichage de l'espace de travail
|
||
workspacePath=Chemin d'accès à l'espace de travail
|
||
workspacePathDescription=L'emplacement du répertoire de données de l'espace de travail
|
||
workspaceCreationAlertTitle=Création d'un espace de travail
|
||
workspaceDeletionTitle=Supprimer l'espace de travail
|
||
workspaceDeletionContent=Tu veux supprimer cet espace de travail ? Ça va supprimer définitivement son répertoire de données, y compris toutes les connexions et tous les paramètres qui y sont stockés.
|
||
developerForceSshTty=Forcer le TTY SSH
|
||
developerForceSshTtyDescription=Fais en sorte que toutes les connexions SSH allouent un pty pour tester la prise en charge d'un stderr manquant et d'un pty.
|
||
developerDisableSshTunnelGateways=Désactiver le tunneling de la passerelle SSH
|
||
developerDisableSshTunnelGatewaysDescription=N'utilise pas de sessions tunnel pour les passerelles ; connecte-toi plutôt directement au système.
|
||
ttyWarning=La connexion a alloué de force un pty/tty et ne fournit pas de flux stderr séparé.\n\nÇa peut poser quelques problèmes.\n\nSi tu peux, essaie de faire en sorte que la commande de connexion n'alloue pas de pty.
|
||
xshellSetup=Configuration de Xshell
|
||
termiusSetup=Configuration de Termius
|
||
tryPtbDescription=Teste les nouvelles fonctionnalités dès leur sortie dans les versions de développement d'XPipe
|
||
confirmVaultUnencryptTitle=Confirmer le déchiffrement du « vault »
|
||
confirmVaultUnencryptContent=Tu veux vraiment désactiver le chiffrement avancé du « vault » ? Ça va supprimer le chiffrement supplémentaire des données stockées et écraser les données existantes.
|
||
enableHttpApi=Activer l'API HTTP
|
||
enableHttpApiDescription=Active l'API, ce qui permet à des programmes externes d'appeler le démon XPipe pour effectuer des actions sur tes connexions gérées.
|
||
chooseCustomIcon=Choisis une icône personnalisée
|
||
gitVault=Vault Git
|
||
fileBrowser=Explorateur de fichiers
|
||
confirmAllDeletions=Confirmer toutes les suppressions
|
||
confirmAllDeletionsDescription=Indique s'il faut afficher une boîte de dialogue de confirmation pour toutes les opérations de suppression. Par défaut, seule la suppression des répertoires nécessite une confirmation.
|
||
yesterday=Hier
|
||
green=Vert
|
||
yellow=Jaune
|
||
blue=Bleu
|
||
red=Rouge
|
||
cyan=Cyan
|
||
purple=Violet
|
||
asktextAlertTitle=Invite
|
||
fileWriteSudoTitle=Écriture dans un fichier via sudo
|
||
fileWriteSudoContent=Le fichier que tu essaies d'écrire ne t'accorde pas les droits d'écriture. Tu veux écrire ce fichier en tant que root avec sudo ? Ça te fera automatiquement passer en mode root, soit avec tes identifiants actuels, soit via une invite.
|
||
dontAllowTerminalRestart=Ne pas autoriser le redémarrage du terminal
|
||
dontAllowTerminalRestartDescription=Par défaut, les sessions de terminal peuvent être relancées après leur fermeture depuis le terminal lui-même. Pour permettre ça, XPipe accepte ces requêtes externes provenant du terminal pour relancer la session\n\nXPipe n'a aucun contrôle sur le terminal ni sur l'origine de cet appel ; des applications locales malveillantes peuvent donc également utiliser cette fonctionnalité pour établir des connexions via XPipe. La désactivation de cette fonctionnalité permet d'éviter ce scénario.
|
||
openDocumentation=Ouvrir la documentation
|
||
openDocumentationDescription=Rends-toi sur la page de la doc XPipe pour en savoir plus sur ce problème
|
||
renameAll=Tout renommer
|
||
logging=Journalisation
|
||
enableTerminalLogging=Activer la journalisation du terminal
|
||
enableTerminalLoggingDescription=Active la journalisation côté client pour toutes les sessions de terminal. Toutes les entrées et sorties de la session de terminal sont enregistrées dans un fichier journal de session. Note que les informations sensibles, comme les demandes de mot de passe, ne sont pas enregistrées.
|
||
terminalLoggingDirectory=Journaux de session de terminal
|
||
terminalLoggingDirectoryDescription=Tous les fichiers journaux sont stockés dans le répertoire de données XPipe sur ton système local.
|
||
openSessionLogs=Ouvrir les journaux de session
|
||
sessionLogging=Journalisation du terminal
|
||
sessionActive=Une session en arrière-plan est en cours pour cette connexion.\n\nPour arrêter cette session manuellement, clique sur l'indicateur d'état.
|
||
skipValidation=Ignorer la validation
|
||
scriptsIntroHeader=À propos des scripts
|
||
scriptsIntroContent=Tu peux exécuter des scripts au démarrage du shell, dans l'explorateur de fichiers et à la demande. Tu peux créer toi-même des scripts dans XPipe ou en importer des existants depuis ton système local ou depuis un dépôt Git distant.
|
||
scriptsIntroBottomHeader=Utilisation de scripts
|
||
scriptsIntroBottomContent=Il y a plein d'exemples de scripts pour te lancer. Tu peux cliquer sur le bouton « Modifier » de chaque script pour voir comment ils sont implémentés. Il faut d'abord activer les scripts pour qu'ils s'exécutent et apparaissent dans les menus ; il y a un bouton à cet effet sur chaque script.
|
||
scriptsIntroBottomButton=Pour commencer
|
||
scriptSourcesIntroHeader=Sources des scripts
|
||
scriptSourcesIntroContent=Tu peux ajouter des sources de scripts personnalisées pour accéder instantanément à toute une collection de scripts shell. Les sources locales et les dépôts Git distants sont tous deux pris en charge. Tous les scripts détectés dans la source seront automatiquement disponibles.
|
||
scriptSourcesIntroButton=Ajouter une source...
|
||
checkForSecurityUpdates=Vérifier les mises à jour de sécurité
|
||
checkForSecurityUpdatesDescription=XPipe peut vérifier les mises à jour de sécurité potentielles indépendamment des mises à jour habituelles des fonctionnalités. Lorsque cette option est activée, les mises à jour de sécurité au moins importantes te seront recommandées, même si la vérification habituelle des mises à jour est désactivée.\n\nSi tu désactives ce paramètre, aucune requête de version externe ne sera effectuée et tu ne seras pas averti des mises à jour de sécurité.
|
||
clickToDock=Clique pour ancrer le terminal
|
||
terminalStarting=En attente du démarrage du terminal...
|
||
#custom
|
||
pinTab=Épingler l'onglet
|
||
#custom
|
||
unpinTab=Détacher l'onglet
|
||
pinned=Épinglé
|
||
enableConnectionHubTerminalDocking=Ancrer la fenêtre du terminal au hub de connexion
|
||
enableConnectionHubTerminalDockingDescription=Tu peux ancrer des fenêtres de terminal à la fenêtre de l'application XPipe dans le hub de connexion pour simuler un terminal plus ou moins intégré. Les fenêtres de terminal sont alors gérées par XPipe pour s'adapter en permanence à l'ancrage.
|
||
enableFileBrowserTerminalDocking=Activer l'ancrage du terminal de l'explorateur de fichiers
|
||
enableFileBrowserTerminalDockingDescription=Tu peux ancrer des fenêtres de terminal à la fenêtre de l'application XPipe dans l'explorateur de fichiers pour simuler un terminal en quelque sorte intégré. Les fenêtres de terminal sont alors gérées par XPipe pour s'adapter en permanence à l'ancrage.
|
||
downloadsDirectory=Répertoire de téléchargements personnalisés
|
||
downloadsDirectoryDescription=Le répertoire personnalisé dans lequel les fichiers téléchargés seront placés lorsque tu cliques sur le bouton « Déplacer vers les téléchargements ». Par défaut, XPipe utilisera ton répertoire de téléchargements utilisateur.
|
||
pinLocalMachineOnStartup=Épingler l'onglet « Ordinateur local » au démarrage
|
||
pinLocalMachineOnStartupDescription=Ouvre automatiquement un onglet « Ordinateur local » et épingle-le. C'est pratique si tu utilises souvent un explorateur de fichiers en mode fractionné avec l'ordinateur local et le système de fichiers distant ouverts.
|
||
terminalErrorDescription=Cette erreur est fatale et XPipe ne peut pas continuer sans la corriger.
|
||
groupName=Nom du groupe
|
||
chmodPermissions=Nouvelles autorisations
|
||
editFilesWithDoubleClick=Modifie les fichiers en double-cliquant dessus
|
||
editFilesWithDoubleClickDescription=Quand cette option est activée, un double-clic sur un fichier l'ouvre directement dans ton éditeur de texte au lieu d'afficher le menu contextuel.
|
||
fileBrowserDateFormat=Format de date
|
||
fileBrowserDateFormatDescription=Le format utilisé pour afficher les dates de modification dans l'explorateur de fichiers.
|
||
censorMode=Mode de censure
|
||
censorModeDescription=Masque toutes les informations telles que les noms d'hôtes, les noms d'utilisateurs, les noms de connexion, etc.\n\nC'est utile si tu comptes faire une capture d'écran ou partager ton écran avec XPipe sans divulguer d'informations.
|
||
addIdentity=Identité...
|
||
identities=Identités
|
||
addMacro=Action...
|
||
identitiesIntroHeader=À propos des identités
|
||
identitiesIntroContent=Si tu réutilises souvent les mêmes combinaisons de noms d'utilisateur, de mots de passe et de clés, ça peut être utile de créer des identités réutilisables. Ça te permet de les retrouver rapidement quand tu ajoutes de nouvelles connexions.
|
||
identitiesIntroBottomHeader=Partage d'identités
|
||
identitiesIntroBottomContent=Tu peux ajouter des identités localement ou les synchroniser dans le dépôt Git lorsque cette fonctionnalité est activée. Ça te permet de partager de manière sélective des identités entre plusieurs systèmes et avec d'autres membres de l'équipe.
|
||
identitiesIntroBottomButton=Configurer la synchronisation
|
||
identitiesIntroButton=Créer une identité
|
||
userName=Nom d'utilisateur
|
||
vaultAuth=Chiffrement par défaut du coffre-fort
|
||
userAuth=Mot de passe personnel de l'utilisateur
|
||
roleAuth=Contrôle d'accès basé sur les rôles
|
||
team=Équipe
|
||
teamSettings=Paramètres de l'équipe
|
||
teamVaults=Vaults d'équipe
|
||
#custom
|
||
vaultTypeNameDefault=Coffre-fort par défaut
|
||
vaultTypeNamePersonal=Vault personnel
|
||
vaultTypeNameTeam=Vault d'équipe
|
||
teamVaultsDescription=Les coffres d'équipe permettent à plusieurs utilisateurs et rôles d'accéder en toute sécurité à un coffre partagé. Tu peux configurer les connexions et les identités pour qu'elles soient partagées entre tous les utilisateurs ou réservées à des utilisateurs et rôles spécifiques en les chiffrant avec leur propre clé. Les autres utilisateurs du coffre-fort ne peuvent pas accéder aux connexions et identités personnelles ou liées à un rôle s’ils n’ont pas accès à la clé.
|
||
vaultTypeContentDefault=Tu utilises actuellement un coffre-fort par défaut sans utilisateur ni phrase de passe personnalisée. Les secrets sont chiffrés avec la clé locale du coffre-fort.\n\nTu peux passer à un coffre-fort personnel en créant un compte utilisateur pour le coffre-fort. Ça te permet de chiffrer les secrets du coffre-fort avec ta propre phrase de passe, que tu devras saisir à chaque connexion pour déverrouiller le coffre-fort.
|
||
vaultTypeContentPersonal=Tu utilises actuellement un coffre-fort personnel pour ton compte utilisateur. Les secrets sont chiffrés avec ta phrase de passe personnelle.
|
||
vaultTypeContentTeam=Tu utilises actuellement un coffre-fort d'équipe, qui permet à plusieurs utilisateurs d'accéder en toute sécurité à un coffre-fort partagé. Tu peux configurer les connexions et les identités pour qu'elles soient partagées par tous les utilisateurs ou qu'elles ne soient disponibles que pour ton compte personnel ou ton rôle, en les chiffrant avec ta clé personnelle ou celle de ton rôle. Les autres utilisateurs du coffre-fort ne peuvent pas accéder à tes connexions et identités personnelles ou liées à un rôle s’ils n’ont pas accès à la clé.
|
||
roleManagement=Gestion des rôles
|
||
roleManagementEmpty=Gestion des rôles
|
||
roleManagementDescription=Gère les rôles de « vault » existants ou en crée de nouveaux. Chaque rôle de « vault » dispose de sa propre clé secrète, utilisée pour chiffrer les connexions et les identités qui ne doivent être accessibles qu’à ce rôle et à aucun autre.
|
||
roleManagementEmptyDescription=Gère les rôles de « vault » existants ou en crée de nouveaux. Chaque rôle de « vault » dispose de sa propre clé secrète, utilisée pour chiffrer les connexions et les identités qui ne doivent être accessibles qu’à ce rôle et à personne d’autre.\n\nLes comptes basés sur les rôles pour une équipe sont pris en charge dans la formule « Professional ».
|
||
userManagement=Gestion des utilisateurs
|
||
userManagementEmpty=Gestion des utilisateurs
|
||
userManagementDescription=Gère ton utilisateur de coffre-fort existant ou crée-en un nouveau. Ton utilisateur de coffre-fort dispose de sa propre phrase de passe, qui sert à chiffrer les connexions et les identités.
|
||
userManagementEmptyDescription=Gère ton utilisateur de coffre-fort existant ou crée-en un nouveau. Ton utilisateur de coffre-fort dispose de sa propre phrase de passe, qui sert à chiffrer les connexions et les identités. Crée un utilisateur pour toi-même afin de pouvoir chiffrer les connexions et les identités avec ta clé personnelle.
|
||
userIntroHeader=Gestion des utilisateurs
|
||
userIntroContent=Crée ton premier compte utilisateur pour commencer. Ça te permettra de verrouiller cet espace de travail avec un mot de passe.
|
||
addReusableIdentity=Ajouter une identité réutilisable
|
||
users=Utilisateurs
|
||
syncVault=Synchronisation du Vault
|
||
syncVaultDescription=Pour synchroniser ton vault sur plusieurs systèmes, active la synchronisation Git pour ce vault.
|
||
enableGitSync=Activer la synchronisation Git
|
||
browseVault=Données du Vault
|
||
browseVaultDescription=Tu peux jeter un œil toi-même au répertoire du « vault » dans ton gestionnaire de fichiers. Note que les modifications externes ne sont pas recommandées et peuvent entraîner divers problèmes.
|
||
browseVaultButton=Parcourir le coffre-fort
|
||
vaultUsers=Utilisateurs de Vault
|
||
createHeapDump=Créer un vidage de mémoire
|
||
createHeapDumpDescription=Vider le contenu de la mémoire dans un fichier pour dépanner l'utilisation de la mémoire
|
||
initializingApp=Chargement des connexions
|
||
checkingLicense=Vérification de la licence
|
||
loadingGit=Synchronisation avec le dépôt Git
|
||
loadingGpg=Lancer le démon GnuPG pour git
|
||
loadingSettings=Chargement des paramètres
|
||
loadingConnections=Chargement des connexions
|
||
unlockingVault=Déverrouillage du « vault »
|
||
loadingUserInterface=Chargement de l'interface utilisateur
|
||
ptbNoticeTitle=Avis concernant la version de test publique
|
||
ptbNoticeContent=Tu utilises une version PTB d'XPipe. Cette version est instable et peut contenir des bugs. Tu ne devrais pas l'utiliser comme version de tous les jours. Elle ne bénéficiera pas non plus de mises à jour régulières après sa période de test. Pour ça, tu devras installer et lancer la version normale d'XPipe.
|
||
userDeletionTitle=Suppression d'un utilisateur
|
||
userDeletionContent=Tu veux supprimer cet utilisateur du coffre-fort ? Ça va rechiffrer toutes les données avec la clé par défaut du coffre-fort. Ça va prendre un certain temps.
|
||
roleDeletionTitle=Suppression d'un rôle
|
||
roleDeletionContent=Tu veux supprimer ce rôle de coffre-fort ? Ça va rechiffrer toutes les identités et tous les secrets de connexion qui utilisent ce rôle pour qu'ils ne l'utilisent plus. Ça risque de prendre un certain temps.
|
||
killTransfer=Interrompre le transfert
|
||
destination=Destination
|
||
configuration=Configuration
|
||
newFile=Nouveau fichier
|
||
newLink=Nouveau lien
|
||
linkName=Nom du lien
|
||
scanConnections=Rechercher les connexions disponibles...
|
||
createShortcut=Créer un raccourci sur le bureau
|
||
browseFiles=Parcourir les fichiers
|
||
clone=Cloner
|
||
targetPath=Chemin d'accès cible
|
||
newDirectory=Nouveau répertoire
|
||
copyShareLink=Copier le lien
|
||
selectStore=Sélectionner « Store »
|
||
saveSource=Enregistrer pour plus tard
|
||
execute=Exécuter
|
||
deleteChildren=Supprimer tous les éléments enfants
|
||
abstractHostDescriptionDescription=Donne une description facultative à cet hôte
|
||
selectSource=Sélectionner la source
|
||
additionalOptions=Options supplémentaires
|
||
input=Saisie
|
||
machine=Machine
|
||
open=Ouvrir
|
||
edit=Modifier
|
||
scriptContents=Contenu du script
|
||
scriptContentsDescription=Les commandes de script à exécuter
|
||
snippets=Dépendances des scripts
|
||
snippetsDescription=Autres scripts à exécuter en premier
|
||
snippetsDependenciesDescription=Tous les scripts qui doivent être exécutés le cas échéant
|
||
isDefault=À exécuter lors de l'initialisation dans tous les shells compatibles
|
||
#custom
|
||
bringToShells=Apporter à tous les shells compatibles
|
||
executionType=Type d'exécution
|
||
executionTypeDescription=Dans quels contextes utiliser ce script
|
||
#custom
|
||
minimumShellDialect=Type de shell
|
||
minimumShellDialectDescription=Le type de shell dans lequel exécuter ce script
|
||
script.displayName=Script Shell
|
||
script.displayDescription=Créer un script shell réutilisable
|
||
openInNewTab=Ouvrir dans un nouvel onglet
|
||
executeInBackground=en arrière-plan
|
||
executeInTerminal=dans $TERM$
|
||
#custom
|
||
back=Retour
|
||
browseInWindowsExplorer=Parcourir dans l'Explorateur Windows
|
||
browseInDefaultFileManager=Parcourir dans le gestionnaire de fichiers par défaut
|
||
browseInFinder=Parcourir dans le Finder
|
||
copy=Copier
|
||
paste=Coller
|
||
copyLocation=Copier l'emplacement
|
||
absolutePaths=Chemins absolus
|
||
absoluteLinkPaths=Chemins d'accès absolus
|
||
absolutePathsQuoted=Chemins absolus entre guillemets
|
||
fileNames=Noms de fichiers
|
||
linkFileNames=Noms de fichiers des liens
|
||
fileNamesQuoted=Noms de fichiers (entre guillemets)
|
||
deleteFile=Supprimer $FILE$
|
||
editWithEditor=Modifier avec $EDITOR$
|
||
followLink=Suivre le lien
|
||
goForward=Aller de l'avant
|
||
showDetails=Afficher les détails
|
||
showDetailsDescription=Afficher la trace de la pile de l'erreur
|
||
openFileWith=Ouvrir avec...
|
||
openWithDefaultApplication=Ouvrir avec l'application par défaut
|
||
rename=Renommer
|
||
run=Lancer
|
||
openInTerminal=Ouvrir dans le terminal
|
||
file=Fichier
|
||
directory=Répertoire
|
||
symbolicLink=Lien symbolique
|
||
desktopEnvironment.displayName=Environnement de bureau
|
||
desktopEnvironment.displayDescription=Créer une configuration réutilisable pour un environnement de bureau à distance
|
||
desktopHost=Hôte du bureau
|
||
desktopHostDescription=La connexion du bureau à utiliser comme base
|
||
desktopShellDialect=Dialecte du shell
|
||
desktopShellDialectDescription=Le dialecte de shell à utiliser pour exécuter des scripts et des applications
|
||
desktopSnippets=Extraits de script
|
||
desktopSnippetsDescription=Liste des extraits de script réutilisables à exécuter en premier
|
||
desktopInitScript=Script d'initialisation
|
||
desktopInitScriptDescription=Commandes d'initialisation spécifiques à cet environnement
|
||
desktopTerminal=Application de terminal
|
||
desktopTerminalDescription=Le terminal à utiliser sur le bureau pour lancer des scripts dans
|
||
desktopApplication.displayName=Application de bureau
|
||
desktopApplication.displayDescription=Lancer une application sur un bureau à distance
|
||
desktopBase=Bureau
|
||
desktopBaseDescription=Le bureau sur lequel tu vas lancer cette application
|
||
desktopEnvironmentBase=Environnement de bureau
|
||
desktopEnvironmentBaseDescription=L'environnement de bureau sur lequel cette application doit s'exécuter
|
||
desktopApplicationPath=Chemin d'accès à l'application
|
||
desktopApplicationPathDescription=Le chemin d'accès au fichier exécutable à lancer
|
||
desktopApplicationArguments=Arguments
|
||
desktopApplicationArgumentsDescription=Les arguments facultatifs à passer à l'application
|
||
desktopCommand.displayName=Commande de bureau
|
||
desktopCommand.displayDescription=Exécuter une commande dans un environnement de bureau à distance
|
||
desktopCommandScript=Commandes
|
||
desktopCommandScriptDescription=Les commandes à exécuter dans l'environnement
|
||
service.displayName=Service
|
||
service.displayDescription=Rediriger un service distant vers ton ordinateur local
|
||
serviceLocalPort=Port local explicite
|
||
serviceLocalPortDescription=Le port local vers lequel rediriger le trafic ; sinon, un port aléatoire est utilisé
|
||
serviceRemotePort=Port distant
|
||
serviceRemotePortDescription=Le port sur lequel le service est en cours d'exécution
|
||
serviceHost=Hôte de service
|
||
serviceHostDescription=L'entrée hôte ou l'adresse manuelle du serveur sur lequel le service est en cours d'exécution
|
||
openWebsite=Ouvrir le site web
|
||
customServiceGroup.displayName=Groupe de services
|
||
customServiceGroup.displayDescription=Regrouper plusieurs services dans une seule catégorie
|
||
initScript=Script d'initialisation - À exécuter lors de l'initialisation du shell
|
||
shellScript=Script de session shell - Rendre un script accessible pour qu'il s'exécute pendant une session shell
|
||
runnableScript=Script exécutable - Permet d'exécuter le script directement depuis le hub de connexion
|
||
fileScript=Script de fichier - Permet d'exécuter un script sur les fichiers sélectionnés dans l'explorateur de fichiers
|
||
runScript=Lancer le script
|
||
copyUrl=Copier l'URL
|
||
fixedServiceGroup.displayName=Groupe de services
|
||
fixedServiceGroup.displayDescription=Lister les services disponibles sur un système
|
||
mappedService.displayName=Service
|
||
mappedService.displayDescription=Interagir avec un service exposé par un conteneur
|
||
customService.displayName=Service
|
||
customService.displayDescription=Ouvrir ou tunneler automatiquement un port de service distant sur ta machine locale
|
||
fixedService.displayName=Service
|
||
fixedService.displayDescription=Utiliser un service prédéfini
|
||
noServices=Aucun service disponible
|
||
hasServices=$COUNT$ services disponibles
|
||
hasService=$COUNT$ service disponible
|
||
noConnections=Aucune connexion disponible
|
||
hasConnections=$COUNT$ connexions disponibles
|
||
hasConnection=$COUNT$ connexion disponible
|
||
noShells=Aucun shell disponible
|
||
hasShells=$COUNT$ shells disponibles
|
||
hasShell=$COUNT$ shell disponible
|
||
noPorts=Aucun port disponible
|
||
hasPorts=$COUNT$ ports disponibles
|
||
hasPort=$COUNT$ port disponible
|
||
openHttp=Ouvrir le service HTTP
|
||
openHttps=Ouvrir le service HTTPS
|
||
noScriptsAvailable=Aucun script activé et compatible n'est disponible
|
||
scriptsDisabled=Scripts désactivés
|
||
changeIcon=Changer l'icône
|
||
init=Init
|
||
#custom
|
||
shell=Shell
|
||
hub=Hub
|
||
script=script
|
||
genericScript=Générique
|
||
gradleTasks=Tâches Gradle
|
||
runTask=Lancer la tâche
|
||
archiveName=Nom de l'archive
|
||
compress=Compresser
|
||
compressContents=Compresser le contenu
|
||
#custom
|
||
untarHere=Extraire ici (archive tar)
|
||
#custom
|
||
untarDirectory=Extraire vers $DIR$ (archive tar)
|
||
#custom
|
||
unzipDirectory=Extraire vers $DIR$ (archive zip)
|
||
#custom
|
||
gunzipDirectory=Décompresser avec Gunzip vers $DIR$
|
||
#custom
|
||
unzipHere=Extraire ici (archive zip)
|
||
requiresRestart=Un redémarrage est nécessaire pour que les modifications soient prises en compte.
|
||
download=Télécharger
|
||
servicePath=Chemin d'accès au service
|
||
servicePathDescription=Le sous-chemin facultatif lors de l'ouverture de l'URL dans un navigateur
|
||
active=Actif
|
||
inaccessible=Inaccessible
|
||
disabled=Désactivé
|
||
inactive=Inactif
|
||
starting=Démarrage
|
||
running=En cours d'exécution
|
||
remotePort=Port distant
|
||
remotePortNumber=Port distant $PORT$
|
||
userIdentity=Identité personnelle
|
||
roleIdentity=Identité basée sur les rôles
|
||
globalIdentity=Identité globale
|
||
rolePasswordManagerIdentity=Identité dans un gestionnaire de mots de passe basée sur les rôles
|
||
identityChoice=Identité de l'utilisateur
|
||
identityChoiceDescription=Choisis une identité prédéfinie ou indique tes identifiants de connexion juste pour cette connexion
|
||
defineNewIdentityOrSelect=Saisis-en un nouveau ou choisis-en un existant
|
||
localIdentity.displayName=Identité locale
|
||
localIdentity.displayDescription=Crée une identité réutilisable pour ce coffre-fort local
|
||
syncedIdentity.displayName=Identité synchronisée
|
||
syncedIdentity.displayDescription=Créer une identité réutilisable synchronisée avec le coffre-fort distant
|
||
localIdentity=Identité locale
|
||
syncedIdentity=Identité synchronisée
|
||
keyNotSynced=Le fichier de clé n'est pas encore synchronisé avec le dépôt Git. Utilise le bouton « Ajouter à Git » pour ajouter le fichier de clé.
|
||
usernameDescription=Le nom d'utilisateur pour se connecter
|
||
identity.displayName=Identité
|
||
identity.displayDescription=Créer une identité réutilisable pour les connexions
|
||
local=Local
|
||
shared=Global
|
||
userDescription=Le nom d'utilisateur ou l'identité prédéfinie pour se connecter
|
||
identityAccessLevel=Niveau d'accès
|
||
identityPerRole=Accès basé sur les rôles
|
||
identityPerRoleDescription=Limiter l'accès à cette identité et aux connexions qui y sont associées à certains rôles
|
||
identityPerRoleDisabled=Accès basé sur les rôles (nécessite la configuration d'une équipe)
|
||
identityPerRoleDisabledDescription=Limiter l'accès à cette identité et aux connexions qui y sont associées à certains rôles
|
||
library=Bibliothèque
|
||
location=Emplacement de la clé
|
||
keyAuthentication=Authentification par clé
|
||
keyAuthenticationDescription=La méthode d'authentification à utiliser si l'authentification par clé est requise
|
||
locationDescription=Le chemin d'accès au fichier de ta clé privée correspondante
|
||
keyFile=Fichier de clé local
|
||
keyPassword=Phrase de passe
|
||
key=Clé
|
||
yubikeyPiv=Yubikey PIV
|
||
pageant=Pageant
|
||
gpgAgent=Agent GPG
|
||
customPkcs11Library=Bibliothèque PKCS#11 personnalisée
|
||
sshAgent=Agent OpenSSH
|
||
none=Aucun
|
||
empty=Vide
|
||
index=Index...
|
||
otherExternal=Autres méthodes d'authentification externes
|
||
sync=Synchronisation
|
||
vaultSync=Synchronisation du Vault
|
||
customUsername=Nom d'utilisateur
|
||
customUsernameDescription=L'utilisateur alternatif facultatif sous lequel se connecter
|
||
customUsernamePassword=Mot de passe
|
||
customUsernamePasswordDescription=Le mot de passe de l'utilisateur à utiliser quand l'authentification sudo est requise
|
||
#custom
|
||
showInternalPods=Afficher les pods internes
|
||
showAllNamespaces=Afficher tous les espaces de noms
|
||
showInternalContainers=Afficher les conteneurs internes
|
||
refresh=Actualiser
|
||
vmwareGui=Lancer l'interface graphique
|
||
monitorVm=Surveiller la VM
|
||
#custom
|
||
addCluster=Ajouter un cluster ...
|
||
showNonRunningInstances=Afficher les instances qui ne sont pas en cours d'exécution
|
||
vmwareGuiDescription=Si tu veux lancer une machine virtuelle en arrière-plan ou dans une fenêtre.
|
||
vmwareEncryptionPassword=Mot de passe de chiffrement
|
||
vmwareEncryptionPasswordDescription=Le mot de passe facultatif utilisé pour chiffrer la machine virtuelle.
|
||
vmPasswordDescription=Le mot de passe requis pour l'utilisateur invité.
|
||
vmPassword=Mot de passe de l'utilisateur
|
||
vmUser=Utilisateur invité
|
||
runTempContainer=Lancer un conteneur temporaire
|
||
vmUserDescription=Le nom d'utilisateur de ton utilisateur invité principal
|
||
dockerTempRunAlertTitle=Lancer un conteneur temporaire
|
||
dockerTempRunAlertHeader=Ça va lancer un processus shell dans un conteneur temporaire qui sera automatiquement supprimé une fois arrêté.
|
||
imageName=Nom de l'image
|
||
imageNameDescription=L'identifiant de l'image de conteneur à utiliser
|
||
containerName=Nom du conteneur
|
||
containerNameDescription=Le nom personnalisé facultatif du conteneur
|
||
vm=Machine virtuelle
|
||
vmDescription=Le fichier de configuration associé.
|
||
vmwareScan=Hyperviseurs de bureau VMware
|
||
vmwareMachine.displayName=Machine virtuelle VMware
|
||
vmwareMachine.displayDescription=Se connecter à une machine virtuelle via SSH
|
||
vmwareInstallation.displayName=Installation de l'hyperviseur VMware Desktop
|
||
vmwareInstallation.displayDescription=Interagir avec les machines virtuelles installées via son interface en ligne de commande
|
||
start=Démarrer
|
||
stop=Arrêt
|
||
forceStop=Forcer l'arrêt
|
||
kill=Kill
|
||
pause=Pause
|
||
rdpTunnelHost=Hôte cible
|
||
rdpTunnelHostDescription=La connexion SSH par laquelle passe la connexion RDP
|
||
rdpTunnelUsername=Nom d'utilisateur
|
||
rdpTunnelUsernameDescription=L'utilisateur personnalisé sous lequel tu te connectes ; si ce champ est laissé vide, c'est l'utilisateur SSH qui est utilisé
|
||
rdpFileLocation=Emplacement du fichier
|
||
rdpFileLocationDescription=Le chemin d'accès au fichier .rdp
|
||
rdpPasswordAuthentication=Authentification par mot de passe
|
||
rdpFiles=Fichiers RDP
|
||
rdpPasswordAuthenticationDescription=Le mot de passe à saisir ou à copier dans le presse-papiers, selon la prise en charge du client
|
||
rdpFile.displayName=Fichier RDP
|
||
rdpFile.displayDescription=Se connecter à un système via un fichier .rdp existant
|
||
computerName=Nom de l'ordinateur
|
||
pssComputerNameDescription=Le nom de l'ordinateur auquel se connecter
|
||
credentialUser=Identifiant de l'utilisateur
|
||
credentialUserDescription=L'utilisateur sous lequel tu dois te connecter.
|
||
credentialPassword=Mot de passe d'identification
|
||
credentialPasswordDescription=Le mot de passe de l'utilisateur.
|
||
sshConfig=Fichiers de configuration SSH
|
||
autostart=Se connecter automatiquement au démarrage de XPipe
|
||
acceptHostKey=Accepter la clé de l'hôte
|
||
modifyHostKeyPermissions=Modifier les autorisations de la clé hôte
|
||
attachContainer=Connecter
|
||
containerLogs=Afficher les journaux
|
||
openSftpClient=Ouvrir dans un client SFTP externe
|
||
openTermius=Ouvrir dans Termius
|
||
showInternalInstances=Afficher les instances internes
|
||
editPod=Modifier un pod
|
||
deleteKnownHosts=Supprime « .ssh/known_hosts »
|
||
deleteKnownHostsDescription=Supprime le fichier « .ssh/known_hosts » pour corriger le problème de fichier corrompu
|
||
acceptHostKeyDescription=Fais confiance à la nouvelle clé de l'hôte et continue
|
||
modifyHostKeyPermissionsDescription=Essaie de supprimer les droits d'accès du fichier d'origine pour qu'OpenSSH fonctionne correctement
|
||
psSession.displayName=Session à distance PowerShell
|
||
psSession.displayDescription=Se connecter via New-PSSession et Enter-PSSession
|
||
sshLocalTunnel.displayName=Tunnel SSH local
|
||
sshLocalTunnel.displayDescription=Établir un tunnel SSH vers un hôte distant
|
||
sshRemoteTunnel.displayName=Tunnel SSH à distance
|
||
sshRemoteTunnel.displayDescription=Établir un tunnel SSH inversé depuis un hôte distant
|
||
sshDynamicTunnel.displayName=Tunnel SSH dynamique
|
||
sshDynamicTunnel.displayDescription=Configurer un proxy SOCKS via une connexion SSH
|
||
shellEnvironmentGroup.displayName=Les environnements shell
|
||
shellEnvironmentGroup.displayDescription=Les environnements shell
|
||
shellEnvironment.displayName=Environnement Shell
|
||
shellEnvironment.displayDescription=Créer un environnement de démarrage personnalisé pour le shell
|
||
shellEnvironment.informationFormat=$TYPE$ environnement
|
||
shellEnvironment.elevatedInformationFormat=$ELEVATION$ $TYPE$ environnement
|
||
environmentConnectionDescription=La connexion de base pour créer un environnement permettant de
|
||
environmentScriptDescription=Le script d'initialisation personnalisé facultatif à exécuter dans le shell
|
||
environmentSnippets=Scripts Shell
|
||
commandSnippetsDescription=Les scripts shell prédéfinis facultatifs à exécuter en premier
|
||
environmentSnippetsDescription=Les scripts shell prédéfinis facultatifs à exécuter lors de l'initialisation
|
||
shellTypeDescription=Le type de shell à lancer explicitement
|
||
originPort=Port d'origine
|
||
originAddress=Adresse d'origine
|
||
remoteAddress=Adresse distante
|
||
remoteSourceAddress=Adresse source distante
|
||
remoteSourcePort=Port source distant
|
||
#custom
|
||
originDestinationPort=Port de destination côté origine
|
||
#custom
|
||
originDestinationAddress=Adresse de destination côté origine
|
||
origin=Origine
|
||
remoteHost=Hôte distant
|
||
address=Adresse
|
||
proxmox.displayName=Proxmox
|
||
proxmox.displayDescription=Se connecter à des systèmes dans un environnement virtuel Proxmox
|
||
proxmoxVm.displayName=Proxmox VM
|
||
proxmoxVm.displayDescription=Se connecter à une machine virtuelle dans Proxmox VE via SSH
|
||
proxmoxContainer.displayName=Proxmox Container
|
||
proxmoxContainer.displayDescription=Se connecter à un conteneur dans Proxmox VE
|
||
sshDynamicTunnel.hostDescription=Le système à utiliser comme proxy SOCKS
|
||
sshDynamicTunnel.bindingDescription=À quelles adresses faut-il lier le tunnel ?
|
||
sshRemoteTunnel.hostDescription=Le système à partir duquel lancer le tunnel distant vers l'origine
|
||
sshRemoteTunnel.bindingDescription=À quelles adresses faut-il lier le tunnel ?
|
||
sshLocalTunnel.hostDescription=Le système cible du tunnel
|
||
sshLocalTunnel.bindingDescription=À quelles adresses faut-il lier le tunnel ?
|
||
sshLocalTunnel.localAddressDescription=L'adresse locale à associer
|
||
sshLocalTunnel.remoteAddressDescription=L'adresse distante à associer
|
||
cmd.displayName=Commande
|
||
cmd.displayDescription=Exécuter une commande arbitraire sur un système
|
||
k8sPod.displayName=Pod Kubernetes
|
||
k8sPod.displayDescription=Se connecter à un pod et à ses conteneurs via kubectl
|
||
k8sContainer.displayName=Conteneur Kubernetes
|
||
k8sContainer.displayDescription=Ouvrir un shell vers un conteneur
|
||
k8sCluster.displayName=Cluster Kubernetes
|
||
k8sCluster.displayDescription=Se connecter à un cluster et à ses pods via kubectl
|
||
sshTunnelGroup.displayName=Tunnels SSH
|
||
sshTunnelGroup.displayCategory=Tous les types de tunnels SSH
|
||
local.displayName=Ordinateur local
|
||
local.displayDescription=Le shell de la machine locale
|
||
cygwin=Cygwin
|
||
msys2=MSYS2
|
||
gitWindows=Git pour Windows
|
||
#custom
|
||
gitForWindows.displayName=Git For Windows
|
||
gitForWindows.displayDescription=Accède à ton environnement Git For Windows local
|
||
msys2.displayName=MSYS2
|
||
msys2.displayDescription=Accéder aux shells de ton environnement MSYS2
|
||
cygwin.displayName=Cygwin
|
||
cygwin.displayDescription=Accéder aux shells de ton environnement Cygwin
|
||
namespace=Espace de noms
|
||
gitVaultIdentityStrategy=Identité SSH Git
|
||
gitVaultIdentityStrategyDescription=Si tu as choisi d'utiliser une URL Git SSH comme dépôt distant et que ton dépôt distant nécessite une identité SSH, active cette option.\n\nSi tu as fourni une URL HTTP, tu peux ignorer cette option.
|
||
dockerContainers=Conteneurs Docker
|
||
dockerCmd.displayName=client CLI Docker
|
||
dockerCmd.displayDescription=Accéder aux conteneurs Docker via le client CLI de Docker
|
||
wslCmd.displayName=Installation de WSL
|
||
wslCmd.displayDescription=Accéder aux instances WSL via le client CLI wsl
|
||
k8sCmd.displayName=client kubectl
|
||
k8sCmd.displayDescription=Accéder aux clusters Kubernetes via kubectl
|
||
k8sClusters=Clusters Kubernetes
|
||
#custom
|
||
shells=Shells disponibles
|
||
inspectContainer=Inspecter
|
||
inspectContext=Inspecter
|
||
k8sClusterNameDescription=Le nom du contexte dans lequel se trouve le cluster.
|
||
#custom
|
||
pod=Pod
|
||
podName=Nom du pod
|
||
k8sClusterContext=Contexte
|
||
k8sClusterContextDescription=Le nom du contexte dans lequel se trouve le cluster
|
||
k8sClusterNamespace=Espace de noms
|
||
k8sClusterNamespaceDescription=L'espace de noms personnalisé ou celui par défaut s'il est vide
|
||
k8sConfigLocation=Fichier de configuration
|
||
k8sConfigLocationDescription=Le fichier kubeconfig personnalisé ou celui par défaut s'il est laissé vide
|
||
#custom
|
||
inspectPod=Inspecter le pod
|
||
showAllContainers=Afficher les conteneurs qui ne sont pas en cours d'exécution
|
||
showAllPods=Afficher les pods qui ne sont pas en cours d'exécution
|
||
k8sPodHostDescription=L'hôte sur lequel se trouve le pod
|
||
k8sContainerDescription=Le nom du conteneur Kubernetes
|
||
k8sPodDescription=Le nom du pod Kubernetes
|
||
podDescription=Le pod sur lequel se trouve le conteneur
|
||
k8sClusterHostDescription=L'hôte par lequel il faut accéder au cluster. kubectl doit y être installé et configuré pour pouvoir accéder au cluster.
|
||
connection=Connexion
|
||
shellCommand.displayName=Commande shell personnalisée
|
||
shellCommand.displayDescription=Ouvrir un shell standard via une commande personnalisée
|
||
ssh.displayName=Connexion SSH
|
||
ssh.displayDescription=Connecte-toi à un système distant via ton client SSH en ligne de commande local
|
||
sshConfig.displayName=Fichier de configuration SSH
|
||
sshConfig.displayDescription=Se connecter aux hôtes définis dans un fichier de configuration SSH
|
||
#custom
|
||
sshConfigHost.displayName=Hôte du fichier de configuration SSH
|
||
sshConfigHost.displayDescription=Se connecter à un hôte défini dans un fichier de configuration SSH
|
||
sshConfigHost.password=Mot de passe
|
||
sshConfigHost.passwordDescription=Indique le mot de passe facultatif pour la connexion de l'utilisateur.
|
||
sshConfigHost.identityPassphrase=Phrase de passe de clé
|
||
sshConfigHost.identityPassphraseDescription=Indique la phrase de passe facultative pour ta clé.
|
||
shellCommand.hostDescription=L'hôte sur lequel la commande doit être exécutée
|
||
shellCommand.commandDescription=La commande qui va ouvrir un shell
|
||
commandType=Type de commande
|
||
commandTypeDescription=Comment exécuter la commande
|
||
commandDescription=Les commandes personnalisées à exécuter sur l'hôte
|
||
commandHostDescription=L'hôte sur lequel tu vas exécuter la commande
|
||
commandDataFlowDescription=Comment cette commande gère les entrées et les sorties
|
||
commandElevationDescription=Exécute cette commande avec des droits d'accès élevés
|
||
commandShellTypeDescription=Le shell à utiliser pour cette commande
|
||
limitedSystem=Il s'agit d'un système limité ou embarqué
|
||
limitedSystemDescription=N'essaie pas d'identifier le type de shell, c'est nécessaire pour les systèmes embarqués aux ressources limitées ou les appareils IoT
|
||
sshForwardX11=Transfert X11
|
||
sshForwardX11Description=Active le transfert X11 pour la connexion
|
||
customAgent=Agent personnalisé
|
||
identityAgent=Agent d'identité
|
||
usage=Utilisation
|
||
wslHostDescription=L'hôte sur lequel se trouve l'instance WSL. WSL doit y être installé.
|
||
wslDistributionDescription=Le nom de l'instance WSL
|
||
wslUsernameDescription=Le nom d'utilisateur à utiliser pour te connecter. Si tu ne le précises pas, c'est le nom d'utilisateur par défaut qui sera utilisé.
|
||
wslPasswordDescription=Le mot de passe de l'utilisateur qui peut être utilisé pour les commandes sudo.
|
||
dockerHostDescription=L'hôte sur lequel se trouve le conteneur Docker. Docker doit y être installé.
|
||
dockerContainerDescription=Le nom du conteneur Docker
|
||
localMachine=Ordinateur local
|
||
rootScan=Environnement du shell Sudo
|
||
loginEnvironmentScan=Environnement de connexion personnalisé
|
||
k8sScan=Cluster Kubernetes
|
||
options=Options
|
||
dockerRunningScan=Conteneurs Docker en cours d'exécution
|
||
dockerAllScan=Tous les conteneurs Docker
|
||
wslScan=Instances WSL
|
||
sshScan=Connexions de configuration SSH
|
||
runAsUser=Exécuter en tant qu'utilisateur
|
||
runAsUserDescription=Lance cet environnement shell en tant qu'autre utilisateur
|
||
default=Par défaut
|
||
sources=Sources
|
||
administrator=Administrateur
|
||
wslHost=Hôte WSL
|
||
timeout=Délai d'expiration
|
||
installLocation=Emplacement d'installation
|
||
installLocationDescription=L'emplacement où ton environnement « $NAME$ » est installé
|
||
wsl.displayName=Sous-système Windows pour Linux
|
||
wsl.displayDescription=Se connecter à une instance WSL fonctionnant sous Windows
|
||
docker.displayName=Conteneur Docker
|
||
docker.displayDescription=Se connecter à un conteneur Docker
|
||
port=Port
|
||
user=Utilisateur
|
||
password=Mot de passe
|
||
method=Méthode
|
||
uri=URL
|
||
proxy=Proxy
|
||
distribution=Distribution
|
||
username=Nom d'utilisateur
|
||
#custom
|
||
shellType=Type de shell
|
||
browseFile=Parcourir les fichiers
|
||
openShell=Ouvrir un shell dans le terminal
|
||
openCommand=Exécuter une commande dans le terminal
|
||
editFile=Modifier le fichier
|
||
description=Description
|
||
furtherCustomization=Personnalisation avancée
|
||
furtherCustomizationDescription=Pour plus d'options de configuration, utilise les fichiers de configuration ssh
|
||
browse=Parcourir
|
||
configHost=Hôte
|
||
configHostDescription=L'hôte sur lequel se trouve la configuration
|
||
configLocation=Emplacement de la configuration
|
||
configLocationDescription=Le chemin d'accès au fichier de configuration
|
||
gateway=Passerelle
|
||
gatewayDescription=La passerelle optionnelle à utiliser lors de la connexion
|
||
rdpGateway=Passerelle de connexion
|
||
rdpGatewayDescription=La passerelle facultative. Prend en charge à la fois les hôtes SSH pour la création de tunnels et les serveurs de passerelle RD
|
||
connectionInformation=Cible de connexion
|
||
connectionInformationDescription=À quel système se connecter ?
|
||
passwordAuthentication=Authentification par mot de passe
|
||
passwordAuthenticationDescription=Le mot de passe facultatif à utiliser pour l'authentification ou avec sudo
|
||
sshConfigString.displayName=Connexion SSH basée sur un fichier de configuration
|
||
sshConfigString.displayDescription=Crée une connexion SSH personnalisée au format de configuration SSH
|
||
sshConfigStringContent=Configuration
|
||
sshConfigStringContentDescription=Options SSH pour la connexion au format de configuration OpenSSH
|
||
vnc.displayName=Connexion VNC via SSH
|
||
vnc.displayDescription=Ouvrir une session VNC via une connexion tunnelisée
|
||
#custom
|
||
binding=Liaison
|
||
vncPortDescription=Le port sur lequel le serveur VNC est à l'écoute
|
||
rdpPortDescription=Le port sur lequel le serveur RDP est à l'écoute
|
||
vncUsername=Nom d'utilisateur
|
||
vncUsernameDescription=Le nom d'utilisateur VNC (facultatif)
|
||
vncPassword=Mot de passe
|
||
vncPasswordDescription=Le mot de passe VNC
|
||
x11WslInstance=Instance WSL de redirection X11
|
||
x11WslInstanceDescription=La distribution locale du sous-système Windows pour Linux (WSL) à utiliser comme serveur X11 quand tu utilises le transfert X11 dans une connexion SSH. Cette distribution doit être une distribution WSL2.
|
||
#custom
|
||
openAsRoot=Ouvrir en tant que root
|
||
openInWSL=Ouvrir dans WSL
|
||
launch=Lancer
|
||
sshTrustKeyContent=La clé de l'hôte n'est pas connue, et tu as activé la vérification manuelle de la clé de l'hôte.\n\n$CONTENT$
|
||
sshTrustKeyTitle=Clé d'hôte inconnue
|
||
rdpTunnel.displayName=Connexion RDP via SSH
|
||
rdpTunnel.displayDescription=Se connecter via RDP par une connexion tunnelisée
|
||
rdpEnableDesktopIntegration=Activer l'intégration au bureau
|
||
rdpEnableDesktopIntegrationDescription=Lancer des applications à distance, à condition que la liste blanche RDP l'autorise
|
||
rdpSetupAdminTitle=Configuration RDP requise
|
||
rdpSetupAllowTitle=Application à distance RDP
|
||
rdpSetupAllowContent=Le lancement direct d'applications à distance n'est actuellement pas autorisé sur le système distant. Tu veux l'activer dans le registre ? Ça te permettra de lancer tes applications à distance directement depuis XPipe en désactivant la liste blanche pour les applications RDP à distance.
|
||
rdpServerEnableTitle=Serveur RDP
|
||
rdpServerEnableContent=Le serveur RDP est désactivé sur le système cible. Tu veux l'activer dans le registre pour autoriser les connexions RDP à distance ?
|
||
rdp=RDP
|
||
rdpScan=Tunnel RDP via SSH
|
||
wslX11SetupTitle=Configuration de WSL X11
|
||
wslX11SetupContent=XPipe peut utiliser ta distribution WSL locale pour faire office de serveur d'affichage X11. Tu veux configurer X11 sur $DIST$? Ça va installer les paquets X11 de base sur la distribution WSL et ça peut prendre un peu de temps. Tu peux aussi changer de distribution dans le menu des paramètres.
|
||
command=Commande
|
||
vncSystem=Système cible VNC
|
||
vncSystemDescription=Le système avec lequel on interagit réellement. C'est généralement le même que l'hôte du tunnel
|
||
vncHost=Hôte VNC cible
|
||
vncHostDescription=Le système sur lequel le serveur VNC est en cours d'exécution
|
||
vncDirectHost=Hôte
|
||
vncDirectHostDescription=L'entrée hôte ou l'adresse manuelle du serveur sur lequel le serveur VNC est en cours d'exécution
|
||
rdpDirectHost=Hôte
|
||
rdpDirectHostDescription=L'entrée hôte ou l'adresse manuelle du serveur sur lequel le serveur RDP est en cours d'exécution
|
||
gitVaultTitle=Vault Git
|
||
gitVaultForcePushContent=Tu veux forcer la mise en ligne vers le dépôt distant ? Ça va remplacer complètement tout le contenu du dépôt distant par celui de ton dépôt local, y compris l'historique.
|
||
gitVaultOverwriteLocalContent=Tu veux écraser les modifications apportées à ton vault local ? Ça va appliquer toutes les modifications à distance à ton dépôt local.
|
||
rdpSimple.displayName=Connexion RDP
|
||
rdpSimple.displayDescription=Se connecter à un système via RDP
|
||
rdpUsername=Nom d'utilisateur
|
||
rdpUsernameDescription=Le nom d'utilisateur avec lequel tu dois te connecter. Peut inclure un préfixe de domaine
|
||
addressDescription=Où se connecter
|
||
rdpAdditionalOptions=Options RDP supplémentaires
|
||
rdpAdditionalOptionsDescription=Options RDP brutes à inclure, au même format que dans les fichiers .rdp
|
||
proxmoxVncConfirmTitle=Accès VNC
|
||
proxmoxVncConfirmContent=Tu veux activer l'accès VNC pour la VM ? Ça va permettre un accès direct au client VNC dans le fichier de configuration de la VM $FILE$ et redémarrer la machine virtuelle.
|
||
dockerContext.displayName=Contexte Docker
|
||
dockerContext.displayDescription=Interagir avec des conteneurs situés dans un contexte spécifique
|
||
vmActions=Actions de la machine virtuelle
|
||
dockerContextActions=Actions contextuelles
|
||
k8sPodActions=Actions du pod
|
||
openVnc=Activer l'accès VNC
|
||
addVnc=Ajouter une connexion VNC
|
||
serial.displayName=Connexion série
|
||
serial.displayDescription=Ouvrir une connexion série dans un terminal
|
||
serialPort=Port série
|
||
serialPortDescription=Le port série / périphérique auquel se connecter
|
||
baudRate=Débit en bauds
|
||
dataBits=Bits de données
|
||
stopBits=Bits d'arrêt
|
||
parity=Parité
|
||
flowControlWindow=Contrôle de flux
|
||
serialImplementation=Implémentation série
|
||
serialImplementationDescription=L'outil à utiliser pour se connecter au port série
|
||
serialHost=Hôte
|
||
serialHostDescription=Le système sur lequel on accède au port série
|
||
serialPortConfiguration=Configuration du port série
|
||
serialPortConfigurationDescription=Paramètres de configuration du périphérique série connecté
|
||
serialInformation=Informations sur la connexion série
|
||
openXShell=Ouvrir dans XShell
|
||
tsh.displayName=Teleport
|
||
tsh.displayDescription=Connecte-toi à tes nœuds Teleport via tsh
|
||
tshNode.displayName=Nœud Teleport
|
||
#custom
|
||
tshNode.displayDescription=Se connecter à un nœud Teleport dans un cluster
|
||
teleportCluster=Cluster
|
||
#custom
|
||
teleportClusterDescription=Le cluster dans lequel se trouve le nœud
|
||
teleportProxy=Proxy
|
||
teleportProxyDescription=Le serveur proxy utilisé pour se connecter au nœud
|
||
teleportHost=Hôte
|
||
teleportHostDescription=Le nom d'hôte du nœud
|
||
teleportUser=Utilisateur
|
||
teleportUserDescription=Le nom d'utilisateur utilisé pour se connecter
|
||
login=Connexion
|
||
hyperVInstall.displayName=Hyper-V
|
||
hyperVInstall.displayDescription=Se connecter aux machines virtuelles gérées par Hyper-V
|
||
hyperVVm.displayName=Machine virtuelle Hyper-V
|
||
hyperVVm.displayDescription=Se connecter à une machine virtuelle Hyper-V via SSH ou PSSession
|
||
#custom
|
||
trustHost=Faire confiance à l'hôte
|
||
trustHostDescription=Ajouter ComputerName à la liste des hôtes de confiance
|
||
copyIp=Copier l'adresse IP
|
||
vncDirect.displayName=Connexion VNC
|
||
vncDirect.displayDescription=Se connecter à un système via VNC
|
||
editConfiguration=Modifier le fichier de configuration
|
||
#custom
|
||
viewInDashboard=Voir dans le tableau de bord
|
||
setDefault=Définir par défaut
|
||
removeDefault=Supprimer la valeur par défaut
|
||
connectAsOtherUser=Se connecter en tant qu'autre utilisateur
|
||
provideUsername=Indique un autre nom d'utilisateur pour te connecter
|
||
vmIdentity=Identité de l'invité
|
||
vmIdentityDescription=La méthode d'authentification par identité SSH à utiliser pour se connecter si nécessaire
|
||
vmPort=Port
|
||
vmPortDescription=Le port auquel se connecter via SSH
|
||
#custom
|
||
forwardAgent=Transférer l'agent
|
||
forwardAgentDescription=Rendre les identités de l'agent SSH disponibles sur le système distant
|
||
virshUri=URI
|
||
virshUriDescription=L'URI de l'hyperviseur ; les alias sont également pris en charge
|
||
virshDomain.displayName=domaine libvirt
|
||
virshDomain.displayDescription=Se connecter à un domaine libvirt
|
||
virshHypervisor.displayName=hyperviseur libvirt
|
||
virshHypervisor.displayDescription=Se connecter à un pilote d'hyperviseur pris en charge par libvirt
|
||
virshInstall.displayName=client en ligne de commande libvirt
|
||
virshInstall.displayDescription=Se connecter à tous les hyperviseurs libvirt disponibles via virsh
|
||
addHypervisor=Ajouter un hyperviseur
|
||
interactiveTerminal=Terminal interactif
|
||
editDomain=Modifier le domaine
|
||
libvirt=domaines libvirt
|
||
customIp=IP personnalisée
|
||
customIpDescription=Remplace la détection par défaut de l'adresse IP locale de la machine virtuelle si tu utilises des fonctionnalités réseau avancées
|
||
automaticallyDetect=Détecter automatiquement
|
||
userAddDialogTitle=Créer un nouvel utilisateur du coffre-fort
|
||
userEditDialogTitle=Modifier l'utilisateur du « vault »
|
||
roleAddDialogTitle=Créer un nouveau rôle
|
||
roleEditDialogTitle=Modifier un rôle
|
||
keyPassphrase=Phrase de passe de la clé
|
||
keyPassphraseDescription=La phrase de passe facultative pour ta clé
|
||
passphrase=Phrase de passe
|
||
newPassphrase=Nouveau mot de passe
|
||
repeatPassphrase=Confirme ton mot de passe
|
||
vaultRole=Rôle dans le coffre-fort
|
||
loginAlertTitle=Déverrouiller le coffre-fort
|
||
vaultUser=Utilisateur du Vault
|
||
me=Moi
|
||
addRole=Ajouter un rôle...
|
||
addRoleDescription=Crée un nouveau rôle pour ce coffre-fort
|
||
addUser=Ajouter un utilisateur...
|
||
addUserDescription=Créer une phrase de passe utilisateur pour ce coffre-fort
|
||
skip=Passer
|
||
userChangePasswordAlertTitle=Changement de mot de passe
|
||
roleChangeSecretAlertTitle=Changement de secret
|
||
docs=Documentation
|
||
lxd.displayName=Conteneur LXD
|
||
lxd.displayDescription=Se connecter à un conteneur LXD via lxc
|
||
lxdCmd.displayName=Client CLI LXD
|
||
lxdCmd.displayDescription=Accéder aux conteneurs LXD via le client CLI lxc
|
||
podman.displayName=Conteneur Podman
|
||
podman.displayDescription=Se connecter à un conteneur Podman
|
||
incusInstall.displayName=Incus Machine Manager
|
||
incusInstall.displayDescription=Accéder aux conteneurs Incus via le client CLI d'Incus
|
||
incusContainer.displayName=Conteneur Incus
|
||
incusContainer.displayDescription=Se connecter à un conteneur Incus
|
||
podmanCmd.displayName=Podman CLI
|
||
podmanCmd.displayDescription=Accéder aux conteneurs Podman via le client CLI
|
||
lxdHostDescription=L'hôte sur lequel se trouve le conteneur LXD. Il faut que lxc soit installé.
|
||
lxdContainerDescription=Le nom du conteneur LXD
|
||
podmanContainers=Conteneurs Podman
|
||
lxdContainers=Conteneurs LXD
|
||
incusContainers=Conteneurs Incus
|
||
container=Conteneur
|
||
containerDescription=L'identifiant du conteneur
|
||
host=Hôte
|
||
containerActions=Actions sur les conteneurs
|
||
serialConsole=Console série
|
||
editRunConfiguration=Modifier la configuration d'exécution
|
||
communityDescription=Un outil de connexion super pratique, parfait pour tes besoins personnels.
|
||
upgradeDescription=Une gestion professionnelle des connexions pour toute ton infrastructure de serveurs.
|
||
discoverPlans=Découvre les options de mise à niveau
|
||
extendProfessional=Passe aux dernières fonctionnalités professionnelles
|
||
communityItem1=Connexions illimitées à des systèmes et outils non commerciaux
|
||
communityItem2=Une intégration transparente avec tes terminaux et éditeurs déjà installés
|
||
communityItem3=Navigateur de fichiers à distance très complet
|
||
communityItem4=Un système de scripts puissant pour tous les shells
|
||
communityItem5=Intégration de Git pour la synchronisation et le partage des infos de connexion
|
||
upgradeItem1=Comprend toutes les fonctionnalités de l'édition Community
|
||
upgradeItem2=Le forfait Homelab prend en charge un nombre illimité d'hyperviseurs et propose des fonctionnalités SSH avancées
|
||
upgradeItem3=La formule « Professional » prend également en charge les systèmes d'exploitation et les outils d'entreprise
|
||
upgradeItem4=La formule Enterprise t'offre une flexibilité totale, adaptée à ton cas d'utilisation particulier
|
||
upgrade=Mise à niveau
|
||
upgradeTitle=Forfaits disponibles
|
||
status=Statut
|
||
type=Type
|
||
licenseAlertTitle=Licence requise
|
||
useCommunity=Continuer avec la version Community
|
||
previewDescription=Teste les nouvelles fonctionnalités pendant quelques semaines après leur sortie.
|
||
tryPreview=Activer l'aperçu
|
||
previewItem1=Accès complet aux nouvelles fonctionnalités professionnelles pendant 2 semaines après leur sortie
|
||
previewItem2=Essaie les nouvelles fonctionnalités sans engagement
|
||
licensedTo=Sous licence accordée à
|
||
email=Adresse e-mail
|
||
apply=Appliquer
|
||
clear=Effacer
|
||
activate=Activer
|
||
validUntil=Valable jusqu'au
|
||
licenseActivated=Licence activée
|
||
restart=Redémarrer
|
||
lockVault=Verrouiller le coffre-fort
|
||
restartApp=Redémarrer XPipe
|
||
free=Gratuit
|
||
upgradeInfo=Tu trouveras ci-dessous des informations sur la mise à niveau vers une licence.
|
||
upgradeInfoPreview=Tu trouveras ci-dessous des informations sur la mise à niveau vers une licence ou tu peux essayer la version d'aperçu.
|
||
enterLicenseKey=Saisis la clé de licence pour effectuer la mise à niveau
|
||
isOnlySupported=$FEATURE$ n'est pris en charge qu'avec au moins une licence « $TYPE$ »
|
||
#custom
|
||
areOnlySupported=$FEATURES$ ne sont pris en charge qu'avec au moins une licence « $TYPE$ »
|
||
legacyLicense=Cette licence ne comprenait que les nouvelles fonctionnalités de la version Professional sorties dans l'année suivant l'achat.
|
||
previewExpiredLicense=Cette fonctionnalité était récemment disponible gratuitement en avant-première, mais cette période est désormais terminée.
|
||
openApiDocs=Documentation de l'API
|
||
openApiDocsDescription=La documentation de l'API HTTP est disponible en ligne, y compris une spécification OpenAPI au format .yaml. Tu peux l'ouvrir dans ton navigateur web ou dans ton client HTTP préféré.
|
||
#custom
|
||
openApiDocsButton=Ouvrir la documentation
|
||
pythonApi=API Python
|
||
restrictedIdentity=L'accès à cette identité et aux connexions associées est limité aux rôles suivants :\n$ROLES$
|
||
restrictedConnection=L'accès à cette connexion et à tous ses éléments enfants est limité aux rôles suivants :\n$ROLES$
|
||
#custom
|
||
developerPrintInitFiles=Afficher l'exécution des fichiers d'initialisation
|
||
developerPrintInitFilesDescription=Affiche tous les scripts d'initialisation du shell qui s'exécutent au lancement d'un terminal.
|
||
developerShowSensitiveCommands=Enregistrer les données sensibles
|
||
developerShowSensitiveCommandsDescription=Inclure les commandes sensibles et les secrets dans les fichiers journaux pour le débogage.
|
||
#custom
|
||
developerShowOrderIndices=Afficher les indices de tri
|
||
developerShowOrderIndicesDescription=Afficher les indices de classement internes utilisés pour les connexions et les catégories dans le hub de connexion.
|
||
checkingForUpdates=Recherche de mises à jour
|
||
checkingForUpdatesDescription=Récupération des dernières informations sur la version
|
||
downloadingUpdate=Récupération de la version ( $VERSION$)
|
||
downloadingUpdateDescription=Téléchargement du pack de mise à jour
|
||
updateNag=Ça fait un moment que tu n'as pas mis à jour XPipe. Tu passes peut-être à côté des nouvelles fonctionnalités et des corrections apportées par les dernières versions.
|
||
updateNagTitle=Rappel de mise à jour
|
||
#custom
|
||
updateNagButton=Voir les versions
|
||
refreshServices=Actualiser les services
|
||
serviceProtocolType=Type de protocole de service
|
||
serviceProtocolTypeDescription=Gérer la manière d'ouvrir le service
|
||
serviceCommand=La commande à exécuter une fois que le service est actif
|
||
serviceCommandDescription=L'espace réservé $ADDRESS sera remplacé par l'adresse réelle
|
||
value=Valeur
|
||
showAdvancedOptions=Afficher les options avancées
|
||
sshAdditionalConfigOptions=Options de configuration supplémentaires
|
||
remoteFileManager=Gestionnaire de fichiers à distance
|
||
clearUserData=Supprimer les données utilisateur
|
||
clearUserDataDescription=Supprimer toutes les données de configuration de l'utilisateur, y compris les connexions
|
||
clearUserDataTitle=Suppression des données utilisateur
|
||
clearUserDataContent=Ça va supprimer toutes les données utilisateur locales de xpipe et redémarrer l'application. Si tes connexions te tiennent à cœur, pense à les synchroniser d'abord avec un dépôt Git.
|
||
undefined=Non défini
|
||
copyAddress=Copier l'adresse
|
||
netbirdDeviceScan=Connexions Netbird
|
||
netbirdId=Clé publique du pair
|
||
netbirdIdDescription=L'identifiant de clé publique interne Netbird du pair
|
||
tailscaleDeviceScan=Connexions Tailscale
|
||
tailscaleInstall.displayName=Installation de Tailscale
|
||
tailscaleInstall.displayDescription=Connecte-toi aux appareils de ton « tailnet » via SSH
|
||
tailscaleDevice.displayName=Appareil Tailscale
|
||
tailscaleDevice.displayDescription=Connecte-toi à un appareil de ton tailnet via SSH
|
||
tailscaleId=ID de l'appareil
|
||
tailscaleIdDescription=L'identifiant interne de l'appareil Tailscale
|
||
tailscaleHostName=Nom d'hôte
|
||
tailscaleHostNameDescription=Le nom d'hôte de l'appareil sur le tailnet
|
||
tailscaleUsername=Nom d'utilisateur
|
||
tailscaleUsernameDescription=L'utilisateur sous lequel se connecter
|
||
tailscalePassword=Mot de passe
|
||
tailscalePasswordDescription=Le mot de passe utilisateur qui peut être utilisé pour sudo
|
||
scriptName=Nom du script
|
||
scriptNameDescription=Donne un nom personnalisé à ce script
|
||
scriptTemplateNameDescription=Enregistre une copie de ce modèle de script sous un nom de ton choix
|
||
identityName=Nom d'identité
|
||
identityNameDescription=Donne un nom personnalisé à cette identité
|
||
identityTemplateNameDescription=Enregistre une copie de ce modèle d'identité sous un nom de ton choix
|
||
tailscaleTailnet.displayName=Tailnet
|
||
tailscaleTailnet.displayDescription=Connecte-toi à un tailnet spécifique avec ton compte
|
||
puttyConnections=Connexions PuTTY
|
||
kittyConnections=Connexions KiTTY
|
||
icons=Icônes
|
||
customIcons=Icônes personnalisées
|
||
iconSources=Sources des icônes
|
||
iconSourcesDescription=Tu peux ajouter ici tes propres sources d'icônes. XPipe détectera tous les fichiers .svg présents à l'emplacement indiqué et les ajoutera à la liste des icônes disponibles.\n\nLes répertoires locaux et les dépôts Git distants sont tous deux pris en charge comme emplacements d'icônes.
|
||
refreshSources=Actualiser les icônes
|
||
refreshSourcesDescription=Mettre à jour toutes les icônes à partir des sources disponibles
|
||
addDirectoryIconSource=Ajouter une source de répertoire...
|
||
addDirectoryIconSourceDescription=Ajouter des icônes à partir d'un répertoire local
|
||
#custom
|
||
addGitIconSource=Ajouter une source git ...
|
||
addGitIconSourceDescription=Ajouter des icônes situées dans un dépôt Git distant
|
||
repositoryUrl=URL du dépôt Git
|
||
iconDirectory=Répertoire d'icônes
|
||
addUnsupportedKexMethod=Ajouter une méthode d'échange de clés non prise en charge
|
||
addUnsupportedKexMethodDescription=Autorise l'utilisation de la méthode d'échange de clés « $VAL$ » pour cette connexion
|
||
addUnsupportedHostKeyType=Ajouter un type de clé hôte non pris en charge
|
||
addUnsupportedHostKeyTypeDescription=Autorise l'utilisation du type de clé hôte « $VAL$ » pour cette connexion
|
||
addUnsupportedMacType=Ajouter un type de MAC non pris en charge
|
||
#custom
|
||
addUnsupportedMacTypeDescription=Autoriser l'utilisation du type MAC $VAL$ pour cette connexion
|
||
addUnsupportedCipher=Ajouter un algorithme de chiffrement non pris en charge
|
||
#custom
|
||
addUnsupportedCipherDescription=Autoriser l'utilisation de l'algorithme de chiffrement $VAL$ pour cette connexion
|
||
runSilent=en arrière-plan, sans que tu t'en rendes compte
|
||
runInFileBrowser=dans un explorateur de fichiers
|
||
runInConnectionHub=dans le hub de connexion
|
||
commandOutput=Résultat d'une commande
|
||
iconSourceDeletionTitle=Supprimer la source de l'icône
|
||
iconSourceDeletionContent=Tu veux supprimer cette source d'icônes et toutes les icônes qui y sont associées ?
|
||
refreshIcons=Actualiser les icônes
|
||
refreshIconsDescription=Récupération, rendu et mise en cache de toutes les icônes disponibles (plus de 1 000) provenant de sources externes sous forme de fichiers .png. Ça va prendre un peu de temps...
|
||
refreshIconsIntro=Télécharger des icônes
|
||
refreshIconsIntroDescription=Ici, tu peux définir des icônes personnalisées pour tes connexions. Il faut d'abord télécharger le jeu d'icônes par défaut. Tu peux aussi configurer des sources d'icônes personnalisées dans le menu des paramètres.
|
||
#custom
|
||
vaultUserLegacy=Utilisateur du coffre-fort (mode de compatibilité héritée limité)
|
||
upgradeInstructions=Instructions de mise à niveau
|
||
externalActionTitle=Demande d'action externe
|
||
externalActionContent=Une action externe a été demandée. Tu veux autoriser le lancement d'actions depuis l'extérieur de XPipe ?
|
||
externalUrlTitle=Demande d'action vers une URL externe
|
||
externalUrlContent=Une action URL externe a été ouverte. Tu veux autoriser le lancement d'URL depuis l'extérieur de XPipe à l'avenir ?
|
||
noScriptStateAvailable=Actualiser pour vérifier la compatibilité du script...
|
||
documentationDescription=Consulte la documentation
|
||
customEditorCommandInTerminal=Exécuter une commande personnalisée dans un terminal
|
||
customEditorCommandInTerminalDescription=Si ton éditeur fonctionne en mode terminal, tu peux activer cette option pour ouvrir automatiquement un terminal et exécuter la commande dans la session de terminal à la place.\n\nTu peux utiliser cette option avec des éditeurs comme vi, vim, nvim et d'autres.
|
||
disableHttpsTlsCheck=Désactiver la vérification du certificat des requêtes HTTPS
|
||
disableHttpsTlsCheckDescription=Si ton entreprise déchiffre ton trafic HTTPS au niveau des pare-feu à l'aide de l'interception SSL, toutes les requêtes HTTP échoueront à moins que les certificats ne soient considérés comme fiables. Tu peux activer cette option et désactiver la validation des certificats TLS à des fins de test si quelque chose ne fonctionne pas comme prévu avec les certificats personnalisés.
|
||
noProxy=Pas de proxy
|
||
noProxyDescription=N'utilise pas de serveur proxy pour les adresses correspondant aux valeurs suivantes
|
||
connectionsSelected=$NUMBER$ connexions sélectionnées
|
||
addConnections=Ajouter des connexions
|
||
browseDirectory=Parcourir le répertoire
|
||
openTerminal=Ouvrir un terminal
|
||
#custom
|
||
documentation=Documentation
|
||
report=Signaler une erreur
|
||
keePassXcLocation=Emplacement d'installation
|
||
keePassXcLocationDescription=L'emplacement personnalisé facultatif de l'installation de KeePassXc si l'installation existante ne peut pas être détectée automatiquement ou si tu souhaites en utiliser une autre.
|
||
keePassXcNotAssociated=Lien vers KeePassXC
|
||
keePassXcNotAssociatedDescription=XPipe n'est pas associé à ta base de données KeePassXC locale. Clique ci-dessous pour effectuer cette opération ponctuelle qui consiste à associer XPipe à la base de données KeePassXC afin que XPipe puisse récupérer tes mots de passe.
|
||
keePassXcAssociateMore=Connecte davantage de bases de données
|
||
keePassXcAssociateMoreDescription=Tu peux être connecté à plusieurs bases de données KeePassXC en même temps
|
||
keePassXcAssociated=Liens vers KeePassXC
|
||
keePassXcAssociatedDescription=XPipe est connecté aux bases de données KeePassXC locales suivantes :
|
||
keePassXcNotAssociatedButton=Lier la base de données
|
||
identifier=Identifiant
|
||
#custom
|
||
passwordManagerMapping=Mappage personnalisé des clés
|
||
passwordManagerMappingDescription=Les données JSON peuvent stocker n'importe quelle entrée clé-valeur ; tu devras donc définir un mappage permettant à XPipe de trouver, à partir de certaines clés, des entrées spécifiques telles que le nom d'utilisateur, le mot de passe et les clés SSH. Le mappage par défaut peut être remplacé par des identités individuelles si nécessaire.
|
||
passwordManagerCommand=Commande personnalisée
|
||
passwordManagerCommandDescription=La commande personnalisée à exécuter pour récupérer les mots de passe. La chaîne de caractères $KEY sera remplacée par la clé de mot de passe entre guillemets lors de l'appel. Ça devrait lancer l'interface en ligne de commande de ton gestionnaire de mots de passe pour afficher le mot de passe brut ou les identifiants au format JSON sur la sortie standard.
|
||
chooseTemplate=Choisis un modèle
|
||
keePassXcPlaceholder=URL d'une entrée KeePassXC
|
||
terminalEnvironment=Environnement de terminal
|
||
terminalEnvironmentDescription=Si tu veux utiliser les fonctionnalités d'un environnement WSL local sous Linux pour personnaliser ton terminal, tu peux l'utiliser comme environnement de terminal.\n\nToutes les commandes d'initialisation personnalisées du terminal et la configuration du multiplexeur de terminaux seront alors exécutées dans cette distribution WSL.
|
||
terminalInitScript=Script d'initialisation du terminal
|
||
terminalInitScriptDescription=Commandes à exécuter dans l'environnement du terminal avant le lancement de la connexion. Tu peux t'en servir pour configurer l'environnement du terminal au démarrage.
|
||
terminalMultiplexer=Multiplexeur de terminaux
|
||
terminalMultiplexerDescription=Le multiplexeur de terminal à utiliser à la place des onglets dans un terminal. Ça va remplacer certaines fonctionnalités de gestion du terminal, comme la gestion des onglets, par les fonctionnalités du multiplexeur.\n\nIl faut que le fichier exécutable du multiplexeur soit installé sur le système.
|
||
terminalMultiplexerWindowsDescription=Le multiplexeur de terminal à utiliser à la place des onglets dans un terminal. Ça va remplacer certaines fonctionnalités du terminal, comme la gestion des onglets, par les fonctionnalités du multiplexeur.\n\nÇa nécessite d'utiliser un environnement de terminal WSL sous Windows et d'installer le fichier exécutable du multiplexeur sur le système WSL.
|
||
terminalAlwaysPauseOnExit=Toujours faire une pause à la fermeture
|
||
terminalAlwaysPauseOnExitDescription=Quand cette option est activée, quand tu quittes une session de terminal, on te demandera toujours si tu veux redémarrer ou fermer la session. Si elle est désactivée, XPipe ne te le demandera que pour les connexions qui ont échoué et qui se terminent par une erreur.
|
||
querying=Requête en cours...
|
||
queryFailed=La requête n'a renvoyé aucun secret exploitable
|
||
retrievedPassword=Obtenu : $PASSWORD$
|
||
refreshOpenpubkey=Actualiser l'identité openpubkey
|
||
refreshOpenpubkeyDescription=Lance la commande « opkssh refresh » pour que l'identité openpubkey soit à nouveau valide
|
||
all=Tout
|
||
terminalPrompt=Invite du terminal
|
||
terminalPromptDescription=L'outil d'invite de terminal à utiliser sur tes terminaux distants. L'activation d'une invite de terminal va automatiquement installer et configurer l'outil d'invite sur le système cible à l'ouverture d'une session de terminal.\n\nÇa ne modifie aucune configuration d'invite existante ni aucun fichier de profil sur le système. Ça va augmenter le temps de chargement du terminal la première fois, le temps que l'invite soit installée sur le système distant. Ton terminal aura peut-être besoin de polices supplémentaires pour afficher correctement l'invite.
|
||
terminalPromptConfiguration=Configuration de l'invite du terminal
|
||
terminalPromptConfig=Fichier de configuration
|
||
terminalPromptConfigDescription=Le fichier de configuration personnalisé à appliquer à l'invite de commande. Cette configuration sera automatiquement mise en place sur le système cible lors de l'initialisation du terminal et servira de configuration par défaut pour l'invite de commande.\n\nSi tu veux utiliser le fichier de configuration par défaut existant sur chaque système, tu peux laisser ce champ vide.
|
||
passwordManagerKey=Entrée d'identifiants
|
||
passwordManagerKeyDescription=L'identifiant de l'entrée d'identifiants permettant de fournir un nom d'utilisateur et un mot de passe
|
||
passwordManagerPasswordKey=Entrée d'identifiants
|
||
passwordManagerPasswordKeyDescription=L'identifiant de l'entrée d'identifiants permettant de fournir le mot de passe
|
||
passwordManagerAgent=Agent de gestion des mots de passe
|
||
passwordManagerInPlaceKey=Gestionnaire de mots de passe
|
||
passwordManagerInPlaceKeyKey=Identifiant du gestionnaire de mots de passe pour l'entrée de clé SSH
|
||
dockerComposeProject.displayName=Projet Docker Compose
|
||
dockerComposeProject.displayDescription=Regrouper les conteneurs d'un projet Compose
|
||
sshVerboseOutput=Activer le mode détaillé de SSH
|
||
sshVerboseOutputDescription=Ça va afficher plein d'infos de débogage quand tu te connectes via SSH. C'est utile pour résoudre les problèmes liés aux connexions SSH.
|
||
dontUseGateway=N'utilise pas de passerelle
|
||
dontUseGatewayDescription=N'utilise pas l'hôte de l'hyperviseur comme passerelle et connecte-toi directement à l'adresse IP
|
||
categoryColor=Couleur de catégorie
|
||
categoryColorDescription=La couleur par défaut à utiliser pour les connexions de cette catégorie
|
||
categorySync=Synchronisation avec le dépôt Git
|
||
categorySyncDescription=Synchronise automatiquement toutes les connexions avec le dépôt Git. Toutes les modifications locales apportées aux connexions seront poussées vers le serveur distant.
|
||
categorySyncSpecial=Synchronisation avec le dépôt Git\n(Non configurable pour la catégorie spéciale «$NAME$ »)
|
||
categoryDontAllowScripts=Désactiver toutes les modifications
|
||
categoryDontAllowScriptsDescription=Désactive toute exécution de commandes et autres opérations sur les systèmes de cette catégorie pour empêcher toute modification. Ça désactivera toutes les fonctionnalités de script, les commandes de l'environnement shell, les invites de commande, et bien plus encore.
|
||
categoryConfirmAllModifications=Confirme toutes les modifications
|
||
categoryConfirmAllModificationsDescription=Vérifie d'abord toute modification apportée à une connexion ou à un système de fichiers. Ça permet d'éviter les opérations accidentelles sur des systèmes importants.
|
||
categoryDefaultIdentity=Identité par défaut
|
||
categoryDefaultIdentityDescription=Si tu utilises souvent une certaine identité sur plusieurs systèmes de cette catégorie, définir une identité par défaut te permettra de la présélectionner lors de la création de nouvelles connexions.
|
||
categoryDefaultGateway=Passerelle par défaut
|
||
categoryDefaultGatewayDescription=Utilise par défaut le système de passerelle spécifié pour toutes les connexions de cette catégorie si aucune autre passerelle n'est indiquée pour une connexion.
|
||
#custom
|
||
categoryConfigTitle=Configuration de $NAME$
|
||
configure=Configurer
|
||
addConnection=Ajouter une connexion
|
||
noCompatibleConnection=Aucune connexion compatible trouvée
|
||
noCompatibleIdentity=Aucune identité compatible trouvée
|
||
newCategory=Nouvelle catégorie
|
||
dockerComposeRestricted=Le projet Compose est verrouillé par $NAME$ et ne peut pas être modifié depuis l'extérieur. Utilise $NAME$ pour gérer ce projet Compose.
|
||
restricted=Accès restreint
|
||
restrictedAccess=Accès restreint
|
||
disableSshPinCaching=Désactiver la mise en cache du code PIN SSH
|
||
disableSshPinCachingDescription=XPipe mettra automatiquement en cache tous les codes PIN saisis pour une clé lorsque tu utilises une forme d'authentification matérielle.\n\nSi tu désactives cette option, tu devras ressaisir le code PIN à chaque tentative de connexion.
|
||
#custom
|
||
gitSyncPull=Fais un pull pour synchroniser les modifications Git distantes
|
||
#custom
|
||
enpassVaultFile=Fichier du coffre-fort
|
||
enpassVaultFileDescription=Le fichier « Vault » local d'Enpass.
|
||
flat=Plat
|
||
recursive=Récursif
|
||
rdpAllowListBlocked=L'application RemoteApp sélectionnée ne figure pas dans la liste blanche RDP du serveur et ne peut pas être lancée.
|
||
passworkServerUrl=URL du serveur
|
||
passworkServerUrlDescription=URL du serveur de gestion des mots de passe
|
||
passworkAccessToken=Jeton d'accès à l'API
|
||
passworkAccessTokenDescription=Le jeton d'accès à l'API à utiliser
|
||
passworkMasterKey=Clé principale de l'API
|
||
passworkMasterKeyDescription=La clé principale de l'API à utiliser. Cette valeur peut ne pas être nécessaire, selon que tu utilises le chiffrement côté client ou côté serveur dans Passwork
|
||
psonoServerUrl=URL du serveur
|
||
psonoServerUrlDescription=URL du serveur backend psono
|
||
psonoApiKey=Clé API
|
||
psonoApiKeyDescription=La clé API à utiliser, au format uuid
|
||
psonoApiSecretKey=Clé secrète de l'API
|
||
psonoApiSecretKeyDescription=La clé secrète de l'API sous forme de chaîne hexadécimale de 64 octets
|
||
passboltServerUrl=URL du serveur
|
||
passboltServerUrlDescription=URL du serveur backend de Passbolt
|
||
passboltPassphrase=Phrase de passe
|
||
passboltPassphraseDescription=La phrase de passe de la clé privée du coffre-fort
|
||
passboltPrivateKey=Clé privée
|
||
passboltPrivateKeyDescription=Le fichier de clé privée GPG du coffre-fort
|
||
focusWindowOnNotifications=Mettre la fenêtre au premier plan lors des notifications
|
||
focusWindowOnNotificationsDescription=Fais passer XPipe au premier plan lorsqu'une notification ou un message d'erreur s'affiche, par exemple lorsqu'une connexion ou un tunnel se termine de manière inattendue.
|
||
gitUsername=Nom d'utilisateur Git personnalisé
|
||
gitUsernameDescription=L'utilisateur personnalisé à utiliser pour s'authentifier auprès du dépôt Git distant. Par défaut, XPipe utilisera les identifiants actuellement configurés pour la ligne de commande Git.\n\nCe paramètre remplacera les identifiants par défaut déjà configurés pour ton client Git local.
|
||
gitPassword=Mot de passe Git personnalisé / jeton d'accès personnel
|
||
gitPasswordDescription=Le mot de passe ou le jeton d'accès personnel à utiliser pour t'authentifier. Le fait que tu aies besoin d'un mot de passe ou d'un jeton d'accès personnel dépend du fournisseur Git distant. Ce paramètre remplacera les identifiants par défaut déjà configurés pour ton client CLI Git local.
|
||
gitPasswordValue=Mot de passe / jeton d'accès personnel
|
||
setReadOnly=Définir en lecture seule
|
||
unsetReadOnly=Désactiver le mode lecture seule
|
||
categoryFreeze=Figer les configurations de connexion
|
||
categoryFreezeDescription=Marque les configurations de connexion comme étant en lecture seule. Ça veut dire qu'aucune configuration de connexion existante de cette catégorie ne peut être modifiée. Par contre, tu peux ajouter de nouvelles connexions.
|
||
updateFail=L'installation de la mise à jour a échoué
|
||
updateReinstallAction=Effectuer une réinstallation propre
|
||
updateReinstallActionDescription=Réinstalle XPipe au lieu de faire une mise à jour incrémentielle, tes données seront conservées
|
||
updateFailAction=Installer la mise à jour manuellement
|
||
updateFailActionDescription=Découvre les dernières versions sur GitHub
|
||
onePasswordPlaceholder=Nom de l'élément | URL op://
|
||
computeDirectorySizes=Calculer la taille des répertoires
|
||
computeSize=Calculer la taille
|
||
customSpiceCommand=Commande personnalisée
|
||
customSpiceCommandDescription=La commande personnalisée à exécuter pour lancer des sessions SPICE. La chaîne de caractères $FILE sera remplacée par le chemin d'accès au fichier .vv, entre guillemets, lors de l'appel de la commande.
|
||
vncClient=Client VNC
|
||
vncClientDescription=Le client VNC à lancer lors de l'ouverture de connexions VNC dans XPipe.\n\nTu as le choix entre utiliser le client VNC intégré à XPipe ou, si tu souhaites davantage de personnalisation, lancer un client VNC externe installé localement.
|
||
integratedXPipeVncClient=Client VNC XPipe intégré
|
||
customVncCommand=Commande personnalisée
|
||
customVncCommandDescription=La commande personnalisée à exécuter pour lancer des sessions VNC. La chaîne de caractères $ADDRESS sera remplacée par l'adresse entre guillemets lors de l'appel.
|
||
vncConnections=Connexions VNC
|
||
passwordManagerIdentity=Identité du gestionnaire de mots de passe
|
||
passwordManagerIdentity.displayName=Identité du gestionnaire de mots de passe
|
||
passwordManagerIdentity.displayDescription=Récupérer les identifiants d'une identité depuis ton gestionnaire de mots de passe
|
||
passwordCopied=Mot de passe de connexion copié dans le presse-papiers
|
||
macroAdd=Ajouter une macro
|
||
macroName=Nom de la macro
|
||
macroNameDescription=Donne un nom personnalisé à cette macro
|
||
actionId=ID d'action
|
||
actionIdDescription=L'action à exécuter avec cette macro
|
||
macroRefs=Connexions associées
|
||
macroRefsDescription=Les connexions à utiliser pour exécuter l'action
|
||
connectionCopy=Copie
|
||
actionPickerTitle=Choisis une action
|
||
actionPickerDescription=Clique sur un élément pour effectuer une action. Au lieu d'exécuter l'action, tu peux créer et modifier des raccourcis vers cette action en mode de sélection des raccourcis d'action.
|
||
cancelActionPicker=Annuler la sélection d'action
|
||
actionShortcut=Raccourci d'action
|
||
actionShortcuts=Raccourcis d'action
|
||
actionStore=Magasin d'actions
|
||
actionStoreDescription=L'entrée du magasin sur laquelle l'action doit être exécutée
|
||
actionStores=Magasins d'actions
|
||
#custom
|
||
actionStoresDescription=Les entrées sur lesquelles exécuter l'action
|
||
actionDesktopShortcut=Raccourci sur le bureau
|
||
actionDesktopShortcutDescription=Crée un raccourci pour cette action sur ton bureau
|
||
actionCommand=Ligne de commande
|
||
actionCommandDescription=La commande à lancer pour effectuer cette action
|
||
actionUrlShortcut=Raccourci URL
|
||
actionUrlShortcutDescription=Copie une URL qui peut déclencher ces actions quand tu l'ouvres
|
||
actionUrlShortcutDisabled=Lien raccourci (indisponible)
|
||
actionUrlShortcutDisabledDescription=Le type d'installation « $TYPE$ » ne prend pas en charge l'ouverture d'URL
|
||
actionApiCall=Demande API
|
||
actionApiCallDescription=Lance cette action depuis l'API HTTP
|
||
actionMacro=Macro d'action
|
||
actionMacroDescription=Crée une macro avec des fonctionnalités avancées pour cette action
|
||
createMacro=Créer une macro
|
||
actionConfiguration=Paramètres
|
||
actionConfigurationDescription=Les paramètres à transmettre à l'action exécutée
|
||
confirmAction=Confirmer l'action
|
||
actionConnections=Connexions d'actions
|
||
actionConnectionsDescription=Les connexions sur lesquelles exécuter l'action
|
||
actionConnection=Connexion d'action
|
||
actionConnectionDescription=La connexion sur laquelle exécuter l'action
|
||
appleContainerInstall.displayName=Conteneurs Apple
|
||
appleContainerInstall.displayDescription=Accéder aux instances de conteneurs Apple via l'interface en ligne de commande (CLI) des conteneurs
|
||
appleContainer.displayName=Conteneur Apple
|
||
appleContainer.displayDescription=Accéder aux instances de conteneurs Apple via l'interface en ligne de commande (CLI) des conteneurs
|
||
appleContainerHostDescription=L'hôte sur lequel se trouve le conteneur Apple
|
||
appleContainerDescription=Le nom du conteneur Apple
|
||
appleContainers=Conteneurs Apple
|
||
category=Catégorie
|
||
includeRoot=Inclure la racine
|
||
excludeRoot=Exclure la racine
|
||
templateConfiguration=Créer un modèle
|
||
untemplateConfiguration=Supprimer le modèle
|
||
template=Modèle
|
||
actionApiUrl=$URL$ (Copier le corps JSON)
|
||
copyBody=Copier le corps de la requête
|
||
gitRepoTerminalOpen=Ouvrir le dépôt dans le terminal
|
||
gitRepoTerminalOpenDescription=Jette un œil au dépôt toi-même avec la ligne de commande
|
||
gitRepoOverwriteLocal=Écraser les modifications locales
|
||
gitRepoOverwriteLocalDescription=Remplacer toutes les modifications locales par celles du serveur distant
|
||
gitRepoForcePush=Remplacer les modifications à distance
|
||
gitRepoForcePushDescription=Utilise la commande « git push --force » pour appliquer tes modifications locales au dépôt distant
|
||
gitRepoDontWarn=Ne m'avertis plus
|
||
gitRepoDontWarnDescription=Si c'est normal, fais en sorte que XPipe ignore cette erreur à l'avenir
|
||
gitRepoTryAgain=Réessaie
|
||
gitRepoTryAgainDescription=Réessaie la même opération
|
||
gitRepoEnablePlain=Utiliser la synchronisation simple des répertoires
|
||
gitRepoEnablePlainDescription=N'initialise pas de dépôt Git pour synchroniser les modifications dans le répertoire
|
||
gitRepoCreateBare=Utilise git sync
|
||
gitRepoCreateBareDescription=Initialiser un nouveau dépôt Git « bare » dans le répertoire « sync »
|
||
gitRepoDisable=Désactive le « git vault » pour l'instant
|
||
gitRepoDisableDescription=Ne valide aucune modification pendant cette session
|
||
gitRepoPullRefresh=Récupérer les modifications et actualiser
|
||
gitRepoPullRefreshDescription=Fusionner les modifications à distance et recharger les données
|
||
#custom
|
||
breakOutCategory=Séparer dans une catégorie distincte
|
||
mergeCategory=Fusionner une catégorie
|
||
openWinScp=Ouvrir dans WinSCP
|
||
uninstallApplication=Désinstaller
|
||
uninstallApplicationDescription=Exécute le script de désinstallation fourni pour désinstaller complètement XPipe
|
||
k8sEditPodTitle=Appliquer les modifications
|
||
k8sEditPodContent=Tu veux appliquer les modifications effectuées via la commande kubectl apply ? Un redémarrage du pod sera probablement nécessaire pour que les modifications prennent effet.
|
||
virshEditDomainTitle=Appliquer les modifications
|
||
virshEditDomainContent=Tu veux appliquer les modifications au domaine ? Un redémarrage du domaine sera probablement nécessaire pour que les modifications prennent effet.
|
||
pkcs11Impl=Implémentation PKCS#11
|
||
pkcs11ImplDescription=L'implémentation PKCS#11 à utiliser pour récupérer les clés matérielles
|
||
pkcs11Library=Bibliothèque PKCS#11
|
||
pkcs11LibraryDescription=Le chemin d'accès au fichier de bibliothèque liée dynamiquement
|
||
sshAgentSocket=Socket d'agent SSH personnalisée
|
||
sshAgentSocketDescription=Le socket personnalisé à utiliser pour communiquer avec l'agent SSH. Cet agent personnalisé peut être utilisé pour une connexion en sélectionnant l'option d'agent personnalisé correspondante.
|
||
publicKey=Sélecteur de clé
|
||
publicKeyDescription=La clé publique facultative qui oblige l'agent à ne proposer que la clé privée correspondante
|
||
publicKeyRequired=Sélecteur de clé
|
||
publicKeyRequiredDescription=La clé publique pour forcer l'agent à ne proposer que la clé privée correspondante
|
||
agentKeyName=Sélecteur de clé
|
||
agentKeyNameDescription=Le nom de l'entrée de clé SSH dans l'agent du gestionnaire de mots de passe
|
||
actions=Actions
|
||
hcloudServer.displayName=Serveur cloud Hetzner
|
||
hcloudServer.displayDescription=Accéder à un serveur hébergé sur le cloud Hetzner via SSH
|
||
hcloudInstall.displayName=CLI Hetzner Cloud
|
||
#custom
|
||
hcloudInstall.displayDescription=Accède aux serveurs hébergés sur le cloud Hetzner via hcloud
|
||
hcloudContext.displayName=Contexte hcloud
|
||
#custom
|
||
hcloudContext.displayDescription=Accéder aux serveurs d'un contexte hcloud
|
||
metrics=Indicateurs
|
||
#custom
|
||
openInVsCode=Ouvrir dans VSCode
|
||
addCloud=Cloud...
|
||
hcloudToken=jeton hcloud
|
||
hcloudTokenDescription=Le jeton cloud Hetzner à utiliser. Pour plus d'infos, consulte la documentation
|
||
hcloudLogin=Connexion au cloud Hetzner
|
||
clearHcloudToken=Effacer le jeton hcloud
|
||
clearHcloudTokenDescription=Supprime le jeton existant pour pouvoir te reconnecter
|
||
selectIdentity=Sélectionner une identité
|
||
enableMcpServer=Activer le serveur MCP
|
||
enableMcpServerDescription=Active le serveur XPipe MCP, ce qui permet aux clients MCP externes d'envoyer des requêtes au serveur MCP. Tu trouveras ci-dessous les détails de configuration.
|
||
enableMcpMutationTools=Activer les outils de mutation MCP
|
||
enableMcpMutationToolsDescription=Par défaut, seuls les outils en lecture seule sont activés sur le serveur MCP. Ça permet d'éviter toute opération accidentelle susceptible de modifier le système.\n\nSi tu prévois d'apporter des modifications aux systèmes via des clients MCP, assure-toi que ton client MCP est configuré pour te demander de confirmer toute action potentiellement destructrice avant d'activer cette option. Une reconnexion de tous les clients MCP est nécessaire pour que cette modification prenne effet.
|
||
mcpClientConfigurationDetails=Configuration du client MCP
|
||
mcpClientConfigurationDetailsDescription=Utilise ces données de configuration pour te connecter au serveur XPipe MCP depuis le client MCP de ton choix.
|
||
switchHostAddress=Changer l'adresse de l'hôte
|
||
addAnotherHostName=Ajouter un autre nom d'hôte
|
||
addNetwork=Analyse du réseau local...
|
||
networkScan=Analyse du réseau local
|
||
networkScanStore=Hôte cible
|
||
networkScanStoreDescription=L'hôte pour lequel tu veux analyser le réseau local
|
||
useAsGateway=Utiliser l'hôte comme passerelle
|
||
useAsGatewayDescription=Indique si l'hôte cible doit servir de passerelle pour les connexions établies
|
||
resolveIpAddresses=Trouver les noms d'hôtes correspondant aux adresses IP
|
||
resolveIpAddressesDescription=Convertir les adresses IP trouvées en noms DNS à l'aide d'une recherche DNS inversée
|
||
networkScanType=Type de connexion
|
||
networkScanTypeDescription=Le type de connexion et les ports associés à rechercher
|
||
networkScanBroadcastAddress=Adresse de diffusion
|
||
networkScanBroadcastAddressDescription=L'adresse à pinguer pour afficher la liste des appareils disponibles
|
||
emptyDirectory=Ce répertoire a l'air vide
|
||
emptyFilteredDirectory=Aucun fichier correspondant n'a été trouvé dans le répertoire
|
||
hcloudConfigFile=fichier de configuration hcloud
|
||
hcloudConfigFileDescription=L'emplacement du fichier de configuration .toml de l'interface CLI de hcloud
|
||
preferMonochromeIcons=Privilégie les icônes monochromes
|
||
preferMonochromeIconsDescription=Quand cette option est activée, les variables d'icônes monochromes seront privilégiées par rapport aux versions colorées par défaut d'une icône, à condition qu'une variante d'icône en mode clair ou foncé soit disponible pour une icône provenant d'une source.\n\nIl faut actualiser les icônes pour que ça s'applique.
|
||
manageSubscription=Gérer l'abonnement
|
||
noListeningServer=Pas de serveur à l'écoute
|
||
networkScanResults=Résultats de l'analyse
|
||
networkScanResultsDescription=La liste des systèmes détectés sur le réseau
|
||
localShellDialect=Shell local
|
||
localShellDialectDescription=Le shell utilisé pour les opérations locales. Si le shell local par défaut est désactivé ou ne fonctionne pas correctement, cette option permet de basculer vers un autre shell.\n\nCertaines configurations, comme les entrées PATH personnalisées, peuvent ne pas s'appliquer au shell de secours si elles n'ont pas encore été définies dans les fichiers de profil du shell concerné.
|
||
agentSocketNotFound=Aucun socket d'agent actif n'a été trouvé
|
||
agentSocket=Emplacement du socket
|
||
agentSocketDescription=Le chemin d'accès au fichier du socket de l'agent
|
||
agentSocketNotConfigured=Aucun socket personnalisé n'a encore été configuré
|
||
downloadInProgress=$NAME$ téléchargement en cours
|
||
enableTerminalStartupBell=Activer la sonnerie de démarrage du terminal
|
||
enableTerminalStartupBellDescription=Lance une commande de bip/sonnerie dans une nouvelle session de terminal. Si ton émulateur de terminal prend en charge les sonneries, ça peut t'aider à repérer plus facilement les instances de terminal qui viennent d'être lancées.
|
||
invalidSshGatewayChain=Configuration de chaîne de passerelles mixte non valide, comprenant à la fois des passerelles de saut et des passerelles non-saut.
|
||
syncFileExists=Le fichier synchronisé « $FILE$ » existe déjà
|
||
replaceFile=Remplacer le fichier
|
||
replaceFileDescription=Remplace le fichier existant par celui-ci
|
||
renameFile=Renommer un fichier
|
||
renameFileDescription=Renomme ce fichier pour le synchroniser
|
||
newFileName=Nouveau nom de fichier
|
||
#custom
|
||
parentHostDoesNotSupportTunneling=L'hôte parent $NAME$ ne prend pas en charge le tunneling
|
||
connectionNotesTemplate=Modèle de notes
|
||
connectionNotesTemplateDescription=Le modèle Markdown à utiliser quand tu ajoutes une nouvelle note à une connexion.
|
||
connectionNotesButton=Modifier les notes
|
||
rdpSmartSizing=Activer le redimensionnement intelligent
|
||
rdpSmartSizingDescription=Quand cette option est activée, mstsc réduit la taille du bureau si la fenêtre est trop petite pour l'afficher en pleine résolution. Le format d'image du bureau est conservé lors de la réduction.
|
||
disableStartOnInit=Désactiver le démarrage automatique
|
||
enableStartOnInit=Activer le démarrage automatique
|
||
fileReadSudoTitle=Lecture d'un fichier Sudo
|
||
fileReadSudoContent=Le fichier que tu essaies de lire ne t'accorde pas les droits de lecture en tant qu'utilisateur actuel. Tu veux lire ce fichier en tant qu'utilisateur root avec sudo ? Ça te fera automatiquement passer en mode root, soit avec les identifiants existants, soit via une invite.
|
||
netbirdInstall.displayName=Installation de Netbird
|
||
netbirdInstall.displayDescription=Connecte-toi aux pairs de ton réseau Netbird
|
||
netbirdProfile.displayName=Profil Netbird
|
||
netbirdProfile.displayDescription=Lister les pairs d'un profil spécifique
|
||
netbirdPeer.displayName=Pair Netbird
|
||
netbirdPeer.displayDescription=Se connecter à un pair via SSH
|
||
netbirdPublicKey=Clé publique
|
||
netbirdPublicKeyDescription=La clé publique interne du pair
|
||
netbirdHostName=Nom d'hôte
|
||
netbirdHostNameDescription=Le nom d'hôte du pair sur le réseau
|
||
vncRefSystem=Système associé
|
||
vncRefSystemDescription=L'entrée de connexion à associer à cette connexion VNC. Laisse ce champ vide s'il n'y en a pas
|
||
abstractHost.displayName=Hôte abstrait
|
||
abstractHost.displayDescription=Créer une entrée pour un hôte qui ne prend pas en charge les connexions shell
|
||
abstractHostAddress=Adresse de l'hôte
|
||
abstractHostAddressDescription=L'adresse de l'hôte
|
||
abstractHostGateway=Passerelle
|
||
abstractHostGatewayDescription=Le système de passerelle facultatif par lequel on peut accéder à cet hôte
|
||
abstractHostConvert=Convertir en entrée d'hôte abstraite
|
||
noHosts=Aucun hôte disponible
|
||
hasHosts=$COUNT$ hôtes disponibles
|
||
hasHost=$COUNT$ hôtes disponibles
|
||
largeFileWarningTitle=Modification de fichiers volumineux
|
||
largeFileWarningContent=Le fichier que tu veux modifier est assez volumineux : $SIZE$. Tu es sûr de vouloir ouvrir ce fichier dans ton éditeur de texte ?
|
||
rdpAskpassUser=Nom d'utilisateur RDP de l'ordinateur hôte $HOST$
|
||
rdpAskpassPassword=Mot de passe RDP pour l'utilisateur $USER$
|
||
rdpGatewayAskpassPassword=Mot de passe de la passerelle RDP pour l'utilisateur $USER$
|
||
inPlaceKey=Clé
|
||
inPlaceKeyText=Contenu de la clé privée
|
||
inPlaceKeyTextDescription=Le contenu de la clé privée
|
||
netbirdSelfhosted=Instance Netbird auto-hébergée
|
||
netbirdSelfhostedDescription=Indique une URL personnalisée au lieu d'utiliser la version hébergée sur le cloud
|
||
netbirdManagementUrl=URL d'administration de Netbird
|
||
netbirdManagementUrlDescription=L'URL de gestion de ton instance auto-hébergée
|
||
netbirdSetupKey=Clé de configuration
|
||
netbirdSetupKeyDescription=Si tu utilises des clés de configuration, tu peux en utiliser une pour te connecter
|
||
netbirdLogin=Connexion à Netbird
|
||
addProfile=Ajouter un profil
|
||
netbirdProfileName=Nom du profil
|
||
netbirdProfileNameDescription=Saisis le nom du nouveau profil Netbird
|
||
openSftp=Ouvrir dans une session SFTP
|
||
capslockWarning=Le verrouillage des majuscules est activé
|
||
inherit=Hériter (=$VALUE$)
|
||
sshConfigStringSelected=Hôte cible
|
||
sshConfigStringSelectedDescription=S'il y a plusieurs hôtes, c'est le premier qui sert de cible. Change l'ordre de tes hôtes pour changer la cible
|
||
#custom
|
||
tunnelToLocalhost=Tunneliser le port distant
|
||
tunnelToLocalhostDescription=Créer automatiquement un tunnel entre le port distant et localhost
|
||
tags=Mots-clés
|
||
#custom
|
||
tag=Étiquette
|
||
addNewTag=Créer une nouvelle balise
|
||
createTag=Créer une balise...
|
||
inPlacePublicKey=Clé publique
|
||
inPlacePublicKeyDescription=La clé publique associée à la clé privée indiquée
|
||
sshKeygenTitle=Générer une nouvelle clé SSH
|
||
sshKeygenAlgorithm=Algorithme
|
||
sshKeygenAlgorithmDescription=L'algorithme de génération de clés asymétriques à utiliser pour la clé
|
||
rsaBits=Bits
|
||
rsaBitsDescription=Nombre de bits dans la clé générée
|
||
sshKeygenComment=Commentaire
|
||
sshKeygenCommentDescription=Le commentaire facultatif pour cette clé
|
||
sshKeygenPassphrase=Phrase de passe
|
||
sshKeygenPassphraseDescription=La phrase de passe facultative pour cette clé
|
||
ed25519SkResident=Créer une clé résidente
|
||
ed25519SkResidentDescription=Stocker la clé privée sur la clé de sécurité matérielle
|
||
ed25519SkResidentKeyName=Libellé de la clé résidente
|
||
ed25519SkResidentKeyNameDescription=Donne un nom à la clé. C'est nécessaire quand tu stockes plusieurs clés sur la clé de sécurité
|
||
ed25519SkPinRequired=Demander le code PIN
|
||
ed25519SkPinRequiredDescription=Demander la saisie d'un code PIN à chaque utilisation
|
||
ed25519SkUserPresenceRequired=Exiger la présence de l'utilisateur
|
||
ed25519SkUserPresenceRequiredDescription=Nécessite un contact ou une action similaire lors de l'utilisation. Certaines clés de sécurité exigent que cette fonction soit activée
|
||
copyPublicKey=Copier la clé publique
|
||
generatePublicKey=Générer une clé publique
|
||
publicKeyGenerateNotice=Peut être générée à partir d'une clé privée
|
||
identityApplyTargetHost=Cible
|
||
identityApplyTargetHostDescription=Le système auquel appliquer l'identité
|
||
identityApplyAuthorizedHost=Clé SSH autorisée
|
||
identityApplyAuthorizedHostDescription=La clé SSH a été ajoutée au fichier authorized_keys
|
||
identityApplyAuthorizedHostButton=Ajouter une clé au fichier
|
||
applyIdentityToHost=Appliquer l'identité à l'hôte...
|
||
identityApplyMissingPublicKeyTitle=Clé publique manquante
|
||
identityApplyMissingPublicKeyContent=La clé SSH de l'identité n'est associée à aucune clé publique. Une clé publique est nécessaire pour l'utiliser sur d'autres systèmes. Rends-toi dans la configuration de l'identité pour générer la clé publique.
|
||
valid=Valide
|
||
notValid=Non valide
|
||
warning=Avertissement
|
||
identityApplyTitle=Appliquer l'identité
|
||
identityApplyConfigPasswordEnabled=Authentification par mot de passe activée
|
||
identityApplyConfigPasswordEnabledDescription=L'authentification par mot de passe est toujours activée dans la configuration de sshd
|
||
identityApplyConfigPasswordDisabled=Authentification par mot de passe désactivée
|
||
identityApplyConfigPasswordDisabledDescription=L'authentification par mot de passe est toujours désactivée dans la configuration de sshd
|
||
identityApplyConfigKeyEnabled=Authentification par clé activée
|
||
identityApplyConfigKeyEnabledDescription=L'authentification par clé est toujours activée dans la configuration de sshd
|
||
identityApplyConfigKeyDisabled=Authentification par clé désactivée
|
||
identityApplyConfigKeyDisabledDescription=L'authentification par clé est toujours désactivée dans la configuration de sshd
|
||
identityApplyConfigRootDisabledWarning=Connexion en tant qu'administrateur désactivée
|
||
identityApplyConfigRootDisabledWarningDescription=La connexion en tant qu'utilisateur root n'est pas activée dans la configuration de sshd
|
||
identityApplyConfigAdminWarning=Clés d'administrateur configurées
|
||
identityApplyConfigAdminWarningDescription=Il faudra peut-être ajouter la clé au fichier administrators_authorized_keys à la place pour les utilisateurs administrateurs
|
||
identityApplyConfigCaConfigured=Autorité de certification de confiance configurée
|
||
identityApplyConfigCaConfiguredDescription=Le serveur SSH est configuré avec une autorité de certification (CA) personnalisée pour les certificats. Tu ne voudras probablement pas ajouter cette clé directement dans le fichier authorized_keys
|
||
identityApplyEditConfig=Modifier la configuration
|
||
identityApplyEditConfigDescription=Ouvre le fichier de configuration de sshd dans l'éditeur pour corriger les éventuels problèmes
|
||
identityApplyEditAuthorizedKeys=Modifier les clés autorisées
|
||
identityApplyEditAuthorizedKeysDescription=Ouvre le fichier authorized_keys dans l'éditeur pour modifier ou supprimer d'autres clés
|
||
identityApplyEditConfigButton=Ouvre le fichier sshd_config
|
||
identityApplyEditAuthorizedKeysButton=Ouvre le fichier authorized_keys
|
||
identityApplySetStoreIdentity=Identité de connexion définie
|
||
identityApplySetStoreIdentityDescription=L'identité est configurée pour être utilisée par la connexion
|
||
identityApplySetStoreIdentityButton=Appliquer l'identité
|
||
generateKey=Générer une clé
|
||
fileSecret=Secret basé sur un fichier
|
||
commandSecret=Commande
|
||
httpRequestSecret=Réponse HTTP
|
||
fileSecretChoice=Emplacement du fichier
|
||
fileSecretChoiceDescription=Le chemin d'accès au fichier contenant la clé de chiffrement du groupe. Comme ce fichier est accessible sur toutes les plateformes, tu peux utiliser le caractère « ~ » dans le chemin pour désigner le répertoire personnel. Le fichier doit être disponible sur tous les systèmes à partir desquels tu déverrouilles le coffre-fort, sinon la connexion échouera.
|
||
vaultAuthentication=Accès au Vault
|
||
vaultAuthenticationDescription=Comment t'authentifier / déverrouiller les données du « vault ». Il existe plusieurs façons de chiffrer et de déverrouiller les données du « vault », selon que tu souhaites ou non partager certaines parties de ces données, et comment tu veux le faire.
|
||
groupAuthFailed=Échec de l'authentification du mot de passe
|
||
userAuthFailed=Échec de l'authentification par mot de passe
|
||
savingChanges=Enregistrement des modifications
|
||
synchronizingChanges=Synchronisation des modifications
|
||
awsDeviceScan=AWS
|
||
aws=AWS
|
||
awsCliInstallTitle=AWS CLI requis
|
||
awsCliInstallContent=L'intégration AWS nécessite que l'AWS CLI soit installée sur ton système local
|
||
teleportInstallTitle=Le client Teleport tsh est nécessaire
|
||
teleportInstallContent=L'intégration de Teleport nécessite que l'outil en ligne de commande tsh soit installé sur ton système local
|
||
awsProfileCreateTitle=Nouveau profil AWS
|
||
awsProfileAccessKey=Clé d'accès
|
||
awsProfileName=Nom du profil
|
||
awsProfileNameDescription=Le nom d'affichage du nouveau profil
|
||
awsProfileRegion=Région
|
||
awsProfileRegionDescription=La région AWS associée au profil
|
||
awsProfileAccessKeyId=Identifiant de la clé d'accès
|
||
awsProfileAccessKeyIdDescription=L'identifiant de la clé d'accès utilisateur IAM
|
||
awsProfileSecretAccessKey=Clé d'accès secrète
|
||
awsProfileSecretAccessKeyDescription=La clé d'accès secrète associée
|
||
awsInstall.displayName=Installation de l'AWS CLI
|
||
awsInstall.displayDescription=Connecte-toi à tes systèmes AWS via l'interface de ligne de commande AWS (AWS CLI)
|
||
awsProfile.displayName=Profil AWS CLI
|
||
awsProfile.displayDescription=Accéder à AWS via un profil spécifique
|
||
awsInstanceId=ID d'instance
|
||
awsInstanceIdDescription=L'identifiant interne de cette instance
|
||
awsInstanceUseSsm=Se connecter via SSM
|
||
awsInstanceUseSsmDescription=Utilise l'outil SSM pour te connecter à l'instance via SSH
|
||
awsEc2Instance.displayName=Instance AWS EC2
|
||
awsEc2Instance.displayDescription=Se connecter à une instance EC2 via SSH
|
||
awsS3Group.displayName=Compartiments S3
|
||
awsS3Group.displayDescription=Accéder aux compartiments S3 d'un profil AWS
|
||
awsS3Bucket.displayName=Compartiment S3
|
||
awsS3Bucket.displayDescription=Accéder à un compartiment S3 d'un profil AWS
|
||
awsEc2Group.displayName=Instances EC2
|
||
awsEc2Group.displayDescription=Accéder aux instances EC2 d'un profil AWS
|
||
awsEc2InstanceSsmTerminal=Ouvrir le terminal SSM
|
||
genericS3Bucket.displayName=Compartiment S3 générique
|
||
genericS3Bucket.displayDescription=Accéder à un compartiment S3 générique via l'interface de ligne de commande AWS (AWS CLI)
|
||
addFileSystem=Système de fichiers...
|
||
genericS3BucketHost=Hôte
|
||
genericS3BucketHostDescription=L'entrée hôte ou l'adresse manuelle du serveur S3
|
||
genericS3BucketPortDescription=Le port sur lequel le serveur S3 est à l'écoute
|
||
genericS3BucketAccessKeyId=Identifiant de la clé d'accès
|
||
genericS3BucketAccessKeyIdDescription=L'identifiant de la clé d'accès utilisateur IAM
|
||
genericS3BucketSecretAccessKey=Clé d'accès secrète
|
||
genericS3BucketSecretAccessKeyDescription=La clé d'accès secrète associée
|
||
genericS3BucketHttps=Activer HTTPS
|
||
genericS3BucketHttpsDescription=Utilise le protocole HTTPS pour te connecter au serveur. Certains fournisseurs peuvent exiger l'utilisation du protocole HTTPS
|
||
tunnelled=En tunnel
|
||
awsInstallSync=Synchronisation de la configuration
|
||
awsInstallSyncDescription=Synchronise les fichiers de configuration de l'AWS CLI vers le « vault » Git
|
||
awsInstallLocation=Emplacement des données utilisateur
|
||
awsInstallLocationDescription=Le chemin d'accès à l'emplacement où se trouvent les fichiers de configuration de l'AWS CLI
|
||
instanceActions=Actions d'instance
|
||
openSplit=Ouvrir dans un terminal divisé
|
||
terminalSplitStrategy=Sens de division de l'affichage
|
||
terminalSplitStrategyDescription=Détermine comment les onglets du terminal sont répartis quand tu utilises la fonctionnalité d'affichage fractionné en mode batch pour ouvrir plusieurs sessions de terminal les unes à côté des autres.
|
||
terminalSplitStrategyDisabledDescription=Détermine comment les onglets du terminal sont répartis lorsque tu utilises la fonctionnalité d'affichage fractionné en mode batch pour ouvrir plusieurs sessions de terminal côte à côte.\n\nTa configuration actuelle du terminal ne prend pas en charge l'affichage fractionné.
|
||
horizontal=Horizontal
|
||
vertical=Vertical
|
||
balanced=Équilibré
|
||
close=Fermer
|
||
helpButton=$TOPIC$ lien vers la documentation
|
||
quickAccess=Accès rapide
|
||
#custom
|
||
toggleEnabled=Changer d'état
|
||
currentPath=Chemin d'accès actuel
|
||
directoryContents=Contenu du répertoire
|
||
directoryOptions=Options du répertoire
|
||
chooseConnectionType=Choisis le type de connexion
|
||
batchMode=Mode batch
|
||
toggleButton=Bouton bascule
|
||
tailscaleUseSsh=Utiliser l'authentification SSH Tailscale
|
||
tailscaleUseSshDescription=Se connecter via le serveur SSH Tailscale lui-même, sans aucune authentification SSH
|
||
portDescription=Le port sur lequel le serveur SSH est en cours d'exécution
|
||
sshGatewayType=Type de passerelle
|
||
sshGatewayTypeDescription=Choisir de se connecter à la cible via un tunnel ou avec l'option ProxyJump
|
||
gatewayTunnel=Tunnel de passerelle
|
||
proxyJump=Proxy de relais
|
||
commandTypeAsyncBackground=Exécuter en arrière-plan de manière détachée
|
||
commandTypeSyncBackground=Lancer en arrière-plan et attendre la fin
|
||
commandTypeTerminalBackground=Ouvrir dans le terminal
|
||
asyncBackgroundCommand=Commande en arrière-plan
|
||
syncBackgroundCommand=Commande en arrière-plan bloquante
|
||
terminalBackgroundCommand=Commande du terminal
|
||
testingConnection=Test de connexion...
|
||
openManagementConsole=Ouvrir la console d'administration
|
||
openLxcTerminal=Ouvrir le terminal LXC
|
||
openContainerConsole=Ouvrir la console série
|
||
keeper2fa=Méthode d'authentification à deux facteurs (2FA)
|
||
keeper2faDescription=La méthode d'authentification à deux facteurs principale configurée pour ton compte. Active cette option si ton compte Keeper nécessite une authentification à deux facteurs pour accéder à tes mots de passe.
|
||
keeperTotpDuration=Durée personnalisée du code 2FA
|
||
keeperTotpDurationDescription=Remplace la durée par défaut de validité d'un code 2FA. Ça ne s'applique que si la politique de ton organisation autorise la modification de cette durée.\n\nLes valeurs possibles sont : $VALUES$
|
||
keeperOtherAuth=Autres (RSA SecurID, Duo Security, Keeper DNA, etc.)
|
||
extractReusableIdentities=Extraire les identités réutilisables
|
||
identitiesAdded=Identités ajoutées
|
||
syncMode=Mode de synchronisation
|
||
syncModeDescription=Détermine comment les modifications doivent être synchronisées.\n\nLe mode « Instant » envoie et récupère les modifications dès que possible, les modes « Démarrage » et « Sortie » synchronisent en une seule fois toutes les modifications effectuées pendant une session, et le mode « Manuel » ne synchronise que lorsque tu le lances.
|
||
toggleTerminalDock=Afficher/masquer le terminal ancré\n\nRaccourci : $SHORTCUT$
|
||
scriptDirectory=Emplacement du répertoire
|
||
scriptDirectoryDescription=Le répertoire local contenant les fichiers de scripts shell
|
||
scriptSourceUrl=URL du dépôt
|
||
scriptSourceUrlDescription=L'URL d'un dépôt Git distant contenant des fichiers de scripts shell
|
||
scriptCollectionSourceType=Type de source
|
||
scriptCollectionSourceTypeDescription=Le type de source à partir de laquelle les scripts shell doivent être chargés
|
||
scriptCollectionSourceEntry=Entrée source
|
||
scriptCollectionSourceEntryDescription=La source à partir de laquelle les scripts shell doivent être chargés
|
||
gitRepository=Dépôt Git
|
||
scriptCollectionSource.displayName=Source du script
|
||
scriptCollectionSource.displayDescription=Importer automatiquement des scripts shell existants depuis une source externe
|
||
directorySource=Répertoire source
|
||
gitRepositorySource=Source du dépôt Git
|
||
refreshSource=Actualiser la source
|
||
scriptTextSourceUrl=URL du script
|
||
scriptTextSourceUrlDescription=L'URL pour récupérer le fichier de script
|
||
scriptSourceType=Source du script
|
||
scriptSourceTypeDescription=Où trouver le script ?
|
||
scriptSourceTypeInPlace=Script intégré
|
||
scriptSourceTypeUrl=URL externe
|
||
scriptSourceTypeSource=Source existante
|
||
importScripts=Importer des scripts
|
||
scriptsContained=$NUMBER$ scripts
|
||
scriptSourceCollectionImportTitle=Importer des scripts depuis la source ($SELECTED$/$COUNT$)
|
||
noScriptsFound=Aucun script trouvé
|
||
tunnel=Tunnel
|
||
notInitialized=Pas encore initialisé
|
||
selectCategory=Choisis une catégorie...
|
||
scriptSourceName=Nom du script
|
||
scriptSourceNameDescription=Le nom du fichier du script dans la source
|
||
workspaceRestartTitle=Espace de travail prêt
|
||
workspaceRestartContent=Le nouvel espace de travail a été créé et un raccourci a été ajouté sur le bureau. Tu peux cliquer sur ce raccourci ou redémarrer XPipe dès maintenant pour ouvrir automatiquement le nouvel espace de travail.
|
||
browseShortcut=Parcourir le raccourci
|
||
syncModeInstant=Synchronisation instantanée
|
||
syncModeSession=Synchronisation au démarrage et à la fermeture
|
||
syncModeManual=Synchroniser manuellement
|
||
pushChanges=Pousser les modifications
|
||
pullChanges=Récupérer les modifications
|
||
sourcedFrom=Source : $SOURCE$
|
||
inPlaceScript=Script intégré
|
||
generic=Générique
|
||
syncToPlainDirectory=Synchronisation avec un répertoire simple
|
||
syncToPlainDirectoryDescription=Lors de la synchronisation vers un répertoire local, tu peux soit considérer ce répertoire comme un autre dépôt Git, soit simplement comme un répertoire classique. Si l'option « répertoire classique » est activée, le répertoire n'est pas initialisé en tant que dépôt Git.
|
||
openSpiceSession=Ouvrir une session SPICE
|
||
terminalBehaviour=Comportement du terminal
|
||
noScanPossible=Aucune connexion prise en charge n'a été trouvée
|
||
networkSwitchPorts=Ports réseau
|
||
nswitchGroup.displayName=Ports réseau
|
||
nswitchGroup.displayDescription=Lister les ports disponibles sur un périphérique réseau
|
||
nswitchPort.displayName=Port réseau
|
||
nswitchPort.displayDescription=Contrôler un port spécifique sur un commutateur réseau
|
||
enablePort=Activer le port
|
||
shutdownPort=Désactiver un port
|
||
resetPort=Réinitialiser le port
|
||
useSystemDefault=Utiliser les paramètres par défaut du système
|
||
portStatus=État du port
|
||
clearCounters=Réinitialiser les compteurs
|
||
showStatus=Afficher l'état
|
||
showAllPorts=Afficher tous les ports
|
||
activeLicense=Licence
|
||
activeLicenseDescription=Activer une clé de licence XPipe
|
||
authenticatorApp=Appli d'authentification
|
||
securityKey=Clé de sécurité
|
||
mcpAdditionalContext=Contexte MCP supplémentaire
|
||
mcpAdditionalContextDescription=Instructions supplémentaires à transmettre au client MCP. Utilise ça pour contrôler le comportement de l'agent et fournir un contexte supplémentaire pour ta configuration personnelle.
|
||
mcpAdditionalContextSample=- Ne redémarre aucun service ni démon automatiquement sans avoir d'abord confirmé\n- Quand tu configures une interface réseau, utilise toujours 192.168.1.1/24 comme passerelle
|
||
prefsRestartTitle=Redémarrage nécessaire
|
||
prefsRestartContent=Certaines options que tu as modifiées nécessitent un redémarrage de l'application pour être prises en compte. Tu veux redémarrer XPipe maintenant ?
|
||
bashShell=Shell Bash
|
||
sshKeyRetrieved=Clé SSH
|
||
sshKeyRetrievedMissingStrategy=Clé SSH (choisis la méthode de récupération ci-dessous)
|
||
inlineKey=Récupérer directement depuis le gestionnaire de mots de passe
|
||
inlineSeparateKey=Récupérer une clé supplémentaire
|
||
keyAgent=Utiliser l'intégration de l'agent
|
||
protonPassAgent=Utiliser l'intégration de l'agent
|
||
passwordManagerKeyStrategy=Méthode de récupération des clés SSH
|
||
passwordManagerKeyStrategyDescription=Comment récupérer les clés SSH stockées dans le gestionnaire de mots de passe. Quand cette option est désactivée, aucune clé ne peut être récupérée. Quand un agent SSH est configuré, il doit être correctement lancé dans le gestionnaire de mots de passe.
|
||
passwordManagerPreferIds=Privilégie les identifiants d'entrée plutôt que les noms
|
||
passwordManagerPreferIdsDescription=Quand tu choisis une entrée du gestionnaire de mots de passe via le bouton « Liste », XPipe remplira le champ avec l'ID plutôt qu'avec le nom lisible par l'utilisateur si cette option est activée. L'utilisation des ID est plus fiable quand les entrées sont renommées dans le gestionnaire de mots de passe.
|
||
sshAgentNoKeys=L'agent n'a pas de clés pour le moment
|
||
sshAgentHasKeys=L'agent propose actuellement les clés suivantes :
|
||
passwordManagerNoKeys=Aucune entrée de gestionnaire de mots de passe n'a été trouvée
|
||
passwordManagerHasKeys=Entrées disponibles dans le gestionnaire de mots de passe :
|
||
networkInterfacesBroadcastNone=Aucune interface réseau n'a pu être détectée automatiquement
|
||
networkInterfacesBroadcastFound=L'hôte de diffusion possède les adresses de diffusion suivantes :
|
||
networkInterfacesNone=Aucune interface réseau n'a pu être détectée automatiquement
|
||
networkInterfacesFound=Le système dispose des interfaces réseau suivantes :
|
||
passwordManagerNoAgentSupport=Le gestionnaire de mots de passe ne prend pas en charge la récupération des clés SSH via un agent
|
||
passwordManagerNoAgentConfigured=XPipe n'est pas configuré pour récupérer les clés SSH depuis l'agent
|
||
passwordManagerEmpty=Aucun gestionnaire de mots de passe n'est configuré
|
||
passwordManagerSshKeyConfig=Configuration d'un gestionnaire de mots de passe
|
||
passwordManagerSshKeyConfigDescription=Vérifie l'état du gestionnaire de mots de passe
|
||
keePassXcOpenSshAgent=Utiliser l'agent OpenSSH
|
||
keePassXcPageant=Utilise Pageant
|
||
passwordManagerSshAgentSocket=Socket de l'agent SSH
|
||
passwordManagerSshAgentSocketDescription=Le socket à utiliser pour communiquer avec l'agent.
|
||
passwordManagerSshKeysNotSupported=La configuration actuelle du gestionnaire de mots de passe ne permet pas de récupérer les clés SSH
|
||
passwordManagerAdditionalKey=Clé SSH supplémentaire
|
||
passwordManagerAdditionalKeyDescription=La clé SSH à utiliser en plus des identifiants fournis par le gestionnaire de mots de passe
|
||
multiIdentity.displayName=Identité multiple
|
||
multiIdentity.displayDescription=Passer d'une identité à l'autre pour se connecter à un système
|
||
multiIdentityList=Liste d'identités
|
||
multiIdentityListDescription=La liste des identités entre lesquelles basculer
|
||
switchIdentity=Changer d'identité
|
||
onePasswordManagerAccount=Remplacement de compte
|
||
onePasswordManagerAccountDescription=L'adresse e-mail ou l'identifiant 1Password à utiliser explicitement si plusieurs comptes sont enregistrés. Si ce paramètre n'est pas défini, le premier compte disponible sera utilisé par défaut.
|
||
hashicorpVaultAddress=Adresse Vault
|
||
hashicorpVaultAddressDescription=L'URL pour accéder à ton cluster à l'adresse
|
||
hashicorpVaultNamespace=Espace de noms Vault
|
||
#custom
|
||
hashicorpVaultNamespaceDescription=L'espace de noms à utiliser pour accéder à Vault. Si ce champ est laissé vide, aucune information d'espace de noms n'est transmise.
|
||
hashicorpVaultSignerMount=Montage du moteur de secrets SSH
|
||
hashicorpVaultSignerMountDescription=Remplace le chemin d'accès par défaut où le moteur de secrets SSH est monté
|
||
hashicorpVaultAuthType=Authentification Vault
|
||
hashicorpVaultAuthTypeDescription=Comment s'authentifier auprès de Vault. On te recommande le paramètre par défaut qui utilise l'authentification via l'interface CLI de Vault, surtout si tu utilises des méthodes d'authentification qui ne sont pas explicitement mentionnées ici.
|
||
hashicorpVaultAuthAppRole=AppRole
|
||
hashicorpVaultAuthToken=Jeton
|
||
hashicorpVaultAuthExisting=Utilise la ligne de commande (CLI) de Vault
|
||
hashicorpVaultRoleId=RoleID
|
||
hashicorpVaultRoleIdDescription=L'UUID de l'AppRole
|
||
hashicorpVaultSecretId=SecretID
|
||
hashicorpVaultSecretIdDescription=Le secret correspondant à l'AppRole
|
||
hashicorpVaultToken=Jeton
|
||
hashicorpVaultTokenDescription=Le jeton d'authentification à utiliser
|
||
#custom
|
||
hashicorpVaultMapping=Mappage par défaut des clés
|
||
hashicorpVaultMappingDescription=Le Vault peut en gros stocker des données chiffrées arbitraires sous forme d'entrées clé-valeur ; tu devras donc définir un mappage permettant à XPipe de trouver, à partir de clés, des entrées individuelles telles que le nom d'utilisateur, le mot de passe et les clés SSH. Le mappage par défaut peut être remplacé par des identités individuelles si besoin.
|
||
passwordManagerUsernameMapping=Nom d'utilisateur
|
||
passwordManagerPasswordMapping=Mot de passe
|
||
passwordManagerPrivateKeyMapping=Clé privée SSH
|
||
passwordManagerPublicKeyMapping=Clé publique SSH
|
||
recentSearches=Recherches récentes
|
||
recentSearchesDescription=Filtre pour les attributs de connexion
|
||
recentSearchesDescriptionNames=<nom>, par exemple «$CONTENT$ »
|
||
recentSearchesDescriptionTags=<tag>, par exemple «$CONTENT$ »
|
||
recentSearchesDescriptionTypes=<type>, par exemple «$CONTENT$ »
|
||
recentSearchesDescriptionState=<état>, par exemple «$CONTENT$ »
|
||
recentSearchesDescriptionJoin=<s1>, <s2> sont séparés par des virgules
|
||
recentQuickConnections=Connexions récentes et rapides
|
||
recentQuickConnectionsDescription=Connexion rapide via une chaîne de caractères
|
||
recentUrls=URL récentes
|
||
recentUrlsDescription=Connexion rapide via des URL
|
||
editContainerUnitFile=Modifier le fichier d'unité de conteneur
|
||
clipboardNoticeTitle=Mot de passe copié
|
||
clipboardNoticeContent=Comme l'application cible ne prend pas en charge la saisie directe des mots de passe, ton mot de passe a été copié dans ton presse-papiers pour que tu puisses le coller. À l'avenir, ça se fera automatiquement. Tu peux voir l'icône du presse-papiers qui t'indique ça dans le coin en bas à droite.
|
||
sftpNoticeTitle=Transferts de fichiers volumineux
|
||
sftpNoticeContent=Les fichiers que tu essaies de transférer sont assez volumineux. La session actuelle utilise le SSH brut, ce qui ne te permet pas d'atteindre la meilleure vitesse de transfert possible. Si tu as besoin d'augmenter la vitesse de transfert, tu peux envisager d'ouvrir une session SFTP vers le système via le menu contextuel de l'explorateur de fichiers.
|
||
hideVaultEntryNames=Masquer les noms des entrées du « vault » dans Git
|
||
hideVaultEntryNamesDescription=Supprime tous les noms de connexion et autres informations des fichiers README et des messages de commit lorsque la synchronisation Git est activée. Cette option empêche toute compréhension de la structure du contenu chiffré du « vault ».
|
||
disableHardwareAcceleration=Désactiver l'accélération matérielle
|
||
disableHardwareAccelerationDescription=Désactive l'utilisation de la carte graphique pour le rendu et utilise uniquement un pipeline de rendu logiciel.\n\nÇa entraîne une baisse de performances importante, mais ça peut être la seule solution pour le rendu s'il y a des problèmes avec le pilote de la carte graphique.
|
||
disableRdpWindowsSecurityWarning=Désactiver l'avertissement de sécurité RDP
|
||
disableRdpWindowsSecurityWarningDescription=Ne pas afficher le nouvel avertissement de Windows concernant les fichiers .rdp non signés à chaque fois que tu lances une nouvelle session.\n\nÇa va modifier la clé de registre pour que le client RDP de Windows revienne à son ancien comportement. Cette action va faire apparaître une fenêtre contextuelle demandant les droits d'administrateur.
|
||
rdpWindowsSecurityWarningDialogTitle=Avertissements de sécurité RDP
|
||
rdpWindowsSecurityWarningDialogContent=Depuis la version 26200 de Windows, le système affiche désormais systématiquement un avertissement lorsqu'un fichier RDP non signé est lancé, quel que soit son contenu.\n\nTu peux désactiver cet avertissement depuis XPipe dans le menu des paramètres.
|
||
openSettings=Ouvrir les paramètres
|
||
openSettingsDescription=Accède à l'entrée de paramètres correspondante
|
||
toggleSizeLock=Activer/désactiver le verrouillage de la taille
|
||
useExternalNetcatForProxies=Utilise l'exécutable netcat installé en externe pour les proxys
|
||
useExternalNetcatForProxiesDescription=Si possible, utilise l'exécutable netcat installé localement pour servir de proxy aux connexions SSH, plutôt que la fonctionnalité de proxy intégrée. Pour ça, il faut que ncat soit installé sous Windows et nc sur les autres systèmes d'exploitation.
|
||
networkProxy.displayName=Proxy HTTP/SOCKS
|
||
networkProxy.displayDescription=Configurer un serveur proxy HTTP/SOCKS pour l'utiliser comme passerelle
|
||
networkProxyType=Type de proxy
|
||
networkProxyTypeDescription=Le protocole du serveur proxy
|
||
networkProxyHost=Hôte
|
||
networkProxyHostDescription=L'hôte sur lequel le serveur proxy est exécuté
|
||
networkProxyPort=Port
|
||
networkProxyPortDescription=Le port sur lequel le serveur proxy est à l'écoute
|
||
networkProxyUsername=Nom d'utilisateur
|
||
networkProxyUsernameDescription=Le nom d'utilisateur pour se connecter au proxy si une authentification est requise
|
||
networkProxyPassword=Mot de passe
|
||
networkProxyPasswordDescription=Le mot de passe pour se connecter au proxy si une authentification est requise
|
||
httpProxy=Proxy HTTP
|
||
httpProxyDescription=Le proxy à utiliser pour tout type de requêtes HTTP envoyées par XPipe et d'autres outils externes.\n\nSi le proxy déchiffre le trafic TLS, on te demandera d'ajouter tes certificats personnalisés au magasin de certificats interne d'XPipe une fois la connexion établie. Tu peux utiliser le bouton « Tester » pour vérifier la connectivité.
|
||
httpProxyConfiguration=Configuration d'un proxy HTTP
|
||
addProxy=Ajouter un proxy...
|
||
httpProxyError=Configurer les paramètres du proxy HTTP
|
||
httpProxyErrorDescription=Ajoute les informations d'authentification du proxy HTTP dans le menu des paramètres
|
||
systemDefault=Valeur par défaut du système
|
||
hardwareSecurityKey=Clé de sécurité matérielle (PKCS#11)
|
||
macOsKeychain=Trousseau de macOS
|
||
customLibrary=Bibliothèque personnalisée
|
||
unsyncedIdentityTitle=Identité non synchronisée
|
||
unsyncedIdentityContent=Cette connexion est configurée pour être synchronisée sur plusieurs systèmes, mais l’identité que tu as sélectionnée est uniquement locale. Cela entraînera l’absence de cette identité sur les autres systèmes.\n\nTu peux soit convertir cette identité locale en identité synchronisée, soit la convertir en identité multiple pour basculer entre plusieurs identités locales sur chaque système synchronisé.
|
||
rdpDock=Ancrer la fenêtre
|
||
rdpDockDescription=Si cette option est activée, toute fenêtre RDP ouverte sera ancrée à la fenêtre intégrée du bureau à distance à onglets.
|
||
reloadSizes=Se reconnecter pour redimensionner
|
||
reconnect=Se reconnecter
|
||
certificateFile=Fichier de certificat
|
||
checkValidity=Vérifier la validité
|
||
certificatePublicKey=Clé publique de certificat
|
||
certificatePublicKeyDescription=Le fichier de clé publique qui contient le certificat
|
||
certificateDialogTitle=Certificat $FILE$
|
||
certificateDialogExpiredTitle=Le certificat $FILE$ a expiré
|
||
certificateDialogNotValidTitle=Le certificat $FILE$ n'est pas encore valide
|
||
renew=Renouveler
|
||
shortLivedCertImpl=Mise en œuvre d'un certificat à durée de vie limitée
|
||
shortLivedCertImplDescription=La méthode facultative à utiliser pour renouveler les certificats s'ils ont une durée de vie courte
|
||
certificateRole=Nom du rôle
|
||
certificateRoleDescription=Le rôle avec lequel signer la clé publique
|
||
testConfig=Configuration de test
|
||
testConfigDescription=Vérifie que la configuration fonctionne
|
||
applyingVaultChanges=Application des modifications de chiffrement du « vault »...
|
||
allowExternalApiRequests=Autoriser les requêtes API externes
|
||
allowExternalApiRequestsDescription=Par défaut, le serveur API n'écoute que sur localhost. Si tu veux aussi accepter des connexions provenant de l'extérieur de localhost, tu peux activer cette option.
|
||
certificateRenewCommand=Commande de renouvellement de certificat
|
||
certificateRenewCommandDescription=La commande personnalisée à exécuter dans $SHELL$ pour renouveler le certificat s'il a expiré
|
||
touchNoticeTitle=Confirmer la présence de l'utilisateur
|
||
touchNoticeContent=Ta clé de sécurité te demande de confirmer ta présence, par exemple en la touchant. À partir de maintenant, quand ça sera nécessaire, un indicateur d'empreinte digitale s'affichera dans le coin en bas à droite.
|
||
rdpUseSystemDisplayScale=Utiliser l'échelle d'affichage du système
|
||
rdpUseSystemDisplayScaleDescription=Applique à la connexion à distance le même facteur d'échelle d'affichage que celui de ton écran local.
|
||
rescan=Relancer la recherche
|
||
hostAddressPrompt=Saisis le nom d'hôte ou l'adresse IP
|
||
connectionHandling=Gestion des connexions
|
||
connectionConfiguration=Configuration de la connexion
|
||
move=Déplacer
|
||
confirmDeletionTitle=Confirmer la suppression
|
||
confirmDeletionContent=Tu veux supprimer les entrées sélectionnées ?
|
||
creationMinimizeNoticeTitle=Fenêtre de dialogue minimisée
|
||
creationMinimizeNoticeContent=La boîte de dialogue actuelle a été réduite. Tu peux la rouvrir en cliquant sur l'icône de réduction située dans le coin en bas à droite.
|
||
terminalDockDialogTitle=Ancrage de terminaux
|
||
terminalDockDialogContent=Tu veux que tes fenêtres de terminal restent toujours ancrées à l'application XPipe ? Tu peux modifier le comportement des fenêtres de terminal dans le menu des paramètres.
|
||
applicationBehaviour=Comportement de l'application
|
||
availableShells=Shells disponibles
|
||
keepEnabled=Rester activé
|
||
backgroundSessionInactivityTimeout=Délai d'inactivité du shell en arrière-plan
|
||
backgroundSessionInactivityTimeoutDescription=Le nombre de secondes après lesquelles les sessions shell en arrière-plan seront fermées si elles n'ont pas été utilisées.\n\nPar défaut, XPipe garde ouvertes en arrière-plan les connexions shell vers les systèmes distants pour pouvoir les réutiliser plus tard et accélérer les opérations. Si tu veux les fermer automatiquement au bout d'un certain temps, tu peux activer cette option.
|
||
certificateDetails=Détails du certificat
|
||
certificateDetailsDescription=Vérifie si c'est le bon certificat
|
||
certificateName=Nom
|
||
certificateNameDescription=Donne un nom reconnaissable au certificat enregistré
|
||
#custom
|
||
trust=Faire confiance
|
||
untrustedCertificateTitle=Certificat non fiable
|
||
browseCertificateStoreButton=Parcourir les certificats personnalisés
|
||
browseCertificateStore=Magasin de certificats
|
||
browseCertificateStoreDescription=Ouvre le répertoire du magasin de certificats pour gérer les certificats TLS personnalisés acceptés au format .pem. Les certificats sont ajoutés automatiquement quand c'est nécessaire et confirmés par l'utilisateur ; tu n'as donc pas besoin de les ajouter manuellement ici.
|
||
proxyTestAddressDialogTitle=Saisis l'adresse
|
||
proxyTestAddress=Adresse de test
|
||
proxyTestAddressDescription=L'adresse à laquelle se connecter via HTTP en passant par le proxy pour tester la connectivité
|
||
gpgSyncDialogTitle=Synchronisation avec la signature des commits
|
||
gpgSyncDialogContent=Tu as activé la signature des commits pour Git, par exemple avec des clés GPG ou SSH. Ça va ralentir les opérations de synchronisation, donc les modifications importantes pourraient prendre un peu plus de temps à se synchroniser que d'habitude.
|
||
downloadDialogTitle=Téléchargement terminé
|
||
downloadDialogContent=Les fichiers ont été téléchargés sur ton ordinateur. Tu peux maintenant les glisser-déposer depuis la zone de téléchargement en bas à gauche vers ton environnement de bureau et tes applications habituelles.
|
||
syncInProgressTitle=Synchronisation en cours
|
||
syncInProgressContent=Tes modifications sont en cours d'enregistrement et de synchronisation. Tu devrais voir les modifications sur le dépôt distant une fois l'opération terminée.
|
||
syncIdentity=Synchroniser l'identité
|
||
convertToMulti=Convertir en multi
|
||
sshDisableShellInitTimeout=Ce système met beaucoup de temps à se connecter
|
||
sshDisableShellInitTimeoutDescription=Désactive tout délai d'expiration de connexion au cas où l'authentification mettrait longtemps à aboutir
|
||
bitwardenUnlock=Déverrouille le coffre-fort avec ton mot de passe principal Bitwarden
|
||
enpassUnlock=Saisis le mot de passe principal du coffre-fort Enpass
|
||
keeperSmsUnlock=Saisis le code SMS de Keeper Commander
|
||
keeper2faUnlock=Saisir le code 2FA de Keeper
|
||
keeperUnlock=Saisis ton mot de passe principal Keeper pour déverrouiller
|
||
wakeOnLanHost=Hôte cible
|
||
wakeOnLanHostDescription=Le système à réveiller
|
||
wakeOnLanGateway=Hôte de diffusion
|
||
wakeOnLanGatewayDescription=Le système à partir duquel envoyer la diffusion
|
||
wakeOnLanBroadcastAddress=Adresse de diffusion
|
||
wakeOnLanBroadcastAddressDescription=L'adresse de diffusion à laquelle envoyer le paquet
|
||
wakeOnLanAddress=Adresse MAC
|
||
wakeOnLanAddressDescription=L'adresse MAC de l'interface réseau cible
|
||
wakeOnLan.displayName=Wake-on-Lan
|
||
wakeOnLan.displayDescription=Réveiller un ordinateur en veille en envoyant un paquet magique
|
||
wakeOnLanInterface=Interface $ADDR$
|
||
webtopAppList=Liste des applications
|
||
selectApps=Sélectionner des progiciels
|
||
selectAppsDescription=Sélectionne les paquets d'application à installer sur le système
|
||
selectAppsForce=Forcer la réinstallation
|
||
selectAppsForceDescription=Réinstalle les applications sélectionnées pour les mettre à jour vers la dernière version
|
||
webtopMode=Mode Webtop
|
||
desktopMode=Mode bureau
|
||
mobileMode=Mode mobile
|
||
webtopTransferSettings=Transférer les paramètres
|
||
webtopTransferSettingsDescription=Applique tes paramètres locaux à l'environnement Webtop
|
||
webtopRebuildContainer=Reconstruire le conteneur
|
||
webtopRebuildContainerDescription=Recréer le conteneur avec la dernière image de conteneur
|
||
configureWebtop=Configurer Webtop
|
||
transfer=Transférer
|
||
rebuild=Reconstruire
|
||
webtop.displayName=XPipe Webtop
|
||
webtop.displayDescription=Accéder à un environnement Webtop et le gérer à distance
|
||
webtopHost=Hôte
|
||
webtopHostDescription=Le conteneur sur lequel l'environnement Webtop s'exécute
|
||
webtopDeploymentName=Nom d'hôte
|
||
webtopDeploymentNameDescription=Le nom du conteneur
|
||
webtopDeploymentType=Type de déploiement
|
||
webtopDeploymentTypeDescription=Le type de système conteneurisé sur lequel le webtop doit être déployé
|
||
webtopDeploymentTitle=Créer un modèle de déploiement Webtop
|
||
generateConfig=Suivant...
|
||
webtopDeploymentHostEnvironment=Environnement d'hébergement de déploiement
|
||
webtopDeploymentHostEnvironmentDescription=L'environnement hôte du conteneur dans lequel le webtop doit être créé
|
||
webtopDeploymentHostname=Nom d'hôte
|
||
webtopDeploymentHostnameDescription=Le nom du conteneur
|
||
webtopDeploymentLocale=Langue
|
||
webtopDeploymentLocaleDescription=La langue par défaut de l'environnement de bureau Webtop
|
||
webtopDeploymentVolumeMountPath=Chemin d'accès au volume
|
||
webtopDeploymentVolumeMountPathDescription=Le chemin d'accès sur l'hôte où les données utilisateur du conteneur doivent être stockées
|
||
webtopDeploymentEnableApiServer=Activer le serveur API
|
||
webtopDeploymentEnableApiServerDescription=Autoriser les requêtes API HTTP XPipe à distance vers le serveur pour la gestion programmatique
|
||
openWizard=Ouvrir l'assistant
|
||
webtopContainerConfigTitle=Configuration des conteneurs
|
||
webtopConfigComposeFile=Fichier Compose
|
||
webtopConfigComposeFileDescription=Le contenu du fichier de configuration généré à déployer
|
||
webtopConfigComposeDirectory=Répertoire de destination
|
||
webtopConfigComposeDirectoryDescription=Le répertoire dans lequel créer le projet Compose
|
||
webtopConfigTargetImageFile=Fichier image cible
|
||
webtopConfigTargetImageFileDescription=Où enregistrer le fichier image OCI sur l'hôte
|
||
webtopConfigVmid=VMID du conteneur
|
||
webtopConfigVmidDescription=Le VMID du conteneur qui vient d'être créé
|
||
webtopConfigStorage=Stockage
|
||
webtopConfigStorageDescription=L'espace de stockage PVE sur lequel le conteneur doit être stocké
|
||
webtopSettingsApplyTitle=Paramètres de transfert
|
||
webtopSettingsApplyContent=Tu veux transférer tes paramètres XPipe locaux vers l'environnement Webtop XPipe distant ?
|
||
webtopSettingsApplyDoneTitle=Transfert des paramètres terminé
|
||
webtopSettingsApplyDoneNoSyncTitle=Transfert des paramètres terminé
|
||
webtopSettingsApplyDoneContent=Tes paramètres locaux ont été appliqués à l'environnement Webtop.
|
||
webtopSettingsApplyDoneNoSyncContent=Tes paramètres locaux ont été appliqués à l'environnement Webtop. Pour synchroniser également tes connexions, configure la synchronisation Git dans le menu des paramètres, puis transfère à nouveau les paramètres.
|
||
deploy=Déployer
|
||
#custom
|
||
transferSettings=Transférer les paramètres
|
||
webtopDeployStatusPull=Téléchargement de l'image (~1,6 Go) ...
|
||
webtopDeployStatusTransfer=Transfert de l'image en cours...
|
||
webtopDeployStatusCreate=Création d'un conteneur...
|
||
webtopDeployStatusTest=En attente du démarrage de l'application...
|
||
webtopDeployStatusTransferSettings=Application de l'état...
|
||
saveAs=Enregistrer sous
|
||
unlock=Déverrouiller
|
||
userLoginPasswordManagerDialogTitle=Une autre méthode de déverrouillage du coffre-fort est disponible
|
||
userLoginPasswordManagerDialogContent=Tu peux désormais déverrouiller le coffre-fort via ton gestionnaire de mots de passe. Il te suffit de cliquer sur l'icône en forme d'engrenage à côté du champ de la phrase de passe et de configurer l'entrée dans ton gestionnaire de mots de passe.
|
||
webtopAccessVpnProvider=Connecte le conteneur lui-même à un VPN (le système ne sera accessible qu'au sein du VPN)
|
||
webtopAccessSelfManaged=Gère les accès comme tu veux (contrôle total sur la manière dont les ports seront mis à disposition)
|
||
webtopAccessSshAccess=Se connecter via la clé de l'appli (disponible uniquement dans l'appli)
|
||
webtopPreconfiguredDialogTitle=XPipe Webtop
|
||
webtopPreconfiguredDialogContent=Si tu es un nouvel utilisateur et que tu as commencé par l'environnement Webtop d'XPipe, sache que tu profiteras d'une meilleure expérience sur ton bureau local. De nombreuses intégrations avancées ne sont disponibles et ne fonctionnent que sur ton bureau local. L'environnement Webtop est limité à certains égards, car il s'exécute dans un conteneur.
|
||
webtopAccessWebBrowser=Navigateur web (fonctionne sur n'importe quel appareil équipé d'un navigateur web)
|
||
webtopAccessMobileApp=Application mobile (disponible sur les appareils Android et iOS) [Pas encore sortie]
|
||
webtopAccessBoth=Les deux (depuis un navigateur web et une appli mobile)
|
||
webtopDeploymentAccessScope=Portée d'accès
|
||
webtopDeploymentAccessScopeDescription=Comment tu comptes accéder à Webtop (ça influe sur la configuration du conteneur)
|
||
webtopDeploymentAccessConfig=Contrôle d'accès
|
||
webtopDeploymentAccessConfigDescription=Comment tu veux gérer le contrôle d'accès et la visibilité de l'interface web
|
||
webtopDeploymentVpnType=Type de VPN
|
||
webtopDeploymentVpnTypeDescription=Le VPN facultatif permettant d'accéder au Webtop
|
||
webtopAccessExposePorts=Exposer les ports
|
||
webtopAccessExposePortsDescription=Rendre les ports des conteneurs accessibles depuis l'extérieur
|
||
webtopDeploymentTarget=Cible
|
||
webtopDeploymentAccess=Contrôle d'accès
|
||
webtopDeploymentConfiguration=Configuration des conteneurs
|
||
rdpGatewayHost=Ordinateur hôte de passerelle
|
||
rdpGatewayHostDescription=L'adresse du serveur passerelle RDS
|
||
rdpGatewayPassword=Utiliser un mot de passe
|
||
rdpGatewayPasswordDescription=Est-ce que la passerelle demande un mot de passe pour s'authentifier ?
|
||
rdpGatewayReusePassword=Réutiliser les identifiants
|
||
rdpGatewayReusePasswordDescription=Réutiliser les identifiants du serveur RDP cible pour la passerelle
|
||
rdpGatewayIdentity=Identifiants de la passerelle
|
||
rdpGatewayIdentityDescription=Les identifiants permettant de s'authentifier auprès de la passerelle
|
||
rdpGateway.displayName=Passerelle RD
|
||
rdpGateway.displayDescription=Créer une passerelle Bureau à distance à utiliser avec les connexions RDP
|
||
rdpFile=Fichier RDP
|
||
freeRdpArguments=Arguments supplémentaires de ligne de commande
|
||
freeRdpArgumentsDescription=Ajoute des arguments de ligne de commande personnalisés pour FreeRDP ; chaque ligne correspond à un argument
|
||
remminaRdpArguments=Options supplémentaires
|
||
remminaRdpArgumentsDescription=Ajoute des options personnalisées au fichier .remmina à inclure au lancement ; chaque ligne correspond à une option
|
||
remminaVncArguments=Options supplémentaires
|
||
remminaVncArgumentsDescription=Ajoute des options personnalisées au fichier .remmina à inclure au lancement ; chaque ligne correspond à une option
|
||
webtopMobileConnect=Mobile Connect
|
||
webtopMobileConnectTitle=Se connecter depuis l'appli mobile
|
||
webtopConnectHostConfiguration=Méthode de connexion externe
|
||
webtopConnectHostConfigurationDescription=Comment se connecter à distance au système Webtop
|
||
webtopConnectHostDirect=Hôte/adresse IP directement accessible
|
||
keyAuth=Authentification par clé SSH
|
||
webtopConnectTailscaleDeviceName=Nom de l'appareil Tailscale
|
||
webtopConnectTailscaleDeviceNameDescription=L'identifiant de l'appareil du système Webtop au sein du Tailnet
|
||
webtopConnectNetbirdPeerAddress=Adresse du pair Netbird
|
||
webtopConnectNetbirdPeerAddressDescription=Le nom du nœud du système Webtop au sein de Netbird
|
||
webtopConnectAuth=Authentification
|
||
webtopConnectAuthDescription=La méthode d'authentification pour se connecter à distance en toute sécurité au Webtop
|
||
webtopConnectSshKey=Clé SSH
|
||
webtopConnectSshKeyDescription=Génère automatiquement une nouvelle clé SSH à utiliser pour l'authentification
|
||
webtopConnectSshKeyName=Nom de la clé
|
||
webtopConnectSshKeyNameDescription=Donne un nom unique à cette clé pour pouvoir l'identifier plus tard
|
||
webtopConnectSshKeyNamePrompt=Par exemple, « téléphone pro » si tu veux y accéder depuis cet appareil
|
||
generateCode=Générer un code...
|
||
webtopQrCodeTitle=Scanne le code pour accéder à $NAME$ avec l'appli XPipe
|
||
done=C'est bon
|
||
webtopConnectHostChoice=Adresse de l'hôte
|
||
webtopConnectHostChoiceDescription=Le nom d'hôte ou l'adresse IP accessible depuis l'extérieur, ainsi que le port SSH du conteneur Webtop
|
||
moveDown=Déplacer vers le bas
|
||
moveUp=Déplacer vers le haut
|
||
makeActive=Activer
|
||
multiIdentityExclusive=Lier les identités exclusivement à ceci
|
||
multiIdentityExclusiveDescription=Affiche toutes les identités contenues en tant qu'enfants de cette identité multiple pour une meilleure organisation
|
||
passwordManagerCommandOutputType=Type de sortie de commande
|
||
passwordManagerCommandOutputTypeDescription=Comment les informations confidentielles récupérées sont formatées lorsqu'elles sont affichées sur stdout par la commande. Ça peut être soit un mot de passe brut, soit un format JSON. La sortie JSON est préférable, car elle permet d'inclure plusieurs champs au lieu d'un simple mot de passe.
|
||
passwordManagerCommandOutputTypeRaw=Mot de passe brut
|
||
passwordManagerCommandOutputTypeJson=Objet JSON
|
||
userAddUsername=Nom d'utilisateur
|
||
userAddUsernameDescription=Le nom de l'utilisateur du « vault » avec lequel tu te connectes
|
||
userAddPassphrase=Phrase de passe
|
||
userAddPassphraseDescription=La phrase de passe qui sera nécessaire pour déverrouiller le coffre-fort au démarrage
|
||
userAddRepeatPassphrase=Confirme ton mot de passe
|
||
userAddRepeatPassphraseDescription=Entrez à nouveau la même phrase de passe
|
||
roleAddUsername=Nom du rôle
|
||
roleAddUsernameDescription=Le nom du rôle du coffre-fort
|
||
roleAuthenticationType=Récupération du secret d'un rôle
|
||
roleAuthenticationTypeDescription=Comment récupérer automatiquement le secret de rôle lors du déverrouillage du « vault »
|
||
unavailable=Indisponible
|
||
rolePasswordManagerKey=Entrée d'identifiants
|
||
rolePasswordManagerKeyDescription=L'identifiant du gestionnaire de mots de passe associé au secret de rôle
|
||
roleAllAddDialogTitle=Créer un rôle par défaut initial
|
||
roleAllAddDialogContent=Un coffre-fort basé sur les rôles nécessite un rôle par défaut que tous les utilisateurs doivent posséder. Le secret de ce rôle sert à chiffrer les données du coffre-fort destinées à tous les utilisateurs. Continue pour créer ce rôle.
|
||
roleUnlockFailedTitle=Échec du déverrouillage du Vault
|
||
roleUnlockFailedContent=Le déverrouillage automatique du rôle dans le coffre-fort pour le rôle « $NAME$ » a échoué. Tu veux réessayer ou annuler cette opération ? Ça rendra inaccessibles les connexions qui dépendent de ce rôle
|
||
noRolesAssigned=Aucun rôle attribué
|
||
manyRoles=$NUMBER$ rôles
|
||
allRoles=Tous les rôles
|
||
restrictAccessTo=Limiter l'accès à :
|
||
syncedMultiIdentity=Identités multiples synchronisées
|
||
localMultiIdentity=Identités multiples locales
|
||
webtopUrlDialogTitle=URLs Webtop
|
||
webtopUrlDialogContent=Tu as ouvert une URL XPipe pour te connecter à un environnement Webtop avec l'appli de bureau. Cette URL doit être ouverte sur un appareil mobile sur lequel l'appli XPipe est installée pour relier automatiquement ton environnement Webtop à ton appli.
|
||
syncUrlAlreadySyncedTitle=Synchronisation Git
|
||
syncUrlAlreadySyncedContent=Tu essaies de te connecter à un dépôt Git alors que tu as déjà configuré un autre dépôt distant de synchronisation.
|
||
apiServer=Serveur API
|
||
keePassXcUnlockWaitTitle=Déverrouillage requis
|
||
keePassXcUnlockWaitContent=Ta base de données KeePassXC est actuellement verrouillée. En attente du déverrouillage de la base de données KeePassXC...
|
||
sshCertificateFileLicense=Authentification SSH par certificat
|
||
servicesLicense=Services multiples en tunnel
|
||
dockerContextLicense=Plusieurs contextes Docker
|
||
proxmoxLicense=Plus d'un nœud Proxmox
|
||
hyperVLicense=Connexions Hyper-V
|
||
workspacesLicense=Plusieurs espaces de travail
|
||
teamLicense=Vaults d'équipe
|
||
libvirtLicense=Virtualisation libvirt
|
||
hcloudLicense=Systèmes cloud Hetzner
|
||
teleportLicense=Connexions Teleport
|
||
tailscaleLicense=Plus d'un « tailnet »
|
||
netbirdLicense=Plus d'un profil Netbird
|
||
awsLicense=Systèmes AWS
|
||
proxmoxEnterpriseLicense=Systèmes Proxmox Enterprise
|
||
enterpriseOsLicense=Systèmes d'exploitation d'entreprise
|
||
ciscoLicense=Appareils réseau Cisco
|
||
juniperLicense=Appareils réseau Juniper
|
||
remoteDesktopGatewayLicense=Passerelles RDP
|
||
rdpHidpi=Optimiser pour les écrans Retina
|
||
rdpHidpiDescription=Active les optimisations HiDPI pour utiliser la résolution native maximale dès que possible
|
||
vaultMigratedTitle=Migration du Vault
|
||
vaultMigratedContent=Ton « vault » a été migré. Note que la migration a supprimé tous les utilisateurs et groupes associés au « vault » ; tu devras donc les recréer dans le menu des paramètres.
|
||
vaultMigratedGitContent=Ton coffre-fort a été migré. Note que la migration a supprimé tous les utilisateurs et groupes du coffre-fort ; tu devras donc les recréer dans le menu des paramètres.\n\nUne fois que tu auras fait ça, tu pourras aussi réactiver la synchronisation Git.\n\nNote qu’en raison de bugs dans la v23.9 et les versions antérieures, ne charge pas le coffre-fort synchronisé à partir de ces anciennes versions maintenant qu’il a été migré. Installe manuellement les mises à jour sur les autres systèmes synchronisés avant de lancer XPipe, sinon le coffre-fort risque d’être corrompu et devra être restauré manuellement à l’aide de la commande `git reset`.
|
||
orderDisabledNotice=Impossible de réorganiser les éléments dans le mode de tri actuel
|
||
skipAllRoles=Ignorer tous les rôles
|
||
skipRole=Ignorer le rôle
|
||
disableRole=Désactiver le rôle
|
||
feedback=Commentaires
|
||
bitwardenCustomServerToggle=Utiliser un serveur Bitwarden personnalisé
|
||
bitwardenCustomServerToggleDescription=Faut-il utiliser un serveur personnalisé pour Bitwarden plutôt que bitwarden.com ?
|
||
bitwardenCustomServer=Adresse du serveur
|
||
bitwardenCustomServerDescription=L'adresse du serveur Bitwarden
|
||
bitwardenCustomServerTitle=Connexion au serveur Bitwarden
|
||
batchActionsIncompatible=Des types d’entrées mixtes ont été sélectionnés, aucune action n’est disponible
|
||
batchActionsEmpty=Aucune action n'est disponible pour les entrées sélectionnées
|
||
commitChanges=Valider les modifications
|
||
bitwardenPasswordPlaceholder=Nom de l'élément | UUID de l'élément
|
||
bitwardenPasswordLogin=Mot de passe
|
||
bitwardenSsoLogin=SSO
|
||
bitwardenApiKeyLogin=Clé API
|
||
bitwardenLoginMethod=Méthode de connexion
|
||
bitwardenLoginMethodDescription=Comment se connecter à son compte Bitwarden
|
||
externalLaunchTitle=Lancement d'une connexion externe
|
||
externalLaunchContent=Une demande d'établissement de connexion a été envoyée par un client externe. Est-ce toi qui l'as lancée et veux-tu autoriser cette opération à l'avenir ?
|
||
selectAvailableRoles=Sélectionne les rôles disponibles
|
||
multiIdentity=Identité multiple
|