diff --git a/erpnext/translations/fr.csv b/erpnext/translations/fr.csv
index 19c0501..43c2bf2 100644
--- a/erpnext/translations/fr.csv
+++ b/erpnext/translations/fr.csv
@@ -1,5839 +1,5772 @@
-DocType: Employee,Salary Mode,Mode de Rémunération
-DocType: Patient,Divorced,Divorcé
-DocType: Buying Settings,Allow Item to be added multiple times in a transaction,Autoriser un article à être ajouté plusieurs fois dans une transaction
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,Annuler la Visite Matérielle {0} avant d'annuler cette Réclamation de Garantie
-apps/erpnext/erpnext/config/education.py +118,Assessment Reports,Rapports d&#39;évaluation
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19,Consumer Products,Produits de Consommation
-DocType: Purchase Receipt,Subscription Detail,Détail de l'Abonnement
-DocType: Supplier Scorecard,Notify Supplier,Notifier Fournisseur
-DocType: Item,Customer Items,Articles du clients
-DocType: Project,Costing and Billing,Coûts et Facturation
-apps/erpnext/erpnext/accounts/doctype/account/account.py +48,Account {0}: Parent account {1} can not be a ledger,Compte {0}: Le Compte parent {1} ne peut pas être un grand livre
-DocType: Item,Publish Item to hub.erpnext.com,Publier un Artice sur hub.erpnext.com
-apps/erpnext/erpnext/config/setup.py +88,Email Notifications,Notifications par Email
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26,Evaluation,Évaluation
-DocType: Item,Default Unit of Measure,Unité de Mesure par Défaut
-DocType: SMS Center,All Sales Partner Contact,Tous les Contacts de Partenaires Commerciaux
-DocType: Employee,Leave Approvers,Approbateurs de Congés
-DocType: Sales Partner,Dealer,Revendeur
-DocType: Consultation,Investigations,Enquêtes
-DocType: Restaurant Order Entry,Click Enter To Add,Cliquez sur Entrée pour Ajouter
-DocType: Employee,Rented,Loué
-DocType: Purchase Order,PO-,PO-
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +225,"Stopped Production Order cannot be cancelled, Unstop it first to cancel","Un Ordre de Fabrication Arrêté ne peut pas être annulé, remettez le d'abord en marche pour l'annuler"
-DocType: Vehicle Service,Mileage,Kilométrage
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +253,Do you really want to scrap this asset?,Voulez-vous vraiment mettre cet actif au rebut ?
-DocType: Drug Prescription,Update Schedule,Mettre à Jour le Calendrier
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44,Select Default Supplier,Sélectionner le Fournisseur par Défaut
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37,Currency is required for Price List {0},Devise est nécessaire pour la liste de prix {0}
-DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,* Sera calculé lors de la transaction.
-DocType: Purchase Order,Customer Contact,Contact Client
-DocType: Patient Appointment,Check availability,Voir les Disponibilités
-DocType: Job Applicant,Job Applicant,Demandeur d'Emploi
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6,This is based on transactions against this Supplier. See timeline below for details,Basé sur les transactions avec ce fournisseur. Voir la chronologie ci-dessous pour plus de détails
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120,Legal,Juridique
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191,Actual type tax cannot be included in Item rate in row {0},Le type de taxe réel ne peut pas être inclus dans le prix de l'Article à la ligne {0}
-DocType: Bank Guarantee,Customer,Client
-DocType: Purchase Receipt Item,Required By,Requis Par
-DocType: Delivery Note,Return Against Delivery Note,Retour contre Bon de Livraison
-DocType: Purchase Order,% Billed,% Facturé
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43,Exchange Rate must be same as {0} {1} ({2}),Taux de Change doit être le même que {0} {1} ({2})
-DocType: Sales Invoice,Customer Name,Nom du Client
-DocType: Vehicle,Natural Gas,Gaz Naturel
-apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64,Bank account cannot be named as {0},Compte Bancaire ne peut pas être nommé {0}
-DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,Titres (ou groupes) sur lequel les entrées comptables sont faites et les soldes sont maintenus.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196,Outstanding for {0} cannot be less than zero ({1}),Solde pour {0} ne peut pas être inférieur à zéro ({1})
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +343,There are no submitted Salary Slips to process.,Il n'y a aucune Fiche de Paie à traiter.
-DocType: Manufacturing Settings,Default 10 mins,10 minutes Par Défaut
-DocType: Leave Type,Leave Type Name,Nom du Type de Congé
-apps/erpnext/erpnext/templates/pages/projects.js +62,Show open,Afficher ouverte
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8,It is necessary to take this action today itself for the above mentioned recurring,Il est nécessaire de faire cette action aujourd'hui pour les documents récurrents mentionnés ci-dessus
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.py +24,Diagnosis and Complaints cannot be left blank,Le diagnostic et les plaintes ne peuvent être laissés en blanc
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +151,Series Updated Successfully,Mise à jour des Séries Réussie
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6,Checkout,Règlement
-DocType: Pricing Rule,Apply On,Appliquer Sur
-DocType: Item Price,Multiple Item prices.,Plusieurs Prix d'Articles.
-,Purchase Order Items To Be Received,Articles à Recevoir du Bon de Commande
-DocType: SMS Center,All Supplier Contact,Tous les Contacts Fournisseurs
-DocType: Support Settings,Support Settings,Réglages du Support
-apps/erpnext/erpnext/projects/doctype/project/project.py +74,Expected End Date can not be less than Expected Start Date,Date de Fin Attendue ne peut pas être antérieure à Date de Début Attendue
-apps/erpnext/erpnext/utilities/transaction_base.py +117,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,Ligne #{0} : Le Prix doit être le même que {1}: {2} ({3} / {4})
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241,New Leave Application,Nouvelle Demande de Congés
-,Batch Item Expiry Status,Statut d'Expiration d'Article du Lot
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184,Bank Draft,Traite Bancaire
-DocType: Membership,membership validaty section,section validaty d&#39;adhésion
-DocType: Mode of Payment Account,Mode of Payment Account,Compte du Mode de Paiement
-DocType: Consultation,Consultation,Consultation
-DocType: Accounts Settings,Show Payment Schedule in Print,Afficher le calendrier de paiement dans Imprimer
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19,Sales and Returns,Ventes et retours
-apps/erpnext/erpnext/stock/doctype/item/item.js +56,Show Variants,Afficher les Variantes
-DocType: Academic Term,Academic Term,Terme Académique
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14,Material,Matériel
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66,Making website,Faire un site web
-DocType: Opening Invoice Creation Tool Item,Quantity,Quantité
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546,Accounts table cannot be blank.,Le tableau de comptes ne peut être vide.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154,Loans (Liabilities),Prêts (Passif)
-DocType: Employee Education,Year of Passing,Année de Passage
-DocType: Item,Country of Origin,Pays d'Origine
-DocType: Soil Texture,Soil Texture Criteria,Critères de texture du sol
-apps/erpnext/erpnext/templates/includes/product_page.js +24,In Stock,En Stock
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16,Primary Contact Details,Détails du contact principal
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46,Open Issues,Ouvrir les Questions
-DocType: Production Order,Production Plan Item,Article du Plan de Production
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +149,User {0} is already assigned to Employee {1},Utilisateur {0} est déjà attribué à l'Employé {1}
-DocType: Lab Test Groups,Add new line,Ajouter une nouvelle ligne
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31,Health Care,Soins de Santé
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65,Delay in payment (Days),Retard de paiement (jours)
-DocType: Payment Terms Template Detail,Payment Terms Template Detail,Détail du modèle de conditions de paiement
-DocType: Hotel Room Reservation,Guest Name,Nom de l&#39;invité
-DocType: Lab Prescription,Lab Prescription,Prescription de laboratoire
-,Delay Days,Jours de retard
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26,Service Expense,Frais de Service
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899,Serial Number: {0} is already referenced in Sales Invoice: {1},Numéro de Série: {0} est déjà référencé dans la Facture de Vente: {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880,Invoice,Facture
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145,Make Retention Stock Entry,Faire une entrée en stock de rétention
-DocType: Purchase Invoice Item,Item Weight Details,Détails du poids de l&#39;article
-DocType: Asset Maintenance Log,Periodicity,Périodicité
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21,Fiscal Year {0} is required,Exercice Fiscal {0} est nécessaire
-DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,La distance minimale entre les rangées de plantes pour une croissance optimale
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21,Defense,Défense
-DocType: Salary Component,Abbr,Abré
-DocType: Appraisal Goal,Score (0-5),Score (0-5)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225,Row {0}: {1} {2} does not match with {3},Ligne {0} : {1} {2} ne correspond pas à {3}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77,Row # {0}:,Ligne # {0} :
-DocType: Timesheet,Total Costing Amount,Montant Total des Coûts
-DocType: Delivery Note,Vehicle No,N° du Véhicule
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +162,Please select Price List,Veuillez sélectionner une Liste de Prix
-DocType: Accounts Settings,Currency Exchange Settings,Paramètres d&#39;échange de devises
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +78,Row #{0}: Payment document is required to complete the trasaction,Ligne #{0} : Document de paiement nécessaire pour compléter la transaction
-DocType: Production Order Operation,Work In Progress,Travaux En Cours
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13,Please select date,Veuillez sélectionner une date
-DocType: Daily Work Summary Group,Holiday List,Liste de Vacances
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127,Accountant,Comptable
-DocType: Hub Settings,Selling Price List,Liste de prix de vente
-DocType: Patient,Tobacco Current Use,Consommation actuelle de tabac
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56,Selling Rate,Prix de vente
-DocType: Cost Center,Stock User,Chargé des Stocks
-DocType: Soil Analysis,(Ca+Mg)/K,(Ca + Mg) / K
-DocType: Company,Phone No,N° de Téléphone
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239,New {0}: #{1},Nouveau(elle) {0}: # {1}
-DocType: Delivery Trip,Initial Email Notification Sent,Notification initiale par e-mail envoyée
-,Sales Partners Commission,Commission des Partenaires de Vente
-DocType: Soil Texture,Sandy Clay Loam,terreau de sol argileux
-DocType: Purchase Invoice,Rounding Adjustment,Arrondi
-apps/erpnext/erpnext/setup/doctype/company/company.py +46,Abbreviation cannot have more than 5 characters,L'abbréviation ne peut pas avoir plus de 5 caractères
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51,Customer &gt; Customer Group &gt; Territory,Client&gt; Groupe de clients&gt; Territoire
-DocType: Physician Schedule Time Slot,Physician Schedule Time Slot,Créneaux Horaires du Médecin
-DocType: Payment Request,Payment Request,Requête de Paiement
-DocType: Asset,Value After Depreciation,Valeur Après Amortissement
-DocType: Student,O+,O+
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8,Related,En Relation
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43,Attendance date can not be less than employee's joining date,Date de présence ne peut pas être antérieure à la date d'embauche de l'employé
-DocType: Grading Scale,Grading Scale Name,Nom de l'Échelle de Notation
-DocType: Subscription,Repeat on Day,Répéter Chaque
-apps/erpnext/erpnext/accounts/doctype/account/account.js +41,This is a root account and cannot be edited.,Il s'agit d'un compte racine qui ne peut être modifié.
-DocType: Sales Invoice,Company Address,Adresse de la Société
-DocType: BOM,Operations,Opérations
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},Impossible de définir l'autorisation sur la base des Prix Réduits pour {0}
-DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name","Attacher un fichier .csv avec deux colonnes, une pour l'ancien nom et une pour le nouveau nom"
-apps/erpnext/erpnext/accounts/utils.py +73,{0} {1} not in any active Fiscal Year.,{0} {1} dans aucun Exercice actif.
-DocType: Packed Item,Parent Detail docname,Nom de Document du Détail Parent
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69,"Reference: {0}, Item Code: {1} and Customer: {2}","Référence: {0}, Code de l&#39;article: {1} et Client: {2}"
-apps/erpnext/erpnext/utilities/user_progress.py +143,Kg,Kg
-apps/erpnext/erpnext/config/hr.py +45,Opening for a Job.,Ouverture d'un Emploi.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114,BOM is not specified for subcontracting item {0} at row {1},La nomenclature n&#39;est pas spécifiée pour l&#39;article de sous-traitance {0} sur la ligne {1}
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149,{0} Result submittted,Résultat {0} soumis
-DocType: Item Attribute,Increment,Incrément
-apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74,Timespan,Période
-apps/erpnext/erpnext/public/js/stock_analytics.js +61,Select Warehouse...,Sélectionner l'Entrepôt ...
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6,Advertising,Publicité
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22,Same Company is entered more than once,La même Société a été entrée plus d'une fois
-DocType: Patient,Married,Marié
-apps/erpnext/erpnext/accounts/party.py +42,Not permitted for {0},Non autorisé pour {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593,Get items from,Obtenir les articles de
-DocType: Price List,Price Not UOM Dependant,Prix non dépendent d' UOM
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467,Stock cannot be updated against Delivery Note {0},Stock ne peut pas être mis à jour pour le Bon de Livraison {0}
-apps/erpnext/erpnext/templates/pages/home.py +25,Product {0},Produit {0}
-apps/erpnext/erpnext/templates/generators/item_group.html +43,No items listed,Aucun article référencé
-DocType: Asset Repair,Error Description,Erreur de description
-DocType: Payment Reconciliation,Reconcile,Réconcilier
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30,Grocery,Épicerie
-DocType: Quality Inspection Reading,Reading 1,Lecture 1
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40,Pension Funds,Fonds de Pension
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +91,Next Depreciation Date cannot be before Purchase Date,La Date de l’Amortissement Suivant ne peut pas être avant la Date d’Achat
-DocType: Crop,Perennial,Vivace
-DocType: Consultation,Consultation Date,Date de Consultation
-DocType: Accounts Settings,Use Custom Cash Flow Format,Utiliser le format de flux de trésorerie personnalisé
-DocType: SMS Center,All Sales Person,Tous les Commerciaux
-DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,**Répartition Mensuelle** vous aide à diviser le Budget / la Cible sur plusieurs mois si vous avez de la saisonnalité dans votre entreprise.
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1752,Not items found,Pas d'objets trouvés
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183,Salary Structure Missing,Grille des Salaires Manquante
-DocType: Lead,Person Name,Nom de la Personne
-DocType: Sales Invoice Item,Sales Invoice Item,Article de la Facture de Vente
-DocType: Account,Credit,Crédit
-DocType: POS Profile,Write Off Cost Center,Centre de Coûts des Reprises
-apps/erpnext/erpnext/public/js/setup_wizard.js +117,"e.g. ""Primary School"" or ""University""","e.g. ""École Primaire"" ou ""Université"""
-apps/erpnext/erpnext/config/stock.py +28,Stock Reports,Rapports de Stock
-DocType: Warehouse,Warehouse Detail,Détail de l'Entrepôt
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,La Date de Fin de Terme ne peut pas être postérieure à la Date de Fin de l'Année Académique à laquelle le terme est lié (Année Académique {}). Veuillez corriger les dates et essayer à nouveau.
-apps/erpnext/erpnext/stock/doctype/item/item.py +268,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item",'Est un Actif Immobilisé’ doit être coché car il existe une entrée d’Actif pour cet article
-DocType: Delivery Trip,Departure Time,Heure de départ
-DocType: Vehicle Service,Brake Oil,Liquide de Frein
-DocType: Tax Rule,Tax Type,Type de Taxe
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +581,Taxable Amount,Montant Taxable
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160,You are not authorized to add or update entries before {0},Vous n'êtes pas autorisé à ajouter ou faire une mise à jour des écritures avant le {0}
-DocType: BOM,Item Image (if not slideshow),Image de l'Article (si ce n'est diaporama)
-DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,(Tarif Horaire / 60) * Temps Réel d’Opération
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1076,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,Ligne {0}: Le Type de Document de Référence doit être soit une Note de Frais soit une Écriture de Journal
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +966,Select BOM,Sélectionner LDM
-DocType: SMS Log,SMS Log,Journal des SMS
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,Coût des Articles Livrés
-apps/erpnext/erpnext/config/hr.py +127,Manage advance amount given to the Employee,Gérer le montant anticipé donné à l&#39;employé
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38,The holiday on {0} is not between From Date and To Date,Le jour de vacances {0} n’est pas compris entre la Date Initiale et la Date Finale
-DocType: Student Log,Student Log,Journal des Étudiants
-apps/erpnext/erpnext/config/buying.py +165,Templates of supplier standings.,Modèles de Classements Fournisseurs.
-DocType: Lead,Interested,Intéressé
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216,Opening,Ouverture
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},Du {0} au {1}
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50,Failed to setup taxes,Échec de la configuration des taxes
-DocType: Item,Copy From Item Group,Copier Depuis un Groupe d'Articles
-DocType: Delivery Trip,Delivery Notification,Notification de livraison
-DocType: Journal Entry,Opening Entry,Écriture d'Ouverture
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25,Account Pay Only,Compte Bénéficiaire Seulement
-DocType: Employee Loan,Repay Over Number of Periods,Rembourser Sur le Nombre de Périodes
-DocType: Stock Entry,Additional Costs,Frais Supplémentaires
-apps/erpnext/erpnext/accounts/doctype/account/account.py +138,Account with existing transaction can not be converted to group.,Un compte contenant une transaction ne peut pas être converti en groupe
-DocType: Lead,Product Enquiry,Demande d'Information Produit
-DocType: Education Settings,Validate Batch for Students in Student Group,Valider le Lot pour les Étudiants en Groupe Étudiant
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35,No leave record found for employee {0} for {1},Aucun congé trouvé pour l’employé {0} pour {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23,Please enter company first,Veuillez d’abord entrer une Société
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365,Please select Company first,Veuillez d’abord sélectionner une Société
-DocType: Employee Education,Under Graduate,Non Diplômé
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27,Target On,Cible Sur
-DocType: BOM,Total Cost,Coût Total
-DocType: Soil Analysis,Ca/K,Ca / K
-DocType: Journal Entry Account,Employee Loan,Prêt Employé
-DocType: Fee Schedule,Send Payment Request Email,Envoyer un Email de Demande de Paiement
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +269,Item {0} does not exist in the system or has expired,L'article {0} n'existe pas dans le système ou a expiré
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44,Real Estate,Immobilier
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1,Statement of Account,Relevé de Compte
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41,Pharmaceuticals,Médicaments
-DocType: Purchase Invoice Item,Is Fixed Asset,Est Immobilisation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +260,"Available qty is {0}, you need {1}","Qté disponible est {0}, vous avez besoin de {1}"
-DocType: Expense Claim Detail,Claim Amount,Montant Réclamé
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56,Duplicate customer group found in the cutomer group table,Groupe de clients en double trouvé dans le tableau des groupes de clients
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31,Supplier Type / Supplier,Fournisseur / Type de Fournisseur
-DocType: Naming Series,Prefix,Préfixe
-apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7,Event Location,Lieu de l'Événement
-DocType: Asset Settings,Asset Settings,Paramètres de l&#39;actif
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68,Consumable,Consommable
-DocType: Student,B-,B-
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98,Successfully unregistered.,Désinscription réussie.
-DocType: Assessment Result,Grade,Note
-DocType: Restaurant Table,No of Seats,Nombre de Sièges
-DocType: Subscription,"To add dynamic subject, use jinja tags like
-
-<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>","Pour ajouter un sujet dynamique, utilisez des tags jinja comme <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>"
-DocType: Sales Invoice Item,Delivered By Supplier,Livré par le Fournisseur
-DocType: Asset Maintenance Task,Asset Maintenance Task,Tâche de Maintenance des Actifs
-DocType: SMS Center,All Contact,Tout Contact
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954,Production Order already created for all items with BOM,Ordre de Production déjà créé pour tous les articles avec LDM
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +231,Annual Salary,Salaire Annuel
-DocType: Daily Work Summary,Daily Work Summary,Récapitulatif Quotidien de Travail
-DocType: Period Closing Voucher,Closing Fiscal Year,Clôture de l'Exercice
-apps/erpnext/erpnext/accounts/party.py +393,{0} {1} is frozen,{0} {1} est gelée
-apps/erpnext/erpnext/setup/doctype/company/company.py +140,Please select Existing Company for creating Chart of Accounts,Veuillez sélectionner une Société Existante pour créer un Plan de Compte
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80,Stock Expenses,Charges de Stock
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +111,Select Target Warehouse,Sélectionner l'Entrepôt Cible
-apps/erpnext/erpnext/hr/doctype/employee/employee.js +80,Please enter Preferred Contact Email,Veuillez entrer l’Email de Contact Préférré
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxNum,CompAuxNum
-DocType: Journal Entry,Contra Entry,Contre-passation
-DocType: Journal Entry Account,Credit in Company Currency,Crédit dans la Devise de la Société
-DocType: Lab Test UOM,Lab Test UOM,UDM de test de laboratoire
-DocType: Delivery Note,Installation Status,Etat de l'Installation
-DocType: BOM,Quality Inspection Template,Modèle d&#39;inspection de la qualité
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135,"Do you want to update attendance?<br>Present: {0}\
-					<br>Absent: {1}",Voulez-vous mettre à jour la fréquentation? <br> Présents: {0} \ <br> Absent: {1}
-apps/erpnext/erpnext/controllers/buying_controller.py +344,Accepted + Rejected Qty must be equal to Received quantity for Item {0},La Qté Acceptée + Rejetée doit être égale à la quantité Reçue pour l'Article {0}
-DocType: Request for Quotation,RFQ-,RFQ-
-DocType: Item,Supply Raw Materials for Purchase,Fournir les Matières Premières pour l'Achat
-DocType: Agriculture Analysis Criteria,Fertilizer,Engrais
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152,At least one mode of payment is required for POS invoice.,Au moins un mode de paiement est nécessaire pour une facture de PDV
-DocType: Products Settings,Show Products as a List,Afficher les Produits en Liste
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +519,Item {0} is not active or end of life has been reached,L'article {0} n’est pas actif ou sa fin de vie a été atteinte
-DocType: Student Admission Program,Minimum Age,Âge Minimum
-apps/erpnext/erpnext/utilities/user_progress.py +187,Example: Basic Mathematics,Exemple : Mathématiques de Base
-DocType: Customer,Primary Address,Adresse principale
-DocType: Production Plan,Material Request Detail,Détail de la demande de matériel
-DocType: Selling Settings,Default Quotation Validity Days,Validité des jours de validité
-apps/erpnext/erpnext/controllers/accounts_controller.py +793,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Pour inclure la taxe de la ligne {0} dans le prix de l'Article, les taxes des lignes {1} doivent également être incluses"
-apps/erpnext/erpnext/config/hr.py +223,Settings for HR Module,Réglages pour le Module RH
-DocType: SMS Center,SMS Center,Centre des SMS
-DocType: Sales Invoice,Change Amount,Changer le Montant
-DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,Définir la valeur de facture pour B2C. B2CL et B2CS calculés sur la base de cette valeur de facture.
-DocType: BOM Update Tool,New BOM,Nouvelle LDM
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36,Show only POS,Afficher uniquement les points de vente
-DocType: Driver,Driving License Categories,Catégories de permis de conduire
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118,Please enter Delivery Date,Entrez la Date de Livraison
-DocType: Depreciation Schedule,Make Depreciation Entry,Créer une Écriture d'Amortissement
-DocType: Appraisal Template Goal,KRA,KRA
-DocType: Lead,Request Type,Type de Demande
-apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17,Make Employee,Créer un Employé
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14,Broadcasting,Radio/Télévision
-apps/erpnext/erpnext/config/accounts.py +313,Setup mode of POS (Online / Offline),Mode de configuration de POS (en ligne / hors ligne)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191,Execution,Exécution
-apps/erpnext/erpnext/config/manufacturing.py +62,Details of the operations carried out.,Détails des opérations effectuées.
-DocType: Asset Maintenance Log,Maintenance Status,Statut d'Entretien
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10,Membership Details,Détails de l&#39;adhésion
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56,{0} {1}: Supplier is required against Payable account {2},{0} {1} : Un Fournisseur est requis pour le Compte Créditeur {2}
-apps/erpnext/erpnext/config/selling.py +52,Items and Pricing,Articles et Prix
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2,Total hours: {0},Nombre total d'heures : {0}
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,From Date should be within the Fiscal Year. Assuming From Date = {0},La Date Initiale doit être dans l'Exercice Fiscal. En supposant Date Initiale = {0}
-DocType: Drug Prescription,Interval,Intervalle
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +252,Preference,Préférence
-DocType: Grant Application,Individual,Individuel
-DocType: Academic Term,Academics User,Utilisateur académique
-DocType: Cheque Print Template,Amount In Figure,Montant En Chiffre
-DocType: Employee Loan Application,Loan Info,Infos sur le Prêt
-apps/erpnext/erpnext/config/maintenance.py +12,Plan for maintenance visits.,Plan pour les visites de maintenance.
-DocType: Supplier Scorecard Period,Supplier Scorecard Period,Période de la Fiche d'Évaluation Fournisseur
-DocType: Share Transfer,Share Transfer,Transfert de partage
-DocType: POS Profile,Customer Groups,Groupes de Clients
-apps/erpnext/erpnext/public/js/financial_statements.js +51,Financial Statements,États Financiers
-DocType: Guardian,Students,Étudiants
-apps/erpnext/erpnext/config/selling.py +91,Rules for applying pricing and discount.,Règles pour l’application des tarifs et des remises.
-DocType: Daily Work Summary,Daily Work Summary Group,Groupe résumé de travail quotidien
-DocType: Physician Schedule,Time Slots,Créneaux Horaires
-apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,La Liste de Prix doit être applicable pour les Achats et les Ventes
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79,Installation date cannot be before delivery date for Item {0},Date d'installation ne peut pas être avant la date de livraison pour l'Article {0}
-DocType: Pricing Rule,Discount on Price List Rate (%),Remise sur la Liste des Prix (%)
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112,Item Template,Modèle d&#39;article
-apps/erpnext/erpnext/healthcare/setup.py +215,Biochemistry,Biochimie
-DocType: Job Offer,Select Terms and Conditions,Sélectionner les Termes et Conditions
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72,Out Value,Valeur Sortante
-DocType: Production Plan,Sales Orders,Commandes Clients
-DocType: Purchase Taxes and Charges,Valuation,Valorisation
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +386,Set as Default,Définir par défaut
-DocType: Production Plan,PLN-,PLN-
-,Purchase Order Trends,Tendances des Bons de Commande
-apps/erpnext/erpnext/utilities/user_progress.py +75,Go to Customers,Aller aux Clients
-DocType: Hotel Room Reservation,Late Checkin,Arrivée tardive
-apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7,The request for quotation can be accessed by clicking on the following link,La demande de devis peut être consultée en cliquant sur le lien suivant
-apps/erpnext/erpnext/config/hr.py +81,Allocate leaves for the year.,Allouer des congés pour l'année.
-DocType: SG Creation Tool Course,SG Creation Tool Course,Cours de Création d'Outil SG
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +262,Insufficient Stock,Stock Insuffisant
-DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,Désactiver la Plannification de Capacité et la Gestion du Temps
-DocType: Email Digest,New Sales Orders,Nouvelles Commandes Client
-DocType: Bank Guarantee,Bank Account,Compte Bancaire
-DocType: Leave Type,Allow Negative Balance,Autoriser un Solde Négatif
-apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13,You cannot delete Project Type 'External',Vous ne pouvez pas supprimer le Type de Projet 'Externe'
-DocType: Employee,Create User,Créer un Utilisateur
-DocType: Selling Settings,Default Territory,Région par Défaut
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53,Television,Télévision
-DocType: Production Order Operation,Updated via 'Time Log',Mis à jour via 'Journal du Temps'
-apps/erpnext/erpnext/controllers/taxes_and_totals.py +430,Advance amount cannot be greater than {0} {1},Montant de l'avance ne peut être supérieur à {0} {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalCode,JournalCode
-DocType: Naming Series,Series List for this Transaction,Liste des Séries pour cette Transaction
-DocType: Company,Enable Perpetual Inventory,Autoriser l'Inventaire Perpétuel
-DocType: Company,Default Payroll Payable Account,Compte de Paie par Défaut
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51,Update Email Group,Metter à jour le Groupe d'Email
-DocType: Sales Invoice,Is Opening Entry,Est Écriture Ouverte
-DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ","Si non cochée, l'article n'apparaîtra pas dans la facture de vente, mais peut être utilisé dans la création de test de groupe."
-DocType: Customer Group,Mention if non-standard receivable account applicable,Mentionner si le compte débiteur applicable n'est pas standard
-DocType: Course Schedule,Instructor Name,Nom de l'Instructeur
-DocType: Supplier Scorecard,Criteria Setup,Configuration du Critère
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +206,For Warehouse is required before Submit,Pour l’Entrepôt est requis avant de Soumettre
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8,Received On,Reçu Le
-DocType: Sales Partner,Reseller,Revendeur
-DocType: Codification Table,Medical Code,Code Médical
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20,Please enter Company,Veuillez entrer une Société
-DocType: Delivery Note Item,Against Sales Invoice Item,Pour l'Article de la Facture de Vente
-DocType: Agriculture Analysis Criteria,Linked Doctype,Doctype lié
-,Production Orders in Progress,Ordres de Production en Cours
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44,Net Cash from Financing,Trésorerie Nette des Financements
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2359,"LocalStorage is full , did not save","Le Stockage Local est plein, l’enregistrement n’a pas fonctionné"
-DocType: Lead,Address & Contact,Adresse &amp; Contact
-DocType: Leave Allocation,Add unused leaves from previous allocations,Ajouter les congés inutilisés des précédentes allocations
-DocType: Sales Partner,Partner website,Site Partenaire
-DocType: Restaurant Order Entry,Add Item,Ajouter un Article
-DocType: Lab Test,Custom Result,Résultat Personnalisé
-DocType: Delivery Stop,Contact Name,Nom du Contact
-DocType: Course Assessment Criteria,Course Assessment Criteria,Critères d'Évaluation du Cours
-DocType: POS Customer Group,POS Customer Group,Groupe Clients PDV
-DocType: Land Unit,Land Unit describing various land assets,Unité terrestre décrivant divers biens fonciers
-DocType: Cheque Print Template,Line spacing for amount in words,Espacement des lignes pour le montant en lettres
-DocType: Vehicle,Additional Details,Détails Supplémentaires
-apps/erpnext/erpnext/templates/generators/bom.html +85,No description given,Aucune Description
-apps/erpnext/erpnext/config/buying.py +13,Request for purchase.,Demande d'Achat.
-DocType: Lab Test,Submitted Date,Date Soumise
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6,This is based on the Time Sheets created against this project,Basé sur les Feuilles de Temps créées pour ce projet
-DocType: Payment Term,Credit Months,Mois de crédit
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +408,Net Pay cannot be less than 0,Salaire Net ne peut pas être inférieur à 0
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,"To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription","Pour arrêter d&#39;envoyer des notifications d&#39;erreurs répétitives du système, nous avons coché la case Disabled dans l&#39;abonnement"
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +121,Relieving Date must be greater than Date of Joining,La Date de Relève doit être postérieure à la Date d’Embauche
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239,Leaves per Year,Congés par Année
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,Ligne {0} : Veuillez vérifier 'Est Avance' sur le compte {1} si c'est une avance.
-apps/erpnext/erpnext/stock/utils.py +219,Warehouse {0} does not belong to company {1},L'entrepôt {0} n'appartient pas à la société {1}
-DocType: Email Digest,Profit & Loss,Profits & Pertes
-apps/erpnext/erpnext/utilities/user_progress.py +144,Litre,Litre
-DocType: Task,Total Costing Amount (via Time Sheet),Montant Total des Coûts (via Feuille de Temps)
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +69,Please setup Students under Student Groups,Veuillez configurer les Étudiants sous des groupes d'Étudiants
-DocType: Item Website Specification,Item Website Specification,Spécification de l'Article sur le Site Web
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449,Leave Blocked,Laisser Verrouillé
-apps/erpnext/erpnext/stock/doctype/item/item.py +739,Item {0} has reached its end of life on {1},L'article {0} a atteint sa fin de vie le {1}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83,Bank Entries,Écritures Bancaires
-DocType: Crop,Annual,Annuel
-DocType: Stock Reconciliation Item,Stock Reconciliation Item,Article de Réconciliation du Stock
-DocType: Stock Entry,Sales Invoice No,N° de la Facture de Vente
-DocType: Material Request Item,Min Order Qty,Qté de Commande Min
-DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,Cours sur l'Outil de Création de Groupe d'Étudiants
-DocType: Lead,Do Not Contact,Ne Pas Contacter
-apps/erpnext/erpnext/utilities/user_progress.py +207,People who teach at your organisation,Personnes qui enseignent dans votre organisation
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135,Software Developer,Developeur Logiciel
-DocType: Item,Minimum Order Qty,Qté de Commande Minimum
-DocType: Pricing Rule,Supplier Type,Type de Fournisseur
-DocType: Course Scheduling Tool,Course Start Date,Date de Début du Cours
-,Student Batch-Wise Attendance,Présence par Lots d'Étudiants
-DocType: POS Profile,Allow user to edit Rate,Autoriser l'utilisateur à modifier le Taux
-DocType: Item,Publish in Hub,Publier dans le Hub
-DocType: Student Admission,Student Admission,Admission des Étudiants
-,Terretory,Territoire
-apps/erpnext/erpnext/stock/doctype/item/item.py +761,Item {0} is cancelled,Article {0} est annulé
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1055,Material Request,Demande de Matériel
-DocType: Bank Reconciliation,Update Clearance Date,Mettre à Jour la Date de Compensation
-,GSTR-2,GSTR-2
-DocType: Item,Purchase Details,Détails de l'Achat
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +394,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},Article {0} introuvable dans la table 'Matières Premières Fournies' dans la Commande d'Achat {1}
-DocType: Salary Slip,Total Principal Amount,Montant total du capital
-DocType: Student Guardian,Relation,Relation
-DocType: Student Guardian,Mother,Mère
-DocType: Restaurant Reservation,Reservation End Time,Heure de fin de la réservation
-DocType: Crop,Biennial,Biennal
-apps/erpnext/erpnext/config/selling.py +18,Confirmed orders from Customers.,Commandes confirmées des clients.
-DocType: Purchase Receipt Item,Rejected Quantity,Quantité Rejetée
-apps/erpnext/erpnext/education/doctype/fees/fees.py +80,Payment request {0} created,Demande de paiement {0} créée
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Open Orders,Commandes ouvertes
-apps/erpnext/erpnext/healthcare/setup.py +255,Low Sensitivity,Faible Sensibilité
-DocType: Notification Control,Notification Control,Contrôle de Notification
-apps/erpnext/erpnext/templates/emails/training_event.html +17,Please confirm once you have completed your training,Veuillez confirmer une fois que vous avez terminé votre formation
-DocType: Lead,Suggestions,Suggestions
-DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Définir des budgets par Groupes d'Articles sur ce Territoire. Vous pouvez également inclure de la saisonnalité en définissant la Répartition.
-DocType: Payment Term,Payment Term Name,Nom du terme de paiement
-DocType: Healthcare Settings,Create documents for sample collection,Créer des documents pour la collecte d&#39;échantillons
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276,Payment against {0} {1} cannot be greater than Outstanding Amount {2},Paiement pour {0} {1} ne peut pas être supérieur à Encours {2}
-DocType: Shareholder,Address HTML,Adresse HTML
-DocType: Lead,Mobile No.,N° Mobile.
-DocType: Maintenance Schedule,Generate Schedule,Créer un Échéancier
-DocType: Purchase Invoice Item,Expense Head,Compte de Charges
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138,Please select Charge Type first,Veuillez d’abord sélectionner le Type de Facturation
-DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ","Vous pouvez définir ici toutes les tâches à effectuer pour cette culture. Le champ de jour est utilisé pour mentionner le jour où la tâche doit être effectuée, 1 étant le 1er jour, etc."
-DocType: Student Group Student,Student Group Student,Étudiant du Groupe d'Étudiants
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,Dernier
-DocType: Asset Maintenance Task,2 Yearly,2 ans
-DocType: Education Settings,Education Settings,Paramètres d&#39;éducation
-DocType: Vehicle Service,Inspection,Inspection
-DocType: Supplier Scorecard Scoring Standing,Max Grade,Note Maximale
-DocType: Email Digest,New Quotations,Nouveaux Devis
-DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,Envoi des fiches de paie à l'employé par Email en fonction de l'email sélectionné dans la fiche Employé
-DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,Le premier Approbateur de Congé dans la liste sera défini comme Approbateur par défaut
-DocType: Tax Rule,Shipping County,Comté de Livraison
-apps/erpnext/erpnext/config/desktop.py +167,Learn,Apprendre
-DocType: Asset,Next Depreciation Date,Date de l’Amortissement Suivant
-apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3,Activity Cost per Employee,Coût de l'Activité par Employé
-DocType: Accounts Settings,Settings for Accounts,Réglages pour les Comptes
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673,Supplier Invoice No exists in Purchase Invoice {0},N° de la Facture du Fournisseur existe dans la Facture d'Achat {0}
-apps/erpnext/erpnext/config/selling.py +118,Manage Sales Person Tree.,Gérer l'Arborescence des Vendeurs.
-DocType: Job Applicant,Cover Letter,Lettre de Motivation
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37,Outstanding Cheques and Deposits to clear,Chèques et Dépôts en suspens à compenser
-DocType: Item,Synced With Hub,Synchronisé avec le Hub
-DocType: Driver,Fleet Manager,Gestionnaire de Flotte
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542,Row #{0}: {1} can not be negative for item {2},Ligne #{0} : {1} ne peut pas être négatif pour l’article {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59,Wrong Password,Mauvais Mot De Passe
-DocType: Item,Variant Of,Variante De
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +406,Completed Qty can not be greater than 'Qty to Manufacture',"Qté Terminée ne peut pas être supérieure à ""Quantité de Fabrication"""
-DocType: Period Closing Voucher,Closing Account Head,Responsable du Compte Clôturé
-DocType: Employee,External Work History,Historique de Travail Externe
-DocType: Physician,Time per Appointment,Temps par Rendez-Vous
-apps/erpnext/erpnext/projects/doctype/task/task.py +110,Circular Reference Error,Erreur de Référence Circulaire
-DocType: Appointment Type,Is Inpatient,Est hospitalisé
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55,Guardian1 Name,Nom du Tuteur 1
-DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,En Toutes Lettres (Exportation) Sera visible une fois que vous enregistrerez le Bon de Livraison.
-DocType: Cheque Print Template,Distance from left edge,Distance du bord gauche
-apps/erpnext/erpnext/utilities/bot.py +29,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),{0} unités de [{1}] (#Formulaire/Article/{1}) trouvées dans [{2}] (#Formulaire/Entrepôt/{2})
-DocType: Lead,Industry,Industrie
-DocType: Employee,Job Profile,Profil de l'Emploi
-DocType: BOM Item,Rate & Amount,Taux et Montant
-apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6,This is based on transactions against this Company. See timeline below for details,Ceci est basé sur les transactions contre cette Société. Voir le calendrier ci-dessous pour plus de détails
-DocType: Stock Settings,Notify by Email on creation of automatic Material Request,Notifier par Email lors de la création automatique de la Demande de Matériel
-apps/erpnext/erpnext/healthcare/setup.py +259,Resistant,Résistant
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77,Please set Hotel Room Rate on {},Veuillez régler le tarif de la chambre d&#39;hôtel sur {}
-DocType: Journal Entry,Multi Currency,Multi-Devise
-DocType: Opening Invoice Creation Tool,Invoice Type,Type de Facture
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939,Delivery Note,Bon de Livraison
-DocType: Consultation,Encounter Impression,Impression de la Visite
-apps/erpnext/erpnext/config/learn.py +82,Setting up Taxes,Configuration des Impôts
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134,Cost of Sold Asset,Coût des Immobilisations Vendus
-DocType: Volunteer,Morning,Matin
-apps/erpnext/erpnext/accounts/utils.py +350,Payment Entry has been modified after you pulled it. Please pull it again.,L’Écriture de Paiement a été modifié après que vous l’ayez récupérée. Veuillez la récupérer à nouveau.
-DocType: Program Enrollment Tool,New Student Batch,Nouveau groupe d'étudiants
-apps/erpnext/erpnext/stock/doctype/item/item.py +478,{0} entered twice in Item Tax,{0} est entré deux fois dans la Taxe de l'Article
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113,Summary for this week and pending activities,Résumé de la semaine et des activités en suspens
-DocType: Student Applicant,Admitted,Admis
-DocType: Workstation,Rent Cost,Coût de la Location
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,Montant Après Amortissement
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,Prochains Événements du Calendrier
-apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1,Variant Attributes,Attributs Variant
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85,Please select month and year,Veuillez sélectionner le mois et l'année
-DocType: Employee,Company Email,E-mail de la Société
-DocType: GL Entry,Debit Amount in Account Currency,Montant Débiteur en Devise du Compte
-DocType: Supplier Scorecard,Scoring Standings,Classement des Fiches d'Évaluation
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21,Order Value,Valeur de la Commande
-apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,Transactions Bancaires/de Trésorerie avec un tiers ou pour transfert interne
-DocType: Shipping Rule,Valid for Countries,Valable pour les Pays
-apps/erpnext/erpnext/stock/doctype/item/item.js +55,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,Cet Article est un Modèle et ne peut être utilisé dans les transactions. Les Attributs d’Articles seront copiés dans les variantes sauf si ‘Pas de Copie’ est coché
-DocType: Grant Application,Grant Application,Demande de subvention
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69,Total Order Considered,Total de la Commande Considéré
-apps/erpnext/erpnext/config/hr.py +243,"Employee designation (e.g. CEO, Director etc.).","Intitulé de poste (e.g.  Directeur Général, Directeur...)"
-DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,Taux auquel la Devise Client est convertie en devise client de base
-DocType: Course Scheduling Tool,Course Scheduling Tool,Outil de Planification des Cours
-apps/erpnext/erpnext/controllers/accounts_controller.py +622,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},Ligne #{0} : La Facture d'Achat ne peut être faite pour un actif existant {1}
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257,[Urgent] Error while creating recurring %s for %s,[Urgent] Erreur lors de la création de %s récurrents pour %s
-DocType: Land Unit,LInked Analysis,Analyse reliée
-DocType: Item Tax,Tax Rate,Taux d'Imposition
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +74,Application period cannot be across two allocation records,La période d&#39;application ne peut pas être sur deux enregistrements d&#39;allocation
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59,{0} already allocated for Employee {1} for period {2} to {3},{0} déjà alloué pour l’Employé {1} pour la période {2} à {3}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141,Purchase Invoice {0} is already submitted,La Facture d’Achat {0} est déjà soumise
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +91,Row # {0}: Batch No must be same as {1} {2},Ligne # {0} : Le N° de Lot doit être le même que {1} {2}
-DocType: Material Request Plan Item,Material Request Plan Item,Objet du plan de demande de matériel
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52,Convert to non-Group,Convertir en non-groupe
-DocType: C-Form Invoice Detail,Invoice Date,Date de la Facture
-DocType: GL Entry,Debit Amount,Montant du Débit
-apps/erpnext/erpnext/accounts/party.py +249,There can only be 1 Account per Company in {0} {1},Il ne peut y avoir qu’un Compte par Société dans {0} {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +425,Please see attachment,Veuillez voir la pièce jointe
-DocType: Purchase Order,% Received,% Reçu
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3,Create Student Groups,Créer des Groupes d'Étudiants
-DocType: Volunteer,Weekends,Fins de semaine
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Credit Note Amount,Montant de la Note de Crédit
-DocType: Setup Progress Action,Action Document,Document d'Action
-DocType: Chapter Member,Website URL,URL de site web
-,Finished Goods,Produits Finis
-DocType: Delivery Note,Instructions,Instructions
-DocType: Quality Inspection,Inspected By,Inspecté Par
-DocType: Asset Maintenance Log,Maintenance Type,Type d'Entretien
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45,{0} - {1} is not enrolled in the Course {2},{0} - {1} n'est pas inscrit dans le Cours {2}
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Serial No {0} does not belong to Delivery Note {1},N° de Série {0} ne fait pas partie du Bon de Livraison {1}
-apps/erpnext/erpnext/templates/pages/demo.html +47,ERPNext Demo,Demo ERPNext
-apps/erpnext/erpnext/public/js/utils/item_selector.js +20,Add Items,Ajouter des Articles
-DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,Paramètre d'Inspection de Qualité de l'Article
-DocType: Depreciation Schedule,Schedule Date,Date du Calendrier
-apps/erpnext/erpnext/config/hr.py +116,"Earnings, Deductions and other Salary components","Revenus, Retenues, et autres composantes Salariales"
-DocType: Packed Item,Packed Item,Article Emballé
-DocType: Job Offer Term,Job Offer Term,Terme de l&#39;offre d&#39;emploi
-apps/erpnext/erpnext/config/buying.py +65,Default settings for buying transactions.,Paramètres par défaut pour les transactions d'achat.
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29,Activity Cost exists for Employee {0} against Activity Type - {1},Des Coûts d'Activité existent pour l'Employé {0} pour le Type d'Activité - {1}
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15,Mandatory field - Get Students From,Champ Obligatoire - Obtenir des étudiants de
-DocType: Program Enrollment,Enrolled courses,Cours Inscrits
-DocType: Currency Exchange,Currency Exchange,Change de Devise
-DocType: Opening Invoice Creation Tool Item,Item Name,Nom d'Article
-DocType: Authorization Rule,Approving User  (above authorized value),Utilisateur Approbateur (valeurs autorisées ci-dessus)
-DocType: Email Digest,Credit Balance,Solde du Crédit
-DocType: Employee,Widowed,Veuf
-DocType: Request for Quotation,Request for Quotation,Appel d'Offre
-DocType: Healthcare Settings,Require Lab Test Approval,Nécessite l'Approbation du Test de Laboratoire
-DocType: Salary Slip Timesheet,Working Hours,Heures de Travail
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +54,Total Outstanding,Total en suspens
-DocType: Naming Series,Change the starting / current sequence number of an existing series.,Changer le numéro initial/actuel d'une série existante.
-DocType: Dosage Strength,Strength,Force
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1533,Create a new Customer,Créer un nouveau Client
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Si plusieurs Règles de Prix continuent de prévaloir, les utilisateurs sont invités à définir manuellement la priorité pour résoudre les conflits."
-apps/erpnext/erpnext/utilities/activation.py +90,Create Purchase Orders,Créer des Commandes d'Achat
-,Purchase Register,Registre des Achats
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +119,Patient not found,Patient non trouvé
-DocType: Scheduling Tool,Rechedule,Replanifier
-DocType: Landed Cost Item,Applicable Charges,Frais Applicables
-DocType: Workstation,Consumable Cost,Coût de Consommable
-DocType: Purchase Receipt,Vehicle Date,Date du Véhicule
-DocType: Student Log,Medical,Médical
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175,Reason for losing,Raison de perdre
-apps/erpnext/erpnext/accounts/doctype/account/account.js +52,Update Account Number,Mettre à jour le numéro
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +42,Lead Owner cannot be same as the Lead,Le Responsable du Prospect ne peut pas être identique au Prospect
-apps/erpnext/erpnext/accounts/utils.py +356,Allocated amount can not greater than unadjusted amount,Le montant alloué ne peut pas être plus grand que le montant non ajusté
-DocType: Announcement,Receiver,Récepteur
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83,Workstation is closed on the following dates as per Holiday List: {0},Le bureau est fermé aux dates suivantes selon la Liste de Vacances : {0}
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32,Opportunities,Opportunités
-DocType: Lab Test Template,Single,Unique
-DocType: Salary Slip,Total Loan Repayment,Total de Remboursement du Prêt
-DocType: Account,Cost of Goods Sold,Coût des marchandises vendues
-DocType: Subscription,Yearly,Annuel
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,Please enter Cost Center,Veuillez entrer un Centre de Coûts
-DocType: Drug Prescription,Dosage,Dosage
-DocType: Journal Entry Account,Sales Order,Commande Client
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69,Avg. Selling Rate,Moy. Taux de vente
-DocType: Assessment Plan,Examiner Name,Nom de l'Examinateur
-DocType: Lab Test Template,No Result,Aucun Résultat
-DocType: Purchase Invoice Item,Quantity and Rate,Quantité et Taux
-DocType: Delivery Note,% Installed,% Installé
-apps/erpnext/erpnext/utilities/user_progress.py +227,Classrooms/ Laboratories etc where lectures can be scheduled.,Les Salles de Classe / Laboratoires etc. où des conférences peuvent être programmées.
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Please enter company name first,Veuillez d’abord entrer le nom de l'entreprise
-DocType: Purchase Invoice,Supplier Name,Nom du Fournisseur
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25,Read the ERPNext Manual,Lire le manuel d’ERPNext
-DocType: Purchase Invoice,01-Sales Return,01-Ventes Retour
-DocType: Account,Is Group,Est un Groupe
-DocType: Email Digest,Pending Purchase Orders,Bons de Commande en Attente
-DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,Régler Automatiquement les Nos de Série basés sur FIFO
-DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,Vérifiez l'Unicité du Numéro de Facture du Fournisseur
-apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34,Primary Address Details,Détails de l&#39;adresse principale
-DocType: Vehicle Service,Oil Change,Vidange
-DocType: Asset Maintenance Log,Asset Maintenance Log,Journal de Maintenance des Actifs
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.','Au Cas N°’ ne peut pas être inférieur à ‘Du Cas N°’
-DocType: Chapter,Non Profit,À But Non Lucratif
-DocType: Production Order,Not Started,Non Commencé
-DocType: Lead,Channel Partner,Partenaire de Canal
-DocType: Account,Old Parent,Grand Parent
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19,Mandatory field - Academic Year,Champ Obligatoire - Année Académique
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +215,{0} {1} is not associated with {2} {3},{0} {1} n&#39;est pas associé à {2} {3}
-DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Personnaliser le texte d'introduction qui fera partie de cet Email. Chaque transaction a une introduction séparée.
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +174,Please set default payable account for the company {0},Veuillez définir le compte créditeur par défaut pour la société {0}
-DocType: Setup Progress Action,Min Doc Count,Compte de Document Minimum
-apps/erpnext/erpnext/config/manufacturing.py +84,Global settings for all manufacturing processes.,Paramètres globaux pour tous les processus de fabrication.
-DocType: Accounts Settings,Accounts Frozen Upto,Comptes Gelés Jusqu'au
-DocType: SMS Log,Sent On,Envoyé le
-apps/erpnext/erpnext/stock/doctype/item/item.py +699,Attribute {0} selected multiple times in Attributes Table,Attribut {0} sélectionné à plusieurs reprises dans le Tableau des Attributs
-DocType: HR Settings,Employee record is created using selected field. ,Le dossier de l'employé est créé en utilisant le champ sélectionné.
-DocType: Sales Order,Not Applicable,Non Applicable
-apps/erpnext/erpnext/config/hr.py +70,Holiday master.,Données de Base des Vacances
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85,Opening Invoice Item,Ouverture d&#39;un poste de facture
-DocType: Request for Quotation Item,Required Date,Date Requise
-DocType: Delivery Note,Billing Address,Adresse de Facturation
-DocType: BOM,Costing,Coût
-DocType: Tax Rule,Billing County,Département de Facturation
-DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Si cochée, le montant de la taxe sera considéré comme déjà inclus dans le Taux d'Impression / Prix d'Impression"
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceRef,PieceRef
-DocType: Request for Quotation,Message for Supplier,Message pour le Fournisseur
-DocType: Driver,DRIVER-.#####,CHAUFFEUR-.#####
-DocType: Sales Invoice,Total Qty,Qté Totale
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62,Guardian2 Email ID,ID Email du Tuteur2
-DocType: Item,Show in Website (Variant),Afficher dans le Website (Variant)
-DocType: Employee,Health Concerns,Problèmes de Santé
-DocType: Payroll Entry,Select Payroll Period,Sélectionner la Période de Paie
-DocType: Purchase Invoice,Unpaid,Impayé
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49,Reserved for sale,Réservé à la Vente
-DocType: Packing Slip,From Package No.,Du N° de Colis
-DocType: Item Attribute,To Range,Au Rang
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,Titres et Dépôts
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method","Impossible de modifier la méthode de valorisation, car il existe des transactions sur certains articles ne possèdant pas leur propre méthode de valorisation"
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82,Total leaves allocated is mandatory,Total des Congés attribués est obligatoire
-DocType: Patient,AB Positive,AB Positif
-DocType: Job Opening,Description of a Job Opening,Description d'une Nouvelle Offre d’Emploi
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110,Pending activities for today,Activités en Attente pour aujourd'hui
-apps/erpnext/erpnext/config/hr.py +24,Attendance record.,Registre des présences.
-DocType: Salary Structure,Salary Component for timesheet based payroll.,Composante Salariale pour la rémunération basée sur la feuille de temps
-DocType: Sales Order Item,Used for Production Plan,Utilisé pour Plan de Production
-DocType: Employee Loan,Total Payment,Paiement Total
-DocType: Manufacturing Settings,Time Between Operations (in mins),Temps entre les opérations (en min)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132,{0} {1} is cancelled so the action cannot be completed,"{0} {1} est annulé, donc l'action ne peut pas être complétée"
-DocType: Customer,Buyer of Goods and Services.,Acheteur des Biens et Services.
-DocType: Journal Entry,Accounts Payable,Comptes Créditeurs
-DocType: Patient,Allergies,Allergies
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33,The selected BOMs are not for the same item,Les LDMs sélectionnées ne sont pas pour le même article
-DocType: Supplier Scorecard Standing,Notify Other,Notifier Autre
-DocType: Vital Signs,Blood Pressure (systolic),Pression Artérielle (Systolique)
-DocType: Pricing Rule,Valid Upto,Valide Jusqu'au
-DocType: Training Event,Workshop,Atelier
-DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,Avertir lors de Bons de Commande
-apps/erpnext/erpnext/utilities/user_progress.py +64,List a few of your customers. They could be organizations or individuals.,Listez quelques-uns de vos clients. Ils peuvent être des entreprise ou des individus.
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23,Enough Parts to Build,Pièces Suffisantes pour Construire
-DocType: POS Profile User,POS Profile User,Utilisateur du profil PDV
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128,Direct Income,Revenu Direct
-DocType: Patient Appointment,Date TIme,Date Heure
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,"Can not filter based on Account, if grouped by Account","Impossible de filtrer sur le Compte , si les lignes sont regroupées par Compte"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130,Administrative Officer,Agent Administratif
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39,Setting up company and taxes,Création d&#39;entreprise et taxes
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22,Please select Course,Veuillez sélectionner un Cours
-DocType: Codification Table,Codification Table,Tableau de Codifications
-DocType: Timesheet Detail,Hrs,Hrs
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349,Please select Company,Veuillez sélectionner une Société
-DocType: Stock Entry Detail,Difference Account,Compte d’Écart
-DocType: Purchase Invoice,Supplier GSTIN,GSTIN du Fournisseur
-apps/erpnext/erpnext/projects/doctype/task/task.py +47,Cannot close task as its dependant task {0} is not closed.,Impossible de fermer une tâche si tâche dépendante {0} n'est pas fermée.
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435,Please enter Warehouse for which Material Request will be raised,Veuillez entrer l’Entrepôt pour lequel une Demande de Matériel sera faite
-DocType: Production Order,Additional Operating Cost,Coût d'Exploitation Supplémentaires
-DocType: Lab Test Template,Lab Routine,Routine de laboratoire
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20,Cosmetics,Produits de Beauté
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18,Please select Completion Date for Completed Asset Maintenance Log,Veuillez sélectionner la date d&#39;achèvement pour le journal de maintenance des actifs terminé
-apps/erpnext/erpnext/stock/doctype/item/item.py +551,"To merge, following properties must be same for both items","Pour fusionner, les propriétés suivantes doivent être les mêmes pour les deux articles"
-DocType: Shipping Rule,Net Weight,Poids Net
-DocType: Employee,Emergency Phone,Téléphone d'Urgence
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82,{0} {1} does not exist.,{0} {1} n&#39;existe pas
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29,Buy,Acheter
-,Serial No Warranty Expiry,Expiration de Garantie du N° de Série
-DocType: Sales Invoice,Offline POS Name,Nom du PDV Hors-ligne`
-apps/erpnext/erpnext/utilities/user_progress.py +177,Student Application,Candidature Étudiante
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20,Please define grade for Threshold 0%,Veuillez définir une note pour le Seuil 0%
-DocType: Sales Order,To Deliver,À Livrer
-DocType: Purchase Invoice Item,Item,Article
-apps/erpnext/erpnext/healthcare/setup.py +256,High Sensitivity,Haute Sensibilité
-apps/erpnext/erpnext/config/non_profit.py +48,Volunteer Type information.,Volontaire Type d&#39;information.
-DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,Modèle de cartographie des flux de trésorerie
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2539,Serial no item cannot be a fraction,N° de série de l'article ne peut pas être une fraction
-DocType: Journal Entry,Difference (Dr - Cr),Écart (Dr - Cr )
-DocType: Account,Profit and Loss,Pertes et Profits
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104,"Not permitted, configure Lab Test Template as required","Non autorisé, configurez le modèle de test de laboratoire au besoin"
-DocType: Patient,Risk Factors,Facteurs de Risque
-DocType: Patient,Occupational Hazards and Environmental Factors,Dangers Professionnels et Facteurs Environnementaux
-DocType: Vital Signs,Respiratory rate,Fréquence Respiratoire
-apps/erpnext/erpnext/config/stock.py +334,Managing Subcontracting,Gestion de la Sous-traitance
-DocType: Vital Signs,Body Temperature,Température Corporelle
-DocType: Project,Project will be accessible on the website to these users,Le Projet sera accessible sur le site web à ces utilisateurs
-DocType: Detected Disease,Disease,Maladie
-apps/erpnext/erpnext/config/projects.py +24,Define Project type.,Définir le Type de Projet.
-DocType: Supplier Scorecard,Weighting Function,Fonction de Pondération
-DocType: Physician,OP Consulting Charge,Honoraires de Consulations Externe
-apps/erpnext/erpnext/utilities/user_progress.py +25,Setup your ,Configurez votre
-DocType: Quotation,Rate at which Price list currency is converted to company's base currency,Taux auquel la devise de la Liste de prix est convertie en devise société de base
-apps/erpnext/erpnext/setup/doctype/company/company.py +70,Account {0} does not belong to company: {1},Le compte {0} n'appartient pas à la société : {1}
-apps/erpnext/erpnext/setup/doctype/company/company.py +52,Abbreviation already used for another company,Abréviation déjà utilisée pour une autre société
-DocType: Selling Settings,Default Customer Group,Groupe de Clients par Défaut
-DocType: Asset Repair,ARLOG-,ARLOG-
-DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction","Si coché, le champ 'Total Arrondi' ne sera visible dans aucune transaction."
-DocType: BOM,Operating Cost,Coût d'Exploitation
-DocType: Crop,Produced Items,Articles produits
-DocType: Sales Order Item,Gross Profit,Bénéfice Brut
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49,Increment cannot be 0,Incrément ne peut pas être 0
-DocType: Company,Delete Company Transactions,Supprimer les Transactions de la Société
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +357,Reference No and Reference Date is mandatory for Bank transaction,Le N° de Référence et la Date de Référence sont nécessaires pour une Transaction Bancaire
-DocType: Purchase Receipt,Add / Edit Taxes and Charges,Ajouter / Modifier Taxes et Charges
-DocType: Payment Entry Reference,Supplier Invoice No,N° de Facture du Fournisseur
-DocType: Territory,For reference,Pour référence
-DocType: Healthcare Settings,Appointment Confirmation,Confirmation de Rendez-Vous
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158,"Cannot delete Serial No {0}, as it is used in stock transactions","Impossible de supprimer les N° de série {0}, s'ils sont dans les mouvements de stock"
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256,Closing (Cr),Fermeture (Cr)
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1,Hello,Bonjour
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118,Move Item,Déplacer l'Article
-DocType: Serial No,Warranty Period (Days),Période de Garantie (Jours)
-DocType: Installation Note Item,Installation Note Item,Article Remarque d'Installation
-DocType: Production Plan Item,Pending Qty,Qté en Attente
-DocType: Budget,Ignore,Ignorer
-apps/erpnext/erpnext/accounts/party.py +397,{0} {1} is not active,{0} {1} n'est pas actif
-apps/erpnext/erpnext/config/accounts.py +272,Setup cheque dimensions for printing,Configurez les dimensions du chèque pour l'impression
-DocType: Salary Slip,Salary Slip Timesheet,Feuille de Temps de la Fiche de Paie
-apps/erpnext/erpnext/controllers/buying_controller.py +160,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Entrepôt Fournisseur obligatoire pour les Reçus d'Achat sous-traités
-DocType: Pricing Rule,Valid From,Valide à Partir de
-DocType: Sales Invoice,Total Commission,Total de la Commission
-DocType: Pricing Rule,Sales Partner,Partenaire Commercial
-apps/erpnext/erpnext/config/buying.py +150,All Supplier scorecards.,Toutes les Fiches d'Évaluation Fournisseurs.
-DocType: Buying Settings,Purchase Receipt Required,Reçu d’Achat Requis
-apps/erpnext/erpnext/stock/doctype/item/item.py +154,Valuation Rate is mandatory if Opening Stock entered,Le Taux de Valorisation est obligatoire si un Stock Initial est entré
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143,No records found in the Invoice table,Aucun enregistrement trouvé dans la table Facture
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34,Please select Company and Party Type first,Veuillez d’abord sélectionner une Société et le Type de Tiers
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31,"Already set default in pos profile {0} for user {1}, kindly disabled default","Déjà défini par défaut dans le profil pos {0} pour l&#39;utilisateur {1}, aimablement désactivé par défaut"
-apps/erpnext/erpnext/config/accounts.py +293,Financial / accounting year.,Exercice comptable / financier
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9,Accumulated Values,Valeurs Accumulées
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162,"Sorry, Serial Nos cannot be merged","Désolé, les N° de Série ne peut pas être fusionnés"
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72,Territory is Required in POS Profile,Le Territoire est Requis dans le Profil PDV
-DocType: Supplier,Prevent RFQs,Interdire les Appels d'Offres
-apps/erpnext/erpnext/utilities/activation.py +83,Make Sales Order,Créer une Commande Client
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168,Salary Slip submitted for period from {0} to {1},Salaire soumis pour la période du {0} au {1}
-DocType: Project Task,Project Task,Tâche du Projet
-,Lead Id,Id du Prospect
-DocType: C-Form Invoice Detail,Grand Total,Total TTC
-DocType: Assessment Plan,Course,Cours
-DocType: Timesheet,Payslip,Fiche de Paie
-apps/erpnext/erpnext/public/js/pos/pos.html +4,Item Cart,Article du Panier
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38,Fiscal Year Start Date should not be greater than Fiscal Year End Date,La Date de Début ne doit pas être postérieure à la Date de Fin de l'Exercice Fiscal
-DocType: Issue,Resolution,Résolution
-DocType: C-Form,IV,IV
-apps/erpnext/erpnext/templates/pages/order.html +76,Delivered: {0},Livré: {0}
-DocType: Expense Claim,Payable Account,Comptes Créditeurs
-DocType: Payment Entry,Type of Payment,Type de Paiement
-DocType: Sales Order,Billing and Delivery Status,Facturation et Statut de Livraison
-DocType: Job Applicant,Resume Attachment,Reprendre la Pièce Jointe
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,Clients Récurrents
-DocType: Leave Control Panel,Allocate,Allouer
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108,Create Variant,Créer une variante
-DocType: Sales Invoice,Shipping Bill Date,Date de facturation
-DocType: Production Order,Production Plan,Plan de production
-DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,Ouverture de l&#39;outil de création de facture
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853,Sales Return,Retour de Ventes
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,Remarque : Le total des congés alloués {0} ne doit pas être inférieur aux congés déjà approuvés {1} pour la période
-,Total Stock Summary,Récapitulatif de l'Inventaire Total
-DocType: Announcement,Posted By,Posté par
-DocType: Item,Delivered by Supplier (Drop Ship),Livré par le Fournisseur (Expédition Directe)
-DocType: Healthcare Settings,Confirmation Message,Message de Confirmation
-apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,Base de données de clients potentiels.
-DocType: Authorization Rule,Customer or Item,Client ou Article
-apps/erpnext/erpnext/config/selling.py +28,Customer database.,Base de données Clients.
-DocType: Quotation,Quotation To,Devis Pour
-DocType: Lead,Middle Income,Revenu Intermédiaire
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228,Opening (Cr),Ouverture (Cr)
-apps/erpnext/erpnext/stock/doctype/item/item.py +871,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,L’Unité de Mesure par Défaut pour l’Article {0} ne peut pas être modifiée directement parce que vous avez déjà fait une (des) transaction (s) avec une autre unité de mesure. Vous devez créer un nouvel article pour utiliser une UDM par défaut différente.
-apps/erpnext/erpnext/accounts/utils.py +354,Allocated amount can not be negative,Le montant alloué ne peut être négatif
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11,Please set the Company,Veuillez définir la Société
-DocType: Share Balance,Share Balance,Partager le solde
-DocType: Purchase Order Item,Billed Amt,Mnt Facturé
-DocType: Training Result Employee,Training Result Employee,Résultat de la Formation – Employé
-DocType: Warehouse,A logical Warehouse against which stock entries are made.,Un Entrepôt logique dans lequel les entrées en stock sont faites.
-DocType: Repayment Schedule,Principal Amount,Montant Principal
-DocType: Employee Loan Application,Total Payable Interest,Total des Intérêts Créditeurs
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +60,Total Outstanding: {0},Total en Attente: {0}
-DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,Feuille de Temps de la Facture de Vente
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118,Reference No & Reference Date is required for {0},N° et Date de Référence sont nécessaires pour {0}
-DocType: Payroll Entry,Select Payment Account to make Bank Entry,Sélectionner Compte de Crédit pour faire l'Écriture Bancaire
-DocType: Hotel Settings,Default Invoice Naming Series,Série de dénomination de facture par défaut
-apps/erpnext/erpnext/utilities/activation.py +136,"Create Employee records to manage leaves, expense claims and payroll","Créer des dossiers Employés pour gérer les congés, les notes de frais et la paie"
-DocType: Restaurant Reservation,Restaurant Reservation,Réservation de restaurant
-DocType: Land Unit,Land Unit Name,Nom de l&#39;unité de terrain
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190,Proposal Writing,Rédaction de Propositions
-DocType: Payment Entry Deduction,Payment Entry Deduction,Déduction d’Écriture de Paiement
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14,Wrapping up,Emballer
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35,Notify Customers via Email,Avertir les clients par courrier électronique
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35,Another Sales Person {0} exists with the same Employee id,Un autre Commercial {0} existe avec le même ID d'Employé
-DocType: Employee Advance,Claimed Amount,Montant réclamé
-apps/erpnext/erpnext/config/education.py +176,Masters,Données de Base
-DocType: Assessment Plan,Maximum Assessment Score,Score d&#39;évaluation maximale
-apps/erpnext/erpnext/config/accounts.py +138,Update Bank Transaction Dates,Mettre à jour les Dates de Transation Bancaire
-apps/erpnext/erpnext/config/projects.py +36,Time Tracking,Suivi du Temps
-DocType: Purchase Invoice,DUPLICATE FOR TRANSPORTER,DUPLICATA POUR LE TRANSPORTEUR
-apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49,Row {0}# Paid Amount cannot be greater than requested advance amount,La ligne {0} # Montant payé ne peut pas être supérieure au montant de l&#39;avance demandée
-DocType: Fiscal Year Company,Fiscal Year Company,Société de l’Exercice Fiscal
-DocType: Packing Slip Item,DN Detail,Détail du Bon de Livraison
-DocType: Training Event,Conference,Conférence
-DocType: Timesheet,Billed,Facturé
-DocType: Batch,Batch Description,Description du Lot
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12,Creating student groups,Créer des groupes d&#39;étudiants
-apps/erpnext/erpnext/accounts/utils.py +727,"Payment Gateway Account not created, please create one manually.","Le Compte Passerelle de Paiement n’existe pas, veuillez en créer un manuellement."
-DocType: Supplier Scorecard,Per Year,Par An
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51,Not eligible for the admission in this program as per DOB,Non admissible à l'admission dans ce programme d'après sa date de naissance
-DocType: Sales Invoice,Sales Taxes and Charges,Taxes et Frais de Vente
-DocType: Employee,Organization Profile,Profil de l'Organisation
-DocType: Vital Signs,Height (In Meter),Hauteur (en Mètres)
-DocType: Student,Sibling Details,Détails Frères et Sœurs
-DocType: Vehicle Service,Vehicle Service,Entretien du Véhicule
-apps/erpnext/erpnext/config/setup.py +101,Automatically triggers the feedback request based on conditions.,Déclencher automatiquement la demande de retour d'expérience en fonction des conditions.
-DocType: Employee,Reason for Resignation,Raison de la Démission
-apps/erpnext/erpnext/config/hr.py +152,Template for performance appraisals.,Modèle pour l'évaluation de la performance.
-DocType: Sales Invoice,Credit Note Issued,Note de Crédit Émise
-DocType: Project Task,Weight,Poids
-DocType: Payment Reconciliation,Invoice/Journal Entry Details,Détails de Facture / Journal d'Écriture
-apps/erpnext/erpnext/accounts/utils.py +83,{0} '{1}' not in Fiscal Year {2},{0} '{1}' n'est pas dans l’Exercice {2}
-DocType: Buying Settings,Settings for Buying Module,Réglages pour le Module d'Achats
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21,Asset {0} does not belong to company {1},L'actif {0} ne fait pas partie à la société {1}
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70,Please enter Purchase Receipt first,Veuillez d’abord entrer un Reçu d'Achat
-DocType: Buying Settings,Supplier Naming By,Nomenclature de Fournisseur Par
-DocType: Activity Type,Default Costing Rate,Coût de Revient par Défaut
-DocType: Maintenance Schedule,Maintenance Schedule,Échéancier d'Entretien
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Les Règles de Tarification sont ensuite filtrées en fonction des Clients, des Groupes de Clients, des Régions, des Fournisseurs, des Groupes de Fournisseurs, des Campagnes, des Partenaires Commerciaux, etc."
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29,Net Change in Inventory,Variation Nette des Stocks
-apps/erpnext/erpnext/config/hr.py +162,Employee Loan Management,Gestion des Prêts des Employés
-DocType: Employee,Passport Number,Numéro de Passeport
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60,Relation with Guardian2,Relation avec Tuteur2
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124,Manager,Directeur
-DocType: Payment Entry,Payment From / To,Paiement De / À
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +177,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},Nouvelle limite de crédit est inférieure à l'encours actuel pour le client. Limite de crédit doit être au moins de {0}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428,Please set account in Warehouse {0},Veuillez définir un compte dans l&#39;entrepôt {0}
-apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,'Basé sur' et 'Groupé par' ne peuvent pas être identiques
-DocType: Sales Person,Sales Person Targets,Objectifs des Commerciaux
-DocType: Installation Note,IN-,DANS-
-DocType: Production Order Operation,In minutes,En Minutes
-DocType: Issue,Resolution Date,Date de Résolution
-DocType: Lab Test Template,Compound,Composé
-DocType: Student Batch Name,Batch Name,Nom du Lot
-DocType: Fee Validity,Max number of visit,Nombre maximum de visites
-,Hotel Room Occupancy,Occupation de la chambre de l&#39;hôtel
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +358,Timesheet created:,Feuille de Temps créée :
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931,Please set default Cash or Bank account in Mode of Payment {0},Veuillez définir un compte de Caisse ou de Banque par défaut pour le Mode de Paiement {0}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24,Enroll,Inscrire
-DocType: GST Settings,GST Settings,Paramètres GST
-DocType: Selling Settings,Customer Naming By,Client Nommé par
-DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,Affichera l'étudiant comme Présent dans le Rapport Mensuel de Présence des Étudiants
-DocType: Depreciation Schedule,Depreciation Amount,Montant d'Amortissement
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56,Convert to Group,Convertir en Groupe
-DocType: Delivery Trip,TOUR-.#####,TOUR-.#####
-DocType: Activity Cost,Activity Type,Type d&#39;activité
-DocType: Request for Quotation,For individual supplier,Pour un fournisseur individuel
-DocType: BOM Operation,Base Hour Rate(Company Currency),Taux Horaire de Base (Devise de la Société)
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,Montant Livré
-DocType: Quotation Item,Item Balance,Solde de l'Article
-DocType: Sales Invoice,Packing List,Liste de Colisage
-apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,Bons de Commande donnés aux Fournisseurs
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43,Publishing,Édition
-DocType: Accounts Settings,Report Settings,Paramètres de rapport
-DocType: Activity Cost,Projects User,Utilisateur/Intervenant Projets
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,Consommé
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158,{0}: {1} not found in Invoice Details table,{0} : {1} introuvable dans la table de Détails de la Facture
-DocType: Asset,Asset Owner Company,Société Propriétaire de l'Actif
-DocType: Company,Round Off Cost Center,Centre de Coûts d’Arrondi
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,La Visite d'Entretien {0} doit être annulée avant d'annuler cette Commande Client
-DocType: Asset Maintenance Log,AML-,AML-
-DocType: Item,Material Transfer,Transfert de Matériel
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24,Could not find path for ,Impossible de trouver un chemin pour
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221,Opening (Dr),Ouverture (Dr)
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39,Posting timestamp must be after {0},Horodatage de Publication doit être après {0}
-apps/erpnext/erpnext/config/accounts.py +39,To make recurring documents,Pour faire des documents récurrents
-,GST Itemised Purchase Register,Registre d'Achat Détaillé GST
-DocType: Course Scheduling Tool,Reschedule,Reporter
-DocType: Employee Loan,Total Interest Payable,Total des Intérêts à Payer
-DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,Taxes et Frais du Coût au Débarquement
-DocType: Production Order Operation,Actual Start Time,Heure de Début Réelle
-DocType: BOM Operation,Operation Time,Heure de l'Opération
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +316,Finish,Terminer
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412,Base,Base
-DocType: Timesheet,Total Billed Hours,Total des Heures Facturées
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1526,Write Off Amount,Montant de la Reprise
-DocType: Leave Block List Allow,Allow User,Autoriser l'Utilisateur
-DocType: Journal Entry,Bill No,Numéro de Facture
-DocType: Company,Gain/Loss Account on Asset Disposal,Compte de Cessions des Immobilisations
-DocType: Vehicle Log,Service Details,Détails du Service
-DocType: Subscription,Quarterly,Trimestriel
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47,EcritureLib,EcritureLib
-DocType: Lab Test Template,Grouped,Groupé
-DocType: Selling Settings,Delivery Note Required,Bon de Livraison Requis
-DocType: Bank Guarantee,Bank Guarantee Number,Numéro de Garantie Bancaire
-DocType: Assessment Criteria,Assessment Criteria,Critères d'Évaluation
-DocType: BOM Item,Basic Rate (Company Currency),Taux de Base (Devise de la Société )
-DocType: Student Attendance,Student Attendance,Présence des Étudiants
-DocType: Sales Invoice Timesheet,Time Sheet,Feuille de Temps
-DocType: Manufacturing Settings,Backflush Raw Materials Based On,Enregistrer les Matières Premières sur la Base de
-DocType: Sales Invoice,Port Code,Code du port
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +948,Reserve Warehouse,Entrepôt de réserve
-DocType: Lead,Lead is an Organization,Le prospect est une organisation
-DocType: Guardian Interest,Interest,Intérêt
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10,Pre Sales,Prévente
-DocType: Instructor Log,Other Details,Autres Détails
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18,Suplier,Fournisseur
-DocType: Lab Test,Test Template,Modèle de Test
-DocType: Restaurant Order Entry Item,Served,Servi
-apps/erpnext/erpnext/config/non_profit.py +13,Chapter information.,Informations sur le chapitre
-DocType: Account,Accounts,Comptes
-DocType: Vehicle,Odometer Value (Last),Valeur Compteur Kilométrique (Dernier)
-apps/erpnext/erpnext/config/buying.py +160,Templates of supplier scorecard criteria.,Modèles de Critères de  Fiche d'Évaluation Fournisseur.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109,Marketing,Marketing
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +290,Payment Entry is already created,L’Écriture de Paiement est déjà créée
-DocType: Request for Quotation,Get Suppliers,Obtenir des Fournisseurs
-DocType: Purchase Receipt Item Supplied,Current Stock,Stock Actuel
-apps/erpnext/erpnext/controllers/accounts_controller.py +609,Row #{0}: Asset {1} does not linked to Item {2},Ligne #{0} : L’Actif {1} n’est pas lié à l'Article {2}
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394,Preview Salary Slip,Aperçu Fiche de Salaire
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54,Account {0} has been entered multiple times,Le compte {0} a été entré plusieurs fois
-DocType: Account,Expenses Included In Valuation,Charges Incluses dans la Valorisation
-apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37,You can only renew if your membership expires within 30 days,Vous ne pouvez renouveler que si votre abonnement expire dans les 30 jours
-DocType: Land Unit,Longitude,Longitude
-,Absent Student Report,Rapport des Absences
-DocType: Crop,Crop Spacing UOM,UOM d&#39;espacement des cultures
-DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,Ne sélectionnez que si vous avez configuré les documents Cash Flow Mapper
-DocType: Email Digest,Next email will be sent on:,Le prochain Email sera envoyé le :
-DocType: Supplier Scorecard,Per Week,Par Semaine
-apps/erpnext/erpnext/stock/doctype/item/item.py +665,Item has variants.,L'article a des variantes.
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154,Total Student,Étudiants total
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65,Item {0} not found,Article {0} introuvable
-DocType: Bin,Stock Value,Valeur du Stock
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +42,Fee records will be created in the background. In case of any error the error message will be updated in the Schedule.,"Les enregistrements d'honoraires seront créés en arrière-plan. En cas d'erreur, le message d'erreur sera mis à jour dans l'annexe."
-apps/erpnext/erpnext/accounts/doctype/account/account.py +239,Company {0} does not exist,Société {0} n'existe pas
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40,{0} has fee validity till {1},{0} a des frais valides jusqu'à {1}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +57,Tree Type,Type d'Arbre
-DocType: BOM Explosion Item,Qty Consumed Per Unit,Qté Consommée Par Unité
-DocType: GST Account,IGST Account,Compte IGST
-DocType: Serial No,Warranty Expiry Date,Date d'Expiration de la Garantie
-DocType: Material Request Item,Quantity and Warehouse,Quantité et Entrepôt
-DocType: Hub Settings,Unregister,Annuler l&#39;inscription
-DocType: Sales Invoice,Commission Rate (%),Taux de Commission (%)
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24,Please select Program,Veuillez sélectionner un Programme
-DocType: Project,Estimated Cost,Coût Estimé
-DocType: Purchase Order,Link to material requests,Lien vers les demandes de matériaux
-DocType: Hub Settings,Publish,Publier
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7,Aerospace,Aérospatial
-,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
-DocType: Journal Entry,Credit Card Entry,Écriture de Carte de Crédit
-apps/erpnext/erpnext/config/accounts.py +57,Company and Accounts,Société et Comptes
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70,In Value,En Valeur
-DocType: Asset Settings,Depreciation Options,Options d&#39;amortissement
-apps/erpnext/erpnext/utilities/transaction_base.py +35,Invalid Posting Time,Heure de publication non valide
-DocType: Lead,Campaign Name,Nom de la Campagne
-DocType: Hotel Room,Capacity,Capacité
-DocType: Selling Settings,Close Opportunity After Days,Fermer Opportunité Après Jours
-,Reserved,Réservé
-DocType: Driver,License Details,Détails de la licence
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85,The field From Shareholder cannot be blank,Le champ De l&#39;actionnaire ne peut pas être vide
-DocType: Purchase Order,Supply Raw Materials,Fournir les Matières Premières
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,Actifs Actuels
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0} n'est pas un Article de stock
-apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',"Partagez vos commentaires sur la formation en cliquant sur 'Retour d'Expérience de la formation', puis 'Nouveau'"
-DocType: Mode of Payment Account,Default Account,Compte par Défaut
-apps/erpnext/erpnext/stock/doctype/item/item.py +272,Please select Sample Retention Warehouse in Stock Settings first,Veuillez d&#39;abord sélectionner Sample Retention Warehouse dans Stock Settings
-DocType: Payment Entry,Received Amount (Company Currency),Montant Reçu (Devise Société)
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192,Lead must be set if Opportunity is made from Lead,Un prospect doit être sélectionné si l'Opportunité est créée à partir d’un Prospect
-apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29,Please select weekly off day,Veuillez sélectionnez les jours de congé hebdomadaires
-DocType: Patient,O Negative,O Négatif
-DocType: Production Order Operation,Planned End Time,Heure de Fin Prévue
-,Sales Person Target Variance Item Group-Wise,Variance d'Objectifs des Commerciaux par Groupe d'Articles
-apps/erpnext/erpnext/accounts/doctype/account/account.py +93,Account with existing transaction cannot be converted to ledger,Un compte contenant une transaction ne peut pas être converti en grand livre
-apps/erpnext/erpnext/config/non_profit.py +33,Memebership Type Details,Memebership Type Détails
-DocType: Delivery Note,Customer's Purchase Order No,Numéro bon de commande du client
-DocType: Budget,Budget Against,Budget Pour
-DocType: Employee,Cell Number,Numéro de Téléphone
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +445,There's no employee for the given criteria. Check that Salary Slips have not already been created.,Il n&#39;y a pas d&#39;employé pour les critères donnés. Vérifiez que les bordereaux de salaire n&#39;ont pas déjà été créés.
-apps/erpnext/erpnext/stock/reorder_item.py +194,Auto Material Requests Generated,Demandes de Matériel Générées Automatiquement
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,Perdu
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152,You can not enter current voucher in 'Against Journal Entry' column,Vous ne pouvez pas entrer le bon actuel dans la colonne 'Pour l'Écriture de Journal'
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50,Reserved for manufacturing,Réservé pour la Fabrication
-DocType: Soil Texture,Sand,Le sable
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25,Energy,Énergie
-DocType: Opportunity,Opportunity From,Opportunité De
-apps/erpnext/erpnext/config/hr.py +98,Monthly salary statement.,Fiche de paie mensuelle.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,Ligne {0}: {1} Numéros de série requis pour l'article {2}. Vous en avez fourni {3}.
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79,Please select a table,Veuillez sélectionner une table
-DocType: BOM,Website Specifications,Spécifications du Site Web
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78,{0} is an invalid email address in 'Recipients',{0} est une adresse e-mail invalide dans 'Destinataires'
-DocType: Special Test Items,Particulars,Particularités
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24,{0}: From {0} of type {1},{0} : Du {0} de type {1}
-DocType: Warranty Claim,CI-,CI-
-apps/erpnext/erpnext/controllers/buying_controller.py +310,Row {0}: Conversion Factor is mandatory,Ligne {0} : Le Facteur de Conversion est obligatoire
-DocType: Student,A+,A +
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}","Plusieurs Règles de Prix existent avec les mêmes critères, veuillez résoudre les conflits en attribuant des priorités. Règles de Prix : {0}"
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +514,Cannot deactivate or cancel BOM as it is linked with other BOMs,Désactivation ou annulation de la LDM impossible car elle est liée avec d'autres LDMs
-DocType: Asset,Maintenance,Entretien
-DocType: Item Attribute Value,Item Attribute Value,Valeur de l'Attribut de l'Article
-DocType: Item,Maximum sample quantity that can be retained,Quantité maximale d&#39;échantillon pouvant être conservée
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +405,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},La ligne {0} # article {1} ne peut pas être transférée plus de {2} par commande d&#39;achat {3}
-apps/erpnext/erpnext/config/selling.py +158,Sales campaigns.,Campagnes de vente.
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +117,Make Timesheet,Créer une Feuille de Temps
-DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
-
-#### Note
-
-The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
-
-#### Description of Columns
-
-1. Calculation Type: 
-    - This can be on **Net Total** (that is the sum of basic amount).
-    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
-    - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
-3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
-4. Description: Description of the tax (that will be printed in invoices / quotes).
-5. Rate: Tax rate.
-6. Amount: Tax amount.
-7. Total: Cumulative total to this point.
-8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.","Modèle de la taxe standard qui peut être appliqué à toutes les Opérations d'Achat. Ce modèle peut contenir la liste des titres d'impôts ainsi que d'autres titre de charges comme ""Livraison"", ""Assurance"", ""Gestion"", etc. 
-
-#### Remarque 
-
-Le taux d'imposition que vous définissez ici sera le taux d'imposition standard pour tous les **Articles**. S'il y a des **Articles** qui ont des taux différents, ils doivent être ajoutés dans la table **Taxe de l'Article** dans les données de base **Article**.
-
-#### Description des Colonnes
-
-1. Type de Calcul : 
-    - Cela peut être le **Total Net** (qui est la somme des montants de base).
-    - **Total / Montant Sur la Ligne Précédente** (pour les taxes ou frais accumulés). Si vous sélectionnez cette option, la taxe sera appliquée en pourcentage du montant ou du total de la ligne précédente (dans la table d'impôts).
-    - **Réel** (comme mentionné).
-2. Titre du Compte : Le journal comptable dans lequel cette taxe sera comptabilisée
-3. Centre de Coût : Si la taxe / redevance est un revenu (comme la livraison) ou une charge, elle doit être comptabilisée dans un Centre de Coûts.
-4. Description : Description de la taxe (qui sera imprimée sur les factures / devis).
-5. Taux : Le taux d'imposition.
-6. Montant : Le montant de la taxe.
-7. Total : Total accumulé à ce point.
-8. Entrez la Ligne : Si elle est basée sur ""Total de la Ligne Précédente"" vous pouvez sélectionner le numéro de la ligne qui sera pris comme base pour ce calcul (par défaut la ligne précédente).
-9. Considérez Taxe ou Charge pour : Dans cette section, vous pouvez spécifier si la taxe / redevance est seulement pour la valorisation (pas une partie du total) ou seulement pour le total (n'ajoute pas de la valeur à l'article) ou pour les deux.
-10. Ajouter ou Déduire : Ce que vous voulez ajouter ou déduire de la taxe."
-DocType: Employee,Bank A/C No.,N° de Compte Bancaire
-DocType: Bank Guarantee,Project,Projet
-DocType: Quality Inspection Reading,Reading 7,Lecture 7
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9,Partially Ordered,Partiellement Ordonné
-DocType: Lab Test,Lab Test,Test de laboratoire
-DocType: Expense Claim Detail,Expense Claim Type,Type de Note de Frais
-DocType: Shopping Cart Settings,Default settings for Shopping Cart,Paramètres par défaut pour le Panier d'Achat
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +26,Add Timeslots,Ajouter des Créneaux
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138,Asset scrapped via Journal Entry {0},Actif mis au rebut via Écriture de Journal {0}
-DocType: Employee Loan,Interest Income Account,Compte d'Intérêts Créditeurs
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58,Review Invitation Sent,Examiner l&#39;invitation envoyée
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13,Biotechnology,Biotechnologie
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109,Office Maintenance Expenses,Charges d'Entretien de Bureau
-apps/erpnext/erpnext/utilities/user_progress.py +51,Go to ,Aller à
-apps/erpnext/erpnext/config/learn.py +47,Setting up Email Account,Configuration du Compte Email
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21,Please enter Item first,Veuillez d’abord entrer l'Article
-DocType: Asset Repair,Downtime,Temps d&#39;arrêt
-DocType: Account,Liability,Passif
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +218,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,Le Montant Approuvé ne peut pas être supérieur au Montant Réclamé à la ligne {0}.
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11,Academic Term: ,Terme académique
-DocType: Salary Detail,Do not include in total,Ne pas inclure au total
-DocType: Company,Default Cost of Goods Sold Account,Compte de Coûts des Marchandises Vendues par Défaut
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1005,Sample quantity {0} cannot be more than received quantity {1},La quantité d&#39;échantillon {0} ne peut pas dépasser la quantité reçue {1}
-apps/erpnext/erpnext/stock/get_item_details.py +369,Price List not selected,Liste des Prix non sélectionnée
-DocType: Employee,Family Background,Antécédents Familiaux
-DocType: Request for Quotation Supplier,Send Email,Envoyer un Email
-apps/erpnext/erpnext/stock/doctype/item/item.py +227,Warning: Invalid Attachment {0},Attention : Pièce jointe non valide {0}
-DocType: Item,Max Sample Quantity,Quantité maximum d&#39;échantillon
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766,No Permission,Aucune Autorisation
-DocType: Vital Signs,Heart Rate / Pulse,Fréquence Cardiaque / Pouls
-DocType: Company,Default Bank Account,Compte Bancaire par Défaut
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59,"To filter based on Party, select Party Type first","Pour filtrer en fonction du Tiers, sélectionnez d’abord le Type de Tiers"
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48,'Update Stock' can not be checked because items are not delivered via {0},'Mettre à Jour le Stock' ne peut pas être coché car les articles ne sont pas livrés par {0}
-DocType: Vehicle,Acquisition Date,Date d'Aquisition
-apps/erpnext/erpnext/utilities/user_progress.py +143,Nos,N°
-DocType: Item,Items with higher weightage will be shown higher,Articles avec poids supérieur seront affichés en haut
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14,Lab Tests and Vital Signs,Tests de laboratoire et signes vitaux
-DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,Détail de la Réconciliation Bancaire
-apps/erpnext/erpnext/controllers/accounts_controller.py +613,Row #{0}: Asset {1} must be submitted,Ligne #{0} : L’Article {1} doit être soumis
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40,No employee found,Aucun employé trouvé
-DocType: Subscription,Stopped,Arrêté
-DocType: Item,If subcontracted to a vendor,Si sous-traité à un fournisseur
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111,Student Group is already updated.,Le Groupe d'Étudiants est déjà mis à jour.
-DocType: SMS Center,All Customer Contact,Tout Contact Client
-DocType: Land Unit,Tree Details,Détails de l’Arbre
-DocType: Training Event,Event Status,Statut de l'Événement
-DocType: Volunteer,Availability Timeslot,Délai de disponibilité
-,Support Analytics,Analyse du Support
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +352,"If you have any questions, please get back to us.","Si vous avez des questions, veuillez revenir vers nous."
-DocType: Cash Flow Mapper,Cash Flow Mapper,Mappeur de flux de trésorerie
-DocType: Item,Website Warehouse,Entrepôt du Site Seb
-DocType: Payment Reconciliation,Minimum Invoice Amount,Montant Minimum de Facturation
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1} : Le Centre de Coûts {2} ne fait pas partie de la Société {3}
-apps/erpnext/erpnext/utilities/user_progress.py +89,Upload your letter head (Keep it web friendly as 900px by 100px),Téléchargez votre tête de lettre (Gardez-le web comme 900px par 100px)
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88,{0} {1}: Account {2} cannot be a Group,{0} {1} : Compte {2} ne peut pas être un Groupe
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table,Ligne d'Article {idx}: {doctype} {docname} n'existe pas dans la table '{doctype}' ci-dessus
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295,Timesheet {0} is already completed or cancelled,La Feuille de Temps {0} est déjà terminée ou annulée
-apps/erpnext/erpnext/templates/pages/projects.html +42,No tasks,Aucune tâche
-DocType: Item Variant Settings,Copy Fields to Variant,Copier les Champs dans une Variante
-DocType: Asset,Opening Accumulated Depreciation,Amortissement Cumulé d'Ouverture
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,Score doit être inférieur ou égal à 5
-DocType: Program Enrollment Tool,Program Enrollment Tool,Outil d’Inscription au Programme
-apps/erpnext/erpnext/config/accounts.py +335,C-Form records,Enregistrements Formulaire-C
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73,The shares already exist,Les actions existent déjà
-apps/erpnext/erpnext/config/selling.py +311,Customer and Supplier,Clients et Fournisseurs
-DocType: Email Digest,Email Digest Settings,Paramètres pour le Compte Rendu par Email
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +354,Thank you for your business!,Merci pour votre entreprise !
-apps/erpnext/erpnext/config/support.py +12,Support queries from customers.,Demande de support des clients
-DocType: Setup Progress Action,Action Doctype,Doctype Action
-,Production Order Stock Report,Rapport de Stock de l’Ordre de Production
-DocType: HR Settings,Retirement Age,Âge de la Retraite
-DocType: Bin,Moving Average Rate,Taux Mobile Moyen
-DocType: Production Plan,Select Items,Sélectionner les Articles
-DocType: Share Transfer,To Shareholder,Pour l&#39;actionnaire
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372,{0} against Bill {1} dated {2},{0} pour la Facture {1} du {2}
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Institution,Configurer l'Institution
-DocType: Program Enrollment,Vehicle/Bus Number,Numéro de Véhicule/Bus
-apps/erpnext/erpnext/education/doctype/course/course.js +17,Course Schedule,Horaire du Cours
-DocType: Request for Quotation Supplier,Quote Status,Statut du Devis
-DocType: Maintenance Visit,Completion Status,État d'Achèvement
-DocType: Daily Work Summary Group,Select Users,Sélectionner les utilisateurs
-DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,Objet de prix de chambre d&#39;hôtel
-DocType: HR Settings,Enter retirement age in years,Entrez l'âge de la retraite en années
-DocType: Crop,Target Warehouse,Entrepôt Cible
-DocType: Payroll Employee Detail,Payroll Employee Detail,Détails de la paye de l'employé
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128,Please select a warehouse,Veuillez sélectionner un entrepôt
-DocType: Cheque Print Template,Starting location from left edge,Position initiale depuis bord gauche
-DocType: Item,Allow over delivery or receipt upto this percent,Autoriser le dépassement des capacités livraison ou de réception jusqu'à ce pourcentage
-DocType: Stock Entry,STE-,STE-
-DocType: Upload Attendance,Import Attendance,Importer Participation
-apps/erpnext/erpnext/public/js/pos/pos.html +113,All Item Groups,Tous les Groupes d'Articles
-apps/erpnext/erpnext/config/setup.py +89,Automatically compose message on submission of transactions.,Composer automatiquement un message sur la soumission de transactions .
-DocType: Production Order,Item To Manufacture,Article à Fabriquer
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteLib,CompteLib
-apps/erpnext/erpnext/buying/utils.py +80,{0} {1} status is {2},Le Statut de {0} {1} est {2}
-DocType: Water Analysis,Collection Temperature ,Température de collecte
-DocType: Employee,Provide Email Address registered in company,Fournir l'Adresse Email enregistrée dans la société
-DocType: Shopping Cart Settings,Enable Checkout,Activer Caisse
-apps/erpnext/erpnext/config/learn.py +202,Purchase Order to Payment,Du Bon de Commande au Paiement
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48,Projected Qty,Qté Projetée
-DocType: Sales Invoice,Payment Due Date,Date d'Échéance de Paiement
-DocType: Drug Prescription,Interval UOM,UDM d'Intervalle
-DocType: Customer,"Reselect, if the chosen address is edited after save","Resélectionner, si l&#39;adresse choisie est éditée après sauvegarde"
-apps/erpnext/erpnext/stock/doctype/item/item.js +492,Item Variant {0} already exists with same attributes,La Variante de l'Article {0} existe déjà avec les mêmes caractéristiques
-DocType: Item,Hub Publishing Details,Détails Publiés sur le Hub
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +114,'Opening','Ouverture'
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130,Open To Do,Ouvrir To Do
-DocType: Notification Control,Delivery Note Message,Message du Bon de Livraison
-DocType: Lab Test Template,Result Format,Format du Résultat
-DocType: Expense Claim,Expenses,Charges
-DocType: Item Variant Attribute,Item Variant Attribute,Attribut de Variante de l'Article
-,Purchase Receipt Trends,Tendances des Reçus d'Achats
-DocType: Payroll Entry,Bimonthly,Bimensuel
-DocType: Vehicle Service,Brake Pad,Plaquettes de Frein
-DocType: Fertilizer,Fertilizer Contents,Contenu de l&#39;engrais
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119,Research & Development,Recherche & Développement
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20,Amount to Bill,Montant à Facturer
-DocType: Company,Registration Details,Informations Légales
-DocType: Timesheet,Total Billed Amount,Montant Total Facturé
-DocType: Item Reorder,Re-Order Qty,Qté de Réapprovisionnement
-DocType: Leave Block List Date,Leave Block List Date,Date de la Liste de Blocage des Congés
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +93,BOM #{0}: Raw material cannot be same as main Item,LDM # {0}: La matière première ne peut pas être identique à l'article principal
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,Total des Frais Applicables dans la Table des Articles de Reçus d’Achat doit être égal au Total des Taxes et Frais
-DocType: Sales Team,Incentives,Incitations
-DocType: SMS Log,Requested Numbers,Numéros Demandés
-DocType: Volunteer,Evening,Soir
-DocType: Customer,Bypass credit limit check at Sales Order,Contrôle de limite de crédit de contournement à la commande client
-apps/erpnext/erpnext/config/hr.py +147,Performance appraisal.,Évaluation des Performances.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +99,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart","Activation de 'Utiliser pour Panier', comme le Panier est activé et qu'il devrait y avoir au moins une Règle de Taxes pour le Panier"
-apps/erpnext/erpnext/controllers/accounts_controller.py +411,"Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.","L’Écriture de Paiement {0} est liée à la Commande {1}, vérifiez si elle doit être récupérée comme une avance dans cette facture."
-DocType: Sales Invoice Item,Stock Details,Détails du Stock
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,Valeur du Projet
-apps/erpnext/erpnext/config/selling.py +321,Point-of-Sale,Point-de-Vente
-DocType: Fee Schedule,Fee Creation Status,Statut de création des honoraires
-DocType: Vehicle Log,Odometer Reading,Relevé du Compteur Kilométrique
-apps/erpnext/erpnext/accounts/doctype/account/account.py +116,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Le solde du compte est déjà Créditeur, vous n'êtes pas autorisé à mettre en 'Solde Doit Être' comme 'Débiteur'"
-DocType: Account,Balance must be,Solde doit être
-DocType: Hub Settings,Publish Pricing,Publier la Tarification
-DocType: Notification Control,Expense Claim Rejected Message,Message de Note de Frais Rejetée
-,Available Qty,Qté Disponible
-DocType: Purchase Taxes and Charges,On Previous Row Total,Le Total de la Rangée Précédente
-DocType: Purchase Invoice Item,Rejected Qty,Qté Rejetée
-DocType: Setup Progress Action,Action Field,Champ d'Action
-DocType: Healthcare Settings,Manage Customer,Gestion Client
-DocType: Delivery Trip,Delivery Stops,Arrêts de livraison
-DocType: Salary Slip,Working Days,Jours Ouvrables
-DocType: Serial No,Incoming Rate,Taux d'Entrée
-DocType: Packing Slip,Gross Weight,Poids Brut
-,Final Assessment Grades,Niveaux d&#39;évaluation finale
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47,Enable Hub,Activer le Hub
-apps/erpnext/erpnext/public/js/setup_wizard.js +110,The name of your company for which you are setting up this system.,Le nom de l'entreprise pour laquelle vous configurez ce système.
-DocType: HR Settings,Include holidays in Total no. of Working Days,Inclure les vacances dans le nombre total de Jours Ouvrés
-apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108,Setup your Institute in ERPNext,Configurez votre institut dans ERPNext
-DocType: Agriculture Analysis Criteria,Plant Analysis,Analyse des plantes
-DocType: Job Applicant,Hold,Tenir
-DocType: Employee,Date of Joining,Date d'Embauche
-DocType: Naming Series,Update Series,Mettre à Jour les Séries
-DocType: Supplier Quotation,Is Subcontracted,Est sous-traité
-DocType: Restaurant Table,Minimum Seating,Sièges Minimum
-DocType: Item Attribute,Item Attribute Values,Valeurs de l'Attribut de l'Article
-DocType: Examination Result,Examination Result,Résultat d'Examen
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845,Purchase Receipt,Reçu d’Achat
-,Received Items To Be Billed,Articles Reçus à Facturer
-apps/erpnext/erpnext/config/accounts.py +303,Currency exchange rate master.,Données de base des Taux de Change
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +204,Reference Doctype must be one of {0},Doctype de la Référence doit être parmi {0}
-apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46,Filter Total Zero Qty,Filtre Total Zéro Qté
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +341,Unable to find Time Slot in the next {0} days for Operation {1},Impossible de trouver le Créneau Horaires dans les {0} prochains jours pour l'Opération {1}
-DocType: Production Order,Plan material for sub-assemblies,Plan de matériaux pour les sous-ensembles
-apps/erpnext/erpnext/config/selling.py +97,Sales Partners and Territory,Partenaires Commerciaux et Régions
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +595,BOM {0} must be active,LDM {0} doit être active
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +409,No Items available for transfer,Aucun article disponible pour le transfert
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218,Closing (Opening + Total),Fermeture (ouverture + total)
-DocType: Journal Entry,Depreciation Entry,Ecriture d’Amortissement
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Please select the document type first,Veuillez d’abord sélectionner le type de document
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65,Cancel Material Visits {0} before cancelling this Maintenance Visit,Annuler les Visites Matérielles {0} avant d'annuler cette Visite de Maintenance
-DocType: Crop Cycle,ISO 8016 standard,Norme ISO 8016
-DocType: Pricing Rule,Rate or Discount,Taux ou rabais
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213,Serial No {0} does not belong to Item {1},N° de Série {0} n'appartient pas à l'Article {1}
-DocType: Purchase Receipt Item Supplied,Required Qty,Qté Requise
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +127,Warehouses with existing transaction can not be converted to ledger.,Les entrepôts avec des transactions existantes ne peuvent pas être convertis en livre.
-DocType: Bank Reconciliation,Total Amount,Montant Total
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32,Internet Publishing,Publication Internet
-DocType: Prescription Duration,Number,Nombre
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25,Creating {0} Invoice,Création de {0} facture
-DocType: Medical Code,Medical Code Standard,Standard du code médical
-DocType: Soil Texture,Clay Composition (%),Composition d&#39;argile (%)
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81,Please save before assigning task.,Veuillez sauvegarder avant d&#39;assigner une tâche.
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74,Balance Value,Valeur du Solde
-DocType: Lab Test,Lab Technician,Technicien de laboratoire
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,Liste de Prix de Vente
-DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
-Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.","Si cochée, un client sera créé et lié au patient. Les factures de patients seront créées sur ce client. Vous pouvez également sélectionner un Client existant tout en créant un Patient."
-DocType: Bank Reconciliation,Account Currency,Compte Devise
-DocType: Lab Test,Sample ID,ID de l'Échantillon
-apps/erpnext/erpnext/accounts/general_ledger.py +165,Please mention Round Off Account in Company,Veuillez indiquer le Compte d’Arrondi de la Société
-DocType: Purchase Receipt,Range,Plage
-DocType: Supplier,Default Payable Accounts,Comptes Créditeur par Défaut
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49,Employee {0} is not active or does not exist,"L'employé {0} n'est pas actif, ou n'existe pas"
-DocType: Fee Structure,Components,Composants
-DocType: Item Barcode,Item Barcode,Code barre article
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +329,Please enter Asset Category in Item {0},Veuillez entrer une Catégorie d'Actif dans la rubrique {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +660,Item Variants {0} updated,Variantes de l'Article {0} mises à jour
-DocType: Quality Inspection Reading,Reading 6,Lecture 6
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9,"to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field
-of this","à générer. Si vous êtes retardé, vous devrez modifier manuellement le champ &quot;Répéter le jour du mois&quot; de ceci"
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +945,Cannot {0} {1} {2} without any negative outstanding invoice,Can not {0} {1} {2} sans aucune facture impayée négative
-DocType: Share Transfer,From Folio No,De Folio No
-DocType: Purchase Invoice Advance,Purchase Invoice Advance,Avance sur Facture d’Achat
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199,Row {0}: Credit entry can not be linked with a {1},Ligne {0} : L’Écriture de crédit ne peut pas être liée à un {1}
-apps/erpnext/erpnext/config/accounts.py +246,Define budget for a financial year.,Définir le budget pour un exercice.
-DocType: Lead,LEAD-,LEAD-
-DocType: Employee,Permanent Address Is,L’Adresse Permanente Est
-DocType: Production Order Operation,Operation completed for how many finished goods?,Opération terminée pour combien de produits finis ?
-DocType: Payment Terms Template,Payment Terms Template,Modèle de termes de paiement
-apps/erpnext/erpnext/public/js/setup_wizard.js +51,The Brand,La Marque
-DocType: Employee,Exit Interview Details,Entretient de Départ
-DocType: Item,Is Purchase Item,Est Article d'Achat
-DocType: Journal Entry Account,Purchase Invoice,Facture d’Achat
-DocType: Stock Ledger Entry,Voucher Detail No,Détail de la Référence N°
-apps/erpnext/erpnext/accounts/page/pos/pos.js +789,New Sales Invoice,Nouvelle Facture de Vente
-DocType: Stock Entry,Total Outgoing Value,Valeur Sortante Totale
-DocType: Physician,Appointments,Rendez-Vous
-apps/erpnext/erpnext/public/js/account_tree_grid.js +224,Opening Date and Closing Date should be within same Fiscal Year,Date d'Ouverture et Date de Clôture devraient être dans le même Exercice
-DocType: Lead,Request for Information,Demande de Renseignements
-,LeaderBoard,Classement
-DocType: Sales Invoice Item,Rate With Margin (Company Currency),Taux avec marge (devise de l&#39;entreprise)
-apps/erpnext/erpnext/accounts/page/pos/pos.js +802,Sync Offline Invoices,Synchroniser les Factures hors-ligne
-DocType: Payment Request,Paid,Payé
-DocType: Program Fee,Program Fee,Frais du Programme
-DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
-It also updates latest price in all the BOMs.","Remplacez une LDM particulière dans toutes les LDM où elles est utilisée. Cela remplacera le lien vers l'ancienne LDM, mettra à jour les coûts et régénérera le tableau ""Article Explosé de LDM"" selon la nouvelle LDM. Cela mettra également à jour les prix les plus récents dans toutes les LDMs."
-DocType: Salary Slip,Total in words,Total En Toutes Lettres
-DocType: Material Request Item,Lead Time Date,Date du Délai
-DocType: Asset,Available-for-use Date,Disponible pour l&#39;utilisation Date
-DocType: Guardian,Guardian Name,Nom du Tuteur
-DocType: Cheque Print Template,Has Print Format,A un Format d'Impression
-DocType: Employee Loan,Sanctioned,Sanctionné
-apps/erpnext/erpnext/accounts/page/pos/pos.js +75, is mandatory. Maybe Currency Exchange record is not created for ,est obligatoire. Peut-être que le Taux de Change n'est pas créé pour
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +126,Row #{0}: Please specify Serial No for Item {1},Ligne # {0} : Veuillez Indiquer le N° de série pour l'article {1}
-DocType: Crop Cycle,Crop Cycle,Cycle de récolte
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pour les articles ""Ensembles de Produits"", l’Entrepôt, le N° de Série et le N° de Lot proviendront de la table ""Liste de Colisage"". Si l’Entrepôt et le N° de Lot sont les mêmes pour tous les produits colisés d’un même article 'Produit Groupé', ces valeurs peuvent être entrées dans la table principale de l’article et elles seront copiées dans la table ""Liste de Colisage""."
-DocType: Student Admission,Publish on website,Publier sur le site web
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651,Supplier Invoice Date cannot be greater than Posting Date,Fournisseur Date de la Facture du Fournisseur ne peut pas être postérieure à Date de Publication
-DocType: Purchase Invoice Item,Purchase Order Item,Article du Bon de Commande
-DocType: Agriculture Task,Agriculture Task,Tâche d&#39;agriculture
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Indirect Income,Revenu Indirect
-DocType: Student Attendance Tool,Student Attendance Tool,Outil de Présence des Étudiants
-DocType: Restaurant Menu,Price List (Auto created),Liste de prix (créée automatiquement)
-DocType: Cheque Print Template,Date Settings,Paramètres de Date
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48,Variance,Variance
-,Company Name,Nom de la Société
-DocType: SMS Center,Total Message(s),Total des Messages
-DocType: Share Balance,Purchased,Acheté
-DocType: Purchase Invoice,Additional Discount Percentage,Pourcentage de réduction supplémentaire
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24,View a list of all the help videos,Afficher la liste de toutes les vidéos d'aide
-DocType: Agriculture Analysis Criteria,Soil Texture,Texture du sol
-DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,Sélectionner le compte principal de la banque où le chèque a été déposé.
-DocType: Selling Settings,Allow user to edit Price List Rate in transactions,Autoriser l'utilisateur l'édition de la Liste des Prix lors des transactions
-DocType: Pricing Rule,Max Qty,Qté Max
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
-						Please enter a valid Invoice","Ligne {0} : La Facture {1} est invalide, elle a peut-être été annulée ou n'existe pas. \ Veuillez entrer une Facture valide"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,Ligne {0} : Paiements contre Commandes Client / Fournisseur doivent toujours être marqués comme des avances
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16,Chemical,Chimique
-DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,Le compte par défaut de Banque / Caisse sera automatiquement mis à jour dans l’écriture de Journal de Salaire lorsque ce mode est sélectionné.
-DocType: BOM,Raw Material Cost(Company Currency),Coût des Matières Premières (Devise Société)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +783,All items have already been transferred for this Production Order.,Tous les éléments ont déjà été transférés pour cet Ordre de Fabrication.
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +87,Row # {0}: Rate cannot be greater than the rate used in {1} {2},Ligne # {0}: Le Taux ne peut pas être supérieur au taux utilisé dans {1} {2}
-apps/erpnext/erpnext/utilities/user_progress.py +144,Meter,Mètre
-DocType: Workstation,Electricity Cost,Coût de l'Électricité
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +22,Lab testing datetime cannot be before collection datetime,Le test de laboratoire datetime ne peut pas être effectué avant la date de collecte
-DocType: HR Settings,Don't send Employee Birthday Reminders,Ne pas envoyer de rappel pour le Jour d'Anniversaire des Employés
-DocType: Expense Claim,Total Advance Amount,Montant total de l&#39;avance
-DocType: Delivery Stop,Estimated Arrival,Arrivée estimée
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34,Save Settings,Enregistrer les paramètres
-DocType: Delivery Stop,Notified by Email,Notifié par courriel
-DocType: Item,Inspection Criteria,Critères d'Inspection
-apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14,Transfered,Transféré
-DocType: BOM Website Item,BOM Website Item,Article de LDM du Site Internet
-apps/erpnext/erpnext/public/js/setup_wizard.js +52,Upload your letter head and logo. (you can edit them later).,Charger votre en-tête et logo. (vous pouvez les modifier ultérieurement).
-DocType: Timesheet Detail,Bill,Facture
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +88,Next Depreciation Date is entered as past date,La Date de l’Amortissement Suivant est obligatoire pour un nouvel Actif
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208,White,Blanc
-DocType: SMS Center,All Lead (Open),Toutes les pistes (Ouvertes)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +257,Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3}),Ligne {0} : Qté non disponible pour {4} dans l'entrepôt {1} au moment de la comptabilisation de l’écriture ({2} {3})
-apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18,You can only select a maximum of one option from the list of check boxes.,Vous ne pouvez sélectionner qu&#39;une seule option au maximum dans la liste des cases à cocher.
-DocType: Purchase Invoice,Get Advances Paid,Obtenir Acomptes Payés
-DocType: Item,Automatically Create New Batch,Créer un Nouveau Lot Automatiquement
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635,Assigning {0} to {1} (row {2}),Affectation de {0} à {1} (ligne {2})
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Make ,Faire
-DocType: Student Admission,Admission Start Date,Date de Début de l'Admission
-DocType: Journal Entry,Total Amount in Words,Montant Total En Toutes Lettres
-apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29,New Employee,Nouvel employé
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,Il y a eu une erreur. Une raison probable pourrait être que vous n'avez pas enregistré le formulaire. Veuillez contacter support@erpnext.com si le problème persiste.
-apps/erpnext/erpnext/templates/pages/cart.html +5,My Cart,Mon Panier
-apps/erpnext/erpnext/controllers/selling_controller.py +129,Order Type must be one of {0},Type de Commande doit être l'un des {0}
-DocType: Lead,Next Contact Date,Date du Prochain Contact
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36,Opening Qty,Quantité d'Ouverture
-DocType: Healthcare Settings,Appointment Reminder,Rappel de Rendez-Vous
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478,Please enter Account for Change Amount,Veuillez entrez un Compte pour le Montant de Change
-DocType: Program Enrollment Tool Student,Student Batch Name,Nom du Lot d'Étudiants
-DocType: Consultation,Doctor,Docteur
-DocType: Holiday List,Holiday List Name,Nom de la Liste de Vacances
-DocType: Repayment Schedule,Balance Loan Amount,Solde du Montant du Prêt
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14,Schedule Course,Cours Calendrier
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +235,Stock Options,Options du Stock
-DocType: Buying Settings,Disable Fetching Last Purchase Details in Purchase Order,Désactiver la récupération des derniers détails d&#39;achat dans la commande d&#39;achat
-DocType: Journal Entry Account,Expense Claim,Note de Frais
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +267,Do you really want to restore this scrapped asset?,Voulez-vous vraiment restaurer cet actif mis au rebut ?
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +381,Qty for {0},Qté pour {0}
-DocType: Leave Application,Leave Application,Demande de Congés
-DocType: Patient,Patient Relation,Relation patient
-apps/erpnext/erpnext/config/hr.py +80,Leave Allocation Tool,Outil de Répartition des Congés
-DocType: Item,Hub Category to Publish,Catégorie du Hub à publier
-DocType: Leave Block List,Leave Block List Dates,Dates de la Liste de Blocage des Congés
-DocType: Sales Invoice,Billing Address GSTIN,Adresse de Facturation GSTIN
-DocType: Assessment Plan,Evaluate,Évaluer
-DocType: Workstation,Net Hour Rate,Taux Horaire Net
-DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,Reçu d'Achat du Coût au Débarquement
-DocType: Company,Default Terms,Termes et Conditions par Défaut
-DocType: Supplier Scorecard Period,Criteria,Critère
-DocType: Packing Slip Item,Packing Slip Item,Article Emballé
-DocType: Purchase Invoice,Cash/Bank Account,Compte Caisse/Banque
-apps/erpnext/erpnext/public/js/queries.js +96,Please specify a {0},Veuillez spécifier un {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73,Removed items with no change in quantity or value.,Les articles avec aucune modification de quantité ou de valeur ont étés retirés.
-DocType: Delivery Note,Delivery To,Livraison à
-apps/erpnext/erpnext/stock/doctype/item/item.js +386,Variant creation has been queued.,La création de variantes a été placée en file d&#39;attente.
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100,Work Summary for {0},Résumé des travaux pour {0}
-apps/erpnext/erpnext/stock/doctype/item/item.py +695,Attribute table is mandatory,Table d'Attribut est obligatoire
-DocType: Production Plan,Get Sales Orders,Obtenir les Commandes Client
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68,{0} can not be negative,{0} ne peut pas être négatif
-DocType: Training Event,Self-Study,Autoformation
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +26,Soil compositions do not add up to 100,Les compositions de sol ne totalisent pas 100
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +554,Discount,Remise
-DocType: Membership,Membership,Adhésion
-DocType: Asset,Total Number of Depreciations,Nombre Total d’Amortissements
-DocType: Sales Invoice Item,Rate With Margin,Tarif Avec Marge
-DocType: Workstation,Wages,Salaires
-DocType: Asset Maintenance,Maintenance Manager Name,Nom du responsable de la maintenance
-DocType: Agriculture Task,Urgent,Urgent
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174,Please specify a valid Row ID for row {0} in table {1},Veuillez spécifier un N° de Ligne valide pour la ligne {0} de la table {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84,Unable to find variable: ,Impossible de trouver une variable:
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +790,Please select a field to edit from numpad,Veuillez sélectionner un champ à modifier sur le pavé numérique
-apps/erpnext/erpnext/stock/doctype/item/item.py +263,Cannot be a fixed asset item as Stock Ledger is created.,Ne peut pas être un article immobilisé car un Journal de Stock a été créé.
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23,Go to the Desktop and start using ERPNext,Accédez au bureau et commencez à utiliser ERPNext
-DocType: Item,Manufacturer,Fabricant
-DocType: Landed Cost Item,Purchase Receipt Item,Article du Reçu d’Achat
-DocType: Purchase Receipt,PREC-RET-,PREC-RET-
-DocType: POS Profile,Sales Invoice Payment,Paiement de la Facture de Vente
-DocType: Quality Inspection Template,Quality Inspection Template Name,Nom du modèle d&#39;inspection de la qualité
-DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,Entrepôt Réservé aux Commandes Clients / Entrepôt de Produits Finis
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71,Selling Amount,Montant de Vente
-DocType: Repayment Schedule,Interest Amount,Montant d'Intérêts
-DocType: Serial No,Creation Document No,N° du Document de Création
-DocType: Share Transfer,Issue,Question
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11,Records,Dossiers
-DocType: Asset,Scrapped,Mis au Rebut
-DocType: Purchase Invoice,Returns,Retours
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +42,WIP Warehouse,Entrepôt (Travaux en Cours)
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195,Serial No {0} is under maintenance contract upto {1},N° de Série {0} est sous contrat de maintenance jusqu'à {1}
-apps/erpnext/erpnext/config/hr.py +35,Recruitment,Recrutement
-DocType: Lead,Organization Name,Nom de l'Organisation
-DocType: Tax Rule,Shipping State,État de livraison
-,Projected Quantity as Source,Quantité Projetée comme Source
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,L'article doit être ajouté à l'aide du bouton 'Obtenir des éléments de Reçus d'Achat'
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858,Delivery Trip,Voyage de livraison
-DocType: Student,A-,A-
-DocType: Share Transfer,Transfer Type,Type de transfert
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Sales Expenses,Frais de Vente
-DocType: Consultation,Diagnosis,Diagnostique
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18,Standard Buying,Achat Standard
-DocType: GL Entry,Against,Contre
-DocType: Item,Default Selling Cost Center,Centre de Coût Vendeur par Défaut
-DocType: Sales Partner,Implementation Partner,Partenaire d'Implémentation
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1623,ZIP Code,Code Postal
-apps/erpnext/erpnext/controllers/selling_controller.py +251,Sales Order {0} is {1},Commande Client {0} est {1}
-DocType: Opportunity,Contact Info,Information du Contact
-apps/erpnext/erpnext/config/stock.py +319,Making Stock Entries,Faire des Écritures de Stock
-DocType: Packing Slip,Net Weight UOM,UDM Poids Net
-DocType: Item,Default Supplier,Fournisseur par Défaut
-DocType: Manufacturing Settings,Over Production Allowance Percentage,Pourcentage d'Allocation en cas de Surproduction
-DocType: Employee Loan,Repayment Schedule,Échéancier de Remboursement
-DocType: Shipping Rule Condition,Shipping Rule Condition,Condition de la Règle de Livraison
-DocType: Holiday List,Get Weekly Off Dates,Obtenir les Dates de Congés
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33,End Date can not be less than Start Date,La date de Fin ne peut pas être antérieure à la Date de Début
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337,Invoice can't be made for zero billing hour,La facture ne peut pas être faite pour une heure de facturation nulle
-DocType: Sales Person,Select company name first.,Sélectionner d'abord le nom de la société.
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189,Email sent to {0},Email envoyé à {0}
-apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,Devis reçus des Fournisseurs.
-apps/erpnext/erpnext/config/manufacturing.py +74,Replace BOM and update latest price in all BOMs,Remplacer la LDM et actualiser les prix les plus récents dans toutes les LDMs
-apps/erpnext/erpnext/controllers/selling_controller.py +27,To {0} | {1} {2},À {0} | {1} {2}
-DocType: Delivery Trip,Driver Name,Nom du conducteur
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,Âge Moyen
-DocType: Education Settings,Attendance Freeze Date,Date du Gel des Présences
-apps/erpnext/erpnext/utilities/user_progress.py +107,List a few of your suppliers. They could be organizations or individuals.,Listez quelques-uns de vos fournisseurs. Ils peuvent être des entreprises ou des individus.
-apps/erpnext/erpnext/templates/pages/home.html +31,View All Products,Voir Tous Les Produits
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20,Minimum Lead Age (Days),Âge Minimum du Prospect (Jours)
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +59,All BOMs,Toutes les LDM
-apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35,Hotel Rooms of type {0} are unavailable on {1},Les chambres d&#39;hôtel de type {0} sont indisponibles le {1}
-DocType: Patient,Default Currency,Devise par Défaut
-DocType: Expense Claim,From Employee,De l'Employé
-DocType: Driver,Cellphone Number,Numéro de téléphone portable
-apps/erpnext/erpnext/controllers/accounts_controller.py +471,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Attention : Le système ne vérifie pas la surfacturation car le montant pour l'Article {0} dans {1} est nul
-DocType: Journal Entry,Make Difference Entry,Créer l'Écriture par Différence
-DocType: Upload Attendance,Attendance From Date,Présence Depuis
-DocType: Appraisal Template Goal,Key Performance Area,Domaine Essentiel de Performance
-DocType: Program Enrollment,Transportation,Transport
-apps/erpnext/erpnext/controllers/item_variant.py +94,Invalid Attribute,Attribut Invalide
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +235,{0} {1} must be submitted,{0} {1} doit être soumis
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159,Quantity must be less than or equal to {0},La quantité doit être inférieure ou égale à {0}
-DocType: SMS Center,Total Characters,Nombre de Caractères
-DocType: Employee Advance,Claimed,Réclamé
-DocType: Crop,Row Spacing,Écartement des rangs
-apps/erpnext/erpnext/controllers/buying_controller.py +164,Please select BOM in BOM field for Item {0},Veuillez sélectionner une LDM dans le champ LDM pour l’Article {0}
-DocType: C-Form Invoice Detail,C-Form Invoice Detail,Formulaire-C Détail de la Facture
-DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,Facture de Réconciliation des Paiements
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38,Contribution %,Contribution %
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}","D'après les Paramètres d'Achat, si Bon de Commande Requis == 'OUI', alors l'utilisateur doit d'abord créer un Bon de Commande pour l'article {0} pour pouvoir créer une Facture d'Achat"
-DocType: Company,Company registration numbers for your reference. Tax numbers etc.,"Numéro d'immatriculation de la Société pour votre référence. Numéros de taxes, etc."
-DocType: Sales Partner,Distributor,Distributeur
-DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,Règles de Livraison du Panier
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252,Production Order {0} must be cancelled before cancelling this Sales Order,L'Ordre de Production {0} doit être annulé avant d’annuler cette Commande Client
-apps/erpnext/erpnext/public/js/controllers/transaction.js +71,Please set 'Apply Additional Discount On',Veuillez définir ‘Appliquer Réduction Supplémentaire Sur ‘
-,Ordered Items To Be Billed,Articles Commandés À Facturer
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46,From Range has to be less than To Range,La Plage Initiale doit être inférieure à la Plage Finale
-DocType: Global Defaults,Global Defaults,Valeurs par Défaut Globales
-apps/erpnext/erpnext/projects/doctype/project/project.py +228,Project Collaboration Invitation,Invitation de Collaboration à un Projet
-DocType: Salary Slip,Deductions,Déductions
-DocType: Leave Allocation,LAL/,LAL/
-DocType: Setup Progress Action,Action Name,Nom de l'Action
-apps/erpnext/erpnext/public/js/financial_statements.js +75,Start Year,Année de Début
-apps/erpnext/erpnext/regional/india/utils.py +25,First 2 digits of GSTIN should match with State number {0},Les 2 premiers chiffres du GSTIN doivent correspondre au numéro de l'État {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +63,PDC/LC,PDC / LC
-DocType: Purchase Invoice,Start date of current invoice's period,Date de début de la période de facturation en cours
-DocType: Salary Slip,Leave Without Pay,Congé Sans Solde
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +385,Capacity Planning Error,Erreur de Planification de Capacité
-,Trial Balance for Party,Balance Auxiliaire
-DocType: Lead,Consultant,Consultant
-DocType: Salary Slip,Earnings,Bénéfices
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +428,Finished Item {0} must be entered for Manufacture type entry,Le Produit Fini {0} doit être saisi pour une écriture de type de Fabrication
-apps/erpnext/erpnext/config/learn.py +87,Opening Accounting Balance,Solde d'Ouverture de Comptabilité
-,GST Sales Register,Registre de Vente GST
-DocType: Sales Invoice Advance,Sales Invoice Advance,Avance sur Facture de Vente
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552,Nothing to request,Aucune requête à effectuer
-apps/erpnext/erpnext/public/js/setup_wizard.js +18,Select your Domains,Sélectionnez vos domaines
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34,Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3},Un autre enregistrement de Budget '{0}' existe déjà pour {1} '{2}' pour l'exercice {3}
-DocType: Item Variant Settings,Fields will be copied over only at time of creation.,Les champs seront copiés uniquement au moment de la création.
-DocType: Setup Progress Action,Domains,Domaines
-apps/erpnext/erpnext/projects/doctype/task/task.py +41,'Actual Start Date' can not be greater than 'Actual End Date',"""Date de Début Réelle"" ne peut être postérieure à ""Date de Fin Réelle"""
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117,Management,Gestion
-DocType: Cheque Print Template,Payer Settings,Paramètres du Payeur
-DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""","Ce sera ajoutée au Code de la Variante de l'Article. Par exemple, si votre abréviation est «SM», et le code de l'article est ""T-SHIRT"", le code de l'article de la variante sera ""T-SHIRT-SM"""
-DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,Salaire Net (en lettres) sera visible une fois que vous aurez enregistré la Fiche de Paie.
-DocType: Purchase Invoice,Is Return,Est un Retour
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,Caution,Mise en Garde
-apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +16,Start day is greater than end day in task '{0}',Le jour de début est supérieur au jour de fin de la tâche &#39;{0}&#39;
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815,Return / Debit Note,Retour / Note de Débit
-DocType: Price List Country,Price List Country,Pays de la Liste des Prix
-DocType: Item,UOMs,UDMs
-apps/erpnext/erpnext/stock/utils.py +212,{0} valid serial nos for Item {1},{0} numéro de série valide pour l'objet {1}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,Code de l'Article ne peut pas être modifié pour le Numéro de Série
-DocType: Purchase Invoice Item,UOM Conversion Factor,Facteur de Conversion de l'UDM
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40,Please enter Item Code to get Batch Number,Veuillez entrer le Code d'Article pour obtenir le Numéro de Lot
-DocType: Stock Settings,Default Item Group,Groupe d'Éléments par Défaut
-DocType: Employee Loan,Partially Disbursed,Partiellement Décaissé
-apps/erpnext/erpnext/config/non_profit.py +73,Grant information.,Accorder des informations.
-apps/erpnext/erpnext/config/buying.py +38,Supplier database.,Base de données fournisseurs.
-DocType: Account,Balance Sheet,Bilan
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750,Cost Center For Item with Item Code ',Centre de Coûts Pour Article ayant un Code Article '
-DocType: Fee Validity,Valid Till,Valable Jusqu'au
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2500,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",Le Mode de Paiement n’est pas configuré. Veuillez vérifier si le compte a été réglé sur Mode de Paiement ou sur Profil de Point de Vente.
-apps/erpnext/erpnext/buying/utils.py +74,Same item cannot be entered multiple times.,Le même article ne peut pas être entré plusieurs fois.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30,"Further accounts can be made under Groups, but entries can be made against non-Groups","D'autres comptes individuels peuvent être créés dans les groupes, mais les écritures ne peuvent être faites que sur les comptes individuels"
-DocType: Lead,Lead,Prospect
-DocType: Email Digest,Payables,Dettes
-DocType: Course,Course Intro,Intro du Cours
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +105,Stock Entry {0} created,Écriture de Stock {0} créée
-apps/erpnext/erpnext/controllers/buying_controller.py +316,Row #{0}: Rejected Qty can not be entered in Purchase Return,Ligne #{0} : Qté Rejetée ne peut pas être entrée dans le Retour d’Achat
-,Purchase Order Items To Be Billed,Articles à Facturer du Bon de Commande
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63,Updating estimated arrival times.,Mise à jour des heures d&#39;arrivée estimées.
-DocType: Program Enrollment Tool,Enrollment Details,Détails d&#39;inscription
-DocType: Purchase Invoice Item,Net Rate,Taux Net
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152,Please select a customer,Veuillez sélectionner un Client
-DocType: Purchase Invoice Item,Purchase Invoice Item,Article de la Facture d'Achat
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,Écritures du Journal du Stock et Écritures du Grand Livre sont republiées pour les Reçus d'Achat sélectionnés
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8,Item 1,Article 1
-DocType: Holiday,Holiday,Vacances
-DocType: Support Settings,Close Issue After Days,Fermer Problème Après Jours
-DocType: Leave Control Panel,Leave blank if considered for all branches,Laisser vide pour toutes les branches
-DocType: Bank Guarantee,Validity in Days,Validité en Jours
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21,C-form is not applicable for Invoice: {0},Formulaire-C n'est pas applicable pour la Facture: {0}
-DocType: Payment Reconciliation,Unreconciled Payment Details,Détails des Paiements Non Réconciliés
-apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6,Member Activity,Activité des membres
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20,Order Count,Compte de Commandes
-DocType: Global Defaults,Current Fiscal Year,Exercice en Cours
-DocType: Purchase Order,Group same items,Groupe les éléments identiques
-DocType: Purchase Invoice,Disable Rounded Total,Désactiver le Total Arrondi
-DocType: Employee Loan Application,Repayment Info,Infos de Remboursement
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448,'Entries' cannot be empty,'Entrées' ne peuvent pas être vides
-DocType: Maintenance Team Member,Maintenance Role,Rôle de maintenance
-apps/erpnext/erpnext/utilities/transaction_base.py +88,Duplicate row {0} with same {1},Ligne {0} en double avec le même {1}
-,Trial Balance,Balance Générale
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +438,Fiscal Year {0} not found,Exercice Fiscal {0} introuvable
-apps/erpnext/erpnext/config/hr.py +305,Setting up Employees,Configuration des Employés
-DocType: Sales Order,SO-,SO-
-DocType: Hotel Room Reservation,Hotel Reservation User,Utilisateur de réservation d&#39;hôtel
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +153,Please select prefix first,Veuillez d’abord sélectionner un préfixe
-DocType: Student,O-,O-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189,Research,Recherche
-DocType: Maintenance Visit Purpose,Work Done,Travaux Effectués
-apps/erpnext/erpnext/controllers/item_variant.py +35,Please specify at least one attribute in the Attributes table,Veuillez spécifier au moins un attribut dans la table Attributs
-DocType: Announcement,All Students,Tous les Etudiants
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +45,Item {0} must be a non-stock item,L'article {0} doit être un article hors stock
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +18,View Ledger,Voir le Livre
-DocType: Grading Scale,Intervals,Intervalles
-apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,Au plus tôt
-apps/erpnext/erpnext/stock/doctype/item/item.py +525,"An Item Group exists with same name, please change the item name or rename the item group","Un Groupe d'Article existe avec le même nom, veuillez changer le nom de l'article ou renommer le groupe d'article"
-DocType: Crop Cycle,Less than a year,Moins d&#39;un an
-apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52,Student Mobile No.,N° de Mobile de l'Étudiant
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105,Rest Of The World,Reste du Monde
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81,The Item {0} cannot have Batch,L'Article {0} ne peut être en Lot
-DocType: Crop,Yield UOM,UOM de rendement
-,Budget Variance Report,Rapport d’Écarts de Budget
-DocType: Salary Slip,Gross Pay,Salaire Brut
-DocType: Item,Is Item from Hub,Est un article sur le Hub
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118,Row {0}: Activity Type is mandatory.,Ligne {0} : Le Type d'Activité est obligatoire.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166,Dividends Paid,Dividendes Payés
-apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36,Accounting Ledger,Livre des Comptes
-DocType: Stock Reconciliation,Difference Amount,Écart de Montant
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +112,Dr {0} on Leave on {1},Dr {0} en congé le {1}
-DocType: Purchase Invoice,Reverse Charge,Autoliquidation
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172,Retained Earnings,Bénéfices Non Répartis
-DocType: Purchase Invoice,05-Change in POS,05-Changement de POS
-DocType: Vehicle Log,Service Detail,Détails du Service
-DocType: BOM,Item Description,Description de l'Article
-DocType: Student Sibling,Student Sibling,Frère et Sœur de l'Étudiant
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18,Payment Mode,Mode de paiement
-DocType: Purchase Invoice,Supplied Items,Articles Fournis
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85,Please set an active menu for Restaurant {0},Veuillez définir un menu actif pour le restaurant {0}
-DocType: Student,STUD.,STUD.
-DocType: Production Order,Qty To Manufacture,Quantité À Fabriquer
-DocType: Email Digest,New Income,Nouveaux Revenus
-DocType: Buying Settings,Maintain same rate throughout purchase cycle,Maintenir le même taux durant le cycle d'achat
-DocType: Opportunity Item,Opportunity Item,Article de l'Opportunité
-,Student and Guardian Contact Details,Détails des Contacts Étudiant et Tuteur
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53,Row {0}: For supplier {0} Email Address is required to send email,Ligne {0} : Pour le fournisseur {0} une Adresse Email est nécessaire pour envoyer des email
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72,Temporary Opening,Ouverture Temporaire
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10,View Hub,Afficher le Hub
-,Employee Leave Balance,Solde des Congés de l'Employé
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147,Balance for Account {0} must always be {1},Solde pour le compte {0} doit toujours être {1}
-DocType: Patient Appointment,More Info,Plus d&#39;infos
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180,Valuation Rate required for Item in row {0},Taux de Valorisation requis pour l’Article de la ligne {0}
-DocType: Supplier Scorecard,Scorecard Actions,Actions de la Fiche d'Évaluation
-apps/erpnext/erpnext/utilities/user_progress.py +166,Example: Masters in Computer Science,Exemple: Master en Sciences Informatiques
-DocType: Purchase Invoice,Rejected Warehouse,Entrepôt Rejeté
-DocType: GL Entry,Against Voucher,Pour le Bon
-DocType: Item,Default Buying Cost Center,Centre de Coûts d'Achat par Défaut
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.","Pour tirer le meilleur parti d’ERPNext, nous vous recommandons de prendre un peu de temps et de regarder ces vidéos d'aide."
-apps/erpnext/erpnext/accounts/page/pos/pos.js +76, to ,à
-DocType: Supplier Quotation Item,Lead Time in days,Délai en Jours
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +58,Accounts Payable Summary,Résumé des Comptes Créditeurs
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +321,Payment of salary from {0} to {1},Paiement du salaire de {0} à {1}
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213,Not authorized to edit frozen Account {0},Vous n'êtes pas autorisé à modifier le compte gelé {0}
-DocType: Journal Entry,Get Outstanding Invoices,Obtenir les Factures Impayées
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +84,Sales Order {0} is not valid,Commande Client {0} invalide
-DocType: Supplier Scorecard,Warn for new Request for Quotations,Avertir lors d'une nouvelle Demande de Devis
-apps/erpnext/erpnext/utilities/activation.py +91,Purchase orders help you plan and follow up on your purchases,Les Bons de Commande vous aider à planifier et à assurer le suivi de vos achats
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151,Lab Test Prescriptions,Prescriptions de test de laboratoire
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166,"The total Issue / Transfer quantity {0} in Material Request {1}  \
-							cannot be greater than requested quantity {2} for Item {3}",La quantité totale d’Émission / Transfert {0} dans la Demande de Matériel {1} \ ne peut pas être supérieure à la quantité demandée {2} pour l’Article {3}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197,Small,Petit
-DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,Ouverture d&#39;un outil de création de facture
-DocType: Education Settings,Employee Number,Numéro d'Employé
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67,Case No(s) already in use. Try from Case No {0},N° de dossier déjà utilisé. Essayez depuis N° de dossier {0}
-DocType: Project,% Completed,% Complété
-,Invoiced Amount (Exculsive Tax),Montant Facturé (Hors Taxes)
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14,Item 2,Article 2
-DocType: Supplier,SUPP-,SUPP-
-DocType: Training Event,Training Event,Évènement de Formation
-DocType: Item,Auto re-order,Re-commande auto
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59,Total Achieved,Total Obtenu
-DocType: Employee,Place of Issue,Lieu d'Émission
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101,Contract,Contrat
-DocType: Plant Analysis,Laboratory Testing Datetime,Test de laboratoire Datetime
-DocType: Email Digest,Add Quote,Ajouter une Citation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +973,UOM coversion factor required for UOM: {0} in Item: {1},Facteur de coversion UDM requis pour l'UDM : {0} dans l'Article : {1}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92,Indirect Expenses,Charges Indirectes
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +97,Row {0}: Qty is mandatory,Ligne {0} : Qté obligatoire
-DocType: Agriculture Analysis Criteria,Agriculture,Agriculture
-apps/erpnext/erpnext/accounts/page/pos/pos.js +794,Sync Master Data,Sync Données de Base
-DocType: Asset Repair,Repair Cost,Coût de réparation
-apps/erpnext/erpnext/utilities/user_progress.py +135,Your Products or Services,Vos Produits ou Services
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15,Failed to login,Échec de la connexion
-DocType: Special Test Items,Special Test Items,Articles de Test Spécial
-DocType: Mode of Payment,Mode of Payment,Mode de Paiement
-apps/erpnext/erpnext/stock/doctype/item/item.py +201,Website Image should be a public file or website URL,L'Image du Site Web doit être un fichier public ou l'URL d'un site web
-DocType: Student Applicant,AP,AP
-DocType: Purchase Invoice Item,BOM,LDM (Liste de Matériaux)
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37,This is a root item group and cannot be edited.,Il s’agit d’un groupe d'élément racine qui ne peut être modifié.
-DocType: Journal Entry Account,Purchase Order,Bon de Commande
-DocType: Vehicle,Fuel UOM,UDM Carburant
-DocType: Warehouse,Warehouse Contact Info,Info de Contact de l'Entrepôt
-DocType: Payment Entry,Write Off Difference Amount,Montant de la Différence de la Reprise
-DocType: Volunteer,Volunteer Name,Nom du bénévole
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +433,"{0}: Employee email not found, hence email not sent",{0} : Adresse email de l'employé introuvable : l’email n'a pas été envoyé
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85,Shipping rule not applicable for country {0},Règle d&#39;expédition non applicable pour le pays {0}
-DocType: Item,Foreign Trade Details,Détails du Commerce Extérieur
-,Assessment Plan Status,Statut du Plan d'Évaluation
-DocType: Email Digest,Annual Income,Revenu Annuel
-DocType: Serial No,Serial No Details,Détails du N° de Série
-DocType: Purchase Invoice Item,Item Tax Rate,Taux de la Taxe sur l'Article
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +75,Please select Physician and Date,Veuillez sélectionner Médecin et Date
-DocType: Student Group Student,Group Roll Number,Numéro de Groupe
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145,"For {0}, only credit accounts can be linked against another debit entry","Pour {0}, seuls les comptes de crédit peuvent être liés avec une autre écriture de débit"
-apps/erpnext/erpnext/projects/doctype/project/project.py +82,Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly,Le total des poids des tâches doit être égal à 1. Veuillez ajuster les poids de toutes les tâches du Projet en conséquence
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,Delivery Note {0} is not submitted,Bon de Livraison {0} n'est pas soumis
-apps/erpnext/erpnext/stock/get_item_details.py +148,Item {0} must be a Sub-contracted Item,L'article {0} doit être un Article Sous-traité
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43,Capital Equipments,Capitaux Immobilisés
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","La Règle de Tarification est d'abord sélectionnée sur la base du champ ‘Appliquer Sur’, qui peut être un Article, un Groupe d'Articles ou une Marque."
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +246,Please set the Item Code first,Veuillez définir le Code d'Article en premier
-DocType: Item,ITEM-,ARTICLE-
-apps/erpnext/erpnext/controllers/selling_controller.py +122,Total allocated percentage for sales team should be 100,Pourcentage total attribué à l'équipe commerciale devrait être de 100
-DocType: Sales Invoice Item,Edit Description,Modifier la description
-DocType: Antibiotic,Antibiotic,Antibiotique
-,Team Updates,Mises à Jour de l’Équipe
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912,For Supplier,Pour Fournisseur
-DocType: Account,Setting Account Type helps in selecting this Account in transactions.,Définir le Type de Compte aide à sélectionner ce Compte dans les transactions.
-DocType: Purchase Invoice,Grand Total (Company Currency),Total TTC (Devise de la Société)
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Create Print Format,Créer Format d'Impression
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5,Fee Created,Honoraires Créés
-apps/erpnext/erpnext/utilities/bot.py +39,Did not find any item called {0},N'a pas trouvé d'élément appelé {0}
-DocType: Supplier Scorecard Criteria,Criteria Formula,Formule du Critère
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,Total Sortant
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Il ne peut y avoir qu’une Condition de Règle de Livraison avec 0 ou une valeur vide pour « A la Valeur"""
-DocType: Authorization Rule,Transaction,Transaction
-DocType: Patient Appointment,Duration,Durée
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Remarque : Ce Centre de Coûts est un Groupe. Vous ne pouvez pas faire des écritures comptables sur des groupes.
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +54,Child warehouse exists for this warehouse. You can not delete this warehouse.,Un entrepôt enfant existe pour cet entrepôt. Vous ne pouvez pas supprimer cet entrepôt.
-DocType: Item,Website Item Groups,Groupes d'Articles du Site Web
-DocType: Purchase Invoice,Total (Company Currency),Total (Devise Société)
-DocType: Daily Work Summary Group,Reminder,Rappel
-apps/erpnext/erpnext/stock/utils.py +207,Serial number {0} entered more than once,Numéro de série {0} est entré plus d'une fois
-DocType: Journal Entry,Journal Entry,Écriture de Journal
-DocType: Expense Claim Advance,Unclaimed amount,Montant non réclamé
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +148,{0} items in progress,{0} articles en cours
-DocType: Workstation,Workstation Name,Nom du Bureau
-DocType: Grading Scale Interval,Grade Code,Code de la Note
-DocType: POS Item Group,POS Item Group,Groupe d'Articles PDV
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17,Email Digest:,Compte Rendu par Email :
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +608,BOM {0} does not belong to Item {1},LDM {0} n’appartient pas à l'article {1}
-DocType: Sales Partner,Target Distribution,Distribution Cible
-DocType: Purchase Invoice,06-Finalization of Provisional assessment,06-Finalisation de l&#39;évaluation provisoire
-DocType: Salary Slip,Bank Account No.,N° de Compte Bancaire
-DocType: Naming Series,This is the number of the last created transaction with this prefix,Numéro de la dernière transaction créée avec ce préfixe
-DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
-{total_score} (the total score from that period),
-{period_number} (the number of periods to present day)
-","Les variables de la fiche d'évaluation peuvent être utilisées, ainsi que: {total_score} (the total score from that period), {period_number} (the number of periods to present day)"
-DocType: Quality Inspection Reading,Reading 8,Lecture 8
-DocType: Sales Partner,Agent,Agent
-DocType: Purchase Invoice,Taxes and Charges Calculation,Calcul des Frais et Taxes
-DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,Comptabiliser les Entrées de Dépréciation d'Actifs Automatiquement
-DocType: BOM Operation,Workstation,Bureau
-DocType: Request for Quotation Supplier,Request for Quotation Supplier,Fournisseur de l'Appel d'Offre
-DocType: Healthcare Settings,Registration Message,Message d'Inscription
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154,Hardware,Matériel
-DocType: Prescription Dosage,Prescription Dosage,Dosage de la prescription
-DocType: Attendance,HR Manager,Responsable RH
-apps/erpnext/erpnext/accounts/party.py +176,Please select a Company,Veuillez sélectionner une Société
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92,Privilege Leave,Congé de Privilège
-DocType: Purchase Invoice,Supplier Invoice Date,Date de la Facture du Fournisseur
-DocType: Asset Settings,This value is used for pro-rata temporis calculation,Cette valeur est utilisée pour le calcul pro-rata temporis
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90,You need to enable Shopping Cart,Vous devez activer le Panier
-DocType: Payment Entry,Writeoff,Écrire
-DocType: Stock Settings,Naming Series Prefix,Attribution d&#39;un nom au préfixe de série
-DocType: Appraisal Template Goal,Appraisal Template Goal,But du Modèle d'Évaluation
-DocType: Salary Component,Earning,Revenus
-DocType: Supplier Scorecard,Scoring Criteria,Critères de Notation
-DocType: Purchase Invoice,Party Account Currency,Devise du Compte de Tiers
-,BOM Browser,Explorateur LDM
-apps/erpnext/erpnext/templates/emails/training_event.html +13,Please update your status for this training event,Veuillez mettre à jour votre statut pour cet événement de formation
-DocType: Item Barcode,EAN,EAN
-DocType: Purchase Taxes and Charges,Add or Deduct,Ajouter ou Déduire
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148,Overlapping conditions found between:,Conditions qui coincident touvées entre :
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187,Against Journal Entry {0} is already adjusted against some other voucher,L'Écriture de Journal {0} est déjà ajustée par un autre bon
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68,Total Order Value,Total de la Valeur de la Commande
-apps/erpnext/erpnext/demo/setup/setup_data.py +328,Food,Alimentation
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,Balance Agée 3
-DocType: Maintenance Schedule Item,No of Visits,Nb de Visites
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165,Maintenance Schedule {0} exists against {1},Un Calendrier de Maintenance {0} existe pour {1}
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36,Enrolling student,Inscrire un étudiant
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33,Currency of the Closing Account must be {0},La devise du Compte Cloturé doit être {0}
-apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},Somme des points pour tous les objectifs devraient être 100. Il est {0}
-DocType: Project,Start and End Dates,Dates de Début et de Fin
-,Delivered Items To Be Billed,Articles Livrés à Facturer
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16,Open BOM {0},Ouvrir LDM {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60,Warehouse cannot be changed for Serial No.,L'entrepôt ne peut être modifié pour le N° de Série
-DocType: Authorization Rule,Average Discount,Remise Moyenne
-DocType: Purchase Invoice Item,UOM,UDM
-DocType: Rename Tool,Utilities,Utilitaires
-DocType: POS Profile,Accounting,Comptabilité
-DocType: Employee,EMP/,EMP/
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133,Please select batches for batched item ,Veuillez sélectionner les lots pour les articles en lots
-DocType: Asset,Depreciation Schedules,Calendriers d'Amortissement
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192,Following accounts might be selected in GST Settings:,Les comptes suivants peuvent être sélectionnés dans les paramètres de TPS:
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +71,Application period cannot be outside leave allocation period,La période de la demande ne peut pas être hors de la période d'allocation de congé
-DocType: Activity Cost,Projects,Projets
-DocType: Payment Request,Transaction Currency,Devise de la Transaction
-apps/erpnext/erpnext/controllers/buying_controller.py +30,From {0} | {1} {2},Du {0} | {1} {2}
-DocType: Production Order Operation,Operation Description,Description de l'Opération
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Impossible de modifier les dates de début et de fin d'exercice une fois que l'exercice est enregistré.
-DocType: Quotation,Shopping Cart,Panier
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,Moy Quotidienne Sortante
-DocType: POS Profile,Campaign,Campagne
-DocType: Supplier,Name and Type,Nom et Type
-DocType: Physician,Contacts and Address,Contacts et Adresse
-DocType: Purchase Invoice,Contact Person,Personne à Contacter
-apps/erpnext/erpnext/projects/doctype/task/task.py +38,'Expected Start Date' can not be greater than 'Expected End Date','Date de Début Prévue' ne peut pas être postérieure à 'Date de Fin Prévue'
-DocType: Course Scheduling Tool,Course End Date,Date de Fin du Cours
-DocType: Holiday List,Holidays,Jours Fériés
-DocType: Sales Order Item,Planned Quantity,Quantité Planifiée
-DocType: Purchase Invoice Item,Item Tax Amount,Montant de la Taxe sur l'Article
-DocType: Water Analysis,Water Analysis Criteria,Critères d&#39;analyse de l&#39;eau
-DocType: Item,Maintain Stock,Maintenir Stock
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +226,Stock Entries already created for Production Order ,Écritures de Stock déjà créées pour l'Ordre de Fabrication
-DocType: Employee,Prefered Email,Email Préféré
-DocType: Student Admission,Eligibility and Details,Admissibilité et Détails
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38,Net Change in Fixed Asset,Variation Nette des Actifs Immobilisés
-DocType: Leave Control Panel,Leave blank if considered for all designations,Laisser vide pour toutes les désignations
-apps/erpnext/erpnext/controllers/accounts_controller.py +799,Charge of type 'Actual' in row {0} cannot be included in Item Rate,Charge de type ' réel ' à la ligne {0} ne peut pas être inclus dans le prix de l'article
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +382,Max: {0},Max : {0}
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,From Datetime,A partir du (Date et Heure)
-DocType: Email Digest,For Company,Pour la Société
-apps/erpnext/erpnext/config/support.py +17,Communication log.,Journal des communications.
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195,"Request for Quotation is disabled to access from portal, for more check portal settings.","L’accès au portail est désactivé pour les Appels d’Offres. Pour plus d’informations, vérifiez les réglages du portail."
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +24,Please setup Employee Naming System in Human Resource &gt; HR Settings,Veuillez configurer le système de dénomination des employés dans Ressources humaines&gt; Paramètres RH
-DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,Variable de la Fiche d'Évaluation Fournisseur
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72,Buying Amount,Montant d'Achat
-DocType: Sales Invoice,Shipping Address Name,Nom de l'Adresse de Livraison
-DocType: Material Request,Terms and Conditions Content,Contenu des Termes et Conditions
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18,There were errors creating Course Schedule,Des erreurs se sont produites lors de la création du programme
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581,cannot be greater than 100,ne peut pas être supérieure à 100
-apps/erpnext/erpnext/stock/doctype/item/item.py +751,Item {0} is not a stock Item,Article {0} n'est pas un article stocké
-DocType: Maintenance Visit,Unscheduled,Non programmé
-DocType: Employee,Owned,Détenu
-DocType: Salary Detail,Depends on Leave Without Pay,Dépend de Congé Non Payé
-DocType: Pricing Rule,"Higher the number, higher the priority","Plus le nombre est grand, plus la priorité est haute"
-,Purchase Invoice Trends,Tendances des Factures d'Achat
-DocType: Employee,Better Prospects,Meilleures Perspectives
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +217,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches","Ligne # {0}: Le lot {1} n'a que {2} qté(s). Veuillez sélectionner un autre lot contenant {3} qtés disponible ou diviser la rangée en plusieurs lignes, pour livrer / émettre à partir de plusieurs lots"
-DocType: Vehicle,License Plate,Plaque d'Immatriculation
-DocType: Appraisal,Goals,Objectifs
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +349,Select POS Profile,Sélectionnez le profil POS
-DocType: Warranty Claim,Warranty / AMC Status,Garantie / Statut AMC
-,Accounts Browser,Navigateur des Comptes
-DocType: Payment Entry Reference,Payment Entry Reference,Référence d’Écriture de Paiement
-DocType: GL Entry,GL Entry,Écriture GL
-DocType: HR Settings,Employee Settings,Paramètres des Employés
-,Batch-Wise Balance History,Historique de Balance des Lots
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73,Print settings updated in respective print format,Réglages d'impression mis à jour au format d'impression respectif
-DocType: Package Code,Package Code,Code du Paquet
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105,Apprentice,Apprenti
-DocType: Purchase Invoice,Company GSTIN,GSTIN de la Société
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105,Negative Quantity is not allowed,Quantité Négative n'est pas autorisée
-DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
-Used for Taxes and Charges",La table de détails de taxe est récupérée depuis les données de base de l'article comme une chaîne de caractères et stockée dans ce champ. Elle est utilisée pour les Taxes et Frais.
-DocType: Supplier Scorecard Period,SSC-,SSC-
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +159,Employee cannot report to himself.,L'employé ne peut pas rendre de compte à lui-même.
-DocType: Account,"If the account is frozen, entries are allowed to restricted users.","Si le compte est gelé, les écritures ne sont autorisés que pour un nombre restreint d'utilisateurs."
-DocType: Email Digest,Bank Balance,Solde Bancaire
-apps/erpnext/erpnext/accounts/party.py +241,Accounting Entry for {0}: {1} can only be made in currency: {2},Écriture Comptable pour {0}: {1} ne peut être effectuée qu'en devise: {2}
-DocType: Job Opening,"Job profile, qualifications required etc.",Profil de l’Emploi. qualifications requises ect...
-DocType: Journal Entry Account,Account Balance,Solde du Compte
-apps/erpnext/erpnext/config/accounts.py +183,Tax Rule for transactions.,Règle de Taxation pour les transactions.
-DocType: Rename Tool,Type of document to rename.,Type de document à renommer.
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53,{0} {1}: Customer is required against Receivable account {2},{0} {1} : Un Client est requis pour le Compte Débiteur {2}
-DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),Total des Taxes et Frais (Devise Société)
-DocType: Weather,Weather Parameter,Paramètre météo
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60,Show unclosed fiscal year's P&L balances,Afficher le solde du compte de résulat des exercices non cloturés
-DocType: Lab Test Template,Collection Details,Détails de la Collection
-DocType: POS Profile,Allow Print Before Pay,Autoriser l&#39;impression avant la paie
-DocType: Land Unit,Linked Soil Texture,Texture de sol liée
-DocType: Shipping Rule,Shipping Account,Compte de Livraison
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92,{0} {1}: Account {2} is inactive,{0} {1} : Compte {2} inactif
-apps/erpnext/erpnext/utilities/activation.py +82,Make Sales Orders to help you plan your work and deliver on-time,Créer des Commandes Clients pour vous aider à planifier votre travail et livrer à temps
-DocType: Quality Inspection,Readings,Lectures
-DocType: Stock Entry,Total Additional Costs,Total des Coûts Additionnels
-DocType: Course Schedule,SH,SH
-DocType: BOM,Scrap Material Cost(Company Currency),Coût de Mise au Rebut des Matériaux (Devise Société)
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66,Sub Assemblies,Sous-Ensembles
-DocType: Asset,Asset Name,Nom de l'Actif
-DocType: Project,Task Weight,Poids de la Tâche
-DocType: Shipping Rule Condition,To Value,Valeur Finale
-DocType: Asset Movement,Stock Manager,Responsable des Stocks
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +158,Source warehouse is mandatory for row {0},Entrepôt source est obligatoire à la ligne {0}
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38,The Payment Term at row {0} is possibly a duplicate.,Le délai de paiement à la ligne {0} est probablement un doublon.
-apps/erpnext/erpnext/public/js/setup_wizard.js +30,Agriculture (beta),Agriculture (beta)
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863,Packing Slip,Bordereau de Colis
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110,Office Rent,Loyer du Bureau
-apps/erpnext/erpnext/config/setup.py +111,Setup SMS gateway settings,Configuration de la passerelle SMS
-DocType: Disease,Common Name,Nom commun
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61,Import Failed!,Échec de l'Importation !
-apps/erpnext/erpnext/public/js/templates/address_list.html +20,No address added yet.,Aucune adresse ajoutée.
-DocType: Workstation Working Hour,Workstation Working Hour,Heures de Travail au Bureau
-DocType: Vital Signs,Blood Pressure,Pression Artérielle
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125,Analyst,Analyste
-DocType: Item,Inventory,Inventaire
-DocType: Item,Sales Details,Détails Ventes
-DocType: Quality Inspection,QI-,QI-
-DocType: Opportunity,With Items,Avec Articles
-DocType: Asset Maintenance,Maintenance Team,Équipe de maintenance
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,In Qty,En Qté
-DocType: Education Settings,Validate Enrolled Course for Students in Student Group,Valider le Cours Inscrit pour les Étudiants en Groupe Étudiant
-DocType: Notification Control,Expense Claim Rejected,Note de Frais Rejetée
-DocType: Item,Item Attribute,Attribut de l'Article
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147,Government,Gouvernement
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40,Expense Claim {0} already exists for the Vehicle Log,Note de Frais {0} existe déjà pour l'Indémnité Kilométrique
-apps/erpnext/erpnext/public/js/setup_wizard.js +64,Institute Name,Nom de l&#39;Institut
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117,Please enter repayment Amount,Veuillez entrer le Montant de remboursement
-apps/erpnext/erpnext/config/stock.py +309,Item Variants,Variantes de l'Article
-apps/erpnext/erpnext/public/js/setup_wizard.js +29,Services,Services
-DocType: HR Settings,Email Salary Slip to Employee,Envoyer la Fiche de Paie à l'Employé par Mail
-DocType: Cost Center,Parent Cost Center,Centre de Coûts Parent
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041,Select Possible Supplier,Sélectionner le Fournisseur Possible
-DocType: Sales Invoice,Source,Source
-DocType: Customer,"Select, to make the customer searchable with these fields","Sélectionnez, pour rendre le client consultable avec ces champs"
-apps/erpnext/erpnext/templates/pages/projects.html +31,Show closed,Afficher fermé
-DocType: Leave Type,Is Leave Without Pay,Est un Congé Sans Solde
-apps/erpnext/erpnext/stock/doctype/item/item.py +260,Asset Category is mandatory for Fixed Asset item,Catégorie d'Actif est obligatoire pour l'article Immobilisé
-DocType: Fee Validity,Fee Validity,Validité des Honoraires
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146,No records found in the Payment table,Aucun enregistrement trouvé dans la table Paiement
-apps/erpnext/erpnext/education/utils.py +19,This {0} conflicts with {1} for {2} {3},Ce {0} est en conflit avec {1} pour {2} {3}
-DocType: Student Attendance Tool,Students HTML,HTML Étudiants
-DocType: POS Profile,Apply Discount,Appliquer Réduction
-DocType: GST HSN Code,GST HSN Code,Code GST HSN
-DocType: Employee External Work History,Total Experience,Expérience Totale
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88,Please setup numbering series for Attendance via Setup &gt; Numbering Series,Veuillez configurer la série de numéros pour la présence via Setup&gt; Série de numéros
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70,Open Projects,Ouvrir les Projets
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295,Packing Slip(s) cancelled,Bordereau(x) de Colis annulé(s)
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36,Cash Flow from Investing,Flux de Trésorerie des Investissements
-DocType: Program Course,Program Course,Cours du Programme
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Freight and Forwarding Charges,Frais de Fret et d'Expédition
-DocType: Homepage,Company Tagline for website homepage,Slogan de la Société pour la page d'accueil du site web
-DocType: Item Group,Item Group Name,Nom du Groupe d'Article
-apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27,Taken,Pris
-DocType: Student,Date of Leaving,Date de Départ
-DocType: Pricing Rule,For Price List,Pour la Liste de Prix
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27,Executive Search,Recrutement de Cadres
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55,Setting defaults,Définition des valeurs par défaut
-apps/erpnext/erpnext/utilities/activation.py +63,Create Leads,Créer des Prospects
-DocType: Maintenance Schedule,Schedules,Horaires
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +464,POS Profile is required to use Point-of-Sale,Un profil PDV est requis pour utiliser le point de vente
-DocType: Purchase Invoice Item,Net Amount,Montant Net
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141,{0} {1} has not been submitted so the action cannot be completed,"{0} {1} n'a pas été soumis, donc l'action ne peut pas être complétée"
-DocType: Purchase Order Item Supplied,BOM Detail No,N° de Détail LDM
-DocType: Landed Cost Voucher,Additional Charges,Frais Supplémentaires
-DocType: Purchase Invoice,Additional Discount Amount (Company Currency),Montant de la Remise Supplémentaire (Devise de la Société)
-DocType: Supplier Scorecard,Supplier Scorecard,Fiche d'Évaluation des Fournisseurs
-DocType: Plant Analysis,Result Datetime,Résultat Datetime
-apps/erpnext/erpnext/accounts/doctype/account/account.js +21,Please create new account from Chart of Accounts.,Veuillez créer un nouveau compte au sein du Plan Comptable.
-,Support Hour Distribution,Répartition des Heures de Support
-DocType: Maintenance Visit,Maintenance Visit,Visite d'Entretien
-DocType: Student,Leaving Certificate Number,Numéro de Certificat
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +63,"Appointment cancelled, Please review and cancel the invoice {0}","Rendez-vous annulé, veuillez vérifier et annuler la facture {0}"
-DocType: Sales Invoice Item,Available Batch Qty at Warehouse,Qté de lot disponible à l'Entrepôt
-apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9,Update Print Format,Mettre à Jour le Format d'Impression
-DocType: Landed Cost Voucher,Landed Cost Help,Aide Coûts Logistiques
-DocType: Purchase Invoice,Select Shipping Address,Sélectionner l'Adresse de Livraison
-apps/erpnext/erpnext/config/non_profit.py +28,Memebership Details,Détails de Memebership
-DocType: Leave Block List,Block Holidays on important days.,Bloquer les Vacances sur les jours importants.
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220,Please input all required Result Value(s),Veuillez entrer toutes les valeurs de résultat requises
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94,Accounts Receivable Summary,Résumé des Comptes Débiteurs
-DocType: Employee Loan,Monthly Repayment Amount,Montant du Remboursement Mensuel
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9,Opening Invoices,Ouverture des factures
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +195,Please set User ID field in an Employee record to set Employee Role,Veuillez définir le champ ID de l'Utilisateur dans un dossier Employé pour définir le Rôle de l’Employés
-DocType: UOM,UOM Name,Nom UDM
-DocType: GST HSN Code,HSN Code,Code HSN
-apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39,Contribution Amount,Montant de la Contribution
-DocType: Purchase Invoice,Shipping Address,Adresse de Livraison
-DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,Cet outil vous permet de mettre à jour ou de corriger la quantité et l'évaluation de stock dans le système. Il est généralement utilisé pour synchroniser les valeurs du système et ce qui existe réellement dans vos entrepôts.
-DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,En Toutes Lettres. Sera visible une fois que vous enregistrez le Bon de Livraison.
-DocType: Expense Claim,EXP,EXP
-DocType: Water Analysis,Container,Récipient
-apps/erpnext/erpnext/education/utils.py +50,Student {0} - {1} appears Multiple times in row {2} & {3},Étudiant {0} - {1} apparaît Plusieurs fois dans la ligne {2} & {3}
-DocType: Healthcare Settings,Manage Sample Collection,Gestion des collections d'échantillons
-DocType: Production Plan,Ignore Existing Ordered Quantity,Ignorer la quantité commandée existante
-DocType: Patient,Tobacco Past Use,Consommation passée de tabac
-DocType: Sales Invoice Item,Brand Name,Nom de la Marque
-DocType: Purchase Receipt,Transporter Details,Détails du Transporteur
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +65,User {0} is already assigned to Physician {1},L'Utilisateur {0} est déjà affecté au Médecin {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2684,Default warehouse is required for selected item,Un Entrepôt par défaut est nécessaire pour l’Article sélectionné
-apps/erpnext/erpnext/utilities/user_progress.py +143,Box,Boîte
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038,Possible Supplier,Fournisseur Potentiel
-DocType: Budget,Monthly Distribution,Répartition Mensuelle
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68,Receiver List is empty. Please create Receiver List,La Liste de Destinataires est vide. Veuillez créer une Liste de Destinataires
-apps/erpnext/erpnext/public/js/setup_wizard.js +31,Healthcare (beta),Santé (bêta)
-DocType: Production Plan Sales Order,Production Plan Sales Order,Commande Client du Plan de Production
-DocType: Sales Partner,Sales Partner Target,Objectif du Partenaire Commercial
-DocType: Loan Type,Maximum Loan Amount,Montant Max du Prêt
-DocType: Pricing Rule,Pricing Rule,Règle de Tarification
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58,Duplicate roll number for student {0},Numéro de liste en double pour l'élève {0}
-DocType: Budget,Action if Annual Budget Exceeded,Action si le Budget Annuel est Dépassé
-apps/erpnext/erpnext/config/learn.py +197,Material Request to Purchase Order,Demande de Matériel au Bon de Commande
-DocType: Shopping Cart Settings,Payment Success URL,URL pour Paiement Effectué avec Succès
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +80,Row # {0}: Returned Item {1} does not exists in {2} {3},Ligne # {0} : article retourné {1} n’existe pas dans {2} {3}
-DocType: Purchase Receipt,PREC-,PREC-
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,Comptes Bancaires
-,Bank Reconciliation Statement,Relevé de Réconciliation Bancaire
-DocType: Consultation,Medical Coding,Codification médicale
-DocType: Healthcare Settings,Reminder Message,Message de Rappel
-,Lead Name,Nom du Prospect
-,POS,PDV
-DocType: C-Form,III,III
-apps/erpnext/erpnext/config/stock.py +314,Opening Stock Balance,Solde d'Ouverture des Stocks
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58,{0} must appear only once,{0} ne doit apparaître qu'une seule fois
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59,Leaves Allocated Successfully for {0},Congés Attribués avec Succès pour {0}
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42,No Items to pack,Pas d’Articles à emballer
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15,Please setup Instructor Naming System in Education &gt; Education Settings,Veuillez configurer le système de nommage de l&#39;instructeur dans Education&gt; Paramètres de l&#39;éducation
-DocType: Shipping Rule Condition,From Value,De la Valeur
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +593,Manufacturing Quantity is mandatory,Quantité de Fabrication est obligatoire
-DocType: Employee Loan,Repayment Method,Méthode de Remboursement
-DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website","Si cochée, la page d'Accueil pour le site sera le Groupe d'Article par défaut"
-DocType: Quality Inspection Reading,Reading 4,Reading 4
-apps/erpnext/erpnext/config/hr.py +132,Claims for company expense.,Notes de frais de la société
-apps/erpnext/erpnext/utilities/activation.py +118,"Students are at the heart of the system, add all your students","Les étudiants sont au cœur du système, ajouter tous vos étudiants"
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +81,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},Ligne #{0} : Date de compensation {1} ne peut pas être antérieure à la Date du Chèque {2}
-DocType: Asset Maintenance Task,Certificate Required,Certificat requis
-DocType: Company,Default Holiday List,Liste de Vacances par Défaut
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196,Row {0}: From Time and To Time of {1} is overlapping with {2},Ligne {0} : Heure de Début et Heure de Fin de {1} sont en conflit avec {2}
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145,Stock Liabilities,Passif du Stock
-DocType: Purchase Invoice,Supplier Warehouse,Entrepôt Fournisseur
-DocType: Opportunity,Contact Mobile No,N° de Portable du Contact
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +395,Select Company,Sélectionnez une entreprise
-,Material Requests for which Supplier Quotations are not created,Demandes de Matériel dont les Devis Fournisseur ne sont pas créés
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,L&#39;utilisateur {0} n&#39;a aucun profil POS par défaut. Vérifiez par défaut à la ligne {1} pour cet utilisateur.
-DocType: Student Group,Set 0 for no limit,Définir à 0 pour aucune limite
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +123,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,Le(s) jour(s) pour le(s)quel(s) vous demandez un congé sont des jour(s) férié(s). Vous n’avez pas besoin d’effectuer de demande.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64,Row {idx}: {field} is required to create the Opening {invoice_type} Invoices,Row {idx}: {field} est requis pour créer les factures {invoice_type} d&#39;ouverture
-DocType: Customer,Primary Address and Contact Detail,Adresse principale et coordonnées
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20,Resend Payment Email,Renvoyer Email de Paiement
-apps/erpnext/erpnext/templates/pages/projects.html +27,New task,Nouvelle tâche
-DocType: Consultation,Appointment,Rendez-Vous
-apps/erpnext/erpnext/utilities/activation.py +74,Make Quotation,Faire un Devis
-apps/erpnext/erpnext/config/education.py +226,Other Reports,Autres Rapports
-apps/erpnext/erpnext/public/js/setup_wizard.js +39,Please select at least one domain.,Veuillez sélectionner au moins un domaine.
-DocType: Dependent Task,Dependent Task,Tâche Dépendante
-apps/erpnext/erpnext/stock/doctype/item/item.py +443,Conversion factor for default Unit of Measure must be 1 in row {0},Facteur de conversion de l'Unité de Mesure par défaut doit être 1 dans la ligne {0}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +189,Leave of type {0} cannot be longer than {1},Les Congés de type {0} ne peuvent pas être plus long que {1}
-DocType: Manufacturing Settings,Try planning operations for X days in advance.,Essayez de planifer des opérations X jours à l'avance.
-DocType: HR Settings,Stop Birthday Reminders,Arrêter les Rappels d'Anniversaire
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235,Please set Default Payroll Payable Account in Company {0},Veuillez définir le Compte Créditeur de Paie par Défaut pour la Société {0}
-DocType: SMS Center,Receiver List,Liste de Destinataires
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1093,Search Item,Rechercher Article
-DocType: Payment Schedule,Payment Amount,Montant du paiement
-DocType: Patient Appointment,Referring Physician,Médecin Référent
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,Montant Consommé
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100,Net Change in Cash,Variation Nette de Trésorerie
-DocType: Assessment Plan,Grading Scale,Échelle de Notation
-apps/erpnext/erpnext/stock/doctype/item/item.py +437,Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unité de Mesure {0} a été saisie plus d'une fois dans la Table de Facteur de Conversion
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +639,Already completed,Déjà terminé
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33,Stock In Hand,Stock Existant
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64,Import Successful!,Importation Réussie !
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29,Payment Request already exists {0},Demande de Paiement existe déjà {0}
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,Coût des Marchandises Vendues
-DocType: Physician,Hospital,Hôpital
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +385,Quantity must not be more than {0},Quantité ne doit pas être plus de {0}
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117,Previous Financial Year is not closed,L’Exercice Financier Précédent n’est pas fermé
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46,Age (Days),Âge (Jours)
-DocType: Quotation Item,Quotation Item,Article du Devis
-DocType: Customer,Customer POS Id,ID PDV du Client
-DocType: Account,Account Name,Nom du Compte
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40,From Date cannot be greater than To Date,La Date Initiale ne peut pas être postérieure à la Date Finale
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198,Serial No {0} quantity {1} cannot be a fraction,N° de série {0} quantité {1} ne peut pas être une fraction
-apps/erpnext/erpnext/config/buying.py +43,Supplier Type master.,Type de Fournisseur principal
-DocType: Purchase Order Item,Supplier Part Number,Numéro de Pièce du Fournisseur
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108,Conversion rate cannot be 0 or 1,Le taux de conversion ne peut pas être égal à 0 ou 1
-DocType: Share Balance,To No,Pour Non
-DocType: Subscription,Reference Document,Document de Référence
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229,{0} {1} is cancelled or stopped,{0} {1} est annulé ou arrêté
-DocType: Accounts Settings,Credit Controller,Controlleur du Crédit
-DocType: Grant Application,Applicant Type,Type de demandeur
-DocType: Purchase Invoice,03-Deficiency in services,03-Déficience dans les services
-DocType: Delivery Note,Vehicle Dispatch Date,Date d'Envoi du Véhicule
-DocType: Healthcare Settings,Default Medical Code Standard,Code Médical Standard par Défaut
-DocType: Purchase Invoice Item,HSN/SAC,HSN / SAC
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237,Purchase Receipt {0} is not submitted,Le Reçu d’Achat {0} n'est pas soumis
-DocType: Company,Default Payable Account,Compte Créditeur par Défaut
-apps/erpnext/erpnext/config/website.py +17,"Settings for online shopping cart such as shipping rules, price list etc.","Réglages pour panier telles que les règles de livraison, liste de prix, etc."
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +113,{0}% Billed,{0}% Facturé
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18,Reserved Qty,Qté Réservées
-DocType: Party Account,Party Account,Compte de Tiers
-apps/erpnext/erpnext/config/setup.py +122,Human Resources,Ressources Humaines
-DocType: Lead,Upper Income,Revenu Élevé
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17,Reject,Rejeter
-DocType: Journal Entry Account,Debit in Company Currency,Débit en Devise Société
-DocType: BOM Item,BOM Item,Article LDM
-DocType: Appraisal,For Employee,Employé
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49,Make Disbursement Entry,Faire une Écriture de Décaissement
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138,Row {0}: Advance against Supplier must be debit,Ligne {0} : L’Avance du Fournisseur doit être un débit
-DocType: Company,Default Values,Valeurs Par Défaut
-DocType: Membership,INR,INR
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60,{frequency} Digest,Rapport {Frequency}
-DocType: Expense Claim,Total Amount Reimbursed,Montant Total Remboursé
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5,This is based on logs against this Vehicle. See timeline below for details,Basé sur les journaux de ce Véhicule. Voir la chronologie ci-dessous pour plus de détails
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90,Against Supplier Invoice {0} dated {1},Pour la Facture Fournisseur {0} datée {1}
-DocType: Customer,Default Price List,Liste des Prix par Défaut
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +322,Asset Movement record {0} created,Registre de Mouvement de l'Actif {0} créé
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,Vous ne pouvez pas supprimer l'Exercice {0}. L'exercice {0} est défini par défaut dans les Réglages Globaux
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,A customer with the same name already exists,Un client avec un nom identique existe déjà
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,Cela permettra de soumettre des bulletins de salaire et de créer une écriture de journal d&#39;accumulation. Voulez-vous poursuivre?
-DocType: Purchase Invoice,Total Net Weight,Poids net total
-DocType: Purchase Invoice,Eligibility For ITC,Admissibilité pour ITC
-DocType: Journal Entry,Entry Type,Type d'Écriture
-,Customer Credit Balance,Solde de Crédit des Clients
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28,Net Change in Accounts Payable,Variation Nette des Comptes Créditeurs
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,EcritureLet,EcritureLet
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +216,Credit limit has been crossed for customer {0} ({1}/{2}),La limite de crédit a été dépassée pour le client {0} ({1} / {2})
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',Client requis pour appliquer une 'Remise en fonction du Client'
-apps/erpnext/erpnext/config/accounts.py +140,Update bank payment dates with journals.,Mettre à jour les dates de paiement bancaires avec les journaux.
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21,Pricing,Tarification
-DocType: Quotation,Term Details,Détails du Terme
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30,Cannot enroll more than {0} students for this student group.,Inscription de plus de {0} étudiants impossible pour ce groupe d'étudiants.
-apps/erpnext/erpnext/templates/print_formats/includes/total.html +4,Total (Without Tax),Total (hors taxes)
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17,Lead Count,Nombre de Prospects
-apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15,{0} must be greater than 0,{0} doit être supérieur à 0
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30,Stock Available,Stock disponible
-DocType: Manufacturing Settings,Capacity Planning For (Days),Planification de Capacité Pendant (Jours)
-apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10,Procurement,Approvisionnement
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66,None of the items have any change in quantity or value.,Aucun des Articles n’a de changement en quantité ou en valeur.
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17,Mandatory field - Program,Champ Obligatoire - Programme
-DocType: Special Test Template,Result Component,Composante de Résultat
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46,Warranty Claim,Réclamation de Garantie
-,Lead Details,Détails du Prospect
-DocType: Volunteer,Availability and Skills,Disponibilité et compétences
-DocType: Salary Slip,Loan repayment,Remboursement de Prêt
-DocType: Purchase Invoice,End date of current invoice's period,Date de fin de la période de facturation en cours
-DocType: Pricing Rule,Applicable For,Applicable Pour
-DocType: Lab Test,Technician Name,Nom du Technicien
-DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,Délier Paiement à l'Annulation de la Facture
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},Le Compteur(kms) Actuel entré devrait être plus grand que le Compteur(kms) initial du Véhicule {0}
-DocType: Restaurant Reservation,No Show,Non Présenté
-DocType: Shipping Rule Country,Shipping Rule Country,Pays de la Règle de Livraison
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10,Leave and Attendance,Congés et Présences
-DocType: Maintenance Visit,Partially Completed,Partiellement Complété
-apps/erpnext/erpnext/healthcare/setup.py +257,Moderate Sensitivity,Sensibilité Modérée
-DocType: Leave Type,Include holidays within leaves as leaves,Inclure les vacances dans les congés en tant que congés
-DocType: Sales Invoice,Packed Items,Articles Emballés
-apps/erpnext/erpnext/config/support.py +27,Warranty Claim against Serial No.,Réclamation de Garantie pour le N° de Série.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +192,'Total','Total'
-DocType: Shopping Cart Settings,Enable Shopping Cart,Activer Panier
-DocType: Employee,Permanent Address,Adresse Permanente
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260,"Advance paid against {0} {1} cannot be greater \
-						than Grand Total {2}",L'avance versée pour {0} {1} ne peut être supérieure \ au Total Général {2}
-DocType: Patient,Medication,Médicaments
-DocType: Production Plan,Include Non Stock Items,Inclure les articles non stockés
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147,Please select item code,Veuillez sélectionner un code d'article
-DocType: Student Sibling,Studying in Same Institute,Étudier au même Institut
-DocType: Territory,Territory Manager,Responsable Régional
-DocType: Packed Item,To Warehouse (Optional),À l'Entrepôt (Facultatif)
-DocType: GST Settings,GST Accounts,Comptes de la TPS
-DocType: Payment Entry,Paid Amount (Company Currency),Montant Payé (Devise Société)
-DocType: Purchase Invoice,Additional Discount,Remise Supplémentaire
-DocType: Selling Settings,Selling Settings,Réglages de Vente
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83,Confirm Action,Confirmer l'Action
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39,Online Auctions,Enchères en Ligne
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100,Please specify either Quantity or Valuation Rate or both,"Veuillez spécifier la Quantité, le Taux de Valorisation ou les deux"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18,Fulfillment,Accomplissement
-apps/erpnext/erpnext/templates/generators/item.html +82,View in Cart,Voir Panier
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103,Marketing Expenses,Frais de Marketing
-,Item Shortage Report,Rapport de Rupture de Stock d'Article
-apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15,Can't create standard criteria. Please rename the criteria,Impossible de créer des critères standard. Veuillez renommer les critères
-apps/erpnext/erpnext/stock/doctype/item/item.js +282,"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Poids est mentionné,\nVeuillez aussi mentionner ""UDM de Poids"""
-DocType: Stock Entry Detail,Material Request used to make this Stock Entry,Demande de Matériel utilisée pour réaliser cette Écriture de Stock
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +68,Next Depreciation Date is mandatory for new asset,Date de l’Amortissement Suivant est obligatoire pour un nouvel actif
-DocType: Student Group Creation Tool,Separate course based Group for every Batch,Groupes basés sur les cours différents pour chaque Lot
-apps/erpnext/erpnext/config/support.py +32,Single unit of an Item.,Seule unité d'un Article.
-DocType: Fee Category,Fee Category,Catégorie d'Honoraires
-DocType: Agriculture Task,Next Business Day,Le jour ouvrable suivant
-DocType: Drug Prescription,Dosage by time interval,Dosage par intervalle de temps
-DocType: Cash Flow Mapper,Section Header,En-tête de section
-,Student Fee Collection,Frais de Scolarité
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +23,Appointment Duration (mins),Durée du Rendez-Vous (min.)
-DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,Faites une Écriture Comptable Pour Chaque Mouvement du Stock
-DocType: Leave Allocation,Total Leaves Allocated,Total des Congés Attribués
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Warehouse required at Row No {0},Entrepôt requis à la Ligne N° {0}
-apps/erpnext/erpnext/public/js/setup_wizard.js +145,Please enter valid Financial Year Start and End Dates,Veuillez entrer des Dates de Début et de Fin d’Exercice Comptable valides
-DocType: Employee,Date Of Retirement,Date de Départ à la Retraite
-DocType: Upload Attendance,Get Template,Obtenir Modèle
-DocType: Material Request,Transferred,Transféré
-DocType: Vehicle,Doors,Portes
-apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117,ERPNext Setup Complete!,Installation d'ERPNext Terminée!
-DocType: Healthcare Settings,Collect Fee for Patient Registration,Collecter les honoraires pour l'inscription des patients
-apps/erpnext/erpnext/stock/doctype/item/item.py +677,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,Impossible de modifier les attributs suite à des mouvements d'inventaire. Faites un nouvel article et transférez la quantité en main au nouvel article
-DocType: Course Assessment Criteria,Weightage,Poids
-DocType: Purchase Invoice,Tax Breakup,Répartition des Taxes
-DocType: Packing Slip,PS-,PS-
-DocType: Member,Non Profit Member,Membre à but non lucratif
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,"{0} {1} : Un Centre de Coûts est requis pour le compte ""Pertes et Profits"" {2}.Veuillez mettre en place un centre de coûts par défaut pour la Société."
-DocType: Payment Schedule,Payment Term,Terme de paiement
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +167,A Customer Group exists with same name please change the Customer name or rename the Customer Group,"Un Groupe de Clients existe avec le même nom, veuillez changer le nom du Client ou renommer le Groupe de Clients"
-DocType: Land Unit,Area,Région
-apps/erpnext/erpnext/public/js/templates/contact_list.html +37,New Contact,Nouveau Contact
-DocType: Territory,Parent Territory,Territoire Parent
-DocType: Purchase Invoice,Place of Supply,Lieu d'Approvisionnement
-DocType: Quality Inspection Reading,Reading 2,Lecture 2
-DocType: Stock Entry,Material Receipt,Réception Matériel
-DocType: Homepage,Products,Produits
-DocType: Announcement,Instructor,Instructeur
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61,Select Item (optional),Sélectionnez l'Article (facultatif)
-DocType: Fee Schedule Student Group,Fee Schedule Student Group,Groupe Étudiant Calendrier des Honoraires
-DocType: Student,AB+,AB+
-DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.","Si cet article a des variantes, alors il ne peut pas être sélectionné dans les commandes clients, etc."
-DocType: Lead,Next Contact By,Contact Suivant Par
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +324,Quantity required for Item {0} in row {1},Quantité requise pour l'Article {0} à la ligne {1}
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +46,Warehouse {0} can not be deleted as quantity exists for Item {1},L'entrepôt {0} ne peut pas être supprimé car il existe une quantité pour l'Article {1}
-DocType: Quotation,Order Type,Type de Commande
-,Item-wise Sales Register,Registre des Ventes par Article
-DocType: Asset,Gross Purchase Amount,Montant d'Achat Brut
-apps/erpnext/erpnext/utilities/user_progress.py +36,Opening Balances,Balances d'Ouverture
-DocType: Asset,Depreciation Method,Méthode d'Amortissement
-DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,Cette Taxe est-elle incluse dans le Taux de Base ?
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Target,Cible Totale
-DocType: Soil Texture,Sand Composition (%),Composition de sable (%)
-DocType: Job Applicant,Applicant for a Job,Candidat à un Emploi
-DocType: Production Plan Material Request,Production Plan Material Request,Demande de Matériel du Plan de Production
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231,No Production Orders created,Pas d'Ordre de Production créé
-DocType: Stock Reconciliation,Reconciliation JSON,Réconciliation JSON
-apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,Trop de colonnes. Exportez le rapport et imprimez-le à l'aide d'un tableur.
-DocType: Purchase Invoice Item,Batch No,N° du Lot
-DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,Autoriser plusieurs Commandes Clients pour un Bon de Commande d'un Client
-DocType: Student Group Instructor,Student Group Instructor,Instructeur de Groupe d'Étudiant
-DocType: Grant Application,Assessment  Mark (Out of 10),Note d&#39;évaluation (sur 10)
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61,Guardian2 Mobile No,N° du Mobile du Tuteur 1
-apps/erpnext/erpnext/setup/doctype/company/company.py +218,Main,Principal
-apps/erpnext/erpnext/stock/doctype/item/item.js +72,Variant,Variante
-DocType: Naming Series,Set prefix for numbering series on your transactions,Définir le préfixe des séries numérotées pour vos transactions
-DocType: Employee Attendance Tool,Employees HTML,Employés HTML
-apps/erpnext/erpnext/stock/doctype/item/item.py +457,Default BOM ({0}) must be active for this item or its template,LDM par défaut ({0}) doit être actif pour ce produit ou son modèle
-DocType: Employee,Leave Encashed?,Laisser Encaissé ?
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32,Opportunity From field is mandatory,Le champ Opportunité De est obligatoire
-DocType: Email Digest,Annual Expenses,Charges Annuelles
-DocType: Item,Variants,Variantes
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1139,Make Purchase Order,Faire un Bon de Commande
-DocType: SMS Center,Send To,Envoyer À
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +134,There is not enough leave balance for Leave Type {0},Il n'y a pas assez de solde de congés pour les Congés de Type {0}
-DocType: Payment Reconciliation Payment,Allocated amount,Montant alloué
-DocType: Sales Team,Contribution to Net Total,Contribution au Total Net
-DocType: Sales Invoice Item,Customer's Item Code,Code de l'Article du Client
-DocType: Stock Reconciliation,Stock Reconciliation,Réconciliation du Stock
-DocType: Territory,Territory Name,Nom de la Région
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +204,Work-in-Progress Warehouse is required before Submit,L'entrepôt des Travaux en Cours est nécessaire avant de Soumettre
-apps/erpnext/erpnext/config/hr.py +40,Applicant for a Job.,Candidat à un Emploi.
-DocType: Purchase Order Item,Warehouse and Reference,Entrepôt et Référence
-DocType: Supplier,Statutory info and other general information about your Supplier,Informations légales et autres informations générales au sujet de votre Fournisseur
-DocType: Item,Serial Nos and Batches,N° de Série et Lots
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42,Student Group Strength,Force du Groupe d'Étudiant
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +256,Against Journal Entry {0} does not have any unmatched {1} entry,L'Écriture de Journal {0} n'a pas d'entrée non associée {1}
-apps/erpnext/erpnext/config/hr.py +142,Appraisals,Évaluation
-apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8,Training Events,Événements de formation
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205,Duplicate Serial No entered for Item {0},Dupliquer N° de Série pour l'Article {0}
-DocType: Shipping Rule Condition,A condition for a Shipping Rule,Une condition pour une Règle de Livraison
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +167,Please enter ,Veuillez entrer
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43,Maintenance Log,Journal de maintenance
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236,Please set filter based on Item or Warehouse,Veuillez définir un filtre basé sur l'Article ou l'Entrepôt
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48,Item Code &gt; Item Group &gt; Brand,Code de l&#39;article&gt; Groupe de produits&gt; Marque
-DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),Le poids net de ce paquet. (Calculé automatiquement comme la somme du poids net des articles)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +798,Discount amount cannot be greater than 100%,Le montant de l&#39;escompte ne peut pas être supérieur à 100%
-DocType: Sales Order,To Deliver and Bill,À Livrer et Facturer
-DocType: Student Group,Instructors,Instructeurs
-DocType: GL Entry,Credit Amount in Account Currency,Montant du Crédit dans la Devise du Compte
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +598,BOM {0} must be submitted,LDM {0} doit être soumise
-apps/erpnext/erpnext/config/accounts.py +460,Share Management,Gestion des partages
-DocType: Authorization Control,Authorization Control,Contrôle d'Autorisation
-apps/erpnext/erpnext/controllers/buying_controller.py +327,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},Ligne #{0} : Entrepôt de Rejet est obligatoire pour l’Article rejeté {1}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810,Payment,Paiement
-apps/erpnext/erpnext/controllers/stock_controller.py +92,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.","L'Entrepôt {0} n'est lié à aucun compte, veuillez mentionner ce compte dans la fiche de l'Entrepôt ou définir un compte d'Entrepôt par défaut dans la Société {1}."
-apps/erpnext/erpnext/utilities/activation.py +81,Manage your orders,Gérer vos commandes
-DocType: Production Order Operation,Actual Time and Cost,Temps et Coût Réels
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Demande de Matériel d'un maximum de {0} peut être faite pour l'article {1} pour la Commande Client {2}
-DocType: Crop,Crop Spacing,Espacement des cultures
-DocType: Course,Course Abbreviation,Abréviation du Cours
-DocType: Student Leave Application,Student Leave Application,Demande de Congé d'Étudiant
-DocType: Item,Will also apply for variants,S'appliquera également pour les variantes
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +217,"Asset cannot be cancelled, as it is already {0}","L'actif ne peut être annulé, car il est déjà {0}"
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} on Half day on {1},Employé {0} sur une demi-journée sur {1}
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42,Total working hours should not be greater than max working hours {0},Le nombre total d'heures travaillées ne doit pas être supérieur à la durée maximale du travail {0}
-apps/erpnext/erpnext/templates/pages/task_info.html +90,On,Sur
-apps/erpnext/erpnext/config/selling.py +62,Bundle items at time of sale.,Grouper les articles au moment de la vente.
-DocType: Material Request Plan Item,Actual Qty,Quantité Réelle
-DocType: Sales Invoice Item,References,Références
-DocType: Quality Inspection Reading,Reading 10,Lecture 10
-DocType: Item,Barcodes,Codes-barres
-DocType: Hub Category,Hub Node,Noeud du Hub
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,Vous avez entré un doublon. Veuillez rectifier et essayer à nouveau.
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129,Associate,Associé
-DocType: Asset Movement,Asset Movement,Mouvement d'Actif
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2199,New Cart,Nouveau Panier
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Item {0} is not a serialized Item,L'article {0} n'est pas un Article avec un numéro de serie
-DocType: SMS Center,Create Receiver List,Créer une Liste de Réception
-DocType: Vehicle,Wheels,Roues
-DocType: Packing Slip,To Package No.,Au N° de Paquet
-DocType: Patient Relation,Family,Famille
-DocType: Production Plan,Material Requests,Les Demandes de Matériel
-DocType: Warranty Claim,Issue Date,Date d'Émission
-DocType: Activity Cost,Activity Cost,Coût de l'Activité
-DocType: Sales Invoice Timesheet,Timesheet Detail,Détails de la Feuille de Temps
-DocType: Purchase Receipt Item Supplied,Consumed Qty,Qté Consommée
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52,Telecommunications,Télécommunications
-apps/erpnext/erpnext/accounts/party.py +264,Billing currency must be equal to either default company's currency or party account currency,La devise de facturation doit être égale à la devise de la société par défaut ou à la devise du compte du partenaire
-DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),Indique que le paquet est une partie de cette livraison (Brouillons Seulement)
-DocType: Soil Texture,Loam,Terreau
-apps/erpnext/erpnext/controllers/accounts_controller.py +700,Row {0}: Due Date cannot be before posting date,Ligne {0}: la date d&#39;échéance ne peut pas être antérieure à la date d&#39;envoi
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36,Make Payment Entry,Faire une Écriture de Paiement
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129,Quantity for Item {0} must be less than {1},Quantité de l'article {0} doit être inférieure à {1}
-,Sales Invoice Trends,Tendances des Factures de Vente
-DocType: Leave Application,Apply / Approve Leaves,Appliquer / Approuver les Congés
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,For,Pour
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Peut se référer à ligne seulement si le type de charge est 'Montant de la ligne précedente' ou 'Total des lignes précedente'
-DocType: Sales Order Item,Delivery Warehouse,Entrepôt de Livraison
-apps/erpnext/erpnext/config/accounts.py +241,Tree of financial Cost Centers.,Arbre des Centres de Coûts financiers.
-DocType: Serial No,Delivery Document No,Numéro de Document de Livraison
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},Veuillez définir ‘Compte de Gain/Perte sur les Cessions d’Immobilisations’ de la Société {0}
-DocType: Landed Cost Voucher,Get Items From Purchase Receipts,Obtenir des Articles à partir des Reçus d'Achat
-DocType: Serial No,Creation Date,Date de Création
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33,Item {0} appears multiple times in Price List {1},L'article {0} apparaît plusieurs fois dans la Liste de Prix {1}
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Selling must be checked, if Applicable For is selected as {0}","Vente doit être vérifiée, si ""Applicable pour"" est sélectionné comme {0}"
-DocType: Production Plan Material Request,Material Request Date,Date de la Demande de Matériel
-DocType: Purchase Order Item,Supplier Quotation Item,Article Devis Fournisseur
-DocType: Manufacturing Settings,Disables creation of time logs against Production Orders. Operations shall not be tracked against Production Order,Désactive la création de registres de temps pour les Ordres de Fabrication. Le suivi des Opérations ne nécessite pas d’Ordres de Fabrication
-DocType: Student,Student Mobile Number,Numéro de Mobile de l'Étudiant
-DocType: Item,Has Variants,A Variantes
-apps/erpnext/erpnext/controllers/accounts_controller.py +487,"Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings","Impossible de surfacturer pour l&#39;article {0} de la ligne {1} plus de {2}. Pour autoriser la surfacturation, veuillez définir les paramètres de stock."
-apps/erpnext/erpnext/templates/emails/training_event.html +11,Update Response,Mettre à jour la Réponse
-apps/erpnext/erpnext/public/js/utils.js +232,You have already selected items from {0} {1},Vous avez déjà choisi des articles de {0} {1}
-DocType: Monthly Distribution,Name of the Monthly Distribution,Nom de la Répartition Mensuelle
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +95,Batch ID is mandatory,Le N° du lot est obligatoire
-DocType: Sales Person,Parent Sales Person,Commercial Parent
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100,The seller and the buyer cannot be the same,Le vendeur et l&#39;acheteur ne peuvent pas être les mêmes
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24,Select the program first,Sélectionnez d&#39;abord le programme
-DocType: Patient Appointment,Patient Age,Âge du patient
-apps/erpnext/erpnext/config/learn.py +253,Managing Projects,Gestion de Projets
-DocType: Supplier,Supplier of Goods or Services.,Fournisseur de Biens ou Services.
-DocType: Budget,Fiscal Year,Exercice Fiscal
-DocType: Asset Maintenance Log,Planned,Prévu
-DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Consultation charges.,Comptes débiteurs par défaut à utiliser si non définis dans la fiche Patient pour enregistrer les honoraires de consultation.
-DocType: Vehicle Log,Fuel Price,Prix du Carburant
-DocType: Budget,Budget,Budget
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +51,Set Open,Définir comme ouvert
-apps/erpnext/erpnext/stock/doctype/item/item.py +257,Fixed Asset Item must be a non-stock item.,Un Article Immobilisé doit être un élément non stocké.
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50,"Budget cannot be assigned against {0}, as it's not an Income or Expense account","Budget ne peut pas être affecté pour {0}, car ce n’est pas un compte de produits ou de charges"
-apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51,Achieved,Atteint
-DocType: Student Admission,Application Form Route,Chemin du Formulaire de Candidature
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66,Territory / Customer,Région / Client
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44,Leave Type {0} cannot be allocated since it is leave without pay,"Le Type de Congé {0} ne peut pas être alloué, car c’est un congé sans solde"
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},Ligne {0} : Le montant alloué {1} doit être inférieur ou égal au montant restant sur la Facture {2}
-DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,En Toutes Lettres. Sera visible une fois que vous enregistrerez la Facture.
-DocType: Lead,Follow Up,Suivre
-DocType: Item,Is Sales Item,Est un Article à Vendre
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,Arborescence de Groupe d'Article
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69,Item {0} is not setup for Serial Nos. Check Item master,L'article {0} n'est pas configuré pour les Numéros de Série. Vérifiez la fiche de l'Article
-DocType: Maintenance Visit,Maintenance Time,Temps d'Entretien
-,Amount to Deliver,Nombre à Livrer
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +334,Same item has been entered multiple times. {0},Le même objet a été saisi à plusieurs reprises. {0}
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,La Date de Début de Terme ne peut pas être antérieure à la Date de Début de l'Année Académique à laquelle le terme est lié (Année Académique {}). Veuillez corriger les dates et essayer à nouveau.
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190,There were errors.,Il y a eu des erreurs.
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +167,Employee {0} has already applied for {1} between {2} and {3} : ,L&#39;employé {0} a déjà postulé pour {1} entre {2} et {3}:
-DocType: Guardian,Guardian Interests,Part du Tuteur
-DocType: Naming Series,Current Value,Valeur actuelle
-apps/erpnext/erpnext/controllers/accounts_controller.py +272,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,Plusieurs Exercices existent pour la date {0}. Veuillez définir la société dans l'Exercice
-DocType: Education Settings,Instructor Records to be created by,Les Enregistrements de l'Instructeur seront créés par
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229,{0} created,{0} créé
-DocType: GST Account,GST Account,Compte de TPS
-DocType: Delivery Note Item,Against Sales Order,Pour la Commande Client
-,Serial No Status,Statut du N° de Série
-DocType: Payment Entry Reference,Outstanding,Solde
-DocType: Supplier,Warn POs,Avertir lors de Bons de Commande
-,Daily Timesheet Summary,Récapitulatif Quotidien des Feuilles de Présence
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137,"Row {0}: To set {1} periodicity, difference between from and to date \
-						must be greater than or equal to {2}","""Ligne {0} : Pour régler la périodicité de {1}, la différence entre la date de début et la date de fin \
-doit être supérieure ou égale à {2}"""
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6,This is based on stock movement. See {0} for details,Basé sur les mouvements de stock. Voir {0} pour plus de détails
-DocType: Pricing Rule,Selling,Vente
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +385,Amount {0} {1} deducted against {2},Montant {0} {1} déduit de {2}
-DocType: Employee,Salary Information,Information sur le Salaire
-DocType: Sales Person,Name and Employee ID,Nom et ID de l’Employé
-apps/erpnext/erpnext/accounts/party.py +309,Due Date cannot be before Posting Date,La Date d'Échéance ne peut être antérieure à la Date de Comptabilisation
-DocType: Website Item Group,Website Item Group,Groupe d'Articles du Site Web
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +458,No salary slip found to submit for the above selected criteria OR salary slip already submitted,Aucun bulletin de salaire ne peut être soumis pour les critères sélectionnés ci-dessus OU le bulletin de salaire déjà soumis
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150,Duties and Taxes,Droits de Douane et Taxes
-DocType: Projects Settings,Projects Settings,Paramètres de projets
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,Please enter Reference date,Veuillez entrer la date de Référence
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44,{0} payment entries can not be filtered by {1},{0} écritures de paiement ne peuvent pas être filtrées par {1}
-DocType: Item Website Specification,Table for Item that will be shown in Web Site,Table pour l'Article qui sera affiché sur le site Web
-DocType: Purchase Order Item Supplied,Supplied Qty,Qté Fournie
-DocType: Purchase Order Item,Material Request Item,Article de Demande de Matériel
-apps/erpnext/erpnext/config/selling.py +75,Tree of Item Groups.,Arbre de Groupes d’Articles .
-DocType: Production Plan,Total Produced Qty,Quantité totale produite
-DocType: Payroll Entry,Get Employee Details,Obtenir les détails de l&#39;employé
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177,Cannot refer row number greater than or equal to current row number for this Charge type,Impossible de se référer au numéro de la ligne supérieure ou égale au numéro de la ligne courante pour ce type de Charge
-DocType: Asset,Sold,Vendu
-,Item-wise Purchase History,Historique d'Achats par Article
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Veuillez cliquer sur ‘Générer Calendrier’ pour récupérer le N° Série ajouté à l'article {0}
-DocType: Account,Frozen,Gelé
-,Open Production Orders,Ouvrir les Ordres de Fabrication
-DocType: Sales Invoice Payment,Base Amount (Company Currency),Montant de Base (Devise de la Société)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +919,Raw Materials,Matières premières
-DocType: Payment Reconciliation Payment,Reference Row,Ligne de Référence
-DocType: Installation Note,Installation Time,Temps d'Installation
-DocType: Sales Invoice,Accounting Details,Détails Comptabilité
-apps/erpnext/erpnext/setup/doctype/company/company.js +113,Delete all the Transactions for this Company,Supprimer toutes les Transactions pour cette Société
-DocType: Patient,O Positive,O Positif
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,Ligne #{0} : L’Opération {1} n’est pas terminée pour {2} qtés de produits finis de l’Ordre de Production # {3}. Veuillez mettre à jour le statut des opérations via les Journaux de Temps
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Investments,Investissements
-DocType: Issue,Resolution Details,Détails de la Résolution
-apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3,Allocations,Allocations
-DocType: Item Quality Inspection Parameter,Acceptance Criteria,Critères d'Acceptation
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159,Please enter Material Requests in the above table,Veuillez entrer les Demandes de Matériel dans le tableau ci-dessus
-DocType: Item Attribute,Attribute Name,Nom de l'Attribut
-DocType: BOM,Show In Website,Afficher dans le Site Web
-DocType: Shopping Cart Settings,Show Quantity in Website,Afficher la Quantité sur le Site
-DocType: Employee Loan Application,Total Payable Amount,Montant Total Créditeur
-DocType: Task,Expected Time (in hours),Durée Prévue (en heures)
-DocType: Item Reorder,Check in (group),Enregistrement (groupe)
-DocType: Soil Texture,Silt,Limon
-,Qty to Order,Quantité à Commander
-DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked","Le titre du compte de Passif ou de Capitaux Propres, dans lequel les Bénéfices/Pertes seront comptabilisés"
-apps/erpnext/erpnext/config/projects.py +31,Gantt chart of all tasks.,Diagramme de Gantt de toutes les tâches.
-DocType: Opportunity,Mins to First Response,Minutes avant la Première Réponse
-DocType: Pricing Rule,Margin Type,Type de Marge
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15,{0} hours,{0} heures
-DocType: Course,Default Grading Scale,Échelle de Notation par Défault
-DocType: Appraisal,For Employee Name,Nom de l'Employé
-DocType: Holiday List,Clear Table,Effacer le tableau
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +106,Available slots,Créneaux Disponibles
-DocType: C-Form Invoice Detail,Invoice No,No de Facture
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +350,Make Payment,Faire un Paiement
-DocType: Room,Room Name,Nom de la Chambre
-DocType: Prescription Duration,Prescription Duration,Durée de la prescription
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +82,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Congé ne peut être demandé / annulé avant le {0}, car le solde de congés a déjà été reporté dans la feuille d'allocation de congés futurs {1}"
-DocType: Activity Cost,Costing Rate,Taux des Coûts
-apps/erpnext/erpnext/config/selling.py +229,Customer Addresses And Contacts,Adresses et Contacts des Clients
-,Campaign Efficiency,Efficacité des Campagnes
-DocType: Discussion,Discussion,Discussion
-DocType: Payment Entry,Transaction ID,Identifiant de Transaction
-DocType: Volunteer,Anytime,À tout moment
-DocType: Patient,Surgical History,Antécédents Chirurgicaux
-DocType: Employee,Resignation Letter Date,Date de la Lettre de Démission
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39,Pricing Rules are further filtered based on quantity.,Les Règles de Tarification sont d'avantage filtrés en fonction de la quantité.
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +131,Not Set,Non Défini
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +334,Please set the Date Of Joining for employee {0},Veuillez définir la Date d'Embauche pour l'employé {0}
-DocType: Task,Total Billing Amount (via Time Sheet),Montant Total de Facturation (via Feuille de Temps)
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,Revenus de Clients Récurrents
-DocType: Soil Texture,Silty Clay Loam,Silo Clay Loam
-DocType: Chapter,Chapter,Chapitre
-apps/erpnext/erpnext/utilities/user_progress.py +143,Pair,Paire
-DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,Le compte par défaut sera automatiquement mis à jour dans la facture de point de vente lorsque ce mode est sélectionné.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +961,Select BOM and Qty for Production,Sélectionner la LDM et la Qté pour la Production
-DocType: Asset,Depreciation Schedule,Calendrier d'Amortissement
-apps/erpnext/erpnext/config/selling.py +124,Sales Partner Addresses And Contacts,Adresses et Contacts des Partenaires de Vente
-DocType: Bank Reconciliation Detail,Against Account,Pour le Compte
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54,Supplier &gt; Supplier Type,Fournisseur&gt; Type de fournisseur
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +53,Half Day Date should be between From Date and To Date,La Date de Demi-Journée doit être entre la Date de Début et la Date de Fin
-DocType: Maintenance Schedule Detail,Actual Date,Date Réelle
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139,Please set the Default Cost Center in {0} company.,Veuillez définir le Centre de coûts par défaut dans la société {0}.
-DocType: Item,Has Batch No,A un Numéro de Lot
-apps/erpnext/erpnext/public/js/utils.js +106,Annual Billing: {0},Facturation Annuelle : {0}
-apps/erpnext/erpnext/config/accounts.py +200,Goods and Services Tax (GST India),Taxe sur les Biens et Services (GST India)
-DocType: Delivery Note,Excise Page Number,Numéro de Page d'Accise
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227,"Company, From Date and To Date is mandatory","Société, Date Début et Date Fin sont obligatoires"
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33,Get from Consultation,Obtenir depuis la Consultation
-DocType: Asset,Purchase Date,Date d'Achat
-DocType: Volunteer,Volunteer Type,Type de bénévole
-DocType: Student,Personal Details,Données Personnelles
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193,Please set 'Asset Depreciation Cost Center' in Company {0},Veuillez définir 'Centre de Coûts des Amortissements d’Actifs’ de la Société {0}
-,Maintenance Schedules,Échéanciers d'Entretien
-DocType: Task,Actual End Date (via Time Sheet),Date de Fin Réelle (via la Feuille de Temps)
-DocType: Soil Texture,Soil Type,Le type de sol
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +380,Amount {0} {1} against {2} {3},Montant {0} {1} pour {2} {3}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277,New Message,Nouveau Message
-,Quotation Trends,Tendances des Devis
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160,Item Group not mentioned in item master for item {0},Le Groupe d'Articles n'est pas mentionné dans la fiche de l'article pour l'article {0}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368,Debit To account must be a Receivable account,Le compte de débit doit être un compte Débiteur
-DocType: Shipping Rule,Shipping Amount,Montant de la Livraison
-DocType: Supplier Scorecard Period,Period Score,Score de la Période
-apps/erpnext/erpnext/utilities/user_progress.py +63,Add Customers,Ajouter des Clients
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Pending Amount,Montant en Attente
-DocType: Lab Test Template,Special,Spécial
-DocType: Purchase Order Item Supplied,Conversion Factor,Facteur de Conversion
-DocType: Purchase Order,Delivered,Livré
-,Vehicle Expenses,Frais de Véhicule
-DocType: Serial No,Invoice Details,Détails de la Facture
-DocType: Grant Application,Show on Website,Afficher sur le site Web
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +212,Expected value after useful life must be greater than or equal to {0},Valeur attendue après utilisation complète doit être supérieure ou égale à {0}
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29,Start on,Démarrer
-DocType: Hub Category,Hub Category,Catégorie du Hub
-DocType: Purchase Invoice,SEZ,SEZ
-DocType: Purchase Receipt,Vehicle Number,Numéro de Véhicule
-DocType: Employee Loan,Loan Amount,Montant du Prêt
-apps/erpnext/erpnext/utilities/user_progress.py +88,Add Letterhead,Ajouter un en-tête
-DocType: Program Enrollment,Self-Driving Vehicle,Véhicule Autonome
-DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,Classement de la Fiche d'Évaluation Fournisseur
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +442,Row {0}: Bill of Materials not found for the Item {1},Ligne {0} : Liste de Matériaux non trouvée pour l’Article {1}
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,Le Total des feuilles attribuées {0} ne peut pas être inférieur aux feuilles déjà approuvées {1} pour la période
-DocType: Journal Entry,Accounts Receivable,Comptes Débiteurs
-,Supplier-Wise Sales Analytics,Analyse des Ventes par Fournisseur
-DocType: Purchase Invoice,Availed ITC Central Tax,Taxe centrale ITC supprimée
-DocType: Salary Structure,Select employees for current Salary Structure,Sélectionner les Employés pour la Grille de Salaire actuelle
-DocType: Sales Invoice,Company Address Name,Nom de l'Adresse de la Société
-DocType: Production Order,Use Multi-Level BOM,Utiliser LDM à Plusieurs Niveaux
-DocType: Bank Reconciliation,Include Reconciled Entries,Inclure les Écritures Réconciliées
-DocType: Course,"Parent Course (Leave blank, if this isn't part of Parent Course)","Cours Parent (Laisser vide, si cela ne fait pas partie du Cours Parent)"
-DocType: Leave Control Panel,Leave blank if considered for all employee types,Laisser vide pour tous les types d'employés
-DocType: Landed Cost Voucher,Distribute Charges Based On,Distribuer les Charges sur la Base de
-DocType: Projects Settings,Timesheets,Feuilles de Temps
-DocType: HR Settings,HR Settings,Paramètres RH
-DocType: Salary Slip,net pay info,Info de salaire net
-DocType: Lab Test Template,This value is updated in the Default Sales Price List.,Cette valeur est mise à jour dans la liste de prix de vente par défaut.
-DocType: Email Digest,New Expenses,Nouvelles Charges
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79,PDC/LC Amount,PDC / LC Montant
-DocType: Shareholder,Shareholder,Actionnaire
-DocType: Purchase Invoice,Additional Discount Amount,Montant de la Remise Supplémentaire
-DocType: Cash Flow Mapper,Position,Position
-DocType: Patient,Patient Details,Détails du patient
-DocType: Patient,B Positive,B Positif
-apps/erpnext/erpnext/controllers/accounts_controller.py +595,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.","Ligne #{0} : Qté doit égale à 1, car l’Article est un actif immobilisé. Veuillez utiliser une ligne distincte pour une qté multiple."
-DocType: Leave Block List Allow,Leave Block List Allow,Autoriser la Liste de Blocage des Congés
-apps/erpnext/erpnext/setup/doctype/company/company.py +317,Abbr can not be blank or space,Abré. ne peut être vide ou contenir un espace
-DocType: Patient Medical Record,Patient Medical Record,Registre médical du patient
-apps/erpnext/erpnext/accounts/doctype/account/account.js +68,Group to Non-Group,Groupe vers Non-Groupe
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50,Sports,Sportif
-DocType: Loan Type,Loan Name,Nom du Prêt
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56,Total Actual,Total Réel
-DocType: Lab Test UOM,Test UOM,UDM de Test
-DocType: Student Siblings,Student Siblings,Frères et Sœurs de l'Étudiants
-apps/erpnext/erpnext/utilities/user_progress.py +143,Unit,Unité
-apps/erpnext/erpnext/stock/get_item_details.py +138,Please specify Company,Veuillez spécifier la Société
-,Customer Acquisition and Loyalty,Acquisition et Fidélisation des Clients
-DocType: Asset Maintenance Task,Maintenance Task,Tâche de maintenance
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118,Please set B2C Limit in GST Settings.,Veuillez définir la limite B2C dans les paramètres GST.
-DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,L'entrepôt où vous conservez le stock d'objets refusés
-DocType: Production Order,Skip Material Transfer,Sauter le Transfert de Materiel
-apps/erpnext/erpnext/setup/utils.py +109,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,Impossible de trouver le taux de change pour {0} à {1} pour la date clé {2}. Veuillez créer une entrée de taux de change manuellement
-DocType: POS Profile,Price List,Liste de Prix
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} est désormais l’Exercice par défaut. Veuillez actualiser la page pour que les modifications soient prises en compte.
-apps/erpnext/erpnext/projects/doctype/task/task.js +45,Expense Claims,Notes de Frais
-DocType: Issue,Support,Support
-,BOM Search,Recherche LDM
-DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.","Publier ""En Stock"" ou ""Pas en Stock"" sur le Hub sur la base du stock disponible dans cet entrepôt."
-DocType: Vehicle,Fuel Type,Type de Carburant
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27,Please specify currency in Company,Veuillez spécifier la devise de la Société
-DocType: Workstation,Wages per hour,Salaires par heure
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},Solde du stock dans le Lot {0} deviendra négatif {1} pour l'Article {2} à l'Entrepôt {3}
-apps/erpnext/erpnext/templates/emails/reorder_item.html +1,Following Material Requests have been raised automatically based on Item's re-order level,Les Demandes de Matériel suivantes ont été créées automatiquement sur la base du niveau de réapprovisionnement de l’Article
-DocType: Email Digest,Pending Sales Orders,Commandes Client en Attente
-apps/erpnext/erpnext/controllers/accounts_controller.py +311,Account {0} is invalid. Account Currency must be {1},Le compte {0} est invalide. La Devise du Compte doit être {1}
-DocType: Healthcare Settings,Remind Before,Rappeler Avant
-apps/erpnext/erpnext/buying/utils.py +34,UOM Conversion factor is required in row {0},Facteur de conversion de l'UDM est obligatoire dans la ligne {0}
-DocType: Production Plan Item,material_request_item,article_demande_de_materiel
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1060,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry","Ligne #{0} : Le Type de Document de Référence doit être une Commande Client, une Facture de Vente ou une Écriture de Journal"
-DocType: Salary Component,Deduction,Déduction
-DocType: Item,Retain Sample,Conserver l&#39;échantillon
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115,Row {0}: From Time and To Time is mandatory.,Ligne {0} : Heure de Début et Heure de Fin obligatoires.
-DocType: Stock Reconciliation Item,Amount Difference,Différence de Montant
-apps/erpnext/erpnext/stock/get_item_details.py +356,Item Price added for {0} in Price List {1},Prix de l'Article ajouté pour {0} dans la Liste de Prix {1}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8,Please enter Employee Id of this sales person,Veuillez entrer l’ID Employé de ce commercial
-DocType: Territory,Classification of Customers by region,Classification des Clients par région
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71,In Production,En production
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +60,Difference Amount must be zero,L’Écart de Montant doit être égal à zéro
-DocType: Project,Gross Margin,Marge Brute
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +61,Please enter Production Item first,Veuillez d’abord entrer l'Article en Production
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45,Calculated Bank Statement balance,Solde Calculé du Relevé Bancaire
-DocType: Normal Test Template,Normal Test Template,Modèle de Test Normal
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64,disabled user,Utilisateur Désactivé
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919,Quotation,Devis
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984,Cannot set a received RFQ to No Quote,Impossible de lier une Réponse à Appel d'Offres reçue à Aucun Devis
-DocType: Quotation,QTN-,QTN-
-DocType: Salary Slip,Total Deduction,Déduction Totale
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18,Select an account to print in account currency,Sélectionnez un compte à imprimer dans la devise du compte
-,Production Analytics,Analyse de la Production
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6,This is based on transactions against this Patient. See timeline below for details,Ceci est basé sur les transactions de ce patient. Voir la chronologie ci-dessous pour plus de détails
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +203,Cost Updated,Coût Mise à Jour
-DocType: Patient,Date of Birth,Date de Naissance
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +129,Item {0} has already been returned,L'article {0} a déjà été retourné
-DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**Exercice** représente un Exercice Financier. Toutes les écritures comptables et autres transactions majeures sont suivis en **Exercice**.
-DocType: Opportunity,Customer / Lead Address,Adresse du Client / Prospect
-DocType: Supplier Scorecard Period,Supplier Scorecard Setup,Configuration de la Fiche d'Évaluation Fournisseur
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133,Assessment Plan Name,Nom du Plan d'Évaluation
-apps/erpnext/erpnext/stock/doctype/item/item.py +232,Warning: Invalid SSL certificate on attachment {0},Attention : certificat SSL non valide sur la pièce jointe {0}
-apps/erpnext/erpnext/utilities/activation.py +64,"Leads help you get business, add all your contacts and more as your leads","Les prospects vous aident à obtenir des contrats, ajoutez tous vos contacts et plus dans votre liste de prospects"
-DocType: Production Order Operation,Actual Operation Time,Temps d'Exploitation Réel
-DocType: Authorization Rule,Applicable To (User),Applicable À (Utilisateur)
-DocType: Purchase Taxes and Charges,Deduct,Déduire
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +237,Job Description,Description de l'Emploi
-DocType: Student Applicant,Applied,Appliqué
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +865,Re-open,Ré-ouvrir
-DocType: Sales Invoice Item,Qty as per Stock UOM,Qté par UDM du Stock
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59,Guardian2 Name,Nom du Tuteur 2
-DocType: Purchase Invoice,02-Post Sale Discount,Remise de vente 02-Post
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +127,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series","Les caractères spéciaux sauf ""-"", ""#"", ""."" et ""/"" ne sont pas autorisés dans le nommage des séries"
-DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.","Garder une Trace des Campagnes de Vente. Garder une trace des Prospects, Devis, Commandes Client etc. depuis les Campagnes pour mesurer le Retour sur Investissement."
-,SO Qty,SO Qté
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91,The field To Shareholder cannot be blank,Le champ Destinataire ne peut pas être vide
-DocType: Guardian,Work Address,Adresse du Bureau
-DocType: Appraisal,Calculate Total Score,Calculer le Résultat Total
-DocType: Asset Repair,Manufacturing Manager,Responsable Fabrication
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191,Serial No {0} is under warranty upto {1},N° de Série {0} est sous garantie jusqu'au {1}
-DocType: Plant Analysis Criteria,Minimum Permissible Value,Valeur minimale autorisée
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41,User {0} already exists,L&#39;utilisateur {0} existe déjà
-apps/erpnext/erpnext/hooks.py +109,Shipments,Livraisons
-DocType: Payment Entry,Total Allocated Amount (Company Currency),Montant Total Alloué (Devise Société)
-DocType: Purchase Order Item,To be delivered to customer,À livrer à la clientèle
-DocType: BOM,Scrap Material Cost,Coût de Mise au Rebut des Matériaux
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} does not belong to any Warehouse,N° de Série {0} ne fait partie de aucun Entrepôt
-DocType: Grant Application,Email Notification Sent,Notification par e-mail envoyée
-DocType: Purchase Invoice,In Words (Company Currency),En Toutes Lettres (Devise Société)
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1009,"Item Code, warehouse, quantity are required on row","Le code d&#39;article, l&#39;entrepôt, la quantité sont requis sur la rangée"
-DocType: Pricing Rule,Supplier,Fournisseur
-apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41,Show Payment Details,Afficher les détails du paiement
-DocType: Consultation,Consultation Time,Durée de Consultation
-DocType: C-Form,Quarter,Trimestre
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106,Miscellaneous Expenses,Charges Diverses
-DocType: Global Defaults,Default Company,Société par Défaut
-apps/erpnext/erpnext/controllers/stock_controller.py +227,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Compte de Charge et d'Écarts est obligatoire pour objet {0} car il impacte la valeur globale des actions
-DocType: Payment Request,PR,PR
-DocType: Cheque Print Template,Bank Name,Nom de la Banque
-apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +29,-Above,-Au-dessus
-DocType: Employee Loan,Employee Loan Account,Compte de Prêt d'un Employé
-DocType: Leave Application,Total Leave Days,Total des Jours de Congé
-DocType: Email Digest,Note: Email will not be sent to disabled users,Remarque : Email ne sera pas envoyé aux utilisateurs désactivés
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14,Number of Interaction,Nombre d'Interactions
-apps/erpnext/erpnext/stock/doctype/item/item.js +105,Item Variant Settings,Paramètres de Variante d'Article
-apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +39,Select Company...,Sélectionner la Société ...
-DocType: Leave Control Panel,Leave blank if considered for all departments,Laisser vide pour tous les départements
-apps/erpnext/erpnext/config/hr.py +228,"Types of employment (permanent, contract, intern etc.).","Type d’emploi (CDI, CDD, Stagiaire, etc.)"
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434,{0} is mandatory for Item {1},{0} est obligatoire pour l’Article {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136,"Item {0}: {1} qty produced, ","Article {0}: {1} quantité produite,"
-DocType: Payroll Entry,Fortnightly,Bimensuel
-DocType: Currency Exchange,From Currency,De la Devise
-DocType: Vital Signs,Weight (In Kilogram),Poids (En Kilogramme)
-DocType: Chapter,"chapters/chapter_name
-leave blank automatically set after saving chapter.",chapitres / nom_chapitre laisser vide automatiquement défini après l'enregistrement du chapitre.
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202,Please set GST Accounts in GST Settings,Veuillez définir les comptes de TPS dans les paramètres de la TPS
-apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31,Type of Business,Type de commerce
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row","Veuillez sélectionner le Montant Alloué, le Type de Facture et le Numéro de Facture dans au moins une ligne"
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128,Cost of New Purchase,Coût du Nouvel Achat
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35,All tasks for the detected diseases were imported,Toutes les tâches pour les maladies détectées ont été importées
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97,Sales Order required for Item {0},Commande Client requise pour l'Article {0}
-DocType: Grant Application,Grant Description,Description de la subvention
-DocType: Purchase Invoice Item,Rate (Company Currency),Prix (Devise Société)
-DocType: Student Guardian,Others,Autres
-DocType: Payment Entry,Unallocated Amount,Montant Non Alloué
-apps/erpnext/erpnext/templates/includes/product_page.js +90,Cannot find a matching Item. Please select some other value for {0}.,Impossible de trouver un article similaire. Veuillez sélectionner une autre valeur pour {0}.
-DocType: POS Profile,Taxes and Charges,Taxes et Frais
-DocType: Item,"A Product or a Service that is bought, sold or kept in stock.","Un Produit ou un Service qui est acheté, vendu ou conservé en stock."
-apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44,No more updates,Pas de mise à jour supplémentaire
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Impossible de sélectionner le type de charge comme étant «Le Montant de la Ligne Précédente» ou «Montant Total de la Ligne Précédente» pour la première ligne
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6,This covers all scorecards tied to this Setup,Cela couvre toutes les fiches d'Évaluation liées à cette Configuration
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29,Child Item should not be a Product Bundle. Please remove item `{0}` and save,Le sous-article ne doit pas être un ensemble de produit. S'il vous plaît retirer l'article `{0}` et sauver
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12,Banking,Banque
-apps/erpnext/erpnext/utilities/activation.py +108,Add Timesheets,Ajouter des Feuilles de Temps
-DocType: Vehicle Service,Service Item,Poste de Service
-DocType: Bank Guarantee,Bank Guarantee,Garantie Bancaire
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39,Please click on 'Generate Schedule' to get schedule,Veuillez cliquer sur ‘Générer Calendrier’ pour obtenir le calendrier
-DocType: Bin,Ordered Quantity,Quantité Commandée
-apps/erpnext/erpnext/public/js/setup_wizard.js +118,"e.g. ""Build tools for builders""","e.g. ""Construire des outils pour les constructeurs"""
-DocType: Grading Scale,Grading Scale Intervals,Intervalles de l'Échelle de Notation
-apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39,Profit for the year,Bénéfice pour l&#39;année
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1} : L’Écriture Comptable pour {2} peut seulement être faite en devise: {3}
-DocType: Fee Schedule,In Process,En Cours
-DocType: Authorization Rule,Itemwise Discount,Remise par Article
-apps/erpnext/erpnext/config/accounts.py +75,Tree of financial accounts.,Arbre des comptes financiers.
-DocType: Cash Flow Mapping,Cash Flow Mapping,Cartographie des flux de trésorerie
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364,{0} against Sales Order {1},{0} pour la Commande Client {1}
-DocType: Account,Fixed Asset,Actif Immobilisé
-apps/erpnext/erpnext/config/stock.py +324,Serialized Inventory,Inventaire Sérialisé
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74,Email not found in default contact,Email non trouvé dans le contact par défaut
-DocType: Employee Loan,Account Info,Information du Compte
-DocType: Activity Type,Default Billing Rate,Prix de Facturation par Défaut
-DocType: Fees,Include Payment,Inclure le Paiement
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77,{0} Student Groups created.,{0} Groupes d'Étudiants créés.
-DocType: Sales Invoice,Total Billing Amount,Montant Total de Facturation
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50,Program in the Fee Structure and Student Group {0} are different.,Le programme dans la structure des frais et le groupe d&#39;étudiants {0} sont différents.
-DocType: Fee Schedule,Receivable Account,Compte Débiteur
-apps/erpnext/erpnext/controllers/accounts_controller.py +617,Row #{0}: Asset {1} is already {2},Ligne #{0} : L’Actif {1} est déjà {2}
-DocType: Quotation Item,Stock Balance,Solde du Stock
-apps/erpnext/erpnext/config/selling.py +316,Sales Order to Payment,De la Commande Client au Paiement
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123,CEO,PDG
-DocType: Purchase Invoice,With Payment of Tax,Avec Paiement de Taxe
-DocType: Expense Claim Detail,Expense Claim Detail,Détail de la Note de Frais
-DocType: Purchase Invoice,TRIPLICATE FOR SUPPLIER,TRIPLICAT POUR LE FOURNISSEUR
-DocType: Land Unit,Is Container,Est le conteneur
-DocType: Crop Cycle,This will be day 1 of the crop cycle,Ce sera le jour 1 du cycle de la culture
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871,Please select correct account,Veuillez sélectionner un compte correct
-DocType: Purchase Invoice Item,Weight UOM,UDM de Poids
-apps/erpnext/erpnext/config/accounts.py +466,List of available Shareholders with folio numbers,Liste des actionnaires disponibles avec numéros de folio
-DocType: Salary Structure Employee,Salary Structure Employee,Grille des Salaires des Employés
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45,Show Variant Attributes,Afficher les attributs de variante
-DocType: Student,Blood Group,Groupe Sanguin
-DocType: Course,Course Name,Nom du Cours
-DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,Les utilisateurs qui peuvent approuver les demandes de congé d'un employé en particulier
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52,Office Equipments,Équipements de Bureau
-DocType: Purchase Invoice Item,Qty,Qté
-DocType: Fiscal Year,Companies,Sociétés
-DocType: Supplier Scorecard,Scoring Setup,Paramétrage de la Notation
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24,Electronics,Électronique
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326,Debit ({0}),Débit ({0})
-DocType: Stock Settings,Raise Material Request when stock reaches re-order level,Créer une demande de matériel lorsque le stock atteint le niveau de réapprovisionnement
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98,Full-time,Temps Plein
-DocType: Payroll Entry,Employees,Employés
-DocType: Employee,Contact Details,Coordonnées
-DocType: C-Form,Received Date,Date de Réception
-DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.","Si vous avez créé un modèle standard dans Modèle de Taxes et Frais de Vente, sélectionnez-en un et cliquez sur le bouton ci-dessous."
-DocType: BOM Scrap Item,Basic Amount (Company Currency),Montant de Base (Devise de la Société)
-DocType: Student,Guardians,Tuteurs
-DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,Les Prix ne seront pas affichés si la Liste de Prix n'est pas définie
-DocType: Stock Entry,Total Incoming Value,Valeur Entrante Totale
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362,Debit To is required,Compte de Débit Requis
-apps/erpnext/erpnext/utilities/activation.py +109,"Timesheets help keep track of time, cost and billing for activites done by your team","Les Feuilles de Temps aident au suivi du temps, coût et facturation des activités effectuées par votre équipe"
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,Liste des Prix d'Achat
-apps/erpnext/erpnext/config/buying.py +155,Templates of supplier scorecard variables.,Modèles des Variables de  Fiche d'Évaluation Fournisseur.
-DocType: Job Offer Term,Offer Term,Terme de la Proposition
-DocType: Asset,Quality Manager,Responsable Qualité
-DocType: Job Applicant,Job Opening,Offre d’Emploi
-DocType: Payment Reconciliation,Payment Reconciliation,Réconciliation des Paiements
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153,Please select Incharge Person's name,Veuillez sélectionner le nom du/de la Responsable
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51,Technology,Technologie
-DocType: Hub Settings,Unregister from Hub,Annuler l&#39;inscription de Hub
-apps/erpnext/erpnext/public/js/utils.js +108,Total Unpaid: {0},Total des Impayés : {0}
-DocType: BOM Website Operation,BOM Website Operation,Opération de LDM du Site Internet
-apps/erpnext/erpnext/config/manufacturing.py +18,Generate Material Requests (MRP) and Production Orders.,Générer des Demandes de Matériel (MRP) et des Ordres de Fabrication.
-DocType: Supplier Scorecard,Supplier Score,Note du Fournisseur
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +208,Total Invoiced Amt,Mnt Total Facturé
-DocType: Supplier,Warn RFQs,Avertir lors des Appels d'Offres
-DocType: BOM,Conversion Rate,Taux de Conversion
-apps/erpnext/erpnext/templates/pages/product_search.html +3,Product Search,Recherche de Produit
-DocType: Assessment Plan,To Time,Horaire de Fin
-DocType: Authorization Rule,Approving Role (above authorized value),Rôle Approbateur (valeurs autorisées ci-dessus)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118,Credit To account must be a Payable account,Le compte À Créditer doit être un compte Créditeur
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43,Please select Student Admission which is mandatory for the paid student applicant,Veuillez sélectionner obligatoirement une Admission d'Étudiant pour la candidature étudiante payée
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +348,BOM recursion: {0} cannot be parent or child of {2},Répétition LDM : {0} ne peut pas être parent ou enfant de {2}
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21,Please select a Price List to publish pricing,Veuillez sélectionner une liste de prix pour publier les prix
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38,Budget List,Liste budgétaire
-DocType: Production Order Operation,Completed Qty,Quantité Terminée
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148,"For {0}, only debit accounts can be linked against another credit entry","Pour {0}, seuls les comptes de débit peuvent être liés avec une autre écriture de crédit"
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27,Price List {0} is disabled,La Liste de Prix {0} est désactivée
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127,Row {0}: Completed Qty cannot be more than {1} for operation {2},Ligne {0} : Qté Complétée ne peut pas être supérieure à {1} pour l’opération {2}
-DocType: Manufacturing Settings,Allow Overtime,Autoriser les Heures Supplémentaires
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry","L'Article Sérialisé {0} ne peut pas être mis à jour en utilisant la réconciliation des stocks, veuillez utiliser l'entrée de stock"
-DocType: Training Event Employee,Training Event Employee,Évènement de Formation – Employé
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1017,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,Maximum d&#39;échantillons - {0} peut être conservé pour le lot {1} et l&#39;article {2}.
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +6,Add Time Slots,Ajouter des Créneaux
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201,{0} Serial Numbers required for Item {1}. You have provided {2}.,{0} Numéros de Série requis pour objet {1}. Vous en avez fourni {2}.
-DocType: Stock Reconciliation Item,Current Valuation Rate,Taux de Valorisation Actuel
-DocType: Item,Customer Item Codes,Codes Articles du Client
-DocType: Training Event,Advance,Avance
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,for making recurring again.,pour que le document soit à nouveau un document récurrent.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122,Exchange Gain/Loss,Profits / Pertes sur Change
-DocType: Opportunity,Lost Reason,Raison de la Perte
-apps/erpnext/erpnext/controllers/accounts_controller.py +264,Row #{0}: Account {1} does not belong to company {2},Ligne # {0}: le compte {1} n&#39;appartient pas à la société {2}
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30,Unable to find DocType {0},Impossible de trouver DocType {0}
-apps/erpnext/erpnext/public/js/templates/address_list.html +22,New Address,Nouvelle Adresse
-DocType: Quality Inspection,Sample Size,Taille de l'Échantillon
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47,Please enter Receipt Document,Veuillez entrer le Document de Réception
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369,All items have already been invoiced,Tous les articles ont déjà été facturés
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49,Please specify a valid 'From Case No.',Veuillez spécifier un ‘Depuis le Cas N°.’ valide
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24,Further cost centers can be made under Groups but entries can be made against non-Groups,"D'autres centres de coûts peuvent être créés dans des Groupes, mais des écritures ne peuvent être faites que sur des centres de coûts individuels."
-apps/erpnext/erpnext/config/setup.py +66,Users and Permissions,Utilisateurs et Autorisations
-DocType: Vehicle Log,VLOG.,VLOG.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +996,Production Orders Created: {0},Ordres de Production Créés: {0}
-DocType: Branch,Branch,Branche
-DocType: Soil Analysis,Ca/(K+Ca+Mg),Ca / (K + Ca + Mg)
-DocType: Delivery Trip,Fulfillment User,Utilisateur Fulfillment
-apps/erpnext/erpnext/config/setup.py +61,Printing and Branding,Impression et Marque
-DocType: Company,Total Monthly Sales,Total des Ventes Mensuelles
-DocType: Agriculture Analysis Criteria,Weather,Météo
-DocType: Bin,Actual Quantity,Quantité Réelle
-DocType: Shipping Rule,example: Next Day Shipping,Exemple : Livraison le Jour Suivant
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187,Serial No {0} not found,N° de Série {0} introuvable
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291,Subscription has been {0},L&#39;abonnement a été {0}
-DocType: Fee Schedule Program,Fee Schedule Program,Programme de planification des honoraires
-DocType: Fee Schedule Program,Student Batch,Lot d'Étudiants
-apps/erpnext/erpnext/utilities/activation.py +119,Make Student,Créer un Étudiant
-DocType: Supplier Scorecard Scoring Standing,Min Grade,Note Minimale
-apps/erpnext/erpnext/projects/doctype/project/project.py +216,You have been invited to collaborate on the project: {0},Vous avez été invité à collaborer sur le projet : {0}
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +135,Physician not available on {0},Le médecin n'est pas disponible le {0}
-DocType: Leave Block List Date,Block Date,Bloquer la Date
-DocType: Crop,Crop,Culture
-DocType: Purchase Receipt,Supplier Delivery Note,Bon de Livraison du Fournisseur
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70,Apply Now,Choisir
-apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25,Actual Qty {0} / Waiting Qty {1},Qté Réelle {0} / Quantité en Attente {1}
-DocType: Purchase Invoice,E-commerce GSTIN,GSTIN E-commerce
-DocType: Sales Order,Not Delivered,Non Livré
-,Bank Clearance Summary,Bilan des Compensations Bancaires
-apps/erpnext/erpnext/config/setup.py +106,"Create and manage daily, weekly and monthly email digests.","Créer et gérer des résumés  d'E-mail quotidiens, hebdomadaires et mensuels ."
-DocType: Appraisal Goal,Appraisal Goal,Objectif d'Estimation
-DocType: Stock Reconciliation Item,Current Amount,Montant Actuel
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58,Buildings,Bâtiments
-DocType: Fee Schedule,Fee Structure,Structure d'Honoraires
-DocType: Timesheet Detail,Costing Amount,Montant des Coûts
-DocType: Student Admission Program,Application Fee,Frais de Dossier
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52,Submit Salary Slip,Soumettre la Fiche de Paie
-apps/erpnext/erpnext/controllers/selling_controller.py +136,Maxiumm discount for Item {0} is {1}%,Remise maximum pour l'article {0} est de {1} %
-apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16,Import in Bulk,Importer en Masse
-DocType: Sales Partner,Address & Contacts,Adresse &amp; Contacts
-DocType: SMS Log,Sender Name,Nom de l'Expéditeur
-DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,Critères d&#39;analyse de l&#39;agriculture
-DocType: POS Profile,[Select],[Choisir]
-DocType: Vital Signs,Blood Pressure (diastolic),Pression Artérielle (Diastolique)
-DocType: SMS Log,Sent To,Envoyé À
-DocType: Agriculture Task,Holiday Management,Gestion des vacances
-DocType: Payment Request,Make Sales Invoice,Faire des Factures de Vente
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Softwares,Softwares
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +51,Next Contact Date cannot be in the past,La Date de Prochain Contact ne peut pas être dans le passé
-DocType: Company,For Reference Only.,Pour Référence Seulement.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +99,Physician {0} not available on {1},Le médecin {0} n'est pas disponible le {1}
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2565,Select Batch No,Sélectionnez le N° de Lot
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61,Invalid {0}: {1},Invalide {0} : {1}
-,GSTR-1,GSTR-1
-DocType: Purchase Invoice,PINV-RET-,PINV-RET-
-DocType: Fee Validity,Reference Inv,Facture de Référence
-DocType: Sales Invoice Advance,Advance Amount,Montant de l'Avance
-DocType: Manufacturing Settings,Capacity Planning,Planification de Capacité
-DocType: Supplier Quotation,Rounding Adjustment (Company Currency,Arrondi (Devise Société)
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43,'From Date' is required,'Date début' est requise
-DocType: Journal Entry,Reference Number,Numéro de Référence
-DocType: Employee,Employment Details,Détails de l'Emploi
-DocType: Employee,New Workplace,Nouveau Lieu de Travail
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,Définir comme Fermé
-apps/erpnext/erpnext/stock/get_item_details.py +127,No Item with Barcode {0},Aucun Article avec le Code Barre {0}
-DocType: Normal Test Items,Require Result Value,Nécessite la Valeur du Résultat
-DocType: Item,Show a slideshow at the top of the page,Afficher un diaporama en haut de la page
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +527,Boms,Listes de Matériaux
-apps/erpnext/erpnext/stock/doctype/item/item.py +161,Stores,Magasins
-DocType: Project Type,Projects Manager,Chef de Projet
-DocType: Serial No,Delivery Time,Heure de la Livraison
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,Basé Sur le Vieillissement
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +66,Appointment cancelled,Rendez-Vous Annulé
-DocType: Item,End of Life,Fin de Vie
-apps/erpnext/erpnext/demo/setup/setup_data.py +331,Travel,Déplacement
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +182,No active or default Salary Structure found for employee {0} for the given dates,Aucune Structure de Salaire active ou par défaut trouvée pour employé {0} pour les dates données
-DocType: Leave Block List,Allow Users,Autoriser les Utilisateurs
-DocType: Purchase Order,Customer Mobile No,N° de Portable du Client
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1,Recurring,Récurrent
-DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,Détails du modèle de mappage de flux de trésorerie
-DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,Suivre séparément les Produits et Charges pour les gammes de produits.
-DocType: Rename Tool,Rename Tool,Outil de Renommage
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72,Update Cost,Mettre à jour le Coût
-DocType: Item Reorder,Item Reorder,Réorganiser les Articles
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463,Show Salary Slip,Afficher la Fiche de Salaire
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849,Transfer Material,Transfert de Matériel
-DocType: Fees,Send Payment Request,Envoyer une Demande de Paiement
-DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.","Spécifier les opérations, le coût d'exploitation et donner un N° d'Opération unique à vos opérations."
-DocType: Water Analysis,Origin,Origine
-apps/erpnext/erpnext/controllers/status_updater.py +201,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,Ce document excède la limite de {0} {1} pour l’article {4}. Faites-vous un autre {3} contre le même {2} ?
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1154,Please set recurring after saving,Veuillez définir la récurrence après avoir sauvegardé
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769,Select change amount account,Sélectionner le compte de change
-DocType: Purchase Invoice,Price List Currency,Devise de la Liste de Prix
-DocType: Naming Series,User must always select,L'utilisateur doit toujours sélectionner
-DocType: Stock Settings,Allow Negative Stock,Autoriser un Stock Négatif
-DocType: Installation Note,Installation Note,Note d'Installation
-DocType: Soil Texture,Clay,Argile
-DocType: Topic,Topic,Sujet
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45,Cash Flow from Financing,Flux de Trésorerie du Financement
-DocType: Budget Account,Budget Account,Compte de Budget
-DocType: Quality Inspection,Verified By,Vérifié Par
-apps/erpnext/erpnext/setup/doctype/company/company.py +78,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Impossible de changer la devise par défaut de la société, parce qu'il y a des opérations existantes. Les transactions doivent être annulées pour changer la devise par défaut."
-DocType: Cash Flow Mapping,Is Income Tax Liability,La dette d&#39;impôt sur le revenu
-DocType: Grading Scale Interval,Grade Description,Description de la Note
-DocType: Stock Entry,Purchase Receipt No,N° du Reçu d'Achat
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,Arrhes
-DocType: Sales Invoice, Shipping Bill Number,Numéro de facture d&#39;expédition
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34,Traceability,Traçabilité
-DocType: Asset Maintenance Log,Actions performed,Actions réalisées
-DocType: Cash Flow Mapper,Section Leader,Chef de section
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137,Source of Funds (Liabilities),Source des Fonds (Passif)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418,Quantity in row {0} ({1}) must be same as manufactured quantity {2},Quantité à la ligne {0} ({1}) doit être égale a la quantité fabriquée {2}
-DocType: Supplier Scorecard Scoring Standing,Employee,Employé
-DocType: Asset Repair,Failure Date,Date d&#39;échec
-DocType: Sample Collection,Collected Time,Heure de Collecte
-DocType: Company,Sales Monthly History,Historique des Ventes Mensuel
-DocType: Asset Maintenance Task,Next Due Date,prochaine date d&#39;échéance
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214,Select Batch,Sélectionnez le Lot
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244,{0} {1} is fully billed,{0} {1} est entièrement facturé
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +47,Vital Signs,Signes Vitaux
-DocType: Training Event,End Time,Heure de Fin
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63,Active Salary Structure {0} found for employee {1} for the given dates,Grille de Salaire active {0} trouvée pour l'employé {1} pour les dates données
-DocType: Payment Entry,Payment Deductions or Loss,Déductions sur le Paiement ou Perte
-DocType: Soil Analysis,Soil Analysis Criterias,Critères d&#39;analyse des sols
-apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,Termes contractuels standards pour Ventes ou Achats
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +100,Group by Voucher,Groupe par Bon
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +195,Are you sure you want to cancel this appointment?,Êtes-vous sûr de vouloir annuler ce rendez-vous?
-DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,Forfait de prix de chambre d&#39;hôtel
-apps/erpnext/erpnext/config/crm.py +6,Sales Pipeline,Pipeline de Ventes
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201,Please set default account in Salary Component {0},Veuillez définir le compte par défaut dans la Composante Salariale {0}
-apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,Requis Pour
-DocType: Rename Tool,File to Rename,Fichier à Renommer
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200,Please select BOM for Item in Row {0},Veuillez sélectionnez une LDM pour l’Article à la Ligne {0}
-apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28,Account {0} does not match with Company {1} in Mode of Account: {2},Le Compte {0} ne correspond pas à la Société {1} dans le Mode de Compte : {2}
-apps/erpnext/erpnext/controllers/buying_controller.py +289,Specified BOM {0} does not exist for Item {1},La LDM {0} spécifiée n'existe pas pour l'Article {1}
-DocType: Soil Texture,Sandy Loam,terreau arigileux
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,L'Échéancier d'Entretien {0} doit être annulé avant d'annuler cette Commande Client
-DocType: POS Profile,Applicable for Users,Applicable aux Utilisateurs
-DocType: Notification Control,Expense Claim Approved,Note de Frais Approuvée
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +320,Salary Slip of employee {0} already created for this period,Fiche de Paie de l'employé {0} déjà créée pour cette période
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155,Pharmaceutical,Pharmaceutique
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,Coût des Articles Achetés
-DocType: Selling Settings,Sales Order Required,Commande Client Requise
-DocType: Purchase Invoice,Credit To,À Créditer
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46,PieceDate,PieceDate
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31,Active Leads / Customers,Prospects / Clients Actifs
-DocType: Employee Education,Post Graduate,Post-Diplômé
-DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,Détails de l'Échéancier d'Entretien
-DocType: Supplier Scorecard,Warn for new Purchase Orders,Avertir lors des nouveaux Bons de Commande
-DocType: Quality Inspection Reading,Reading 9,Lecture 9
-DocType: Supplier,Is Frozen,Est Gelé
-apps/erpnext/erpnext/stock/utils.py +224,Group node warehouse is not allowed to select for transactions,Un noeud de groupe d'entrepôt ne peut pas être sélectionné pour les transactions
-DocType: Buying Settings,Buying Settings,Réglages d'Achat
-DocType: Stock Entry Detail,BOM No. for a Finished Good Item,N° d’Article Produit Fini LDM
-DocType: Upload Attendance,Attendance To Date,Présence Jusqu'à
-DocType: Request for Quotation Supplier,No Quote,Aucun Devis
-DocType: Warranty Claim,Raised By,Créé par
-DocType: Payment Gateway Account,Payment Account,Compte de Paiement
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909,Please specify Company to proceed,Veuillez spécifier la Société pour continuer
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27,Net Change in Accounts Receivable,Variation Nette des Comptes Débiteurs
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88,Compensatory Off,Congé Compensatoire
-DocType: Job Offer,Accepted,Accepté
-DocType: Grant Application,Organization,Organisation
-DocType: BOM Update Tool,BOM Update Tool,Outil de mise à jour de LDM
-DocType: SG Creation Tool Course,Student Group Name,Nom du Groupe d'Étudiants
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17,Show exploded view,Afficher la vue éclatée
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7,Creating Fees,Création d'Honoraires
-apps/erpnext/erpnext/setup/doctype/company/company.js +91,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,Veuillez vous assurer que vous voulez vraiment supprimer tous les transactions de cette société. Vos données de base resteront intactes. Cette action ne peut être annulée.
-apps/erpnext/erpnext/templates/pages/product_search.html +21,Search Results,Résultats de la Recherche
-DocType: Room,Room Number,Numéro de la Chambre
-apps/erpnext/erpnext/utilities/transaction_base.py +103,Invalid reference {0} {1},Référence invalide {0} {1}
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +187,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0} ({1}) ne peut pas être supérieur à la quantité prévue ({2}) dans l’Ordre de Production {3}
-DocType: Shipping Rule,Shipping Rule Label,Étiquette de la Règle de Livraison
-DocType: Journal Entry Account,Payroll Entry,Entrée de la paie
-apps/erpnext/erpnext/setup/doctype/company/company.js +35,Make Tax Template,Créer un modèle d&#39;imposition
-apps/erpnext/erpnext/public/js/conf.js +28,User Forum,Forum de l'Utilisateur
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +318,Raw Materials cannot be blank.,Matières Premières ne peuvent pas être vides.
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498,"Could not update stock, invoice contains drop shipping item.","Impossible de mettre à jour de stock, facture contient un élément en livraison directe."
-DocType: Lab Test Sample,Lab Test Sample,Échantillon de test de laboratoire
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491,Quick Journal Entry,Écriture Rapide dans le Journal
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200,You can not change rate if BOM mentioned agianst any item,Vous ne pouvez pas modifier le taux si la LDM est mentionnée pour un article
-DocType: Restaurant,Invoice Series Prefix,Préfixe de la Série de Factures
-DocType: Employee,Previous Work Experience,Expérience de Travail Antérieure
-DocType: Stock Entry,For Quantity,Pour la Quantité
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205,Please enter Planned Qty for Item {0} at row {1},Veuillez entrer la Qté Planifiée pour l'Article {0} à la ligne {1}
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93,Google Maps integration is not enabled,L&#39;intégration de Google Maps n&#39;est pas activée
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241,{0} {1} is not submitted,{0} {1} n'a pas été soumis
-DocType: Member,Membership Expiry Date,Date d&#39;expiration de l&#39;adhésion
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +127,{0} must be negative in return document,{0} doit être négatif dans le document de retour
-,Minutes to First Response for Issues,Minutes avant la Première Réponse aux Questions
-DocType: Purchase Invoice,Terms and Conditions1,Termes et Conditions
-apps/erpnext/erpnext/public/js/setup_wizard.js +109,The name of the institute for which you are setting up this system.,Le nom de l'institut pour lequel vous configurez ce système.
-DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Les écritures comptables sont gelées jusqu'à cette date, personne ne peut ajouter / modifier les entrées sauf les rôles spécifiés ci-dessous."
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116,Please save the document before generating maintenance schedule,Veuillez enregistrer le document avant de générer le calendrier d'entretien
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30,Latest price updated in all BOMs,Prix les plus récents mis à jour dans toutes les LDMs
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,Statut du Projet
-DocType: UOM,Check this to disallow fractions. (for Nos),Cochez cette case pour interdire les fractions. (Pour les numéros)
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +446,The following Production Orders were created:,Les Ordres de Production suivants ont été créés:
-DocType: Student Admission Program,Naming Series (for Student Applicant),Nom de la Série (pour le Candidat Étudiant)
-DocType: Delivery Note,Transporter Name,Nom du Transporteur
-DocType: Authorization Rule,Authorized Value,Valeur Autorisée
-DocType: BOM,Show Operations,Afficher Opérations
-,Minutes to First Response for Opportunity,Minutes avant la Première Réponse à une Opportunité
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Absent,Total des Absences
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +848,Item or Warehouse for row {0} does not match Material Request,L'Article ou l'Entrepôt pour la ligne {0} ne correspond pas avec la Requête de Matériel
-apps/erpnext/erpnext/config/stock.py +191,Unit of Measure,Unité de Mesure
-DocType: Fiscal Year,Year End Date,Date de Fin de l'Exercice
-DocType: Task Depends On,Task Depends On,Tâche Dépend De
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026,Opportunity,Opportunité
-,Completed Production Orders,Ordres de Fabrication Terminés
-DocType: Operation,Default Workstation,Station de Travail par Défaut
-DocType: Notification Control,Expense Claim Approved Message,Message d'une Note de Frais Approuvée
-DocType: Payment Entry,Deductions or Loss,Déductions ou Perte
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247,{0} {1} is closed,{0} {1} est fermé
-DocType: Email Digest,How frequently?,A quelle fréquence ?
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +58,Total Collected: {0},Total Collecté: {0}
-DocType: Purchase Receipt,Get Current Stock,Obtenir le Stock Actuel
-DocType: Purchase Invoice,ineligible,inéligible
-apps/erpnext/erpnext/config/manufacturing.py +46,Tree of Bill of Materials,Arbre des Listes de Matériaux
-DocType: Student,Joining Date,Date d'Inscription
-,Employees working on a holiday,Employés qui travaillent un jour férié
-DocType: Share Balance,Current State,État actuel
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152,Mark Present,Marquer Présent
-DocType: Share Transfer,From Shareholder,De l&#39;actionnaire
-DocType: Project,% Complete Method,% Méthode Complète
-apps/erpnext/erpnext/healthcare/setup.py +181,Drug,Médicament
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200,Maintenance start date can not be before delivery date for Serial No {0},La date de début d'entretien ne peut pas être antérieure à la date de livraison pour le N° de Série {0}
-DocType: Production Order,Actual End Date,Date de Fin Réelle
-DocType: Cash Flow Mapping,Is Finance Cost Adjustment,L&#39;ajustement des coûts financiers
-DocType: BOM,Operating Cost (Company Currency),Coût d'Exploitation (Devise Société)
-DocType: Purchase Invoice,PINV-,PINV-
-DocType: Authorization Rule,Applicable To (Role),Applicable À (Rôle)
-DocType: BOM Update Tool,Replace BOM,Remplacer la LDM
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110,Code {0} already exist,Le code {0} existe déjà
-DocType: Employee Advance,Purpose,Objet
-DocType: Company,Fixed Asset Depreciation Settings,Paramètres d'Amortissement des Immobilisations
-DocType: Item,Will also apply for variants unless overrridden,S'appliquera également pour des variantes sauf si remplacé
-DocType: Purchase Invoice,Advances,Avances
-DocType: Production Order,Manufacture against Material Request,Fabrication pour une Demande de Matériel
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14,Assessment Group: ,Groupe d'Évaluation:
-DocType: Item Reorder,Request for,Demander Pour
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,L'Utilisateur Approbateur ne peut pas être identique à l'utilisateur dont la règle est Applicable
-DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),Taux de base (comme l’UDM du Stock)
-DocType: SMS Log,No of Requested SMS,Nb de SMS Demandés
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +245,Leave Without Pay does not match with approved Leave Application records,Congé sans solde ne correspond pas aux Feuilles de Demandes de Congé Approuvées
-DocType: Campaign,Campaign-.####,Campagne-.####
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21,Next Steps,Prochaines Étapes
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796,Please supply the specified items at the best possible rates,Veuillez fournir les articles spécifiés aux meilleurs tarifs possibles
-DocType: Membership,USD,USD
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28,Make Invoice,Faire une Facture
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80,Remaining Balance,Solde restant
-DocType: Selling Settings,Auto close Opportunity after 15 days,Fermer automatiquement les Opportunités après 15 jours
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,Les Bons de Commande ne sont pas autorisés pour {0} en raison d'une note sur la fiche d'évaluation de {1}.
-apps/erpnext/erpnext/stock/doctype/item/item.py +497,Barcode {0} is not a valid {1} code,Le code à barres {0} n&#39;est pas un code {1} valide
-apps/erpnext/erpnext/public/js/financial_statements.js +83,End Year,Année de Fin
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23,Quot/Lead %,Devis / Prospects %
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +124,Contract End Date must be greater than Date of Joining,La Date de Fin de Contrat doit être supérieure à la Date d'Embauche
-DocType: Driver,Driver,Chauffeur
-DocType: Vital Signs,Nutrition Values,Valeurs Nutritionnelles
-DocType: Lab Test Template,Is billable,Est facturable
-DocType: Delivery Note,DN-,DN-
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +44,"Both ""Physician Schedule"" and Time Per Appointment"" must be set for Dr {0}","""Planning du Médecin"" et ""Temps par Rendez-Vous"" doivent être définis pour le Dr {0}"
-DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,Un tiers distributeur / commerçant / commissionnaire / affilié / revendeur qui vend les produits de l'entreprise en échange d'une commission.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376,{0} against Purchase Order {1},{0} pour le Bon de Commande d'Achat {1}
-DocType: Patient,Patient Demographics,Démographie du Patient
-DocType: Task,Actual Start Date (via Time Sheet),Date de Début Réelle (via la feuille de temps)
-apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15,This is an example website auto-generated from ERPNext,Ceci est un exemple de site généré automatiquement à partir d’ERPNext
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,Balance Agée 1
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +210,Total advance amount cannot be greater than total claimed amount,Le montant total de l&#39;avance ne peut être supérieur au montant total réclamé
-DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.
-
-#### Note
-
-The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.
-
-#### Description of Columns
-
-1. Calculation Type: 
-    - This can be on **Net Total** (that is the sum of basic amount).
-    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
-    - **Actual** (as mentioned).
-2. Account Head: The Account ledger under which this tax will be booked
-3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
-4. Description: Description of the tax (that will be printed in invoices / quotes).
-5. Rate: Tax rate.
-6. Amount: Tax amount.
-7. Total: Cumulative total to this point.
-8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
-9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
-10. Add or Deduct: Whether you want to add or deduct the tax.","Modèle de la taxe standard qui peut être appliqué à toutes les Opérations d'Achat. Ce modèle peut contenir la liste des titres d'impôts ainsi que d'autres titre de charges comme ""Livraison"", ""Assurance"", ""Gestion"", etc. 
-
-#### Remarque 
-
-Le taux d'imposition que vous définissez ici sera le taux d'imposition standard pour tous les **Articles**. S'il y a des **Articles** qui ont des taux différents, ils doivent être ajoutés dans la table **Taxe de l'Article** dans les données de base **Article**.
-
-#### Description des Colonnes
-
-1. Type de Calcul : 
-    - Cela peut être le **Total Net** (qui est la somme des montants de base).
-    - **Total / Montant Sur la Ligne Précédente** (pour les taxes ou frais accumulés). Si vous sélectionnez cette option, la taxe sera appliquée en pourcentage du montant ou du total de la ligne précédente (dans la table d'impôts).
-    - **Réel** (comme mentionné).
-2. Titre du Compte : Le journal comptable dans lequel cette taxe sera comptabilisée
-3. Centre de Coût : Si la taxe / redevance est un revenu (comme la livraison) ou une charge, elle doit être comptabilisée dans un Centre de Coûts.
-4. Description : Description de la taxe (qui sera imprimée sur les factures / devis).
-5. Taux : Le taux d'imposition.
-6. Montant : Le montant de la taxe.
-7. Total : Total accumulé à ce point.
-8. Entrez la Ligne : Si elle est basée sur ""Total de la Ligne Précédente"" vous pouvez sélectionner le numéro de la ligne qui sera pris comme base pour ce calcul (par défaut la ligne précédente).
-9. Considérez Taxe ou Charge pour : Dans cette section, vous pouvez spécifier si la taxe / redevance est seulement pour la valorisation (pas une partie du total) ou seulement pour le total (n'ajoute pas de la valeur à l'article) ou pour les deux.
-10. Ajouter ou Déduire : Ce que vous voulez ajouter ou déduire de la taxe."
-DocType: Homepage,Homepage,Page d'Accueil
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +71,Select Physician...,Sélectionnez le Médecin...
-DocType: Grant Application,Grant Application Details ,Détails de la demande de subvention
-DocType: Purchase Receipt Item,Recd Quantity,Quantité Reçue
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65,Fee Records Created - {0},Archive d'Honoraires Créée - {0}
-DocType: Asset Category Account,Asset Category Account,Compte de Catégorie d'Actif
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913,Row #{0} (Payment Table): Amount must be positive,Row # {0} (Table de paiement): Le montant doit être positif
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44,CompteNum,CompteNum
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +137,Cannot produce more Item {0} than Sales Order quantity {1},Impossible de produire plus d'Article {0} que la quantité {1} du Bon de Commande
-apps/erpnext/erpnext/stock/doctype/item/item.js +362,Select Attribute Values,Sélectionner les valeurs d&#39;attribut
-DocType: Purchase Invoice,Reason For Issuing document,Raison de l&#39;émission du document
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539,Stock Entry {0} is not submitted,Écriture de Stock {0} n'est pas soumise
-DocType: Payment Reconciliation,Bank / Cash Account,Compte Bancaire / de Caisse
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +45,Next Contact By cannot be same as the Lead Email Address,Prochain Contact Par ne peut être identique à l’Adresse Email du Prospect
-DocType: Tax Rule,Billing City,Ville de Facturation
-DocType: Asset,Manual,Manuel
-DocType: Salary Component Account,Salary Component Account,Compte Composante Salariale
-DocType: Global Defaults,Hide Currency Symbol,Masquer le Symbole Monétaire
-apps/erpnext/erpnext/config/non_profit.py +58,Donor information.,Informations sur le donneur
-apps/erpnext/erpnext/config/accounts.py +330,"e.g. Bank, Cash, Credit Card","e.g. Cash, Banque, Carte de crédit"
-DocType: Lead Source,Source Name,Nom de la Source
-DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""","La tension artérielle normale chez un adulte est d&#39;environ 120 mmHg systolique et 80 mmHg diastolique, abrégé &quot;120/80 mmHg&quot;"
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +119,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life","Définissez la durée de conservation des éléments en jours, pour définir l&#39;expiration en fonction de la date de fabrication et de la vie autonome"
-DocType: Journal Entry,Credit Note,Note de Crédit
-DocType: Projects Settings,Ignore Employee Time Overlap,Ignorer le chevauchement de temps des employés
-DocType: Warranty Claim,Service Address,Adresse du Service
-DocType: Asset Maintenance Task,Calibration,Étalonnage
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +102,{0} is a company holiday,{0} est un jour férié en entreprise
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49,Furnitures and Fixtures,Meubles et Accessoires
-DocType: Item,Manufacture,Fabrication
-apps/erpnext/erpnext/utilities/user_progress.py +24,Setup Company,Configurer la Société
-,Lab Test Report,Rapport de test de laboratoire
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,Veuillez d’abord créer un Bon de Livraison
-DocType: Student Applicant,Application Date,Date de la Candidature
-DocType: Salary Detail,Amount based on formula,Montant basé sur la formule
-DocType: Purchase Invoice,Currency and Price List,Devise et liste de prix
-DocType: Opportunity,Customer / Lead Name,Nom du Client / Prospect
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +99,Clearance Date not mentioned,Date de Compensation non indiquée
-apps/erpnext/erpnext/config/manufacturing.py +7,Production,Production
-DocType: Guardian,Occupation,Occupation
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74,Row {0}:Start Date must be before End Date,Ligne {0} : La Date de Début doit être avant la Date de Fin
-DocType: Crop,Planting Area,Zone de plantation
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),Total (Qté)
-DocType: Installation Note Item,Installed Qty,Qté Installée
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4,This could be because of some invalid Email Addresses in the,Cela pourrait être dû à certaines adresses de messagerie invalides dans le
-apps/erpnext/erpnext/utilities/user_progress.py +28,You added ,Vous avez ajouté
-DocType: Purchase Taxes and Charges,Parenttype,Type Parent
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10,Training Result,Résultat de la Formation
-DocType: Purchase Invoice,Is Paid,Est Payé
-DocType: Salary Structure,Total Earning,Total Revenus
-DocType: Purchase Receipt,Time at which materials were received,Heure à laquelle les matériaux ont été reçus
-DocType: Products Settings,Products per Page,Produits par page
-DocType: Stock Ledger Entry,Outgoing Rate,Taux Sortant
-apps/erpnext/erpnext/config/hr.py +233,Organization branch master.,Organisation principale des branches.
-apps/erpnext/erpnext/controllers/accounts_controller.py +312, or ,ou
-DocType: Sales Order,Billing Status,Statut de la Facturation
-apps/erpnext/erpnext/public/js/conf.js +32,Report an Issue,Signaler un Problème
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Utility Expenses,Frais de Services d'Utilité Publique
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64,90-Above,90-Dessus
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +247,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,Ligne #{0} : L’Écriture de Journal {1} n'a pas le compte {2} ou est déjà réconciliée avec une autre référence
-DocType: Supplier Scorecard Criteria,Criteria Weight,Pondération du Critère
-DocType: Buying Settings,Default Buying Price List,Liste des Prix d'Achat par Défaut
-DocType: Payroll Entry,Salary Slip Based on Timesheet,Fiche de Paie basée sur la Feuille de Temps
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43,Buying Rate,Prix d'achat
-DocType: Notification Control,Sales Order Message,Message de la Commande Client
-apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Définir les Valeurs par Défaut comme : Societé, Devise, Exercice Actuel, etc..."
-DocType: Payment Entry,Payment Type,Type de Paiement
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +240,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,Veuillez sélectionner un Lot pour l'Article {0}. Impossible de trouver un seul lot satisfaisant à cette exigence
-DocType: Hub Category,Parent Category,Catégorie Parente
-DocType: Payroll Entry,Select Employees,Sélectionner les Employés
-DocType: Opportunity,Potential Sales Deal,Ventes Potentielles
-DocType: Complaint,Complaints,Plaintes
-DocType: Payment Entry,Cheque/Reference Date,Chèque/Date de Référence
-DocType: Purchase Invoice,Total Taxes and Charges,Total des Taxes et Frais
-DocType: Employee,Emergency Contact,Contact en cas d'Urgence
-DocType: Bank Reconciliation Detail,Payment Entry,Écriture de Paiement
-,sales-browser,navigateur-ventes
-apps/erpnext/erpnext/accounts/doctype/account/account.js +79,Ledger,Livre
-DocType: Patient Medical Record,PMR-,PMR-
-DocType: Drug Prescription,Drug Code,Code du Médicament
-DocType: Target Detail,Target  Amount,Montant Cible
-DocType: POS Profile,Print Format for Online,Format d'Impression en Ligne
-DocType: Shopping Cart Settings,Shopping Cart Settings,Paramètres du Panier
-DocType: Journal Entry,Accounting Entries,Écritures Comptables
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.","Si la règle de tarification sélectionnée est définie pour «Taux», elle écrase la liste de prix. Le taux de la règle de tarification est le taux final, donc aucune autre réduction ne doit être appliquée. Par conséquent, dans les transactions telles que la commande client, la commande d&#39;achat, etc., elle sera récupérée dans le champ &quot;Taux&quot;, plutôt que dans le champ &quot;Tarif liste de prix&quot;."
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},Écriture en double. Merci de vérifier la Règle d’Autorisation {0}
-DocType: Journal Entry Account,Reference Due Date,Date d&#39;échéance de référence
-DocType: Purchase Order,Ref SQ,Réf SQ
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Receipt document must be submitted,Le reçu doit être soumis
-DocType: Purchase Invoice Item,Received Qty,Qté Reçue
-DocType: Stock Entry Detail,Serial No / Batch,N° de Série / Lot
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340,Not Paid and Not Delivered,Non Payé et Non Livré
-DocType: Product Bundle,Parent Item,Article Parent
-DocType: Account,Account Type,Type de Compte
-DocType: Delivery Note,DN-RET-,DN-RET-
-apps/erpnext/erpnext/templates/pages/projects.html +58,No time sheets,Aucunes feuilles de temps
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123,Leave Type {0} cannot be carry-forwarded,Le Type de Congé {0} ne peut pas être reporté
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',L'Échéancier d'Entretien n'est pas créé pour tous les articles. Veuillez clicker sur 'Créer un Échéancier'
-,To Produce,À Produire
-apps/erpnext/erpnext/config/hr.py +93,Payroll,Paie
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included","Pour la ligne {0} dans {1}. Pour inclure {2} dans le prix de l'Article, les lignes {3} doivent également être incluses"
-apps/erpnext/erpnext/utilities/activation.py +101,Make User,Créer un Utilisateur
-DocType: Packing Slip,Identification of the package for the delivery (for print),Identification de l'emballage pour la livraison (pour l'impression)
-DocType: Bin,Reserved Quantity,Quantité Réservée
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34,Please enter valid email address,Entrez une adresse email valide
-DocType: Volunteer Skill,Volunteer Skill,Compétence bénévole
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +780,Please select an item in the cart,Veuillez sélectionner un article dans le panier
-DocType: Landed Cost Voucher,Purchase Receipt Items,Articles du Reçu d’Achat
-apps/erpnext/erpnext/config/learn.py +21,Customizing Forms,Personnalisation des Formulaires
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74,Arrear,Arriéré
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158,Depreciation Amount during the period,Montant d'Amortissement au cours de la période
-apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43,Disabled template must not be default template,Un Modèle Désactivé ne doit pas être un Modèle par Défaut
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +313,For row {0}: Enter planned qty,Pour la ligne {0}: entrez la quantité planifiée
-DocType: Shareholder,SH-,SH-
-DocType: Account,Income Account,Compte de Produits
-DocType: Payment Request,Amount in customer's currency,Montant dans la devise du client
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825,Delivery,Livraison
-DocType: Volunteer,Weekdays,Jours de la semaine
-DocType: Stock Reconciliation Item,Current Qty,Qté Actuelle
-DocType: Restaurant Menu,Restaurant Menu,Le menu du restaurant
-apps/erpnext/erpnext/templates/generators/item_group.html +36,Prev,Précédent
-DocType: Appraisal Goal,Key Responsibility Area,Domaine de Responsabilités Principal
-apps/erpnext/erpnext/utilities/activation.py +127,"Student Batches help you track attendance, assessments and fees for students","Les Lots d'Étudiants vous aide à suivre la présence, les évaluations et les frais pour les étudiants"
-DocType: Payment Entry,Total Allocated Amount,Montant Total Alloué
-apps/erpnext/erpnext/setup/doctype/company/company.py +151,Set default inventory account for perpetual inventory,Configurer le compte d'inventaire par défaut pour l'inventaire perpétuel
-DocType: Item Reorder,Material Request Type,Type de Demande de Matériel
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252,Accural Journal Entry for salaries from {0} to {1},Accumulation des Journaux d'Écritures pour les salaires de {0} à {1}
-apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17,Send Grant Review Email,Envoyer un avis de demande de subvention
-apps/erpnext/erpnext/accounts/page/pos/pos.js +848,"LocalStorage is full, did not save","Le Stockage Local est plein, sauvegarde impossible"
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +99,Row {0}: UOM Conversion Factor is mandatory,Ligne {0} : Facteur de Conversion LDM est obligatoire
-apps/erpnext/erpnext/utilities/user_progress.py +232,Room Capacity,Capacité de la Salle
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +90,Ref,Réf
-DocType: Lab Test,LP-,LP-
-DocType: Healthcare Settings,Registration Fee,Frais d'Inscription
-DocType: Budget,Cost Center,Centre de Coûts
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45,Voucher #,Référence #
-DocType: Notification Control,Purchase Order Message,Message du Bon de Commande
-DocType: Tax Rule,Shipping Country,Pays de Livraison
-DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,Cacher le N° de TVA du Client des Transactions de Vente
-DocType: Upload Attendance,Upload HTML,Charger HTML
-DocType: Employee,Relieving Date,Date de Relève
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","La Règle de Tarification est faite pour remplacer la Liste de Prix / définir le pourcentage de remise, sur la base de certains critères."
-DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,L'entrepôt ne peut être modifié que via Écriture de Stock / Bon de Livraison / Reçu d'Achat
-DocType: Employee Education,Class / Percentage,Classe / Pourcentage
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134,Head of Marketing and Sales,Responsable du Marketing et des Ventes
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72,Income Tax,Impôt sur le Revenu
-apps/erpnext/erpnext/config/selling.py +174,Track Leads by Industry Type.,Suivre les Prospects par Type d'Industrie
-apps/erpnext/erpnext/utilities/user_progress.py +98,Go to Letterheads,Aller aux papiers à en-tête
-DocType: Item Supplier,Item Supplier,Fournisseur de l'Article
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1255,Please enter Item Code to get batch no,Veuillez entrer le Code d'Article pour obtenir n° de lot
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880,Please select a value for {0} quotation_to {1},Veuillez sélectionner une valeur pour {0} devis à {1}
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414,No Items selected for transfer,Aucun élément sélectionné pour le transfert
-apps/erpnext/erpnext/config/selling.py +46,All Addresses.,Toutes les Adresses.
-DocType: Company,Stock Settings,Réglages de Stock
-apps/erpnext/erpnext/accounts/doctype/account/account.py +183,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company","La combinaison est possible seulement si les propriétés suivantes sont les mêmes dans les deux dossiers. Est Groupe, Type de Racine, Société"
-DocType: Vehicle,Electric,Électrique
-DocType: Task,% Progress,% de Progression
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123,Gain/Loss on Asset Disposal,Gain/Perte sur Cessions des Immobilisations
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,Le numéro de compte du compte {0} n'est pas disponible. <br> Veuillez configurer votre plan de comptes correctement.
-DocType: Task,Depends on Tasks,Dépend des Tâches
-apps/erpnext/erpnext/config/selling.py +36,Manage Customer Group Tree.,Gérer l'Arborescence des Groupes de Clients.
-DocType: Shopping Cart Settings,Attachments can be shown without enabling the shopping cart,Les pièces jointes peuvent être affichées sans autoriser le panier
-DocType: Normal Test Items,Result Value,Valeur de Résultat
-DocType: Hotel Room,Hotels,Hôtels
-DocType: Supplier Quotation,SQTN-,SQTN-
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22,New Cost Center Name,Nom du Nouveau Centre de Coûts
-DocType: Leave Control Panel,Leave Control Panel,Quitter le Panneau de Configuration
-DocType: Project,Task Completion,Achèvement de la Tâche
-apps/erpnext/erpnext/templates/includes/product_page.js +21,Not in Stock,En Rupture de Stock
-DocType: Volunteer,Volunteer Skills,Compétences bénévoles
-DocType: Appraisal,HR User,Chargé RH
-DocType: Purchase Invoice,Taxes and Charges Deducted,Taxes et Frais Déductibles
-apps/erpnext/erpnext/hooks.py +142,Issues,Questions
-apps/erpnext/erpnext/controllers/status_updater.py +12,Status must be one of {0},Le statut doit être l'un des {0}
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64,Reminder to update GSTIN Sent,Rappel pour mettre à jour GSTIN Sent
-DocType: Sales Invoice,Debit To,Débit Pour
-DocType: Restaurant Menu Item,Restaurant Menu Item,Élément de menu du restaurant
-DocType: Delivery Note,Required only for sample item.,Requis uniquement pour les échantillons.
-DocType: Stock Ledger Entry,Actual Qty After Transaction,Qté Réelle Après Transaction
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +79,No salary slip found between {0} and {1},Aucune fiche de paie trouvée entre {0} et {1}
-,Pending SO Items For Purchase Request,Articles de Commande Client en Attente Pour la Demande d'Achat
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35,Student Admissions,Admissions des Étudiants
-apps/erpnext/erpnext/accounts/party.py +389,{0} {1} is disabled,{0} {1} est désactivé
-DocType: Supplier,Billing Currency,Devise de Facturation
-DocType: Sales Invoice,SINV-RET-,SINV-RET-
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200,Extra Large,Extra Large
-DocType: Crop,Scientific Name,Nom scientifique
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Leaves,Total des Congés
-DocType: Customer,"Reselect, if the chosen contact is edited after save","Resélectionner, si le contact choisi est édité après sauvegarde"
-DocType: Consultation,In print,Sur impression
-,Profit and Loss Statement,Compte de Résultat
-DocType: Bank Reconciliation Detail,Cheque Number,Numéro de Chèque
-,Sales Browser,Navigateur des Ventes
-DocType: Journal Entry,Total Credit,Total Crédit
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542,Warning: Another {0} # {1} exists against stock entry {2},Attention : Un autre {0} {1} # existe pour l'écriture de stock {2}
-apps/erpnext/erpnext/utilities/user_progress_utils.py +66,Local,Locale
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),Prêts et Avances (Actif)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,Débiteurs
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199,Large,Grand
-DocType: Homepage Featured Product,Homepage Featured Product,Produit Présenté sur la Page d'Accueil
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +247,All Assessment Groups,Tous les Groupes d'Évaluation
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15,New Warehouse Name,Nouveau Nom d'Entrepôt
-apps/erpnext/erpnext/accounts/report/financial_statements.py +257,Total {0} ({1}),Total {0} ({1})
-DocType: C-Form Invoice Detail,Territory,Région
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151,Please mention no of visits required,Veuillez indiquer le nb de visites requises
-DocType: Stock Settings,Default Valuation Method,Méthode de Valorisation par Défaut
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26,Fee,Frais
-apps/erpnext/erpnext/setup/doctype/company/company.js +154,Update in progress. It might take a while.,Mise à jour en cours. Ça peut prendre un moment.
-DocType: Production Plan Item,Produced Qty,Quantité produite
-DocType: Vehicle Log,Fuel Qty,Qté Carburant
-DocType: Production Order Operation,Planned Start Time,Heure de Début Prévue
-DocType: Course,Assessment,Évaluation
-DocType: Payment Entry Reference,Allocated,Alloué
-apps/erpnext/erpnext/config/accounts.py +267,Close Balance Sheet and book Profit or Loss.,Clôturer Bilan et Compte de Résultats.
-DocType: Student Applicant,Application Status,État de la Demande
-DocType: Sensitivity Test Items,Sensitivity Test Items,Articles de test de sensibilité
-DocType: Fees,Fees,Honoraires
-DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,Spécifier le Taux de Change pour convertir une monnaie en une autre
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159,Quotation {0} is cancelled,Devis {0} est annulée
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +114,Total Outstanding Amount,Encours Total
-DocType: Sales Partner,Targets,Cibles
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54,Please register the SIREN number in the company information file,Veuillez enregistrer le numéro SIREN dans le fichier d&#39;information de l&#39;entreprise
-DocType: Price List,Price List Master,Données de Base des Listes de Prix
-DocType: GST Account,CESS Account,Compte CESS
-DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,Toutes les Transactions de Vente peuvent être assignées à plusieurs **Commerciaux** pour configurer et surveiller les objectifs.
-,S.O. No.,S.O. N°.
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241,Please create Customer from Lead {0},Veuillez créer un Client à partir du Prospect {0}
-apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3,Select Patient,Sélectionnez le Patient
-DocType: Price List,Applicable for Countries,Applicable pour les Pays
-DocType: Supplier Scorecard Scoring Variable,Parameter Name,Nom du Paramètre
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52,Student Group Name is mandatory in row {0},Nom du Groupe d'Étudiant est obligatoire dans la ligne {0}
-DocType: Homepage,Products to be shown on website homepage,Produits destinés à être affichés sur la page d’accueil du site web
-apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13,This is a root customer group and cannot be edited.,C’est un groupe de clients racine qui ne peut être modifié.
-DocType: Student,AB-,AB-
-DocType: POS Profile,Ignore Pricing Rule,Ignorez Règle de Prix
-DocType: Employee Education,Graduate,Diplômé
-DocType: Leave Block List,Block Days,Bloquer les Jours
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83,"Shipping Address does not have country, which is required for this Shipping Rule","L&#39;adresse de livraison n&#39;a pas de pays, ce qui est requis pour cette règle d&#39;expédition"
-DocType: Journal Entry,Excise Entry,Écriture d'Accise
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},Attention : La Commande Client {0} existe déjà pour le Bon de Commande du Client {1}
-DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.
-
-Examples:
-
-1. Validity of the offer.
-1. Payment Terms (In Advance, On Credit, part advance etc).
-1. What is extra (or payable by the Customer).
-1. Safety / usage warning.
-1. Warranty if any.
-1. Returns Policy.
-1. Terms of shipping, if applicable.
-1. Ways of addressing disputes, indemnity, liability, etc.
-1. Address and Contact of your Company.","Termes et Conditions Standard qui peuvent être ajoutés aux Ventes et Achats.
-
-Exemples : 
-
-1. Validité de l'offre.
-2. Conditions de paiement (À l'Avance, À Crédit, une partie en avance, etc).
-3. Qu'est-ce qui est en supplément (ou à payer par le Client).
-3. Avertissement d'utilisation / de sécurité.
-4. Garantie, le cas échéant.
-5. Politique de Retour.
-6. Conditions de Livraison, le cas échéant.
-7. Règlement des litiges, indemnisation, responsabilité, etc. 
-8. Adresse et Contact de votre Société."
-DocType: Issue,Issue Type,type de probleme
-DocType: Attendance,Leave Type,Type de Congé
-DocType: Purchase Invoice,Supplier Invoice Details,Détails de la Facture du Fournisseur
-DocType: Agriculture Task,Ignore holidays,Ignorer les vacances
-apps/erpnext/erpnext/controllers/stock_controller.py +233,Expense / Difference account ({0}) must be a 'Profit or Loss' account,Compte de Charge / d'Écart ({0}) doit être un Compte «de Résultat»
-DocType: Project,Copied From,Copié Depuis
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340,Invoice already created for all billing hours,Facture déjà créée pour toutes les heures de facturation
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96,Name error: {0},Erreur de Nom: {0}
-DocType: Cash Flow Mapping,Is Finance Cost,Le coût financier
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,La présence de l'employé {0} est déjà marquée
-DocType: Packing Slip,If more than one package of the same type (for print),Si plus d'un paquet du même type (pour l'impression)
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27,Please set default customer in Restaurant Settings,Veuillez définir le client par défaut dans les paramètres du restaurant
-,Salary Register,Registre du Salaire
-DocType: Warehouse,Parent Warehouse,Entrepôt Parent
-DocType: C-Form Invoice Detail,Net Total,Total Net
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +546,Default BOM not found for Item {0} and Project {1},La LDM par défaut n'a pas été trouvée pour l'Article {0} et le Projet {1}
-apps/erpnext/erpnext/config/hr.py +168,Define various loan types,Définir différents types de prêts
-DocType: Bin,FCFS Rate,Montant PAPS
-DocType: Opening Invoice Creation Tool Item,Outstanding Amount,Montant dû
-apps/erpnext/erpnext/templates/generators/bom.html +71,Time(in mins),Temps (en min)
-DocType: Project Task,Working,Travail en cours
-DocType: Stock Ledger Entry,Stock Queue (FIFO),File d'Attente du Stock (FIFO)
-apps/erpnext/erpnext/public/js/setup_wizard.js +127,Financial Year,Exercice Financier
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46,{0} does not belong to Company {1},{0} n'appartient pas à la Société {1}
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66,Could not solve criteria score function for {0}. Make sure the formula is valid.,Impossible de résoudre la fonction de score de critères pour {0}. Assurez-vous que la formule est valide.
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122,Cost as on,Coût à partir de
-DocType: Healthcare Settings,Out Patient Settings,Paramètres de Patients Externes
-DocType: Account,Round Off,Arrondi
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259,Quantity must be positive,La quantité doit être positive
-DocType: Material Request Plan Item,Requested Qty,Qté Demandée
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96,The fields From Shareholder and To Shareholder cannot be blank,Les champs De l&#39;actionnaire et de l&#39;actionnaire ne peuvent pas être vides
-DocType: Tax Rule,Use for Shopping Cart,Utiliser pour le Panier
-apps/erpnext/erpnext/controllers/item_variant.py +98,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},La Valeur {0} pour l'Attribut {1} n'existe pas dans la liste des Valeurs d'Attribut d’Article valides pour l’Article {2}
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79,Select Serial Numbers,Sélectionnez les Numéros de Série
-DocType: BOM Item,Scrap %,% de Rebut
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46,"Charges will be distributed proportionately based on item qty or amount, as per your selection","Les frais seront distribués proportionnellement à la qté ou au montant de l'article, selon votre sélection"
-DocType: Maintenance Visit,Purposes,Objets
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +111,Atleast one item should be entered with negative quantity in return document,Au moins un article doit être saisi avec quantité négative dans le document de retour
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations","Opération {0} plus longue que toute heure de travail disponible dans le poste {1}, séparer l'opération en plusieurs opérations"
-DocType: Membership,Membership Status,Statut d&#39;adhésion
-,Requested,Demandé
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93,No Remarks,Aucune Remarque
-DocType: Asset,In Maintenance,En maintenance
-DocType: Purchase Invoice,Overdue,En Retard
-DocType: Account,Stock Received But Not Billed,Stock Reçus Mais Non Facturés
-apps/erpnext/erpnext/accounts/doctype/account/account.py +84,Root Account must be a group,Le Compte Racine doit être un groupe
-DocType: Consultation,Drug Prescription,Prescription Médicale
-DocType: Fees,FEE.,HONORAIRES.
-DocType: Employee Loan,Repaid/Closed,Remboursé / Fermé
-DocType: Item,Total Projected Qty,Qté Totale Prévue
-DocType: Monthly Distribution,Distribution Name,Nom de Distribution
-apps/erpnext/erpnext/stock/stock_ledger.py +477,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry","Le taux de valorisation n&#39;a pas été trouvé pour l&#39;élément {0}, qui est requis pour faire des écritures comptables pour {1} {2}. Si l&#39;article traite comme un élément de taux de valorisation nulle dans le {1}, mentionnez-le dans la {1} table d&#39;éléments. Sinon, créez une transaction de stock entrant pour l&#39;élément ou mentionnez le taux d&#39;évaluation dans l&#39;enregistrement de l&#39;élément, puis essayez de soumettre / annuler cette entrée"
-DocType: Course,Course Code,Code de Cours
-apps/erpnext/erpnext/controllers/stock_controller.py +337,Quality Inspection required for Item {0},Inspection de la Qualité requise pour l'Article {0}
-DocType: POS Settings,Use POS in Offline Mode,Utiliser PDV en Mode Hors-Ligne
-DocType: Supplier Scorecard,Supplier Variables,Variables Fournisseur
-DocType: Quotation,Rate at which customer's currency is converted to company's base currency,Taux auquel la devise client est convertie en devise client de base
-DocType: Purchase Invoice Item,Net Rate (Company Currency),Taux Net (Devise Société)
-DocType: Salary Detail,Condition and Formula Help,Aide Condition et Formule
-apps/erpnext/erpnext/config/selling.py +105,Manage Territory Tree.,Gérer l’Arborescence des Régions.
-DocType: Journal Entry Account,Sales Invoice,Facture de Vente
-DocType: Journal Entry Account,Party Balance,Solde du Tiers
-DocType: Cash Flow Mapper,Section Subtotal,Sous-total de la section
-apps/erpnext/erpnext/accounts/page/pos/pos.js +498,Please select Apply Discount On,Veuillez sélectionnez Appliquer Remise Sur
-DocType: Stock Settings,Sample Retention Warehouse,Exemple d&#39;entrepôt de rétention
-DocType: Company,Default Receivable Account,Compte Client par Défaut
-DocType: Physician,Physician Schedule,Calendrier du Médecin
-DocType: Purchase Invoice,Deemed Export,Export Estimé
-DocType: Stock Entry,Material Transfer for Manufacture,Transfert de Matériel pour la Fabrication
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20,Discount Percentage can be applied either against a Price List or for all Price List.,Pourcentage de Réduction peut être appliqué pour une liste de prix en particulier ou pour toutes les listes de prix.
-DocType: Subscription,Half-yearly,Semestriel
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407,Accounting Entry for Stock,Écriture Comptable pour Stock
-DocType: Lab Test,LabTest Approver,Approbateur de test de laboratoire
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61,You have already assessed for the assessment criteria {}.,Vous avez déjà évalué les critères d&#39;évaluation {}.
-DocType: Vehicle Service,Engine Oil,Huile Moteur
-DocType: Sales Invoice,Sales Team1,Équipe des Ventes 1
-apps/erpnext/erpnext/stock/doctype/item/item.py +546,Item {0} does not exist,Article {0} n'existe pas
-DocType: Sales Invoice,Customer Address,Adresse du Client
-DocType: Employee Loan,Loan Details,Détails du Prêt
-DocType: Company,Default Inventory Account,Compte d'Inventaire par Défaut
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192,The folio numbers are not matching,Les numéros de folio ne correspondent pas
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124,Row {0}: Completed Qty must be greater than zero.,Ligne {0} : Qté Complétée doit être supérieure à zéro.
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +249,Payment Request for {0},Demande de paiement pour {0}
-DocType: Item Barcode,Barcode Type,Type de code à barres
-DocType: Antibiotic,Antibiotic Name,Nom de l'Antibiotique
-DocType: Purchase Invoice,Apply Additional Discount On,Appliquer une Remise Supplémentaire Sur
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +69,Select Type...,Sélectionner le Type...
-DocType: Crop Cycle,A link to all the Land Units in which the Crop is growing,Un lien vers toutes les unités terrestres dans lesquelles la culture se développe
-DocType: Account,Root Type,Type de Racine
-DocType: Item,FIFO,"FIFO (Premier entré, Premier sorti)"
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +132,Row # {0}: Cannot return more than {1} for Item {2},Ligne # {0} : Vous ne pouvez pas retourner plus de {1} pour l’Article {2}
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +45,Plot,Terrain
-DocType: Item Group,Show this slideshow at the top of the page,Afficher ce diaporama en haut de la page
-DocType: BOM,Item UOM,UDM de l'Article
-DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),Montant de la Taxe Après Remise (Devise Société)
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +164,Target warehouse is mandatory for row {0},L’Entrepôt cible est obligatoire pour la ligne {0}
-DocType: Cheque Print Template,Primary Settings,Réglages Principaux
-DocType: Purchase Invoice,Select Supplier Address,Sélectionner l'Adresse du Fournisseur
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397,Add Employees,Ajouter des Employés
-DocType: Purchase Invoice Item,Quality Inspection,Inspection de la Qualité
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196,Extra Small,Très Petit
-DocType: Company,Standard Template,Modèle Standard
-DocType: Training Event,Theory,Théorie
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806,Warning: Material Requested Qty is less than Minimum Order Qty,Attention : La Quantité de Matériel Commandé est inférieure à la Qté Minimum de Commande
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211,Account {0} is frozen,Le compte {0} est gelé
-DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,Entité Juridique / Filiale avec un Plan de Comptes différent appartenant à l'Organisation.
-DocType: Payment Request,Mute Email,Email Silencieux
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29,"Food, Beverage & Tobacco","Alimentation, Boissons et Tabac"
-DocType: Account,Account Number,Numéro de compte
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +720,Can only make payment against unbilled {0},Le paiement n'est possible qu'avec les {0} non facturés
-apps/erpnext/erpnext/controllers/selling_controller.py +101,Commission rate cannot be greater than 100,Taux de commission ne peut pas être supérieure à 100
-DocType: Volunteer,Volunteer,Bénévole
-DocType: Stock Entry,Subcontract,Sous-traiter
-apps/erpnext/erpnext/public/js/utils/party.js +166,Please enter {0} first,Veuillez d’abord entrer {0}
-apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104,No replies from,Pas de réponse de
-DocType: Production Order Operation,Actual End Time,Heure de Fin Réelle
-DocType: Item,Manufacturer Part Number,Numéro de Pièce du Fabricant
-DocType: Production Order Operation,Estimated Time and Cost,Durée et Coût Estimés
-DocType: Bin,Bin,Boîte
-DocType: Crop,Crop Name,Nom de la culture
-DocType: SMS Log,No of Sent SMS,Nb de SMS Envoyés
-DocType: Antibiotic,Healthcare Administrator,Administrateur de Santé
-apps/erpnext/erpnext/utilities/user_progress.py +44,Set a Target,Définissez une cible
-DocType: Dosage Strength,Dosage Strength,Force du Dosage
-DocType: Account,Expense Account,Compte de Charge
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49,Software,Logiciel
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203,Colour,Couleur
-DocType: Assessment Plan Criteria,Assessment Plan Criteria,Critères du Plan d'Évaluation
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +118,Expiry date is mandatory for selected item,La date d&#39;expiration est obligatoire pour l&#39;article sélectionné
-DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,Interdire les Bons de Commande d'Achat
-apps/erpnext/erpnext/healthcare/setup.py +258,Susceptible,Sensible
-DocType: Patient Appointment,Scheduled,Prévu
-apps/erpnext/erpnext/config/buying.py +18,Request for quotation.,Appel d'Offre
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle","Veuillez sélectionner un Article où ""Est un Article Stocké"" est ""Non"" et ""Est un Article à Vendre"" est ""Oui"" et il n'y a pas d'autre Groupe de Produits"
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148,Select Customer,Sélectionnez un client
-DocType: Student Log,Academic,Académique
-DocType: Patient,Personal and Social History,Antécédents Personnels et Sociaux
-apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51,User {0} created,Utilisateur {0} créé
-DocType: Fee Schedule,Fee Breakup for each student,Répartition des Honoraires pour chaque élève
-apps/erpnext/erpnext/controllers/accounts_controller.py +540,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),Avance totale ({0}) pour la Commande {1} ne peut pas être supérieure au Total Général ({2})
-DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,Sélectionner une Répartition Mensuelle afin de repartir uniformément les objectifs sur le mois.
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78,Change Code,Modifier le Code
-DocType: Purchase Invoice Item,Valuation Rate,Taux de Valorisation
-DocType: Stock Reconciliation,SR/,SR/
-DocType: Vehicle,Diesel,Diesel
-apps/erpnext/erpnext/stock/get_item_details.py +388,Price List Currency not selected,Devise de la Liste de Prix non sélectionnée
-DocType: Purchase Invoice,Availed ITC Cess,Cess ITC Cess
-,Student Monthly Attendance Sheet,Feuille de Présence Mensuelle des Étudiants
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96,Shipping rule only applicable for Selling,Règle d&#39;expédition applicable uniquement pour la vente
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,Date de Début du Projet
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18,Until,Jusqu'à
-DocType: Rename Tool,Rename Log,Journal des Renommages
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27,Student Group or Course Schedule is mandatory,Le Ggroupe d'Étudiants ou le Calendrier des Cours est obligatoire
-DocType: HR Settings,Maintain Billing Hours and Working Hours Same on Timesheet,Maintenir les Heures Facturables et les Heures de Travail sur la même Feuille de Temps
-DocType: Maintenance Visit Purpose,Against Document No,Pour le Document N°
-DocType: BOM,Scrap,Mettre au Rebut
-apps/erpnext/erpnext/utilities/user_progress.py +214,Go to Instructors,Aller aux Instructeurs
-apps/erpnext/erpnext/config/selling.py +110,Manage Sales Partners.,Gérer les Partenaires Commerciaux.
-DocType: Quality Inspection,Inspection Type,Type d'Inspection
-DocType: Fee Validity,Visited yet,Déjà Visité
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +135,Warehouses with existing transaction can not be converted to group.,Les entrepôts avec des transactions existantes ne peuvent pas être convertis en groupe.
-DocType: Assessment Result Tool,Result HTML,Résultat HTML
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35,Expires On,Expire Le
-apps/erpnext/erpnext/utilities/activation.py +117,Add Students,Ajouter des Étudiants
-apps/erpnext/erpnext/public/js/utils.js +270,Please select {0},Veuillez sélectionner {0}
-DocType: C-Form,C-Form No,Formulaire-C Nº
-DocType: BOM,Exploded_items,Articles-éclatés
-apps/erpnext/erpnext/utilities/user_progress.py +136,List your products or services that you buy or sell.,Listez les produits ou services que vous achetez ou vendez.
-DocType: Water Analysis,Storage Temperature,Température de stockage
-DocType: Employee Attendance Tool,Unmarked Attendance,Participation Non Marquée
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137,Researcher,Chercheur
-DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,Outil d'Inscription au Programme Éudiant
-apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16,Start date should be less than end date for task {0},La date de début doit être inférieure à la date de fin de la tâche {0}
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25,Name or Email is mandatory,Nom ou Email est obligatoire
-DocType: Member,MEM-,MEM-
-DocType: Instructor,Instructor Log,Journal de l&#39;instructeur
-DocType: Purchase Order Item,Returned Qty,Qté Retournée
-DocType: Student,Exit,Quitter
-apps/erpnext/erpnext/accounts/doctype/account/account.py +156,Root Type is mandatory,Le Type de Racine est obligatoire
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29,Failed to install presets,Échec de l&#39;installation des préréglages
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0} est actuellement associée avec une fiche d'évaluation fournisseur {1}. Les appels d'offres pour ce fournisseur doivent être édités avec précaution.
-DocType: Chapter,Non Profit Manager,Gestionnaire à but non lucratif
-DocType: BOM,Total Cost(Company Currency),Coût Total (Devise Société)
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315,Serial No {0} created,N° de Série {0} créé
-DocType: Homepage,Company Description for website homepage,Description de la Société pour la page d'accueil du site web
-DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Pour la commodité des clients, ces codes peuvent être utilisés dans des formats d'impression comme les Factures et les Bons de Livraison"
-apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18,Suplier Name,Nom du Fournisseur
-apps/erpnext/erpnext/accounts/report/financial_statements.py +172,Could not retrieve information for {0}.,Impossible de récupérer les informations pour {0}.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134,Opening Entry Journal,Ouverture du journal d&#39;entrée
-DocType: Sales Invoice,Time Sheet List,Liste de Feuille de Temps
-DocType: Employee,You can enter any date manually,Vous pouvez entrer une date manuellement
-DocType: Healthcare Settings,Result Printed,Résultat Imprimé
-DocType: Asset Category Account,Depreciation Expense Account,Compte de Dotations aux Amortissement
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232,Probationary Period,Période d’Essai
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32,View {0},Voir {0}
-DocType: Customer Group,Only leaf nodes are allowed in transaction,Seuls les noeuds feuilles sont autorisés dans une transaction
-DocType: Project,Total Costing Amount (via Timesheets),Montant total des coûts (via les feuilles de temps)
-DocType: Employee Advance,Expense Approver,Approbateur de Notes de Frais
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136,Row {0}: Advance against Customer must be credit,Ligne {0} : L’Avance du Client doit être un crédit
-apps/erpnext/erpnext/accounts/doctype/account/account.js +89,Non-Group to Group,Non-Groupe à Groupe
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58,Batch is mandatory in row {0},Le lot est obligatoire dans la ligne {0}
-DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,Articles Fournis du Reçus d’Achat
-apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24,To Datetime,À la Date
-apps/erpnext/erpnext/config/selling.py +297,Logs for maintaining sms delivery status,Journaux pour maintenir le statut de livraison des sms
-DocType: Accounts Settings,Make Payment via Journal Entry,Effectuer un Paiement par une Écriture de Journal
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +218,Printed On,Imprimé sur
-DocType: Item,Inspection Required before Delivery,Inspection Requise avant Livraison
-DocType: Item,Inspection Required before Purchase,Inspection Requise avant Achat
-apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93,Pending Activities,Activités en Attente
-DocType: Patient Appointment,Reminded,Rappelé
-DocType: Patient,PID-,PID-
-DocType: Chapter Member,Chapter Member,Membre du chapitre
-DocType: Material Request Plan Item,Minimum Order Quantity,Quantité minimum d&#39;achat
-apps/erpnext/erpnext/public/js/setup_wizard.js +106,Your Organization,Votre Organisation
-DocType: Fee Component,Fees Category,Catégorie d'Honoraires
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +134,Please enter relieving date.,Veuillez entrer la date de relève.
-apps/erpnext/erpnext/controllers/trends.py +149,Amt,Nb
-DocType: Supplier Scorecard,Notify Employee,Notifier l'Employé
-DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,Entrez le nom de la campagne si la source de l'enquête est une campagne
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38,Newspaper Publishers,Éditeurs de Journaux
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30,Select Fiscal Year,Sélectionner l'Exercice
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115,Expected Delivery Date should be after Sales Order Date,La Date de Livraison Prévue doit être après la Date indiquée sur le Bon de Commande de Vente
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,Niveau de Réapprovisionnement
-DocType: Company,Chart Of Accounts Template,Modèle de Plan Comptable
-DocType: Attendance,Attendance Date,Date de Présence
-apps/erpnext/erpnext/stock/get_item_details.py +352,Item Price updated for {0} in Price List {1},Prix de l'Article mis à jour pour {0} dans la Liste des Prix {1}
-DocType: Salary Structure,Salary breakup based on Earning and Deduction.,Détails du Salaire basés sur les Revenus et les Prélèvements.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +128,Account with child nodes cannot be converted to ledger,Un compte avec des enfants ne peut pas être converti en grand livre
-DocType: Purchase Invoice Item,Accepted Warehouse,Entrepôt Accepté
-DocType: Bank Reconciliation Detail,Posting Date,Date de Comptabilisation
-DocType: Item,Valuation Method,Méthode de Valorisation
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203,Mark Half Day,Marquer Demi-Journée
-DocType: Sales Invoice,Sales Team,Équipe des Ventes
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87,Duplicate entry,Écriture en double
-DocType: Program Enrollment Tool,Get Students,Obtenir les Étudiants
-DocType: Serial No,Under Warranty,Sous Garantie
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516,[Error],[Erreur]
-DocType: Sales Order,In Words will be visible once you save the Sales Order.,En Toutes Lettres. Sera visible une fois que vous enregistrerez la Commande Client
-,Employee Birthday,Anniversaire de l'Employé
-apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14,Please select Completion Date for Completed Repair,Veuillez sélectionner la date d&#39;achèvement pour la réparation terminée
-DocType: Student Batch Attendance Tool,Student Batch Attendance Tool,Outil de Présence de Lot d'Étudiants
-apps/erpnext/erpnext/controllers/status_updater.py +210,Limit Crossed,Limite Dépassée
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22,Scheduled Upto,Programmé jusqu&#39;à
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55,Venture Capital,Capital Risque
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,Une période universitaire avec cette 'Année Universitaire' {0} et 'Nom de la Période' {1} existe déjà. Veuillez modifier ces entrées et essayer à nouveau.
-DocType: UOM,Must be Whole Number,Doit être un Nombre Entier
-DocType: Leave Control Panel,New Leaves Allocated (In Days),Nouvelle Allocation de Congés (en jours)
-DocType: Purchase Invoice,Invoice Copy,Copie de Facture
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49,Serial No {0} does not exist,N° de Série {0} n’existe pas
-DocType: Sales Invoice Item,Customer Warehouse (Optional),Entrepôt des Clients (Facultatif)
-DocType: Pricing Rule,Discount Percentage,Remise en Pourcentage
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51,Reserved for sub contracting,Réservé à la sous-traitance
-DocType: Payment Reconciliation Invoice,Invoice Number,Numéro de Facture
-DocType: Shopping Cart Settings,Orders,Commandes
-DocType: Employee Leave Approver,Leave Approver,Approbateur de Congés
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285,Please select a batch,Veuillez sélectionner un lot
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42,JournalLib,JournalLib
-DocType: Assessment Group,Assessment Group Name,Nom du Groupe d'Évaluation
-DocType: Manufacturing Settings,Material Transferred for Manufacture,Matériel Transféré pour la Fabrication
-DocType: Landed Cost Item,Receipt Document Type,Type de Reçu
-DocType: Daily Work Summary Settings,Select Companies,Sélectionner les Sociétés
-,Issued Items Against Production Order,Articles Produits pour un Ordre de Fabrication
-DocType: Antibiotic,Healthcare,Santé
-DocType: Target Detail,Target Detail,Détail Cible
-apps/erpnext/erpnext/stock/doctype/item/item.js +65,Single Variant,Variante unique
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24,All Jobs,Tous les Emplois
-DocType: Sales Order,% of materials billed against this Sales Order,% de matériaux facturés pour cette Commande Client
-DocType: Program Enrollment,Mode of Transportation,Mode de Transport
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49,Period Closing Entry,Écriture de Clôture de la Période
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +75,Select Department...,Sélectionnez le Département ...
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38,Cost Center with existing transactions can not be converted to group,Un Centre de Coûts avec des transactions existantes ne peut pas être converti en groupe
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +367,Amount {0} {1} {2} {3},Montant {0} {1} {2} {3}
-DocType: Account,Depreciation,Amortissement
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102,The number of shares and the share numbers are inconsistent,Le nombre d&#39;actions et le nombre d&#39;actions sont incohérents
-apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),Fournisseur(s)
-DocType: Employee Attendance Tool,Employee Attendance Tool,Outil de Gestion des Présences des Employés
-DocType: Guardian Student,Guardian Student,Tuteur de l'Étudiant
-DocType: Supplier,Credit Limit,Limite de crédit
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Selling Price List Rate,Taux moyen de la liste de prix de vente
-DocType: Salary Component,Salary Component,Composante Salariale
-apps/erpnext/erpnext/accounts/utils.py +495,Payment Entries {0} are un-linked,Écritures de Paiement {0} ne sont pas liées
-DocType: GL Entry,Voucher No,N° de Référence
-,Lead Owner Efficiency,Efficacité des Responsables des Prospects
-DocType: Leave Allocation,Leave Allocation,Allocation de Congés
-DocType: Payment Request,Recipient Message And Payment Details,Message du Destinataire et Détails de Paiement
-DocType: Training Event,Trainer Email,Email du Formateur
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550,Material Requests {0} created,Les Demandes de Matérielles {0} créées
-DocType: Restaurant Reservation,No of People,Nbr de Personnes
-apps/erpnext/erpnext/config/selling.py +164,Template of terms or contract.,Modèle de termes ou de contrat.
-DocType: Purchase Invoice,Address and Contact,Adresse et Contact
-DocType: Cheque Print Template,Is Account Payable,Est Compte Créditeur
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276,Stock cannot be updated against Purchase Receipt {0},Stock ne peut pas être mis à jour pour le Reçu d'Achat {0}
-DocType: Support Settings,Auto close Issue after 7 days,Fermer automatique les Questions après 7 jours
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}","Congé ne peut être alloué avant le {0}, car le solde de congés a déjà été reporté dans la feuille d'allocation de congés futurs {1}"
-apps/erpnext/erpnext/accounts/party.py +318,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),Remarque : Date de Référence / d’Échéance dépasse le nombre de jours de crédit client autorisé de {0} jour(s)
-apps/erpnext/erpnext/education/doctype/program/program.js +8,Student Applicant,Candidature Étudiante
-DocType: Purchase Invoice,ORIGINAL FOR RECIPIENT,ORIGINAL POUR LE DESTINATAIRE
-DocType: Asset Category Account,Accumulated Depreciation Account,Compte d'Amortissement Cumulé
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11,This email is autogenerated,Ce courrier électronique est autogénéré
-DocType: Stock Settings,Freeze Stock Entries,Geler les Entrées de Stocks
-DocType: Program Enrollment,Boarding Student,Enregistrement Étudiant
-DocType: Asset,Expected Value After Useful Life,Valeur Attendue Après Utilisation Complète
-DocType: Item,Reorder level based on Warehouse,Niveau de réapprovisionnement basé sur l’Entrepôt
-DocType: Activity Cost,Billing Rate,Taux de Facturation
-,Qty to Deliver,Quantité à Livrer
-,Stock Analytics,Analyse du Stock
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +518,Operations cannot be left blank,Les opérations ne peuvent pas être laissées vides
-DocType: Maintenance Visit Purpose,Against Document Detail No,Pour le Détail du Document N°
-apps/erpnext/erpnext/regional/france/utils.py +30,Deletion is not permitted for country {0},La suppression n&#39;est pas autorisée pour le pays {0}
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +105,Party Type is mandatory,Type de Tiers Obligatoire
-DocType: Quality Inspection,Outgoing,Sortant
-DocType: Material Request,Requested For,Demandé Pour
-DocType: Quotation Item,Against Doctype,Contre Doctype
-apps/erpnext/erpnext/controllers/buying_controller.py +414,{0} {1} is cancelled or closed,{0} {1} est annulé ou fermé
-DocType: Asset,Calculate Depreciation,Calculer la dépréciation
-DocType: Delivery Note,Track this Delivery Note against any Project,Suivre ce Bon de Livraison pour tous les Projets
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35,Net Cash from Investing,Trésorerie Nette des Investissements
-DocType: Production Order,Work-in-Progress Warehouse,Entrepôt des Travaux en Cours
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111,Asset {0} must be submitted,L'actif {0} doit être soumis
-DocType: Fee Schedule Program,Total Students,Total Étudiants
-apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56,Attendance Record {0} exists against Student {1},Registre des présences {0} existe pour l'Étudiant {1}
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354,Reference #{0} dated {1},Référence #{0} datée du {1}
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164,Depreciation Eliminated due to disposal of assets,Amortissement Eliminé en raison de cessions d'actifs
-DocType: Member,Member,Membre
-apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15,Manage Addresses,Gérer les Adresses
-DocType: Pricing Rule,Item Code,Code de l'Article
-DocType: Serial No,Warranty / AMC Details,Garantie / Détails AMC
-apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116,Select students manually for the Activity based Group,Sélectionner les élèves manuellement pour un Groupe basé sur l'Activité
-DocType: Journal Entry,User Remark,Remarque de l'Utilisateur
-DocType: Lead,Market Segment,Part de Marché
-DocType: Agriculture Analysis Criteria,Agriculture Manager,Directeur de l&#39;agriculture
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +950,Paid Amount cannot be greater than total negative outstanding amount {0},Le Montant Payé ne peut pas être supérieur au montant impayé restant {0}
-DocType: Supplier Scorecard Period,Variables,Variables
-DocType: Employee Internal Work History,Employee Internal Work History,Antécédents Professionnels Interne de l'Employé
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249,Closing (Dr),Fermeture (Dr)
-DocType: Cheque Print Template,Cheque Size,Taille du Chèque
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} not in stock,N° de Série {0} n'est pas en stock
-apps/erpnext/erpnext/config/selling.py +169,Tax template for selling transactions.,Modèle de taxe pour les opérations de vente.
-DocType: Sales Invoice,Write Off Outstanding Amount,Encours de Reprise
-apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27,Account {0} does not match with Company {1},Le Compte {0} ne correspond pas à la Société {1}
-DocType: Education Settings,Current Academic Year,Année Académique Actuelle
-DocType: Stock Settings,Default Stock UOM,UDM par Défaut des Articles
-DocType: Asset,Number of Depreciations Booked,Nombre d’Amortissements Comptabilisés
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32,Against Employee Loan: {0},Pour le Prêt Employé : {0}
-DocType: Landed Cost Item,Receipt Document,Reçu
-DocType: Employee Education,School/University,École/Université
-DocType: Payment Request,Reference Details,Détails de la Référence
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +56,Expected Value After Useful Life must be less than Gross Purchase Amount,Valeur Attendue Après Utilisation Complète doit être inférieure au Montant d'Achat Brut
-DocType: Sales Invoice Item,Available Qty at Warehouse,Qté Disponible à l'Entrepôt
-apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20,Billed Amount,Montant Facturé
-DocType: Share Transfer,(including),(comprenant)
-DocType: Asset,Double Declining Balance,Double Solde Dégressif
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180,Closed order cannot be cancelled. Unclose to cancel.,Les commandes fermées ne peuvent être annulées. Réouvrir pour annuler.
-DocType: Student Guardian,Father,Père
-apps/erpnext/erpnext/controllers/accounts_controller.py +626,'Update Stock' cannot be checked for fixed asset sale,'Mettre à Jour Le Stock’ ne peut pas être coché pour la vente d'actifs immobilisés
-DocType: Bank Reconciliation,Bank Reconciliation,Réconciliation Bancaire
-DocType: Attendance,On Leave,En Congé
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7,Get Updates,Obtenir les Mises à jour
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96,{0} {1}: Account {2} does not belong to Company {3},{0} {1} : Compte {2} ne fait pas partie de la Société {3}
-apps/erpnext/erpnext/stock/doctype/item/item.js +368,Select at least one value from each of the attributes.,Sélectionnez au moins une valeur de chacun des attributs.
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166,Material Request {0} is cancelled or stopped,Demande de Matériel {0} est annulé ou arrêté
-apps/erpnext/erpnext/config/hr.py +310,Leave Management,Gestion des Congés
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +106,Group by Account,Grouper par Compte
-apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21,Please select Employee,Veuillez sélectionner un employé
-DocType: Sales Order,Fully Delivered,Entièrement Livré
-DocType: Lead,Lower Income,Revenu bas
-DocType: Restaurant Order Entry,Current Order,Ordre Actuel
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +183,Source and target warehouse cannot be same for row {0},L'entrepôt source et destination ne peuvent être similaire dans la ligne {0}
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry","Le Compte d’Écart doit être un compte de type Actif / Passif, puisque cette Réconciliation de Stock est une écriture d'à-nouveau"
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107,Disbursed Amount cannot be greater than Loan Amount {0},Le Montant Remboursé ne peut pas être supérieur au Montant du Prêt {0}
-apps/erpnext/erpnext/utilities/user_progress.py +173,Go to Programs,Aller aux Programmes
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +203,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},La ligne {0} # Montant alloué {1} ne peut pas être supérieure au montant non réclamé {2}
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89,Purchase Order number required for Item {0},Numéro de Bon de Commande requis pour l'Article {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +945,Production Order not created,Ordre de Production non créé
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',La ‘Date de Début’ doit être antérieure à la ‘Date de Fin’
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39,Cannot change status as student {0} is linked with student application {1},Impossible de changer le statut car l'étudiant {0} est lié à la candidature de l'étudiant {1}
-DocType: Asset,Fully Depreciated,Complètement Déprécié
-DocType: Item Barcode,UPC-A,UPC-A
-,Stock Projected Qty,Qté de Stock Projeté
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444,Customer {0} does not belong to project {1},Le Client {0} ne fait pas parti du projet {1}
-DocType: Employee Attendance Tool,Marked Attendance HTML,HTML des Présences Validées
-apps/erpnext/erpnext/utilities/activation.py +73,"Quotations are proposals, bids you have sent to your customers","Les devis sont des propositions, offres que vous avez envoyées à vos clients"
-DocType: Sales Invoice,Customer's Purchase Order,N° de Bon de Commande du Client
-DocType: Consultation,Patient,Patient
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47,Bypass credit check at Sales Order ,Contrôle de crédit de contournement à la commande client
-DocType: Land Unit,Check if it is a hydroponic unit,Vérifiez s&#39;il s&#39;agit d&#39;une unité hydroponique
-apps/erpnext/erpnext/config/stock.py +109,Serial No and Batch,N° de Série et lot
-DocType: Warranty Claim,From Company,De la Société
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52,Sum of Scores of Assessment Criteria needs to be {0}.,Somme des Scores de Critères d'Évaluation doit être {0}.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +77,Please set Number of Depreciations Booked,Veuillez définir le Nombre d’Amortissements Comptabilisés
-DocType: Supplier Scorecard Period,Calculations,Calculs
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +89,Value or Qty,Valeur ou Qté
-DocType: Payment Terms Template,Payment Terms,Termes de paiement
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +448,Productions Orders cannot be raised for:,Les Ordres de Production ne peuvent pas être créés pour:
-apps/erpnext/erpnext/utilities/user_progress.py +144,Minute,Minute
-DocType: Purchase Invoice,Purchase Taxes and Charges,Taxes et Frais d’Achats
-DocType: Chapter,Meetup Embed HTML,Meetup Embed HTML
-apps/erpnext/erpnext/utilities/user_progress.py +118,Go to Suppliers,Aller aux Fournisseurs
-,Qty to Receive,Quantité à Recevoir
-DocType: Leave Block List,Leave Block List Allowed,Liste de Blocage des Congés Autorisée
-DocType: Grading Scale Interval,Grading Scale Interval,Intervalle de l'Échelle de Notation
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49,Expense Claim for Vehicle Log {0},Note de Frais pour Indémnité Kilométrique {0}
-DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,Remise (%) sur le Tarif de la Liste de Prix avec la Marge
-apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59,All Warehouses,Tous les Entrepôts
-DocType: Sales Partner,Retailer,Détaillant
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115,Credit To account must be a Balance Sheet account,Le compte À Créditer doit être un compte de Bilan
-apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +122,All Supplier Types,Tous les Types de Fournisseurs
-DocType: Donor,Donor,Donneur
-DocType: Global Defaults,Disable In Words,"Désactiver ""En Lettres"""
-apps/erpnext/erpnext/stock/doctype/item/item.py +59,Item Code is mandatory because Item is not automatically numbered,Le code de l'Article est obligatoire car l'Article n'est pas numéroté automatiquement
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98,Quotation {0} not of type {1},Le devis {0} n'est pas du type {1}
-DocType: Maintenance Schedule Item,Maintenance Schedule Item,Article de Calendrier d'Entretien
-DocType: Sales Order,%  Delivered,% Livré
-apps/erpnext/erpnext/education/doctype/fees/fees.js +105,Please set the Email ID for the Student to send the Payment Request,Configurez l'ID de courrier électronique pour que l'Élève envoie la Demande de Paiement
-DocType: Production Order,PRO-,PRO-
-DocType: Patient,Medical History,Antécédents médicaux
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157,Bank Overdraft Account,Compte de Découvert Bancaire
-DocType: Patient,Patient ID,Identification du patient
-DocType: Physician Schedule,Schedule Name,Nom du calendrier
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48,Make Salary Slip,Créer une Fiche de Paie
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840,Add All Suppliers,Ajouter tous les Fournisseurs
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +89,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,Ligne # {0}: montant attribué ne peut pas être supérieur au montant en souffrance.
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75,Browse BOM,Parcourir la LDM
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155,Secured Loans,Prêts Garantis
-DocType: Purchase Invoice,Edit Posting Date and Time,Modifier la Date et l'Heure de la Publication
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101,Please set Depreciation related Accounts in Asset Category {0} or Company {1},Veuillez définir le Compte relatif aux Amortissements dans la Catégorie d’Actifs {0} ou la Société {1}
-DocType: Lab Test Groups,Normal Range,Plage normale
-DocType: Academic Term,Academic Year,Année Académique
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72,Available Selling,Vente disponible
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169,Opening Balance Equity,Ouverture de la Balance des Capitaux Propres
-DocType: Lead,CRM,CRM
-DocType: Purchase Invoice,N,N
-apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175,Remaining,Restant
-DocType: Appraisal,Appraisal,Estimation
-DocType: Purchase Invoice,GST Details,Détails de la GST
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156,Email sent to supplier {0},Email envoyé au fournisseur {0}
-DocType: Item,Default Sales Unit of Measure,Unité de Mesure par défaut à la Vente
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9,Academic Year: ,Année académique:
-DocType: Opportunity,OPTY-,OPTY-
-apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19,Date is repeated,La Date est répétée
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27,Authorized Signatory,Signataire Autorisé
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +67,Create Fees,Créer des Honoraires
-DocType: Project,Total Purchase Cost (via Purchase Invoice),Coût d'Achat Total (via Facture d'Achat)
-DocType: Training Event,Start Time,Heure de Début
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +400,Select Quantity,Sélectionner Quantité
-DocType: Customs Tariff Number,Customs Tariff Number,Tarifs Personnalisés
-DocType: Patient Appointment,Patient Appointment,Rendez-vous patient
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,Le Rôle Approbateur ne peut pas être identique au rôle dont la règle est Applicable
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64,Unsubscribe from this Email Digest,Se Désinscire de ce Compte Rendu par Email
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830,Get Suppliers By,Obtenir des Fournisseurs
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +172,{0} not found for Item {1},{0} introuvable pour l&#39;élément {1}
-apps/erpnext/erpnext/utilities/user_progress.py +194,Go to Courses,Aller aux Cours
-DocType: Accounts Settings,Show Inclusive Tax In Print,Afficher la taxe inclusive en impression
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17,"Bank Account, From Date and To Date are Mandatory","Compte bancaire, de date et à date sont obligatoires"
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28,Message Sent,Message Envoyé
-apps/erpnext/erpnext/accounts/doctype/account/account.py +98,Account with child nodes cannot be set as ledger,Les comptes avec des nœuds enfants ne peuvent pas être défini comme grand livre
-DocType: C-Form,II,II
-DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,Taux auquel la devise de la Liste de prix est convertie en devise du client de base
-DocType: Purchase Invoice Item,Net Amount (Company Currency),Montant Net (Devise Société)
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +213,Total advance amount cannot be greater than total sanctioned amount,Le montant total de l'avance ne peut être supérieur au montant total approuvé
-DocType: Salary Slip,Hour Rate,Tarif Horaire
-DocType: Stock Settings,Item Naming By,Nomenclature d'Article Par
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46,Another Period Closing Entry {0} has been made after {1},Une autre Entrée de Clôture de Période {0} a été faite après {1}
-DocType: Production Order,Material Transferred for Manufacturing,Matériel Transféré pour la Fabrication
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41,Account {0} does not exists,Le compte {0} n'existe pas
-DocType: Project,Project Type,Type de Projet
-apps/erpnext/erpnext/projects/doctype/task/task.py +142,Child Task exists for this Task. You can not delete this Task.,Une tâche enfant existe pour cette tâche. Vous ne pouvez pas supprimer cette tâche.
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48,DateLet,DateLet
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,Soit la qté cible soit le montant cible est obligatoire.
-apps/erpnext/erpnext/config/projects.py +51,Cost of various activities,Coût des différents types d'activités.
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}","Définir les Événements à {0}, puisque l'employé attaché au Commercial ci-dessous n'a pas d'ID Utilisateur {1}"
-DocType: Timesheet,Billing Details,Détails de la Facturation
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163,Source and target warehouse must be different,Entrepôt source et destination doivent être différents
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101,Not allowed to update stock transactions older than {0},Non autorisé à mettre à jour les transactions du stock antérieures à {0}
-DocType: BOM,Inspection Required,Inspection obligatoire
-DocType: Purchase Invoice Item,PR Detail,Détail PR
-DocType: Driving License Category,Class,Classe
-DocType: Sales Order,Fully Billed,Entièrement Facturé
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101,Shipping rule only applicable for Buying,Règle d&#39;expédition applicable uniquement pour l&#39;achat
-DocType: Vital Signs,BMI,IMC
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,Liquidités
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137,Delivery warehouse required for stock item {0},Entrepôt de Livraison requis pour article du stock {0}
-DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),Le poids brut du colis. Habituellement poids net + poids du matériau d'emballage. (Pour l'impression)
-DocType: Assessment Plan,Program,Programme
-DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Les utilisateurs ayant ce rôle sont autorisés à définir les comptes gelés et à créer / modifier des écritures comptables sur des comptes gelés
-DocType: Serial No,Is Cancelled,Est Annulée
-DocType: Student Group,Group Based On,Groupe basé sur
-DocType: Journal Entry,Bill Date,Date de la Facture
-DocType: Healthcare Settings,Laboratory SMS Alerts,Alertes SMS de laboratoire
-apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20,"Service Item,Type,frequency and expense amount are required","Un Article de Service, le Type, la fréquence et le montant des frais sont exigés"
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Même s'il existe plusieurs Règles de Tarification avec une plus haute priorité, les priorités internes suivantes sont appliquées :"
-DocType: Plant Analysis Criteria,Plant Analysis Criteria,Critères d&#39;analyse des plantes
-DocType: Cheque Print Template,Cheque Height,Hauteur du Chèque
-DocType: Supplier,Supplier Details,Détails du Fournisseur
-DocType: Setup Progress,Setup Progress,Progression de l'Installation
-DocType: Hub Settings,Publish Items to Hub,Publier les articles sur le Hub
-apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35,From value must be less than to value in row {0},De la Valeur doit être inférieure à la valeur de la ligne {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182,Wire Transfer,Virement
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92,Check all,Cochez tout
-DocType: Vehicle Log,Invoice Ref,Facture Ref
-DocType: Company,Default Income Account,Compte de Produits par Défaut
-apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32,Customer Group / Customer,Groupe de Clients / Client
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37,Unclosed Fiscal Years Profit / Loss (Credit),Bénéfice / Perte (Crédit) des Exercices Non Clos
-DocType: Sales Invoice,Time Sheets,Feuilles de Temps
-DocType: Lab Test Template,Change In Item,Modification dans l'Article
-DocType: Payment Gateway Account,Default Payment Request Message,Message de Demande de Paiement par Défaut
-DocType: Item Group,Check this if you want to show in website,Cochez cette case si vous souhaitez afficher sur le site
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338,Balance ({0}),Solde ({0})
-apps/erpnext/erpnext/config/accounts.py +134,Banking and Payments,Banque et Paiements
-,Welcome to ERPNext,Bienvenue sur ERPNext
-apps/erpnext/erpnext/config/learn.py +102,Lead to Quotation,Du Prospect au Devis
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34,Email Reminders will be sent to all parties with email contacts,Les rappels par courriel seront envoyés à toutes les parties avec des contacts par courriel
-DocType: Patient,A Negative,A Négatif
-apps/erpnext/erpnext/templates/includes/product_list.js +45,Nothing more to show.,Rien de plus à montrer.
-DocType: Lead,From Customer,Du Client
-apps/erpnext/erpnext/demo/setup/setup_data.py +327,Calls,Appels
-apps/erpnext/erpnext/utilities/user_progress.py +140,A Product,Un Produit
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207,Batches,Lots
-apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34,Make Fee Schedule,Faire un Echéancier d'Honoraires
-DocType: Purchase Order Item Supplied,Stock UOM,UDM du Stock
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233,Purchase Order {0} is not submitted,Le Bon de Commande {0} n’est pas soumis
-DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),La plage de référence normale pour un adulte est de 16-20 respirations / minute (RCP 2012)
-DocType: Customs Tariff Number,Tariff Number,Tarif
-DocType: Production Order Item,Available Qty at WIP Warehouse,Qté disponible à l'Entrepôt de Travaux en Cours
-apps/erpnext/erpnext/stock/doctype/item/item.js +39,Projected,Projeté
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222,Serial No {0} does not belong to Warehouse {1},N° de Série {0} ne fait pas partie de l’Entrepôt {1}
-apps/erpnext/erpnext/controllers/status_updater.py +174,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Remarque : Le système ne vérifiera pas les sur-livraisons et les sur-réservations pour l’Article {0} car la quantité ou le montant est égal à 0
-DocType: Notification Control,Quotation Message,Message du Devis
-DocType: Employee Loan,Employee Loan Application,Demande de Prêt d'un Employé
-DocType: Issue,Opening Date,Date d'Ouverture
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86,Please save the patient first,S&#39;il vous plaît sauver le patient d&#39;abord
-apps/erpnext/erpnext/education/api.py +80,Attendance has been marked successfully.,La présence a été marquée avec succès.
-DocType: Program Enrollment,Public Transport,Transports Publics
-DocType: Soil Texture,Silt Composition (%),Composition de limon (%)
-DocType: Journal Entry,Remark,Remarque
-DocType: Healthcare Settings,Avoid Confirmation,Éviter la Confirmation
-DocType: Purchase Receipt Item,Rate and Amount,Prix et Montant
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +171,Account Type for {0} must be {1},Le Type de Compte pour {0} doit être {1}
-DocType: Healthcare Settings,Default income accounts to be used if not set in Physician to book Consultation charges.,Comptes de Revenu par défaut à utiliser si non définis dans la fiche du Médecin pour enregistrer les honoraires liés à la consultation.
-apps/erpnext/erpnext/config/hr.py +55,Leaves and Holiday,Congés et Vacances
-DocType: Education Settings,Current Academic Term,Terme Académique Actuel
-DocType: Sales Order,Not Billed,Non Facturé
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +77,Both Warehouse must belong to same Company,Les deux Entrepôt doivent appartenir à la même Société
-apps/erpnext/erpnext/public/js/templates/contact_list.html +34,No contacts added yet.,Aucun contact ajouté.
-DocType: Purchase Invoice Item,Landed Cost Voucher Amount,Montant de la Référence de Coût au Débarquement
-,Item Balance (Simple),Solde de l&#39;objet (simple)
-apps/erpnext/erpnext/config/accounts.py +17,Bills raised by Suppliers.,Factures émises par des Fournisseurs.
-DocType: POS Profile,Write Off Account,Compte de Reprise
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Debit Note Amt,Mnt de la Note de Débit
-apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5,Discount Amount,Remise
-DocType: Purchase Invoice,Return Against Purchase Invoice,Retour contre Facture d’Achat
-DocType: Item,Warranty Period (in days),Période de Garantie (en jours)
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61,Failed to set defaults,Échec de la définition des valeurs par défaut
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56,Relation with Guardian1,Relation avec Tuteur1
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +787,Please select BOM against item {0},Veuillez sélectionner la nomenclature par rapport à l&#39;élément {0}
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18,Make Invoices,Faire des factures
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23,Net Cash from Operations,Trésorerie Nette des Opérations
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26,Item 4,Article 4
-DocType: Student Admission,Admission End Date,Date de Fin de l'Admission
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30,Sub-contracting,Sous-traitant
-DocType: Journal Entry Account,Journal Entry Account,Compte d’Écriture de Journal
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3,Student Group,Groupe Étudiant
-DocType: Shopping Cart Settings,Quotation Series,Séries de Devis
-apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57,"An item exists with same name ({0}), please change the item group name or rename the item","Un article existe avec le même nom ({0}), veuillez changer le nom du groupe d'article ou renommer l'article"
-DocType: Soil Analysis Criteria,Soil Analysis Criteria,Critères d&#39;analyse des sols
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2039,Please select customer,Veuillez sélectionner un client
-DocType: C-Form,I,I
-DocType: Company,Asset Depreciation Cost Center,Centre de Coûts de l'Amortissement d'Actifs
-DocType: Production Plan Sales Order,Sales Order Date,Date de la Commande Client
-DocType: Sales Invoice Item,Delivered Qty,Qté Livrée
-DocType: Assessment Plan,Assessment Plan,Plan d'Évaluation
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +93,Customer {0} is created.,Le client {0} est créé.
-DocType: Stock Settings,Limit Percent,Pourcentage Limite
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82, Currently no stock available in any warehouse,"Actuellement, aucun stock disponible dans aucun entrepôt"
-,Payment Period Based On Invoice Date,Période de Paiement basée sur la Date de la Facture
-DocType: Sample Collection,No. of print,Nbre d'impressions
-DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,Objet de réservation de chambre d&#39;hôtel
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58,Missing Currency Exchange Rates for {0},Taux de Change Manquant pour {0}
-DocType: Assessment Plan,Examiner,Examinateur
-DocType: Student,Siblings,Frères et Sœurs
-DocType: Journal Entry,Stock Entry,Écriture de Stock
-DocType: Payment Entry,Payment References,Références de Paiement
-DocType: C-Form,C-FORM-,FORMULAIRE-C-
-DocType: Vehicle,Insurance Details,Détails Assurance
-DocType: Account,Payable,Créditeur
-DocType: Share Balance,Share Type,Type de partage
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113,Please enter Repayment Periods,Veuillez entrer les Périodes de Remboursement
-apps/erpnext/erpnext/shopping_cart/cart.py +378,Debtors ({0}),Débiteurs ({0})
-DocType: Pricing Rule,Margin,Marge
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,Nouveaux Clients
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74,Gross Profit %,Bénéfice Brut %
-DocType: Appraisal Goal,Weightage (%),Poids (%)
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +499,Change POS Profile,Modifier le profil POS
-DocType: Bank Reconciliation Detail,Clearance Date,Date de Compensation
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7,Assessment Report,Rapport d'Évaluation
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +59,Gross Purchase Amount is mandatory,Montant d'Achat Brut est obligatoire
-apps/erpnext/erpnext/setup/doctype/company/company.js +95,Company name not same,Nom de l&#39;entreprise pas le même
-DocType: Lead,Address Desc,Adresse Desc
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +108,Party is mandatory,Le Tiers est obligatoire
-DocType: Journal Entry,JV-,JV-
-apps/erpnext/erpnext/controllers/accounts_controller.py +707,Rows with duplicate due dates in other rows were found: {list},Des lignes avec des dates d&#39;échéance en double dans les autres lignes ont été trouvées: {list}
-DocType: Topic,Topic Name,Nom du Sujet
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,Atleast one of the Selling or Buying must be selected,Au moins Vente ou Achat doit être sélectionné
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290,Select an employee to get the employee advance.,Sélectionnez un employé pour faire avancer l&#39;employé.
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56,Please select a valid Date,S&#39;il vous plaît sélectionnez une date valide
-apps/erpnext/erpnext/public/js/setup_wizard.js +36,Select the nature of your business.,Sélectionner la nature de votre entreprise.
-DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
-<br>
-Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
-<br>
-Descriptive for tests which have multiple result components and corresponding result entry fields. 
-<br>
-Grouped for test templates which are a group of other test templates.
-<br>
-No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.","Single pour les résultats qui ne nécessitent qu'une seule entrée, résultat UOM et valeur normale <br> Composé pour les résultats qui nécessitent plusieurs champs d'entrée avec les noms d'événement correspondants, les UOM de résultat et les valeurs normales <br> Descriptif pour les tests qui ont plusieurs composants de résultat et les champs de saisie des résultats correspondants. <br> Groupés pour les modèles de test qui sont un groupe d'autres modèles de test. <br> Aucun résultat pour les tests sans résultat. En outre, aucun test de laboratoire n'est créé. par exemple. Sous-tests pour les résultats groupés."
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +81,Row #{0}: Duplicate entry in References {1} {2},Ligne # {0}: entrée en double dans les références {1} {2}
-apps/erpnext/erpnext/config/manufacturing.py +57,Where manufacturing operations are carried.,Là où les opérations de fabrication sont réalisées.
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18,As Examiner,En tant qu&#39;examinateur
-DocType: Asset Movement,Source Warehouse,Entrepôt Source
-DocType: Installation Note,Installation Date,Date d'Installation
-apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30,Share Ledger,Registre des actions
-apps/erpnext/erpnext/controllers/accounts_controller.py +605,Row #{0}: Asset {1} does not belong to company {2},Ligne #{0} : L’Actif {1} n’appartient pas à la société {2}
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206,Sales Invoice {0} created,Facture de Vente {0} créée
-DocType: Employee,Confirmation Date,Date de Confirmation
-DocType: C-Form,Total Invoiced Amount,Montant Total Facturé
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50,Min Qty can not be greater than Max Qty,Qté Min ne peut pas être supérieure à Qté Max
-DocType: Soil Texture,Silty Clay,Argile limoneuse
-DocType: Account,Accumulated Depreciation,Amortissement Cumulé
-DocType: Supplier Scorecard Scoring Standing,Standing Name,Nom du Classement
-DocType: Stock Entry,Customer or Supplier Details,Détails du Client ou du Fournisseur
-DocType: Employee Loan Application,Required by Date,Requis à cette Date
-DocType: Lead,Lead Owner,Responsable du Prospect
-DocType: Production Plan,Sales Orders Detail,Détail des commandes
-DocType: Bin,Requested Quantity,Quantité Demandée
-DocType: Patient,Marital Status,État Civil
-DocType: Stock Settings,Auto Material Request,Demande de Matériel Automatique
-DocType: Delivery Note Item,Available Batch Qty at From Warehouse,Qté de Lot Disponible Depuis l'Entrepôt
-DocType: Customer,CUST-,CUST-
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Idevise,Idevise
-DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,Salaire Brut - Déductions Totales - Remboursement de Prêt
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29,Current BOM and New BOM can not be same,La LDM actuelle et la nouvelle LDM ne peuvent être pareilles
-apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +45,Salary Slip ID,ID Fiche de Paie
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +118,Date Of Retirement must be greater than Date of Joining,La Date de Départ à la Retraite doit être supérieure à Date d'Embauche
-apps/erpnext/erpnext/stock/doctype/item/item.js +68,Multiple Variants,Variantes multiples
-DocType: Sales Invoice,Against Income Account,Pour le Compte de Produits
-apps/erpnext/erpnext/controllers/website_list_for_contact.py +117,{0}% Delivered,{0}% Livré
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,L'article {0} : Qté commandée {1} ne peut pas être inférieure à la qté de commande minimum {2} (défini dans l'Article).
-DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,Pourcentage de Répartition Mensuelle
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49,Please login as another user.,Veuillez vous connecter en tant qu&#39;un autre utilisateur.
-DocType: Daily Work Summary Group User,Daily Work Summary Group User,Utilisateur du groupe Résumé du travail quotidien
-DocType: Territory,Territory Targets,Objectifs Régionaux
-DocType: Soil Analysis,Ca/Mg,Ca / Mg
-DocType: Delivery Note,Transporter Info,Infos Transporteur
-apps/erpnext/erpnext/accounts/utils.py +502,Please set default {0} in Company {1},Veuillez définir {0} par défaut dans la Société {1}
-DocType: Cheque Print Template,Starting position from top edge,Position initiale depuis bord haut
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33,Same supplier has been entered multiple times,Le même fournisseur a été saisi plusieurs fois
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152,Gross Profit / Loss,Bénéfice/Perte Brut
-,Warehouse wise Item Balance Age and Value,Stocker sage article équilibre âge et valeur
-DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,Article Fourni du Bon de Commande
-apps/erpnext/erpnext/public/js/setup_wizard.js +94,Company Name cannot be Company,Nom de la Société ne peut pas être Company
-apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,En-Têtes pour les modèles d'impression.
-apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,Titres pour les modèles d'impression e.g. Facture Proforma.
-DocType: Program Enrollment,Walking,En Marchant
-DocType: Student Guardian,Student Guardian,Tuteur d'Étudiant
-DocType: Member,Member Name,Nom de membre
-DocType: Stock Settings,Use Naming Series,Utiliser la série de noms
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218,Valuation type charges can not marked as Inclusive,Frais de type valorisation ne peuvent pas être marqués comme inclus
-DocType: POS Profile,Update Stock,Mettre à Jour le Stock
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,in the subscription,dans l&#39;abonnement
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,Différentes UDM pour les articles conduira à un Poids Net (Total) incorrect . Assurez-vous que le Poids Net de chaque article a la même unité de mesure .
-DocType: Membership,Payment Details,Détails de paiement
-apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,Taux LDM
-DocType: Asset,Journal Entry for Scrap,Écriture de Journal pour la Mise au Rebut
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83,Please pull items from Delivery Note,Veuillez récupérer les articles des Bons de Livraison
-apps/erpnext/erpnext/accounts/utils.py +472,Journal Entries {0} are un-linked,Les Écritures de Journal {0} ne sont pas liées
-apps/erpnext/erpnext/config/crm.py +92,"Record of all communications of type email, phone, chat, visit, etc.","Enregistrement de toutes les communications de type email, téléphone, chat, visite, etc."
-DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,Classement de la Fiche d'Évaluation Fournisseur
-DocType: Manufacturer,Manufacturers used in Items,Fabricants utilisés dans les Articles
-apps/erpnext/erpnext/accounts/general_ledger.py +168,Please mention Round Off Cost Center in Company,Veuillez indiquer le Centre de Coûts d’Arrondi de la Société
-DocType: Purchase Invoice,Terms,Termes
-DocType: Academic Term,Term Name,Nom du Terme
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332,Credit ({0}),Crédit ({0})
-DocType: Buying Settings,Purchase Order Required,Bon de Commande Requis
-,Item-wise Sales History,Historique des Ventes par Article
-DocType: Expense Claim,Total Sanctioned Amount,Montant Total Validé
-DocType: Land Unit,Land Unit,Unité terrestre
-,Purchase Analytics,Analyses des Achats
-DocType: Sales Invoice Item,Delivery Note Item,Bon de Livraison article
-DocType: Asset Maintenance Log,Task,Tâche
-DocType: Purchase Taxes and Charges,Reference Row #,Ligne de Référence #
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76,Batch number is mandatory for Item {0},Le numéro de lot est obligatoire pour l'Article {0}
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13,This is a root sales person and cannot be edited.,C’est un commercial racine qui ne peut être modifié.
-DocType: Salary Detail,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ","Si cette option est sélectionnée, la valeur spécifiée ou calculée dans ce composant ne contribuera pas aux gains ou aux déductions. Cependant, sa valeur peut être référencée par d&#39;autres composants qui peuvent être ajoutés ou déduits."
-DocType: Asset Settings,Number of Days in Fiscal Year,Nombre de jours dans l&#39;exercice
-,Stock Ledger,Livre d'Inventaire
-apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29,Rate: {0},Prix: {0}
-DocType: Company,Exchange Gain / Loss Account,Compte de Profits / Pertes sur Change
-apps/erpnext/erpnext/config/hr.py +7,Employee and Attendance,Employé et Participation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +92,Purpose must be one of {0},L'Objet doit être parmi {0}
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100,Fill the form and save it,Remplissez et enregistrez le formulaire
-apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26,Community Forum,Forum de la Communauté
-apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52,Actual qty in stock,Qté réelle en stock
-DocType: Homepage,"URL for ""All Products""","URL pour ""Tous les Produits"""
-DocType: Leave Application,Leave Balance Before Application,Solde de Congés Avant Demande
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46,Send SMS,Envoyer un SMS
-DocType: Supplier Scorecard Criteria,Max Score,Score Maximal
-DocType: Cheque Print Template,Width of amount in word,Largeur du montant en toutes lettres
-DocType: Company,Default Letter Head,En-Tête de Courrier par Défaut
-DocType: Purchase Order,Get Items from Open Material Requests,Obtenir des Articles de Demandes Matérielles Ouvertes
-DocType: Hotel Room Amenity,Billable,Facturable
-DocType: Lab Test Template,Standard Selling Rate,Prix de Vente Standard
-DocType: Account,Rate at which this tax is applied,Taux auquel cette taxe est appliquée
-DocType: Cash Flow Mapper,Section Name,Nom de la section
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77,Reorder Qty,Qté de Réapprovisionnement
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28,Current Job Openings,Offres d'Emploi Actuelles
-DocType: Company,Stock Adjustment Account,Compte d'Ajustement du Stock
-apps/erpnext/erpnext/public/js/payment/pos_payment.html +17,Write Off,Reprise
-DocType: Timesheet Detail,Operation ID,ID de l'Opération
-DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.","L'ID (de connexion) de l'Utilisateur Système. S'il est défini, il deviendra la valeur par défaut pour tous les formulaires des RH."
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}: De {1}
-DocType: Task,depends_on,Dépend de
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,Mise à jour des prix les plus récents dans toutes les Listes de Matériaux en file d'attente. Cela peut prendre quelques minutes.
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,Nom du Nouveau Compte. Note: Veuillez ne pas créer de comptes Clients et Fournisseurs
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +201,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,Veuillez définir la série de dénomination pour {0} via Configuration&gt; Paramètres&gt; Naming Series
-apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,Modèles d'Adresse par défaut en fonction du pays
-DocType: Water Analysis,Appearance,Apparence
-apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70,Avg. Buying Price List Rate,Moyenne de la liste de prix d'achat
-DocType: Sales Order Item,Supplier delivers to Customer,Fournisseur livre au Client
-apps/erpnext/erpnext/config/non_profit.py +23,Member information.,Informations sur le membre
-apps/erpnext/erpnext/utilities/bot.py +34,[{0}](#Form/Item/{0}) is out of stock,[{0}] (#Formulaire/Article/{0}) est en rupture de stock
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +58,Asset Maintenance,Maintenance des Actifs
-,Sales Payment Summary,Résumé du paiement des ventes
-DocType: Restaurant,Restaurant,Restaurant
-apps/erpnext/erpnext/accounts/party.py +321,Due / Reference Date cannot be after {0},Date d’échéance / de référence ne peut pas être après le {0}
-apps/erpnext/erpnext/config/setup.py +51,Data Import and Export,Importer et Exporter des Données
-DocType: Patient,Account Details,Détails du compte
-DocType: Crop,Materials Required,Matériaux nécessaires
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76,No students Found,Aucun étudiant Trouvé
-DocType: Medical Department,Medical Department,Département médical
-DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,Critères de Notation de la Fiche d'Évaluation Fournisseur
-apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55,Invoice Posting Date,Date d’Envois de la Facture
-apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25,Sell,Vendre
-DocType: Purchase Invoice,Rounded Total,Total Arrondi
-DocType: Product Bundle,List items that form the package.,Liste des articles qui composent le paquet.
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39,Not permitted. Please disable the Test Template,Pas permis. Veuillez désactiver le modèle de test
-apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,Pourcentage d'Allocation doit être égale à 100 %
-DocType: Crop Cycle,Linked Land Unit,Unité terrestre liée
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584,Please select Posting Date before selecting Party,Veuillez sélectionner la Date de Comptabilisation avant de sélectionner le Tiers
-DocType: Program Enrollment,School House,Maison de l'École
-DocType: Serial No,Out of AMC,Sur AMC
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +82,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,Nombre d’Amortissements Comptabilisés ne peut pas être supérieur à Nombre Total d'Amortissements
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47,Make Maintenance Visit,Effectuer une Visite d'Entretien
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +222,Please contact to the user who have Sales Master Manager {0} role,Veuillez contactez l'utilisateur qui a le rôle de Directeur des Ventes {0}
-DocType: Company,Default Cash Account,Compte de Caisse par Défaut
-apps/erpnext/erpnext/config/accounts.py +62,Company (not Customer or Supplier) master.,Données de base de la Société (ni les Clients ni les Fournisseurs)
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6,This is based on the attendance of this Student,Basé sur la présence de cet Étudiant
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178,No Students in,Aucun étudiant dans
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179,Add more items or open full form,Ajouter plus d'articles ou ouvrir le formulaire complet
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212,Delivery Notes {0} must be cancelled before cancelling this Sales Order,Bons de Livraison {0} doivent être annulés avant d’annuler cette Commande Client
-apps/erpnext/erpnext/utilities/user_progress.py +256,Go to Users,Aller aux Utilisateurs
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Paid amount + Write Off Amount can not be greater than Grand Total,Le Montant Payé + Montant Repris ne peut pas être supérieur au Total Général
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78,{0} is not a valid Batch Number for Item {1},{0} n'est pas un Numéro de Lot valide pour l’Article {1}
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +131,Note: There is not enough leave balance for Leave Type {0},Remarque : Le solde de congé est insuffisant pour le Type de Congé {0}
-apps/erpnext/erpnext/regional/india/utils.py +16,Invalid GSTIN or Enter NA for Unregistered,GSTIN invalide ou Entrez NA si vous n'êtes pas Enregistré
-DocType: Training Event,Seminar,Séminaire
-DocType: Program Enrollment Fee,Program Enrollment Fee,Frais d'Inscription au Programme
-DocType: Item,Supplier Items,Articles Fournisseur
-DocType: Opportunity,Opportunity Type,Type d'Opportunité
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16,New Company,Nouvelle Société
-apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17,Transactions can only be deleted by the creator of the Company,Les Transactions ne peuvent être supprimées que par le créateur de la Société
-apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nombre incorrect d'Écritures Grand Livre trouvées. Vous avez peut-être choisi le mauvais Compte dans la transaction.
-DocType: Employee,Prefered Contact Email,Email de Contact Préféré
-DocType: Cheque Print Template,Cheque Width,Largeur du Chèque
-DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,Valider le Prix de Vente de l'Article avec le Prix d'Achat ou le Taux de Valorisation
-DocType: Fee Schedule,Fee Schedule,Barème d'Honoraires
-DocType: Hub Settings,Publish Availability,Publier la Disponibilité
-DocType: Company,Create Chart Of Accounts Based On,Créer un Plan Comptable Basé Sur
-apps/erpnext/erpnext/projects/doctype/task/task.js +91,Cannot convert it to non-group. Child Tasks exist.,Impossible de le convertir en non-groupe. Des tâches enfants existent.
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +112,Date of Birth cannot be greater than today.,Date de Naissance ne peut être après la Date du Jour.
-,Stock Ageing,Viellissement du Stock
-apps/erpnext/erpnext/education/doctype/student/student.py +38,Student {0} exist against student applicant {1},Étudiant {0} existe pour la candidature d'un étudiant {1}
-DocType: Purchase Invoice,Rounding Adjustment (Company Currency),Arrondi (Devise Société)
-apps/erpnext/erpnext/projects/doctype/task/task.js +39,Timesheet,Feuille de Temps
-DocType: Volunteer,Afternoon,Après-midi
-apps/erpnext/erpnext/controllers/accounts_controller.py +257,{0} '{1}' is disabled,{0} '{1}' est désactivé(e)
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,Définir comme Ouvert
-DocType: Cheque Print Template,Scanned Cheque,Chèque Numérisé
-DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,Envoyer des emails automatiques aux Contacts sur les Transactions soumises.
-DocType: Timesheet,Total Billable Amount,Montant Total Facturable
-DocType: Customer,Credit Limit and Payment Terms,Limite de crédit et conditions de paiement
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20,Item 3,Article 3
-apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6,Order Entry,Saisie de Commande
-DocType: Purchase Order,Customer Contact Email,Email Contact Client
-DocType: Warranty Claim,Item and Warranty Details,Détails de l'Article et de la Garantie
-DocType: Chapter,Chapter Members,Membres du chapitre
-DocType: Sales Team,Contribution (%),Contribution (%)
-apps/erpnext/erpnext/controllers/accounts_controller.py +101,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Remarque : Écriture de Paiement ne sera pas créée car le compte 'Compte Bancaire ou de Caisse' n'a pas été spécifié
-apps/erpnext/erpnext/projects/doctype/project/project.py +69,Project {0} already exists,Le projet {0} existe déjà
-DocType: Medical Department,Nursing User,Utilisateur Infirmier
-DocType: Plant Analysis,Plant Analysis Criterias,Critères d&#39;analyse des plantes
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238,Responsibilities,Responsabilités
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125,Validity period of this quotation has ended.,La période de validité de ce devis a pris fin.
-DocType: Expense Claim Account,Expense Claim Account,Compte de Note de Frais
-DocType: Accounts Settings,Allow Stale Exchange Rates,Autoriser les Taux de Change Existants
-DocType: Sales Person,Sales Person Name,Nom du Vendeur
-apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,Veuillez entrer au moins 1 facture dans le tableau
-apps/erpnext/erpnext/utilities/user_progress.py +244,Add Users,Ajouter des Utilisateurs
-DocType: POS Item Group,Item Group,Groupe d'Article
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16,Student Group: ,Groupe d&#39;étudiants:
-DocType: Item,Safety Stock,Stock de Sécurité
-DocType: Healthcare Settings,Healthcare Settings,Paramètres de Santé
-apps/erpnext/erpnext/projects/doctype/task/task.py +54,Progress % for a task cannot be more than 100.,% de Progression pour une tâche ne peut pas être supérieur à 100.
-DocType: Stock Reconciliation Item,Before reconciliation,Avant la réconciliation
-apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12,To {0},À {0}
-DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),Taxes et Frais Additionnels (Devise Société)
-apps/erpnext/erpnext/stock/doctype/item/item.py +475,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,La Ligne de Taxe d'Article {0} doit indiquer un compte de type Taxes ou Produit ou Charge ou Facturable
-DocType: Sales Order,Partly Billed,Partiellement Facturé
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +43,Item {0} must be a Fixed Asset Item,L'article {0} doit être une Immobilisation
-apps/erpnext/erpnext/stock/doctype/item/item.js +343,Make Variants,Faire des variantes
-DocType: Item,Default BOM,LDM par Défaut
-DocType: Project,Total Billed Amount (via Sales Invoices),Montant total facturé (via les factures de vente)
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +113,Debit Note Amount,Montant de la Note de Débit
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106,"There are inconsistencies between the rate, no of shares and the amount calculated","Il existe des incohérences entre le taux, le nombre d&#39;actions et le montant calculé"
-apps/erpnext/erpnext/setup/doctype/company/company.js +89,Please re-type company name to confirm,Veuillez saisir à nouveau le nom de la société pour confirmer
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +211,Total Outstanding Amt,Encours Total
-DocType: Journal Entry,Printing Settings,Réglages d'Impression
-DocType: Employee Advance,Advance Account,Compte d&#39;avances
-DocType: Job Offer,Job Offer Terms,Conditions d&#39;offre d&#39;emploi
-DocType: Sales Invoice,Include Payment (POS),Inclure Paiement (PDV)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292,Total Debit must be equal to Total Credit. The difference is {0},Le Total du Débit doit être égal au Total du Crédit. La différence est de {0}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11,Automotive,Automobile
-DocType: Vehicle,Insurance Company,Compagnie d'Assurance
-DocType: Asset Category Account,Fixed Asset Account,Compte d'Actif Immobilisé
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414,Variable,Variable
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47,From Delivery Note,Du Bon de Livraison
-DocType: Chapter,Members,Membres
-DocType: Student,Student Email Address,Adresse Email de l'Étudiant
-DocType: Item,Hub Warehouse,Entrepôt du Hub
-DocType: Assessment Plan,From Time,Horaire de Début
-DocType: Hotel Settings,Hotel Settings,Paramètres de l&#39;hôtel
-apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12,In Stock: ,En Stock :
-DocType: Notification Control,Custom Message,Message Personnalisé
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33,Investment Banking,Banque d'Investissement
-DocType: Purchase Invoice,input,contribution
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79,Cash or Bank Account is mandatory for making payment entry,Espèces ou Compte Bancaire est obligatoire pour réaliser une écriture de paiement
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54,Student Address,Adresse de l'Élève
-DocType: Purchase Invoice,Price List Exchange Rate,Taux de Change de la Liste de Prix
-apps/erpnext/erpnext/accounts/doctype/account/account.py +251,Account Number {0} already used in account {1},Numéro de compte {0} déjà utilisé dans le compte {1}
-DocType: POS Profile,POS Profile Name,Nom du profil PDV
-DocType: Hotel Room Reservation,Booked,Réservé
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45,CompAuxLib,CompAuxLib
-DocType: Purchase Invoice Item,Rate,Taux
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104,Intern,Interne
-DocType: Delivery Stop,Address Name,Nom de l'Adresse
-DocType: Stock Entry,From BOM,De LDM
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639,Splitting {0} units of {1},Division de {0} unités de {1}
-DocType: Assessment Code,Assessment Code,Code de l'Évaluation
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73,Basic,de Base
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94,Stock transactions before {0} are frozen,Les transactions du stock avant {0} sont gelées
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219,Please click on 'Generate Schedule',"Veuillez cliquer sur ""Générer calendrier''"
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122,Reference No is mandatory if you entered Reference Date,N° de Référence obligatoire si vous avez entré une date
-DocType: Bank Reconciliation Detail,Payment Document,Document de Paiement
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37,Error evaluating the criteria formula,Erreur lors de l'évaluation de la formule du critère
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +115,Date of Joining must be greater than Date of Birth,La Date d'Embauche doit être après à la Date de Naissance
-DocType: Salary Slip,Salary Structure,Grille des Salaires
-DocType: Account,Bank,Banque
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9,Airline,Compagnie Aérienne
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853,Issue Material,Problème Matériel
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3,An error occured while creating recurring,Une erreur s'est produite lors de la création de la récurrence
-DocType: Material Request Item,For Warehouse,Pour l’Entrepôt
-DocType: Employee,Offer Date,Date de la Proposition
-apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33,Quotations,Devis
-apps/erpnext/erpnext/accounts/page/pos/pos.js +735,You are in offline mode. You will not be able to reload until you have network.,Vous êtes en mode hors connexion. Vous ne serez pas en mesure de recharger jusqu'à ce que vous ayez du réseau.
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47,No Student Groups created.,Aucun Groupe d'Étudiants créé.
-DocType: Purchase Invoice Item,Serial No,N° de Série
-apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119,Monthly Repayment Amount cannot be greater than Loan Amount,Montant du Remboursement Mensuel ne peut pas être supérieur au Montant du Prêt
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143,Please enter Maintaince Details first,Veuillez d’abord entrer les Détails de Maintenance
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,Ligne {0}: la date de livraison prévue ne peut pas être avant la date de commande
-DocType: Purchase Invoice,Print Language,Langue d’Impression
-DocType: Salary Slip,Total Working Hours,Total des Heures Travaillées
-DocType: Sales Invoice,Customer PO Details,Détails du bon de commande client
-DocType: Subscription,Next Schedule Date,Prochaine Date Programmée
-DocType: Stock Entry,Including items for sub assemblies,Incluant les articles pour des sous-ensembles
-DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,Compte d&#39;ouverture temporaire
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1962,Enter value must be positive,La valeur entrée doit être positive
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446,All Territories,Tous les Territoires
-DocType: Purchase Invoice,Items,Articles
-apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34,Student is already enrolled.,L'étudiant est déjà inscrit.
-DocType: Fiscal Year,Year Name,Nom de l'Année
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +240,There are more holidays than working days this month.,Il y a plus de vacances que de jours travaillés ce mois-ci.
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78,PDC/LC Ref,PDC / LC Ref
-DocType: Product Bundle Item,Product Bundle Item,Article d'un Ensemble de Produits
-DocType: Sales Partner,Sales Partner Name,Nom du Partenaire de Vente
-apps/erpnext/erpnext/hooks.py +136,Request for Quotations,Appel d’Offres
-DocType: Payment Reconciliation,Maximum Invoice Amount,Montant Maximal de la Facture
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50,Montantdevise,Montantdevise
-apps/erpnext/erpnext/healthcare/setup.py +210,Haematology,Hématologie
-DocType: Normal Test Items,Normal Test Items,Articles de Test Normal
-DocType: Student Language,Student Language,Langue des Étudiants
-apps/erpnext/erpnext/config/selling.py +23,Customers,Clients
-DocType: Cash Flow Mapping,Is Working Capital,Est le capital de travail
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24,Order/Quot %,Commande / Devis %
-apps/erpnext/erpnext/config/healthcare.py +25,Record Patient Vitals,Enregistrer les Signes Vitaux du Patient
-DocType: Fee Schedule,Institution,Institution
-DocType: Asset,Partially Depreciated,Partiellement Déprécié
-DocType: Issue,Opening Time,Horaire d'Ouverture
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,Les date Du et Au sont requises
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46,Securities & Commodity Exchanges,Bourses de Valeurs Mobilières et de Marchandises
-apps/erpnext/erpnext/stock/doctype/item/item.py +688,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',L’Unité de mesure par défaut pour la variante '{0}' doit être la même que dans le Modèle '{1}'
-DocType: Shipping Rule,Calculate Based On,Calculer en fonction de
-DocType: Delivery Note Item,From Warehouse,De l'Entrepôt
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59,No employees for the mentioned criteria,Aucun employé pour les critères mentionnés
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +946,No Items with Bill of Materials to Manufacture,Aucun Article avec une Liste de Matériel à Fabriquer
-DocType: Hotel Settings,Default Customer,Client par Défaut
-DocType: Assessment Plan,Supervisor Name,Nom du Superviseur
-DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,Ne confirmez pas si le rendez-vous est créé pour le même jour
-DocType: Program Enrollment Course,Program Enrollment Course,Cours d'Inscription au Programme
-DocType: Purchase Taxes and Charges,Valuation and Total,Valorisation et Total
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11,Scorecards,Fiches d'Évaluation
-DocType: Tax Rule,Shipping City,Ville de Livraison
-DocType: Notification Control,Customize the Notification,Personnaliser la Notification
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24,Cash Flow from Operations,Flux de Trésorerie provenant des Opérations
-DocType: Purchase Invoice,Shipping Rule,Règle de Livraison
-DocType: Patient Relation,Spouse,Époux
-DocType: Lab Test Groups,Add Test,Ajouter un Test
-DocType: Manufacturer,Limited to 12 characters,Limité à 12 caractères
-DocType: Journal Entry,Print Heading,Imprimer Titre
-apps/erpnext/erpnext/config/stock.py +146,Delivery Trip service tours to customers.,Tours de service de livraison à la clientèle.
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57,Total cannot be zero,Total ne peut pas être zéro
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16,'Days Since Last Order' must be greater than or equal to zero,'Jours Depuis La Dernière Commande' doit être supérieur ou égal à zéro
-DocType: Plant Analysis Criteria,Maximum Permissible Value,Valeur maximale autorisée
-DocType: Journal Entry Account,Employee Advance,Avances des employés
-DocType: Payroll Entry,Payroll Frequency,Fréquence de la Paie
-DocType: Lab Test Template,Sensitivity,Sensibilité
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +932,Raw Material,Matières Premières
-DocType: Leave Application,Follow via Email,Suivre par E-mail
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55,Plants and Machineries,Usines et Machines
-DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,Montant de la Taxe après Remise
-DocType: Daily Work Summary Settings,Daily Work Summary Settings,Paramètres du Récapitulatif Quotidien
-apps/erpnext/erpnext/controllers/buying_controller.py +457,Please enter Reqd by Date,Veuillez entrer Reqd par date
-DocType: Payment Entry,Internal Transfer,Transfert Interne
-DocType: Asset Maintenance,Maintenance Tasks,Tâches de maintenance
-apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,Soit la qté cible soit le montant cible est obligatoire
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366,Please select Posting Date first,Veuillez d’abord sélectionner la Date de Comptabilisation
-apps/erpnext/erpnext/public/js/account_tree_grid.js +210,Opening Date should be before Closing Date,Date d'Ouverture devrait être antérieure à la Date de Clôture
-DocType: Leave Control Panel,Carry Forward,Reporter
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30,Cost Center with existing transactions can not be converted to ledger,Un Centre de Coûts avec des transactions existantes ne peut pas être converti en grand livre
-DocType: Department,Days for which Holidays are blocked for this department.,Jours pour lesquels les Vacances sont bloquées pour ce département.
-DocType: Crop Cycle,Detected Disease,Maladie détectée
-,Produced,Produit
-DocType: Item,Item Code for Suppliers,Code de l'Article pour les Fournisseurs
-DocType: Issue,Raised By (Email),Créé par (Email)
-DocType: Training Event,Trainer Name,Nom du Formateur
-DocType: Mode of Payment,General,Général
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28,Last Communication,Dernière Communication
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Déduction impossible lorsque la catégorie est pour 'Évaluation' ou 'Vaulation et Total'
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234,Serial Nos Required for Serialized Item {0},N° de Séries Requis pour Article Sérialisé {0}
-apps/erpnext/erpnext/config/accounts.py +144,Match Payments with Invoices,Rapprocher les Paiements avec les Factures
-DocType: Journal Entry,Bank Entry,Écriture Bancaire
-DocType: Authorization Rule,Applicable To (Designation),Applicable À (Désignation)
-,Profitability Analysis,Analyse de Profitabilité
-DocType: Fees,Student Email,Email de l'Étudiant
-DocType: Supplier,Prevent POs,Interdire les Bons de Commande d'Achat
-DocType: Patient,"Allergies, Medical and Surgical History","Allergies, antécédents médicaux et chirurgicaux"
-apps/erpnext/erpnext/templates/generators/item.html +77,Add to Cart,Ajouter au Panier
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,Grouper Par
-DocType: Guardian,Interests,Intérêts
-apps/erpnext/erpnext/config/accounts.py +298,Enable / disable currencies.,Activer / Désactiver les devises
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +110,Dr {0} on Half day Leave on {1},Dr {0} sur une demi-journée de congé le {1}
-DocType: Production Plan,Get Material Request,Obtenir la Demande de Matériel
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Postal Expenses,Frais Postaux
-apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),Total (Mnt)
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26,Entertainment & Leisure,Divertissement et Loisir
-,Item Variant Details,Détails de la variante de l&#39;article
-DocType: Quality Inspection,Item Serial No,No de Série de l'Article
-apps/erpnext/erpnext/utilities/activation.py +135,Create Employee Records,Créer les Dossiers des Employés
-apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68,Total Present,Total des Présents
-apps/erpnext/erpnext/config/accounts.py +105,Accounting Statements,États Financiers
-DocType: Drug Prescription,Hour,Heure
-DocType: Restaurant Order Entry,Last Sales Invoice,Dernière Facture de Vente
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +789,Please select Qty against item {0},Veuillez sélectionner Qté par rapport à l&#39;élément {0}
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,Les Nouveaux N° de Série ne peuvent avoir d'entrepot. L'Entrepôt doit être établi par Écriture de Stock ou Reçus d'Achat
-DocType: Lead,Lead Type,Type de Prospect
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +115,You are not authorized to approve leaves on Block Dates,Vous n'êtes pas autorisé à approuver les congés sur les Dates Bloquées
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +392,All these items have already been invoiced,Tous ces articles ont déjà été facturés
-DocType: Company,Monthly Sales Target,Objectif de Vente Mensuel
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},Peut être approuvé par {0}
-DocType: Hotel Room,Hotel Room Type,Type de chambre d&#39;hôtel
-DocType: Item,Default Material Request Type,Type de Requête de Matériaux par Défaut
-DocType: Supplier Scorecard,Evaluation Period,Période d'Évaluation
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13,Unknown,Inconnu
-DocType: Shipping Rule,Shipping Rule Conditions,Conditions de la Règle de Livraison
-DocType: Purchase Invoice,Export Type,Type d'Exportation
-DocType: Salary Slip Loan,Salary Slip Loan,Salaire Slip Loan
-DocType: BOM Update Tool,The new BOM after replacement,La nouvelle LDM après remplacement
-,Point of Sale,Point de Vente
-DocType: Payment Entry,Received Amount,Montant Reçu
-DocType: Patient,Widow,Veuve
-DocType: GST Settings,GSTIN Email Sent On,Email GSTIN Envoyé Le
-DocType: Program Enrollment,Pick/Drop by Guardian,Déposé/Récupéré par le Tuteur
-DocType: Crop,Planting UOM,Plantation d&#39;UOM
-DocType: Account,Tax,Taxe
-apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45,Not Marked,Non Marqué
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1,Opening Invoices Summary,Ouverture des factures Résumé
-DocType: Education Settings,Education Manager,Gestionnaire de l&#39;éducation
-DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,La longueur minimale entre chaque plante sur le terrain pour une croissance optimale
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry","L'article de Lot {0} ne peut pas être mis à jour à l'aide de la réconciliation des stocks, à la place, utilisez l'Entrée de Stock"
-DocType: Quality Inspection,Report Date,Date du Rapport
-DocType: Student,Middle Name,Deuxième Nom
-DocType: C-Form,Invoices,Factures
-DocType: Water Analysis,Type of Sample,Type d&#39;échantillon
-DocType: Batch,Source Document Name,Nom du Document Source
-DocType: Production Plan,Get Raw Materials For Production,Obtenez des matières premières pour la production
-DocType: Job Opening,Job Title,Titre de l'Emploi
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84,"{0} indicates that {1} will not provide a quotation, but all items \
-					have been quoted. Updating the RFQ quote status.","{0} indique que {1} ne fournira pas de devis, mais tous les articles \ ont été évalués. Mise à jour du statut de devis RFQ."
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1012,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,Nombre maximum d&#39;échantillons - {0} ont déjà été conservés pour le lot {1} et l&#39;article {2} dans le lot {3}.
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125,Please Set Supplier Type in Buying Settings.,Veuillez définir le type de fournisseur dans les paramètres d&#39;achat.
-DocType: Manufacturing Settings,Update BOM Cost Automatically,Mettre à jour automatiquement le coût de la LDM
-DocType: Lab Test,Test Name,Nom du Test
-apps/erpnext/erpnext/utilities/activation.py +99,Create Users,Créer des Utilisateurs
-apps/erpnext/erpnext/utilities/user_progress.py +144,Gram,Gramme
-DocType: Supplier Scorecard,Per Month,Par Mois
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +433,Quantity to Manufacture must be greater than 0.,Quantité à Fabriquer doit être supérieur à 0.
-DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,Calculer le calendrier d&#39;amortissement au prorata selon l&#39;exercice financier
-apps/erpnext/erpnext/config/maintenance.py +17,Visit report for maintenance call.,Rapport de visite pour appel de maintenance
-DocType: Stock Entry,Update Rate and Availability,Mettre à Jour le Prix et la Disponibilité
-DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,Pourcentage que vous êtes autorisé à recevoir ou à livrer en plus de la quantité commandée. Par exemple : Si vous avez commandé 100 unités et que votre allocation est de 10% alors que vous êtes autorisé à recevoir 110 unités.
-DocType: POS Customer Group,Customer Group,Groupe de Clients
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +128,New Batch ID (Optional),Nouveau Numéro de Lot (Optionnel)
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201,Expense account is mandatory for item {0},Compte de charge est obligatoire pour l'article {0}
-DocType: BOM,Website Description,Description du Site Web
-apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47,Net Change in Equity,Variation Nette de Capitaux Propres
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +220,Please cancel Purchase Invoice {0} first,Veuillez d’abord annuler la Facture d'Achat {0}
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43,"Email Address must be unique, already exists for {0}","Adresse Email doit être unique, existe déjà pour {0}"
-DocType: Serial No,AMC Expiry Date,Date d'Expiration CMA
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +871,Receipt,Reçu
-,Sales Register,Registre des Ventes
-DocType: Daily Work Summary Group,Send Emails At,Envoyer Emails À
-DocType: Quotation,Quotation Lost Reason,Raison de la Perte du Devis
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374,Transaction reference no {0} dated {1},Référence de la transaction n° {0} datée du {1}
-apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,Il n'y a rien à modifier.
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116,Summary for this month and pending activities,Résumé du mois et des activités en suspens
-apps/erpnext/erpnext/utilities/user_progress.py +245,"Add users to your organization, other than yourself.","Ajoutez des utilisateurs, autres que vous-même, à votre organisation."
-DocType: Customer Group,Customer Group Name,Nom du Groupe Client
-apps/erpnext/erpnext/public/js/pos/pos.html +98,No Customers yet!,Pas encore de Clients!
-apps/erpnext/erpnext/public/js/financial_statements.js +56,Cash Flow Statement,États des Flux de Trésorerie
-apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +472,No material request created,Aucune demande de matériel créée
-apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23,Loan Amount cannot exceed Maximum Loan Amount of {0},Le Montant du prêt ne peut pas dépasser le Montant Maximal du Prêt de {0}
-apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22,License,Licence
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491,Please remove this Invoice {0} from C-Form {1},Veuillez retirez cette Facture {0} du C-Form {1}
-DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Veuillez sélectionnez Report si vous souhaitez également inclure le solde des congés de l'exercice précédent à cet exercice
-DocType: GL Entry,Against Voucher Type,Pour le Type de Bon
-DocType: Physician,Phone (R),Téléphone (R)
-apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +50,Time slots added,Créneaux Horaires Ajoutés
-DocType: Item,Attributes,Attributs
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31,Enable Template,Activer le Modèle
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226,Please enter Write Off Account,Veuillez entrer un Compte de Reprise
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71,Last Order Date,Date de la Dernière Commande
-DocType: Patient,B Negative,B Négatif
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25,Maintenance Status has to be Cancelled or Completed to Submit,Le statut de maintenance doit être annulé ou complété pour pouvoir être envoyé
-DocType: Hotel Room,Hotel Room,Chambre d&#39;hôtel
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47,Account {0} does not belongs to company {1},Le compte {0} n'appartient pas à la société {1}
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884,Serial Numbers in row {0} does not match with Delivery Note,Les Numéros de Série dans la ligne {0} ne correspondent pas au Bon de Livraison
-DocType: Student,Guardian Details,Détails du Tuteur
-DocType: C-Form,C-Form,Formulaire-C
-apps/erpnext/erpnext/config/hr.py +18,Mark Attendance for multiple employees,Valider la Présence de plusieurs employés
-DocType: Agriculture Task,Start Day,Commence jour
-DocType: Vehicle,Chassis No,N ° de Châssis
-DocType: Payment Request,Initiated,Initié
-DocType: Production Order,Planned Start Date,Date de Début Prévue
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613,Please select a BOM,Veuillez sélectionner une LDM
-DocType: Purchase Invoice,Availed ITC Integrated Tax,Avoir intégré l&#39;impôt intégré de l&#39;ITC
-DocType: Serial No,Creation Document Type,Type de Document de Création
-DocType: Project Task,View Timesheet,Afficher la feuille de temps
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54,End date must be greater than start date,La date de fin doit être supérieure à la date de début
-DocType: Leave Type,Is Encash,Est Encaissement
-DocType: Leave Allocation,New Leaves Allocated,Nouvelle Allocation de Congés
-apps/erpnext/erpnext/controllers/trends.py +269,Project-wise data is not available for Quotation,Les données par projet ne sont pas disponibles pour un devis
-apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30,End on,Termine le
-DocType: Project,Expected End Date,Date de Fin Prévue
-DocType: Budget Account,Budget Amount,Montant Budgétaire
-DocType: Donor,Donor Name,Nom du donateur
-DocType: Appraisal Template,Appraisal Template Title,Titre du modèle d'évaluation
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39,From Date {0} for Employee {1} cannot be before employee's joining Date {2},La Date {0} pour l’Employé {1} ne peut pas être avant la Date d’embauche {2} de l’employé
-apps/erpnext/erpnext/utilities/user_progress_utils.py +29,Commercial,Commercial
-DocType: Patient,Alcohol Current Use,Consommation Actuelle d'Alcool
-DocType: Student Admission Program,Student Admission Program,Programme d&#39;admission des étudiants
-DocType: Payment Entry,Account Paid To,Compte Payé Au
-apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24,Parent Item {0} must not be a Stock Item,L'Article Parent {0} ne doit pas être un Élément de Stock
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +461,"Could not submit any Salary Slip <br>\
-			Possible reasons: <br>\
-			1. Net pay is less than 0. <br>\
-			2. Company Email Address specified in employee master is not valid. <br>",Impossible de soumettre un bordereau de salaire <br> \ Raisons possibles: <br> \ 1. Le salaire net est inférieur à 0. <br> \ 2. L'adresse e-mail de l'entreprise spécifiée dans la fiche employé n'est pas valide. <br>
-apps/erpnext/erpnext/config/selling.py +57,All Products or Services.,Tous les Produits ou Services.
-DocType: Expense Claim,More Details,Plus de Détails
-DocType: Supplier Quotation,Supplier Address,Adresse du Fournisseur
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0} le Budget du Compte {1} pour {2} {3} est de {4}. Il dépassera de {5}
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695,Row {0}# Account must be of type 'Fixed Asset',Ligne {0} # Le compte doit être de type ‘Actif Immobilisé'
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Out Qty,Qté Sortante
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,and unchcked Disabled in the,et désactivé dans le
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +46,Series is mandatory,Série est obligatoire
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28,Financial Services,Services Financiers
-DocType: Student Sibling,Student ID,Carte d'Étudiant
-apps/erpnext/erpnext/config/projects.py +46,Types of activities for Time Logs,Types d'activités pour Journaux de Temps
-DocType: Opening Invoice Creation Tool,Sales,Ventes
-DocType: Stock Entry Detail,Basic Amount,Montant de Base
-DocType: Training Event,Exam,Examen
-DocType: Complaint,Complaint,Plainte
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462,Warehouse required for stock Item {0},L’entrepôt est obligatoire pour l'article du stock {0}
-DocType: Leave Allocation,Unused leaves,Congés non utilisés
-DocType: Patient,Alcohol Past Use,Consommation Passée d'Alcool
-DocType: Fertilizer Content,Fertilizer Content,Contenu d&#39;engrais
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187,Cr,Cr
-DocType: Tax Rule,Billing State,État de la Facturation
-DocType: Share Transfer,Transfer,Transférer
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917,Fetch exploded BOM (including sub-assemblies),Récupérer la LDM éclatée (y compris les sous-ensembles)
-DocType: Authorization Rule,Applicable To (Employee),Applicable À (Employé)
-apps/erpnext/erpnext/controllers/accounts_controller.py +136,Due Date is mandatory,La Date d’Échéance est obligatoire
-apps/erpnext/erpnext/controllers/item_variant.py +82,Increment for Attribute {0} cannot be 0,Incrément pour l'Attribut {0} ne peut pas être 0
-apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19,Rooms Booked,Chambres réservées
-DocType: Journal Entry,Pay To / Recd From,Payé À / Reçu De
-DocType: Naming Series,Setup Series,Configuration des Séries
-DocType: Payment Reconciliation,To Invoice Date,Date de Facture Finale
-DocType: Shareholder,Contact HTML,HTML du Contact
-apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19,Registration fee can not be Zero,Les frais d&#39;inscription ne peuvent pas être zéro
-DocType: Disease,Treatment Period,Période de traitement
-apps/erpnext/erpnext/education/api.py +338,Result already Submitted,Résultat déjà soumis
-apps/erpnext/erpnext/controllers/buying_controller.py +169,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,L&#39;entrepôt réservé est obligatoire pour l&#39;article {0} dans les matières premières fournies
-,Inactive Customers,Clients Inactifs
-DocType: Student Admission Program,Maximum Age,Âge Maximum
-apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28,Please wait 3 days before resending the reminder.,Veuillez patienter 3 jours avant de renvoyer le rappel.
-DocType: Landed Cost Voucher,LCV,LCV
-DocType: Landed Cost Voucher,Purchase Receipts,Reçus d'Achats
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29,How Pricing Rule is applied?,Comment la Règle de Prix doit-elle être appliquée ?
-DocType: Stock Entry,Delivery Note No,Bon de Livraison N°
-DocType: Cheque Print Template,Message to show,Message à afficher
-apps/erpnext/erpnext/public/js/setup_wizard.js +28,Retail,Vente de Détail
-DocType: Student Attendance,Absent,Absent
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591,Product Bundle,Ensemble de Produits
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,Impossible de trouver un score démarrant à {0}. Vous devez avoir des scores couvrant 0 à 100
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212,Row {0}: Invalid reference {1},Ligne {0} : Référence {1} non valide
-DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,Modèle de Taxe et Frais d'Achat
-DocType: Timesheet,TS-,TS-
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,{0} {1}: Either debit or credit amount is required for {2},{0} {1} : Un montant est requis au débit ou au crédit pour {2}
-DocType: GL Entry,Remarks,Remarques
-DocType: Hotel Room Amenity,Hotel Room Amenity,Équipement de la chambre de l&#39;hôtel
-DocType: Payment Entry,Account Paid From,Compte Payé Du
-DocType: Purchase Order Item Supplied,Raw Material Item Code,Code d’Article de Matière Première
-DocType: Task,Parent Task,Tâche Parente
-DocType: Journal Entry,Write Off Based On,Reprise Basée Sur
-apps/erpnext/erpnext/utilities/activation.py +65,Make Lead,Faire un Prospect
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112,Print and Stationery,Impression et Papeterie
-DocType: Stock Settings,Show Barcode Field,Afficher Champ Code Barre
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809,Send Supplier Emails,Envoyer des Emails au Fournisseur
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +97,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.","Salaire déjà traité pour la période entre {0} et {1}, La période de demande de congé ne peut pas être entre cette plage de dates."
-DocType: Chapter Member,Leave Reason,Laissez la raison
-DocType: Guardian Interest,Guardian Interest,Part du Tuteur
-DocType: Volunteer,Availability,Disponibilité
-apps/erpnext/erpnext/config/accounts.py +319,Setup default values for POS Invoices,Configurer les valeurs par défaut pour les factures de point de vente
-apps/erpnext/erpnext/config/hr.py +182,Training,Formation
-DocType: Timesheet,Employee Detail,Détail Employé
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58,Guardian1 Email ID,ID Email du Tuteur1
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68,Next Date's day and Repeat on Day of Month must be equal,Le jour de la Date Suivante et le Jour de Répétition du Mois doivent être égal
-DocType: Lab Prescription,Test Code,Code de Test
-apps/erpnext/erpnext/config/website.py +11,Settings for website homepage,Réglages pour la page d'accueil du site
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40,RFQs are not allowed for {0} due to a scorecard standing of {1},Les Appels d'Offres ne sont pas autorisés pour {0} en raison d'une note de {1} sur la fiche d'évaluation
-DocType: Job Offer,Awaiting Response,Attente de Réponse
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60,Above,Au-dessus
-apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1462,Total Amount {0},Montant Total {0}
-apps/erpnext/erpnext/controllers/item_variant.py +303,Invalid attribute {0} {1},Attribut invalide {0} {1}
-DocType: Supplier,Mention if non-standard payable account,Veuillez mentionner s'il s'agit d'un compte créditeur non standard
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25,Please select the assessment group other than 'All Assessment Groups',Sélectionnez un groupe d'évaluation autre que «Tous les Groupes d'Évaluation»
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67,Row {0}: Cost center is required for an item {1},Ligne {0}: le Centre de Coûts est requis pour un article {1}
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureDate,EcritureDate
-DocType: Training Event Employee,Optional,Optionnel
-DocType: Salary Slip,Earning & Deduction,Revenus et Déduction
-DocType: Agriculture Analysis Criteria,Water Analysis,Analyse de l&#39;eau
-DocType: Chapter,Region,Région
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38,Optional. This setting will be used to filter in various transactions.,Facultatif. Ce paramètre sera utilisé pour filtrer différentes transactions.
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110,Negative Valuation Rate is not allowed,Taux de Valorisation Négatif n'est pas autorisé
-DocType: Holiday List,Weekly Off,Jours de Congé Hebdomadaire
-apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7,Reload Linked Analysis,Recharger l&#39;analyse liée
-DocType: Fiscal Year,"For e.g. 2012, 2012-13","Par exemple: 2012, 2012-13"
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96,Provisional Profit / Loss (Credit),Gain / Perte (Crédit) Provisoire
-DocType: Sales Invoice,Return Against Sales Invoice,Retour contre Facture de Vente
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32,Item 5,Article 5
-DocType: Serial No,Creation Time,Date de Création
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,Revenu Total
-DocType: Patient,Other Risk Factors,Autres facteurs de risque
-DocType: Sales Invoice,Product Bundle Help,Aide pour les Ensembles de Produits
-,Monthly Attendance Sheet,Feuille de Présence Mensuelle
-DocType: Production Order Item,Production Order Item,Article de l'Ordre de Production
-apps/erpnext/erpnext/healthcare/report/lab_test_report/lab_test_report.py +15,No record found,Aucun enregistrement trouvé
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140,Cost of Scrapped Asset,Coût des Immobilisations Mises au Rebut
-apps/erpnext/erpnext/controllers/stock_controller.py +236,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Centre de Coûts est obligatoire pour l’Article {2}
-DocType: Vehicle,Policy No,Politique N°
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686,Get Items from Product Bundle,Obtenir les Articles du Produit Groupé
-DocType: Asset,Straight Line,Linéaire
-DocType: Project User,Project User,Utilisateur du Projet
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +72,Split,Fractionner
-DocType: GL Entry,Is Advance,Est Accompte
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21,Attendance From Date and Attendance To Date is mandatory,La Date de Présence Depuis et la Date de Présence Jusqu'à sont obligatoires
-apps/erpnext/erpnext/controllers/buying_controller.py +156,Please enter 'Is Subcontracted' as Yes or No,Veuillez entrer Oui ou Non pour 'Est sous-traitée'
-DocType: Item,Default Purchase Unit of Measure,Unité de Mesure par défaut à l'Achat
-apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29,Last Communication Date,Date de la Dernière Communication
-DocType: Sales Team,Contact No.,N° du Contact
-DocType: Bank Reconciliation,Payment Entries,Écritures de Paiement
-DocType: Land Unit,Land Unit Details,Détails de l&#39;unité de terrain
-DocType: Land Unit,Latitude,Latitude
-DocType: Production Order,Scrap Warehouse,Entrepôt de Rebut
-DocType: Production Order,Check if material transfer entry is not required,Vérifiez si une un transfert de matériel n'est pas requis
-DocType: Program Enrollment Tool,Get Students From,Obtenir les Étudiants De
-apps/erpnext/erpnext/config/learn.py +263,Publish Items on Website,Publier les Articles sur le Site Web
-apps/erpnext/erpnext/utilities/activation.py +126,Group your students in batches,Regrouper vos étudiants en lots
-DocType: Authorization Rule,Authorization Rule,Règle d'Autorisation
-DocType: POS Profile,Offline POS Section,Section PDV Hors Ligne
-DocType: Sales Invoice,Terms and Conditions Details,Détails des Termes et Conditions
-apps/erpnext/erpnext/templates/generators/item.html +100,Specifications,Caractéristiques
-DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,Modèle de Taxes et Frais de Vente
-apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68,Total (Credit),Total (Crédit)
-DocType: Repayment Schedule,Payment Date,Date de Paiement
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +122,New Batch Qty,Nouvelle Qté de Lot
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10,Apparel & Accessories,Vêtements & Accessoires
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91,Could not solve weighted score function. Make sure the formula is valid.,Impossible de résoudre la fonction de score pondéré. Assurez-vous que la formule est valide.
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67,Number of Order,Nombre de Commandes
-DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML / bannière qui apparaîtra sur le haut de la liste des produits.
-DocType: Shipping Rule,Specify conditions to calculate shipping amount,Spécifier les conditions pour calculer le montant de la livraison
-DocType: Program Enrollment,Institute's Bus,Bus de l&#39;Institut
-DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,Rôle Autorisé à Geler des Comptes & à Éditer des Écritures Gelées
-DocType: Supplier Scorecard Scoring Variable,Path,Chemin
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cannot convert Cost Center to ledger as it has child nodes,Conversion impossible du Centre de Coûts en livre car il possède des nœuds enfants
-DocType: Production Plan,Total Planned Qty,Quantité totale prévue
-apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68,Opening Value,Valeur d'Ouverture
-DocType: Salary Detail,Formula,Formule
-apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47,Serial #,Série #
-DocType: Lab Test Template,Lab Test Template,Modèle de test de laboratoire
-apps/erpnext/erpnext/setup/doctype/company/company.py +181,Sales Account,Compte de vente
-DocType: Purchase Invoice Item,Total Weight,Poids total
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94,Commission on Sales,Commission sur les Ventes
-DocType: Job Offer Term,Value / Description,Valeur / Description
-apps/erpnext/erpnext/controllers/accounts_controller.py +629,"Row #{0}: Asset {1} cannot be submitted, it is already {2}","Ligne #{0} : L’Actif {1} ne peut pas être soumis, il est déjà {2}"
-DocType: Tax Rule,Billing Country,Pays de Facturation
-DocType: Purchase Order Item,Expected Delivery Date,Date de Livraison Prévue
-DocType: Restaurant Order Entry,Restaurant Order Entry,Entrée de commande de restaurant
-apps/erpnext/erpnext/accounts/general_ledger.py +132,Debit and Credit not equal for {0} #{1}. Difference is {2}.,Débit et Crédit non égaux pour {0} # {1}. La différence est de {2}.
-DocType: Asset Maintenance Task,Assign To Name,Attribuer au nom
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98,Entertainment Expenses,Charges de Représentation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98,Make Material Request,Faire une Demande de Matériel
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20,Open Item {0},Ouvrir l'Article {0}
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222,Sales Invoice {0} must be cancelled before cancelling this Sales Order,Facture de Vente {0} doit être annulée avant l'annulation de cette Commande Client
-DocType: Consultation,Age,Âge
-DocType: Sales Invoice Timesheet,Billing Amount,Montant de Facturation
-DocType: Cash Flow Mapping,Select Maximum Of 1,Sélectionnez Maximum de 1
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,Quantité spécifiée invalide pour l'élément {0}. Quantité doit être supérieur à 0.
-DocType: Company,Default Employee Advance Account,Compte d&#39;avances pour employés par défaut
-apps/erpnext/erpnext/config/hr.py +60,Applications for leave.,Demandes de congé.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +164,Account with existing transaction can not be deleted,Un compte contenant une transaction ne peut pas être supprimé
-DocType: Vehicle,Last Carbon Check,Dernière Vérification Carbone
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Legal Expenses,Frais Juridiques
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140,Please select quantity on row ,Veuillez sélectionner la quantité sur la ligne
-apps/erpnext/erpnext/config/accounts.py +277,Make Opening Sales and Purchase Invoices,Faire l&#39;ouverture des ventes et des factures d&#39;achat
-DocType: Purchase Invoice,Posting Time,Heure de Publication
-DocType: Timesheet,% Amount Billed,% Montant Facturé
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +130,"""Time Per Appointment"" hasn""t been set for Dr {0}. Add it in Physician master.","""La durée par rendez-vous"" n'a pas été définie pour le Dr {0}. Ajoutez-la dans les données de base du médecin."
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118,Telephone Expenses,Frais Téléphoniques
-DocType: Sales Partner,Logo,Logo
-DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Cochez cette case si vous voulez forcer l'utilisateur à sélectionner une série avant de l'enregistrer. Il n'y aura pas de série par défaut si vous cochez cette case.
-apps/erpnext/erpnext/stock/get_item_details.py +131,No Item with Serial No {0},Aucun Article avec le N° de Série {0}
-DocType: Email Digest,Open Notifications,Ouvrir les Notifications
-DocType: Payment Entry,Difference Amount (Company Currency),Écart de Montant (Devise de la Société)
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79,Direct Expenses,Charges Directes
-apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,Nouveaux Revenus de Clientèle
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119,Travel Expenses,Frais de Déplacement
-DocType: Maintenance Visit,Breakdown,Panne
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50,Add custom field Subscription in the doctype {0},Ajouter un champ personnalisé Abonnement dans le doctype {0}
-apps/erpnext/erpnext/controllers/accounts_controller.py +813,Account: {0} with currency: {1} can not be selected,Compte : {0} avec la devise : {1} ne peut pas être sélectionné
-DocType: Purchase Receipt Item,Sample Quantity,Quantité d&#39;échantillon
-DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.","Mettre à jour le coût de la LDM automatiquement via le Planificateur, en fonction du dernier taux de valorisation / tarif de la liste de prix / dernier prix d'achat des matières premières."
-DocType: Bank Reconciliation Detail,Cheque Date,Date du Chèque
-apps/erpnext/erpnext/accounts/doctype/account/account.py +50,Account {0}: Parent account {1} does not belong to company: {2},Compte {0}: Le Compte parent {1} n'appartient pas à l'entreprise: {2}
-apps/erpnext/erpnext/setup/doctype/company/company.js +106,Successfully deleted all transactions related to this company!,Suppression de toutes les transactions liées à cette société avec succès !
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +21,As on Date,Comme à la date
-DocType: Appraisal,HR,RH
-DocType: Program Enrollment,Enrollment Date,Date de l'Inscription
-DocType: Healthcare Settings,Out Patient SMS Alerts,Alertes SMS pour Patients
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100,Probation,Essai
-apps/erpnext/erpnext/config/hr.py +115,Salary Components,Composantes Salariales
-DocType: Program Enrollment Tool,New Academic Year,Nouvelle Année Académique
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811,Return / Credit Note,Retour / Note de Crédit
-DocType: Stock Settings,Auto insert Price List rate if missing,Insertion automatique du taux de la Liste de Prix si manquante
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +112,Total Paid Amount,Montant Total Payé
-DocType: GST Settings,B2C Limit,Limite B2C
-DocType: Production Order Item,Transferred Qty,Quantité Transférée
-apps/erpnext/erpnext/config/learn.py +11,Navigating,Naviguer
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188,Planning,Planification
-DocType: Share Balance,Issued,Publié
-apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14,Student Activity,Activité Étudiante
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80,Supplier Id,ID du Fournisseur
-DocType: Payment Request,Payment Gateway Details,Détails de la Passerelle de Paiement
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +277,Quantity should be greater than 0,Quantité doit être supérieure à 0
-DocType: Journal Entry,Cash Entry,Écriture de Caisse
-DocType: Production Plan,Get Items For Production Order,Obtenir des articles pour la commande de production
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17,Child nodes can be only created under 'Group' type nodes,Les noeuds enfants peuvent être créés uniquement dans les nœuds de type &#39;Groupe&#39;
-DocType: Leave Application,Half Day Date,Date de Demi-Journée
-DocType: Academic Year,Academic Year Name,Nom de l'Année Académique
-DocType: Sales Partner,Contact Desc,Desc. du Contact
-apps/erpnext/erpnext/config/hr.py +65,"Type of leaves like casual, sick etc.","Type de congé comme courant, maladie, etc."
-DocType: Email Digest,Send regular summary reports via Email.,Envoyer régulièrement des rapports de synthèse par Email.
-DocType: Payment Entry,PE-,PE-
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +280,Please set default account in Expense Claim Type {0},Veuillez définir le compte par défaut dans le Type de Note de Frais {0}
-DocType: Assessment Result,Student Name,Nom de l'Étudiant
-DocType: Brand,Item Manager,Gestionnaire d'Article
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Payroll Payable,Paie à Payer
-DocType: Buying Settings,Default Supplier Type,Type de Fournisseur par Défaut
-DocType: Plant Analysis,Collection Datetime,Collection Datetime
-DocType: Production Order,Total Operating Cost,Coût d'Exploitation Total
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171,Note: Item {0} entered multiple times,Remarque : Article {0} saisi plusieurs fois
-apps/erpnext/erpnext/config/selling.py +41,All Contacts.,Tous les Contacts.
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Company Abbreviation,Abréviation de la Société
-apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +57,User {0} does not exist,Utilisateur {0} n'existe pas
-DocType: Payment Term,Day(s) after invoice date,Jour (s) après la date de la facture
-DocType: Payment Schedule,Payment Schedule,Calendrier de paiement
-DocType: Subscription,SUB-,SOUS-
-DocType: Item Attribute Value,Abbreviation,Abréviation
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +182,Payment Entry already exists,L’Écriture de Paiement existe déjà
-apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,Non autorisé car {0} dépasse les limites
-apps/erpnext/erpnext/config/hr.py +110,Salary template master.,Base du modèle de salaire.
-apps/erpnext/erpnext/healthcare/setup.py +241,Pathology,Pathologie
-DocType: Restaurant Order Entry,Restaurant Table,Table de restaurant
-DocType: Hotel Room,Hotel Manager,Directeur de l&#39;hôtel
-DocType: Leave Type,Max Days Leave Allowed,Nombre Max de Jours de Congé Autorisé
-apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63,Set Tax Rule for shopping cart,Définir la Règle d'Impôt pour le panier
-DocType: Purchase Invoice,Taxes and Charges Added,Taxes et Frais Additionnels
-,Sales Funnel,Entonnoir de Vente
-apps/erpnext/erpnext/setup/doctype/company/company.py +49,Abbreviation is mandatory,Abréviation est obligatoire
-DocType: Project,Task Progress,Progression de la Tâche
-apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7,Cart,Panier
-,Qty to Transfer,Qté à Transférer
-apps/erpnext/erpnext/config/selling.py +13,Quotes to Leads or Customers.,Devis de Prospects ou Clients.
-DocType: Stock Settings,Role Allowed to edit frozen stock,Rôle Autorisé à modifier un stock gelé
-,Territory Target Variance Item Group-Wise,Variance de l’Objectif par Région et par Groupe d’Article
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143,All Customer Groups,Tous les Groupes Client
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114,Accumulated Monthly,Cumul Mensuel
-apps/erpnext/erpnext/controllers/accounts_controller.py +774,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} est obligatoire. Peut-être qu’un enregistrement de Taux de Change n'est pas créé pour {1} et {2}.
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +43,Tax Template is mandatory.,Un Modèle de Taxe est obligatoire.
-apps/erpnext/erpnext/accounts/doctype/account/account.py +44,Account {0}: Parent account {1} does not exist,Compte {0}: Le Compte parent {1} n'existe pas
-DocType: Purchase Invoice Item,Price List Rate (Company Currency),Taux de la Liste de Prix (Devise Société)
-DocType: Products Settings,Products Settings,Réglages des Produits
-,Item Price Stock,Article Prix Stock
-DocType: Lab Prescription,Test Created,Test Créé
-DocType: Healthcare Settings,Custom Signature in Print,Signature personnalisée dans l&#39;impression
-DocType: Account,Temporary,Temporaire
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +102,Customer LPO No.,Numéro d&#39;ordre client
-DocType: Program,Courses,Cours
-DocType: Monthly Distribution Percentage,Percentage Allocation,Allocation en Pourcentage
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128,Secretary,Secrétaire
-DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction","Si coché, le champ 'En Lettre' ne sera visible dans aucune transaction"
-DocType: Serial No,Distinct unit of an Item,Unité distincte d'un Article
-DocType: Supplier Scorecard Criteria,Criteria Name,Nom du Critère
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295,Please set Company,Veuillez sélectionner une Société
-DocType: Pricing Rule,Buying,Achat
-apps/erpnext/erpnext/config/agriculture.py +24,Diseases & Fertilizers,Maladies et engrais
-DocType: HR Settings,Employee Records to be created by,Dossiers de l'Employés ont été créées par
-DocType: Patient,AB Negative,AB Négatif
-DocType: Sample Collection,SMPL-,SMPL-
-DocType: POS Profile,Apply Discount On,Appliquer Réduction Sur
-DocType: Member,Membership Type,Type d&#39;adhésion
-,Reqd By Date,Requis par Date
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140,Creditors,Créditeurs
-DocType: Assessment Plan,Assessment Name,Nom de l'Évaluation
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +88,Show PDC in Print,Afficher PDC dans Imprimer
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +96,Row # {0}: Serial No is mandatory,Ligne # {0} : N° de série est obligatoire
-DocType: Purchase Taxes and Charges,Item Wise Tax Detail,Détail des Taxes par Article
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,Job Offer,Offre d&#39;emploi
-apps/erpnext/erpnext/public/js/setup_wizard.js +71,Institute Abbreviation,Abréviation de l'Institut
-,Item-wise Price List Rate,Taux de la Liste des Prix par Article
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1073,Supplier Quotation,Devis Fournisseur
-DocType: Quotation,In Words will be visible once you save the Quotation.,En Toutes Lettres. Sera visible une fois que vous enregistrerez le Devis.
-apps/erpnext/erpnext/utilities/transaction_base.py +160,Quantity ({0}) cannot be a fraction in row {1},La quantité ({0}) ne peut pas être une fraction dans la ligne {1}
-DocType: Consultation,C-,C-
-DocType: Attendance,ATT-,ATT-
-apps/erpnext/erpnext/stock/doctype/item/item.py +491,Barcode {0} already used in Item {1},Le Code Barre {0} est déjà utilisé dans l'article {1}
-apps/erpnext/erpnext/config/selling.py +86,Rules for adding shipping costs.,Règles pour l'ajout de frais de port.
-DocType: Hotel Room,Extra Bed Capacity,Capacité de lit supplémentaire
-DocType: Item,Opening Stock,Stock d'Ouverture
-apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,Client est requis
-DocType: Lab Test,Result Date,Date de Résultat
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77,PDC/LC Date,PDC / LC Date
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20,{0} is mandatory for Return,{0} est obligatoire pour un Retour
-DocType: Purchase Order,To Receive,À Recevoir
-apps/erpnext/erpnext/utilities/user_progress.py +249,user@example.com,utilisateur@exemple.com
-DocType: Asset,Asset Owner,Propriétaire de l'Actif
-DocType: Employee,Personal Email,Email Personnel
-apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57,Total Variance,Variance Totale
-DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.","Si activé, le système publiera automatiquement les écritures comptables pour l'inventaire."
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15,Brokerage,Courtage
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +196,Attendance for employee {0} is already marked for this day,La présence de l'employé {0} est déjà marquée pour cette journée
-DocType: Production Order Operation,"in Minutes
-Updated via 'Time Log'",en Minutes Mises à Jour via le 'Journal des Temps'
-DocType: Customer,From Lead,Du Prospect
-apps/erpnext/erpnext/config/manufacturing.py +13,Orders released for production.,Commandes validées pour la production.
-apps/erpnext/erpnext/public/js/account_tree_grid.js +66,Select Fiscal Year...,Sélectionner Exercice ...
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567,POS Profile required to make POS Entry,Profil PDV nécessaire pour faire une écriture de PDV
-DocType: Program Enrollment Tool,Enroll Students,Inscrire des Étudiants
-DocType: Lab Test,Approved Date,Date Approuvée
-apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21,Standard Selling,Vente Standard
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +152,Atleast one warehouse is mandatory,Au moins un entrepôt est obligatoire
-DocType: Serial No,Out of Warranty,Hors Garantie
-DocType: BOM Update Tool,Replace,Remplacer
-apps/erpnext/erpnext/templates/includes/product_list.js +42,No products found.,Aucun Produit trouvé.
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360,{0} against Sales Invoice {1},{0} pour la Facture de Vente {1}
-DocType: Antibiotic,Laboratory User,Utilisateur de laboratoire
-DocType: Sales Invoice,SINV-,SINV-
-DocType: Request for Quotation Item,Project Name,Nom du Projet
-DocType: Customer,Mention if non-standard receivable account,Mentionner si le compte débiteur n'est pas standard
-DocType: Journal Entry Account,If Income or Expense,Si Produits ou Charges
-DocType: Production Order,Required Items,Articles Requis
-DocType: Stock Ledger Entry,Stock Value Difference,Différence de Valeur du Sock
-apps/erpnext/erpnext/config/learn.py +229,Human Resource,Ressource Humaine
-DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,Paiement de Réconciliation des Paiements
-DocType: Disease,Treatment Task,Tâche de traitement
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38,Tax Assets,Actifs d'Impôts
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +653,Production Order has been {0},L'Ordre de Production a été {0}
-DocType: BOM Item,BOM No,N° LDM
-DocType: Instructor,INS/,INS/
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160,Journal Entry {0} does not have account {1} or already matched against other voucher,L’Écriture de Journal {0} n'a pas le compte {1} ou est déjà réconciliée avec une autre pièce justificative
-DocType: Item,Moving Average,Moyenne Mobile
-DocType: BOM Update Tool,The BOM which will be replaced,La LDM qui sera remplacée
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46,Electronic Equipments,Equipements Électroniques
-DocType: Asset,Maintenance Required,Maintenance requise
-DocType: Account,Debit,Débit
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49,Leaves must be allocated in multiples of 0.5,"Les Congés doivent être alloués par multiples de 0,5"
-DocType: Production Order,Operation Cost,Coût de l'Opération
-apps/erpnext/erpnext/config/hr.py +29,Upload attendance from a .csv file,Charger les participations à partir d'un fichier .csv
-apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45,Outstanding Amt,Montant en suspens
-DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,Définir des objectifs par Groupe d'Articles pour ce Commercial
-DocType: Stock Settings,Freeze Stocks Older Than [Days],Geler les Articles plus Anciens que [Jours]
-apps/erpnext/erpnext/controllers/accounts_controller.py +599,Row #{0}: Asset is mandatory for fixed asset purchase/sale,Ligne #{0} : L’Actif est obligatoire pour les achats / ventes d’actifs immobilisés
-DocType: Asset Maintenance Team,Maintenance Team Name,Nom de l&#39;équipe de maintenance
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.","Si deux Règles de Prix ou plus sont trouvées sur la base des conditions ci-dessus, une Priorité est appliquée. La Priorité est un nombre compris entre 0 et 20 avec une valeur par défaut de zéro (vide). Les nombres les plus élévés sont prioritaires s'il y a plusieurs Règles de Prix avec mêmes conditions."
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197,Customer is mandatory if 'Opportunity From' is selected as Customer,Le client est obligatoire si l&#39;option &quot;Opportunité de&quot; est sélectionnée en tant que client
-apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,Exercice Fiscal: {0} n'existe pas
-DocType: Currency Exchange,To Currency,Devise Finale
-DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,Autoriser les utilisateurs suivant à approuver les demandes de congés durant les jours bloqués.
-apps/erpnext/erpnext/config/hr.py +137,Types of Expense Claim.,Types de Notes de Frais.
-apps/erpnext/erpnext/controllers/selling_controller.py +147,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},Le prix de vente pour l'élément {0} est inférieur à son {1}. Le prix de vente devrait être au moins {2}
-DocType: Item,Taxes,Taxes
-DocType: Purchase Invoice,capital goods,biens d&#39;équipement
-DocType: Purchase Invoice Item,Weight Per Unit,Poids par unité
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344,Paid and Not Delivered,Payé et Non Livré
-DocType: Project,Default Cost Center,Centre de Coûts par Défaut
-DocType: Bank Guarantee,End Date,Date de Fin
-apps/erpnext/erpnext/config/stock.py +7,Stock Transactions,Transactions du Stock
-DocType: Budget,Budget Accounts,Comptes de Budgets
-DocType: Employee,Internal Work History,Historique de Travail Interne
-DocType: Depreciation Schedule,Accumulated Depreciation Amount,Montant d'Amortissement Cumulé
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42,Private Equity,Capital Risque
-DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,Variable de la Fiche d'Évaluation Fournisseur
-DocType: Employee Loan,Fully Disbursed,Entièrement Remboursé
-DocType: Maintenance Visit,Customer Feedback,Retour d'Expérience Client
-DocType: Account,Expense,Charges
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54,Score cannot be greater than Maximum Score,Score ne peut pas être supérieure à Score maximum
-apps/erpnext/erpnext/utilities/user_progress.py +126,Customers and Suppliers,Clients et Fournisseurs
-DocType: Item Attribute,From Range,Plage Initiale
-DocType: BOM,Set rate of sub-assembly item based on BOM,Définir le prix des articles de sous-assemblage en fonction de la LDM
-DocType: Hotel Room Reservation,Invoiced,Facturé
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98,Syntax error in formula or condition: {0},Erreur de syntaxe dans la formule ou condition : {0}
-DocType: Daily Work Summary Settings Company,Daily Work Summary Settings Company,Paramètres du Récapitulatif Quotidien de la Société
-apps/erpnext/erpnext/stock/utils.py +125,Item {0} ignored since it is not a stock item,L'article {0} est ignoré puisqu'il n'est pas en stock
-DocType: Appraisal,APRSL,EVAL
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +109,Submit this Production Order for further processing.,Soumettre cet Ordre de Fabrication pour un traitement ultérieur.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Pour ne pas appliquer la Règle de Tarification dans une transaction particulière, toutes les Règles de Tarification applicables doivent être désactivées."
-DocType: Payment Term,Day(s) after the end of the invoice month,Jour (s) après la fin du mois de facture
-DocType: Assessment Group,Parent Assessment Group,Groupe d’Évaluation Parent
-apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27,Jobs,Emplois
-,Sales Order Trends,Tendances des Commandes Client
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,The 'From Package No.' field must neither be empty nor it's value less than 1.,Le 'No de Paquet .' Le champ ne doit pas être vide ni sa valeur être inférieure à 1.
-DocType: Employee,Held On,Tenu le
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +36,Production Item,Article de Production
-,Employee Information,Renseignements sur l'Employé
-DocType: Stock Entry Detail,Additional Cost,Frais Supplémentaire
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48,"Can not filter based on Voucher No, if grouped by Voucher","Impossible de filtrer sur la base du N° de Coupon, si les lignes sont regroupées par Coupon"
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918,Make Supplier Quotation,Créer un Devis Fournisseur
-DocType: Quality Inspection,Incoming,Entrant
-apps/erpnext/erpnext/setup/doctype/company/company.js +70,Default tax templates for sales and purchase are created.,Les modèles de taxe par défaut pour les ventes et les achats sont créés.
-apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57,Assessment Result record {0} already exists.,Le Résultat d'Évaluation {0} existe déjà.
-DocType: BOM,Materials Required (Exploded),Matériel Requis (Éclaté)
-apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60,Please set Company filter blank if Group By is 'Company',Veuillez laisser le filtre de la Société vide si Group By est 'Société'
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66,Posting Date cannot be future date,La Date de Publication ne peut pas être une date future
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +101,Row # {0}: Serial No {1} does not match with {2} {3},Ligne # {0} : N° de série {1} ne correspond pas à {2} {3}
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10,for generating the recurring,pour générer le document récurrent
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86,Casual Leave,Congé Occasionnel
-DocType: Agriculture Task,End Day,Jour de fin
-DocType: Batch,Batch ID,ID du Lot
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380,Note: {0},Note : {0}
-,Delivery Note Trends,Tendance des Bordereaux de Livraisons
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112,This Week's Summary,Résumé Hebdomadaire
-apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22,In Stock Qty,Qté En Stock
-DocType: Delivery Trip,Calculate Estimated Arrival Times,Calculer les heures d&#39;arrivée estimées
-apps/erpnext/erpnext/accounts/general_ledger.py +111,Account: {0} can only be updated via Stock Transactions,Compte : {0} peut uniquement être mis à jour via les Mouvements de Stock
-DocType: Student Group Creation Tool,Get Courses,Obtenir les Cours
-DocType: GL Entry,Party,Tiers
-DocType: Healthcare Settings,Patient Name,Nom du patient
-DocType: Variant Field,Variant Field,Champ de Variante
-DocType: Sales Order,Delivery Date,Date de Livraison
-DocType: Opportunity,Opportunity Date,Date d'Opportunité
-DocType: Purchase Receipt,Return Against Purchase Receipt,Retour contre Reçu d'Achat
-DocType: Water Analysis,Person Responsible,Personne responsable
-DocType: Request for Quotation Item,Request for Quotation Item,Article de l'Appel d'Offre
-DocType: Purchase Order,To Bill,À Facturer
-DocType: Material Request,% Ordered,% Commandé
-DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.","Pour un groupe étudiant basé sur un cours, le cours sera validé pour chaque élève inscrit aux cours du programme."
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103,Piecework,Travail à la Pièce
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Avg. Buying Rate,Moy. Taux d'achat
-DocType: Share Balance,From No,De Non
-DocType: Task,Actual Time (in Hours),Temps Réel (en Heures)
-DocType: Employee,History In Company,Ancienneté dans la Société
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270,New Message from {sender},Nouveau message de {expéditeur}
-DocType: Customer,Customer Primary Address,Adresse principale du client
-apps/erpnext/erpnext/config/learn.py +107,Newsletters,Newsletters
-DocType: Drug Prescription,Description/Strength,Description / Force
-DocType: Share Balance,Is Company,Est Société
-DocType: Stock Ledger Entry,Stock Ledger Entry,Écriture du Livre d'Inventaire
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83,Same item has been entered multiple times,Le même article a été saisi plusieurs fois
-DocType: Department,Leave Block List,Liste de Blocage des Congés
-DocType: Purchase Invoice,Tax ID,Numéro d'Identification Fiscale
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192,Item {0} is not setup for Serial Nos. Column must be blank,L'article {0} n'est pas configuré pour un Numéros de Série. La colonne doit être vide
-DocType: Accounts Settings,Accounts Settings,Paramètres des Comptes
-apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11,Approve,Approuver
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69,"Malformatted address for {0}, please fix to continue.","Adresse malformatée pour {0}, veuillez corriger pour continuer."
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28,"Number of new Account, it will be included in the account name as a prefix","Numéro du nouveau compte, il sera inclus dans le nom du compte en tant que préfixe"
-DocType: Maintenance Team Member,Team Member,Membre de l&#39;équipe
-apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151,No Result to submit,Aucun résultat à soumettre
-DocType: Customer,Sales Partner and Commission,Partenaire Commercial et Commission
-DocType: Employee Loan,Rate of Interest (%) / Year,Taux d'Intérêt (%) / Année
-,Project Quantity,Quantité de Projet
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'","Le Total {0} pour tous les articles est nul, peut-être devriez-vous modifier ‘Distribuez les Frais sur la Base de’"
-DocType: Opportunity,To Discuss,À Discuter
-apps/erpnext/erpnext/stock/stock_ledger.py +377,{0} units of {1} needed in {2} to complete this transaction.,{0} unités de {1} nécessaires dans {2} pour compléter cette transaction.
-DocType: Loan Type,Rate of Interest (%) Yearly,Taux d'Intérêt (%) Annuel
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71,Temporary Accounts,Comptes Temporaires
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207,Black,Noir
-DocType: BOM Explosion Item,BOM Explosion Item,Article Eclaté LDM
-DocType: Shareholder,Contact List,Liste de contacts
-DocType: Account,Auditor,Auditeur
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +132,{0} items produced,{0} articles produits
-apps/erpnext/erpnext/utilities/user_progress.py +55,Learn More,Apprendre Plus
-DocType: Cheque Print Template,Distance from top edge,Distance du bord supérieur
-apps/erpnext/erpnext/stock/get_item_details.py +367,Price List {0} is disabled or does not exist,Liste des Prix {0} est désactivée ou n'existe pas
-DocType: Purchase Invoice,Return,Retour
-DocType: Production Order Operation,Production Order Operation,Opération d’Ordre de Production
-DocType: Pricing Rule,Disable,Désactiver
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +178,Mode of payment is required to make a payment,Mode de paiement est requis pour effectuer un paiement
-DocType: Project Task,Pending Review,Revue en Attente
-apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14,"Edit in full page for more options like assets, serial nos, batches etc.","Modifier en pleine page pour plus d&#39;options comme les actifs, les numéros de série, les lots, etc."
-apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10,Appointments and Consultations,Rendez-Vous et Consultations
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41,{0} - {1} is not enrolled in the Batch {2},{0} - {1} n'est pas inscrit dans le Lot {2}
-apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113,"Asset {0} cannot be scrapped, as it is already {1}","L'actif {0} ne peut pas être mis au rebut, car il est déjà {1}"
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +72,Cheques Required,Chèques requis
-DocType: Task,Total Expense Claim (via Expense Claim),Total des Notes de Frais (via Note de Frais)
-apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177,Mark Absent,Marquer Absent
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40,Failed to setup company,Échec de la configuration de la société
-DocType: Asset Repair,Asset Repair,Réparation d'Actif
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +142,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},Ligne {0} : La devise de la LDM #{1} doit être égale à la devise sélectionnée {2}
-DocType: Journal Entry Account,Exchange Rate,Taux de Change
-DocType: Patient,Additional information regarding the patient,Informations complémentaires concernant le patient
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585,Sales Order {0} is not submitted,Commande Client {0} n'a pas été transmise
-DocType: Homepage,Tag Line,Ligne de Tag
-DocType: Fee Component,Fee Component,Composant d'Honoraires
-apps/erpnext/erpnext/config/hr.py +204,Fleet Management,Gestion de Flotte
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1071,Add items from,Ajouter des articles de
-apps/erpnext/erpnext/config/agriculture.py +7,Crops & Lands,Cultures et terres
-DocType: Cheque Print Template,Regular,Ordinaire
-DocType: Fertilizer,Density (if liquid),Densité (si liquide)
-apps/erpnext/erpnext/education/doctype/course/course.py +20,Total Weightage of all Assessment Criteria must be 100%,Le total des pondérations de tous les Critères d'Évaluation doit être égal à 100%
-DocType: Purchase Order Item,Last Purchase Rate,Dernier Prix d'Achat
-DocType: Account,Asset,Actif
-DocType: Project Task,Task ID,Tâche ID
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84,Stock cannot exist for Item {0} since has variants,Stock ne peut pas exister pour l'Article {0} puisqu'il a des variantes
-DocType: Lab Test,Mobile,Mobile
-,Sales Person-wise Transaction Summary,Résumé des Transactions par Commerciaux
-DocType: Training Event,Contact Number,Numéro de Contact
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0} does not exist,L'entrepôt {0} n'existe pas
-DocType: Monthly Distribution,Monthly Distribution Percentages,Pourcentages de Répartition Mensuelle
-apps/erpnext/erpnext/stock/doctype/batch/batch.py +110,The selected item cannot have Batch,L’article sélectionné ne peut pas avoir de Lot
-DocType: Delivery Note,% of materials delivered against this Delivery Note,% de matériaux livrés pour ce Bon de Livraison
-DocType: Asset Maintenance Log,Has Certificate,A un certificat
-DocType: Project,Customer Details,Détails du client
-DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,Vérifier si l&#39;actif nécessite une maintenance préventive ou un étalonnage
-apps/erpnext/erpnext/public/js/setup_wizard.js +87,Company Abbreviation cannot have more than 5 characters,L&#39;abréviation de l&#39;entreprise ne peut pas comporter plus de 5 caractères
-DocType: Employee,Reports to,Rapports À
-,Unpaid Expense Claim,Note de Frais Impayée
-DocType: Payment Entry,Paid Amount,Montant Payé
-apps/erpnext/erpnext/utilities/user_progress.py +155,Explore Sales Cycle,Explorez le Cycle de Vente
-DocType: Assessment Plan,Supervisor,Superviseur
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869,Retention Stock Entry,Entrée de Stock de rétention
-,Available Stock for Packing Items,Stock Disponible pour les Articles d'Emballage
-DocType: Item Variant,Item Variant,Variante de l'Article
-DocType: Assessment Result Tool,Assessment Result Tool,Outil de Résultat d'Évaluation
-apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24,As Supervisor,En tant que superviseur
-DocType: BOM Scrap Item,BOM Scrap Item,Article Mis au Rebut LDM
-apps/erpnext/erpnext/accounts/page/pos/pos.js +895,Submitted orders can not be deleted,Commandes Soumises ne peuvent pas être supprimés
-apps/erpnext/erpnext/accounts/doctype/account/account.py +114,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Le solde du compte est déjà débiteur, vous n'êtes pas autorisé à définir 'Solde Doit Être' comme 'Créditeur'"
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118,Quality Management,Gestion de la Qualité
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +41,Item {0} has been disabled,L'article {0} a été désactivé
-DocType: Project,Total Billable Amount (via Timesheets),Montant total facturable (via les feuilles de temps)
-DocType: Agriculture Task,Previous Business Day,Jour ouvrable précédent
-DocType: Employee Loan,Repay Fixed Amount per Period,Rembourser un Montant Fixe par Période
-apps/erpnext/erpnext/buying/utils.py +47,Please enter quantity for Item {0},Veuillez entrer une quantité pour l'article {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +210,Credit Note Amt,Mnt de la Note de Crédit
-DocType: Employee External Work History,Employee External Work History,Antécédents Professionnels de l'Employé
-DocType: Opening Invoice Creation Tool,Purchase,Achat
-apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37,Balance Qty,Solde de la Qté
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20,Goals cannot be empty,Les objectifs ne peuvent pas être vides
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15,Enrolling students,Inscription des étudiants
-DocType: Item Group,Parent Item Group,Groupe d’Articles Parent
-DocType: Appointment Type,Appointment Type,Type de Rendez-Vous
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21,{0} for {1},{0} pour {1}
-DocType: Healthcare Settings,Valid number of days,Nombre de Jours Ouvrés
-apps/erpnext/erpnext/setup/doctype/company/company.js +39,Cost Centers,Centres de Coûts
-DocType: Land Unit,Linked Plant Analysis,Analyse des plantes liées
-DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,Taux auquel la devise du fournisseur est convertie en devise société de base
-apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},Ligne #{0}: Minutage en conflit avec la ligne {1}
-DocType: Purchase Invoice Item,Allow Zero Valuation Rate,Autoriser un Taux de Valorisation Égal à Zéro
-DocType: Training Event Employee,Invited,Invité
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +177,Multiple active Salary Structures found for employee {0} for the given dates,Plusieurs Grilles de Salaires Actives trouvées pour l'employé {0} pour les dates données
-apps/erpnext/erpnext/config/accounts.py +308,Setup Gateway accounts.,Configuration des Comptes passerelle.
-DocType: Employee,Employment Type,Type d'Emploi
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42,Fixed Assets,Actifs Immobilisés
-DocType: Payment Entry,Set Exchange Gain / Loss,Définir le change Gain / Perte
-,GST Purchase Register,Registre d'Achat GST
-,Cash Flow,Flux de Trésorerie
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25,Combined invoice portion must equal 100%,La portion combinée de la facture doit être égale à 100%
-DocType: Item Group,Default Expense Account,Compte de Charges par Défaut
-DocType: GST Account,CGST Account,Compte CGST
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53,Student Email ID,ID Email de l'Étudiant
-DocType: Employee,Notice (days),Préavis (jours)
-DocType: Tax Rule,Sales Tax Template,Modèle de la Taxe de Vente
-apps/erpnext/erpnext/accounts/page/pos/pos.js +2494,Select items to save the invoice,Sélectionner les articles pour sauvegarder la facture
-DocType: Employee,Encashment Date,Date de l'Encaissement
-DocType: Training Event,Internet,Internet
-DocType: Special Test Template,Special Test Template,Modèle de Test Spécial
-DocType: Account,Stock Adjustment,Ajustement du Stock
-apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34,Default Activity Cost exists for Activity Type - {0},Un Coût d’Activité par défault existe pour le Type d’Activité {0}
-DocType: Production Order,Planned Operating Cost,Coûts de Fonctionnement Prévus
-DocType: Academic Term,Term Start Date,Date de Début du Terme
-apps/erpnext/erpnext/config/accounts.py +471,List of all share transactions,Liste de toutes les transactions sur actions
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18,Opp Count,Compte d'Opportunités
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244,Please find attached {0} #{1},Veuillez trouver ci-joint {0} # {1}
-apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52,Average Rate,Taux moyen
-apps/erpnext/erpnext/controllers/accounts_controller.py +721,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,Le montant total du paiement dans l'échéancier doit être égal au Total Général / Total Arrondi
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34,Bank Statement balance as per General Ledger,Solde du Relevé Bancaire d’après le Grand Livre
-DocType: Job Applicant,Applicant Name,Nom du Candidat
-DocType: Authorization Rule,Customer / Item Name,Nom du Client / de l'Article
-DocType: Buying Settings,"If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt","Si cette option est activée, les derniers détails d&#39;achat des articles ne seront pas récupérés à partir du bon de commande précédent ou du reçu d&#39;achat."
-DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 
-
-The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".
-
-For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.
-
-Note: BOM = Bill of Materials","Regroupement d' **Articles** dans un autre **Article**. Ceci est utile si vous regroupez certains **Articles** dans un lot et que vous maintenez l'inventaire des **Articles** du lot et non de l'**Article** composé. L'**Article** composé aura ""Article En Stock"" à ""Non"" et ""Article À Vendre"" à ""Oui"". Exemple : Si vous vendez des Ordinateurs Portables et Sacs à Dos séparément et qu'il y a un prix spécial si le client achète les deux, alors l'Ordinateur Portable + le Sac à Dos sera un nouveau Produit Groupé. Remarque: LDM = Liste
-Des Matériaux"
-apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42,Serial No is mandatory for Item {0},N° de Série est obligatoire pour l'Article {0}
-DocType: Item Variant Attribute,Attribute,Attribut
-apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43,Please specify from/to range,Veuillez préciser la plage de / à
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28,Opening {0} Invoice created,Ouverture {0} Facture créée
-DocType: Serial No,Under AMC,Sous AMC
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55,Item valuation rate is recalculated considering landed cost voucher amount,Le taux d'évaluation de l'article est recalculé compte tenu du montant du bon de prix au débarquement
-apps/erpnext/erpnext/config/selling.py +153,Default settings for selling transactions.,Paramètres par défaut pour les transactions de vente.
-DocType: Guardian,Guardian Of ,Tuteur De
-DocType: Grading Scale Interval,Threshold,Seuil
-DocType: BOM Update Tool,Current BOM,LDM Actuelle
-apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +25,Balance (Dr - Cr),Balance (Dr - Cr)
-apps/erpnext/erpnext/public/js/utils.js +55,Add Serial No,Ajouter un Numéro de série
-DocType: Production Order Item,Available Qty at Source Warehouse,Qté Disponible à l'Entrepôt Source
-apps/erpnext/erpnext/config/support.py +22,Warranty,Garantie
-DocType: Purchase Invoice,Debit Note Issued,Notes de Débit Émises
-DocType: Production Order,Warehouses,Entrepôts
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18,{0} asset cannot be transferred,{0} actif ne peut pas être transféré
-DocType: Hotel Room Pricing,Hotel Room Pricing,Prix de la chambre d&#39;hôtel
-apps/erpnext/erpnext/stock/doctype/item/item.js +80,This Item is a Variant of {0} (Template).,Cet article est une Variante de {0} (Modèle).
-DocType: Workstation,per hour,par heure
-apps/erpnext/erpnext/config/buying.py +7,Purchasing,Achat
-DocType: Announcement,Announcement,Annonce
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84,Customer LPO,LPO client
-DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.","Pour un groupe étudiant basé sur un lot, le lot étudiant sera validé pour chaque élève inscrit au programme."
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +51,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,L'entrepôt ne peut pas être supprimé car une écriture existe dans le Livre d'Inventaire pour cet entrepôt.
-apps/erpnext/erpnext/public/js/setup_wizard.js +25,Distribution,Distribution
-DocType: Expense Claim Advance,Expense Claim Advance,Demande de remboursement anticipé
-DocType: Lab Test,Report Preference,Préférence de Rapport
-apps/erpnext/erpnext/config/non_profit.py +43,Volunteer information.,Informations sur le bénévolat
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133,Project Manager,Chef de Projet
-,Quoted Item Comparison,Comparaison d'Article Soumis
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34,Overlap in scoring between {0} and {1},Chevauchement dans la notation entre {0} et {1}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114,Dispatch,Envoi
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74,Max discount allowed for item: {0} is {1}%,Réduction max autorisée pour l'article : {0} est de {1} %
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176,Net Asset value as on,Valeur Nette des Actifs au
-DocType: Crop,Produce,Produire
-DocType: Hotel Settings,Default Taxes and Charges,Taxes et frais de défaut
-DocType: Account,Receivable,Créance
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,Ligne #{0} : Changement de Fournisseur non autorisé car un Bon de Commande existe déjà
-DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,Rôle qui est autorisé à soumettre des transactions qui dépassent les limites de crédit fixées.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +980,Select Items to Manufacture,Sélectionner les Articles à Fabriquer
-DocType: Delivery Stop,Delivery Stop,Arrêt de livraison
-apps/erpnext/erpnext/accounts/page/pos/pos.js +963,"Master data syncing, it might take some time","Données de base en cours de synchronisation, cela peut prendre un certain temps"
-DocType: Item,Material Issue,Sortie de Matériel
-DocType: Employee Education,Qualification,Qualification
-apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42,View Salary Slips,Voir les bulletins de salaire
-DocType: Item Price,Item Price,Prix de l'Article
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48,Soap & Detergent,Savons & Détergents
-DocType: BOM,Show Items,Afficher les Articles
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30,From Time cannot be greater than To Time.,L’Horaire Initial ne peut pas être postérieur à l’Horaire Final
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92,Do you want to notify all the customers by email?,Voulez-vous informer tous les clients par courriel?
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36,Motion Picture & Video,Cinéma & Vidéo
-apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,Commandé
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51,Resume,CV
-DocType: Salary Detail,Component,Composant
-DocType: Assessment Criteria,Assessment Criteria Group,Groupe de Critère d'Évaluation
-DocType: Healthcare Settings,Patient Name By,Nom du patient par
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +72,Opening Accumulated Depreciation must be less than equal to {0},Amortissement Cumulé d'Ouverture doit être inférieur ou égal à {0}
-DocType: Warehouse,Warehouse Name,Nom de l'Entrepôt
-DocType: Naming Series,Select Transaction,Sélectionner la Transaction
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,Veuillez entrer un Rôle Approbateur ou un Rôle Utilisateur
-DocType: Journal Entry,Write Off Entry,Écriture de Reprise
-DocType: BOM,Rate Of Materials Based On,Prix des Matériaux Basé sur
-apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,Analyse du Support
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102,Uncheck all,Décocher tout
-DocType: POS Profile,Terms and Conditions,Termes et Conditions
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49,To Date should be within the Fiscal Year. Assuming To Date = {0},La Date Finale doit être dans l'exercice. En supposant Date Finale = {0}
-DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc","Ici vous pouvez conserver la hauteur, le poids, les allergies, les préoccupations médicales etc."
-DocType: Leave Block List,Applies to Company,S'applique à la Société
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +231,Cannot cancel because submitted Stock Entry {0} exists,Impossible d'annuler car l'Écriture de Stock soumise {0} existe
-DocType: Employee Loan,Disbursement Date,Date de Décaissement
-apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80,'Recipients' not specified,«Destinataires» non spécifiés
-DocType: BOM Update Tool,Update latest price in all BOMs,Mettre à jour le prix le plus récent dans toutes les LDMs
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +39,Medical Record,Dossier médical
-DocType: Vehicle,Vehicle,Véhicule
-DocType: Purchase Invoice,In Words,En Toutes Lettres
-apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15,{0} must be submitted,{0} doit être soumis
-DocType: POS Profile,Item Groups,Groupes d&#39;articles
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +221,Today is {0}'s birthday!,Aujourd'hui c'est l’anniversaire de {0} !
-DocType: Sales Order Item,For Production,Pour la Production
-DocType: Payment Request,payment_url,payment_url
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186,Please add a Temporary Opening account in Chart of Accounts,Veuillez ajouter un compte d&#39;ouverture temporaire dans le plan comptable
-DocType: Customer,Customer Primary Contact,Contact principal du client
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154,Period Closing Journal,Période Clôture Journal
-DocType: Project Task,View Task,Voir Tâche
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22,Opp/Lead %,Opp / Prospect %
-DocType: Material Request,MREQ-,MREQ-
-DocType: Payment Schedule,Invoice Portion,Portion de facture
-,Asset Depreciations and Balances,Amortissements et Soldes d'Actif
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +363,Amount {0} {1} transferred from {2} to {3},Montant {0} {1} transféré de {2} à {3}
-DocType: Sales Invoice,Get Advances Received,Obtenir Acomptes Reçus
-DocType: Email Digest,Add/Remove Recipients,Ajouter/Supprimer des Destinataires
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +498,Transaction not allowed against stopped Production Order {0},Transaction non autorisée pour l'Ordre de Production arrêté {0}
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'","Pour définir cet Exercice Fiscal par défaut, cliquez sur ""Définir par défaut"""
-DocType: Production Plan,Include Subcontracted Items,Inclure les articles sous-traités
-apps/erpnext/erpnext/projects/doctype/project/project.py +218,Join,Joindre
-apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21,Shortage Qty,Qté de Pénurie
-apps/erpnext/erpnext/stock/doctype/item/item.py +671,Cannot change Variant properties after stock transction. You will have to make a new Item to do this.,Impossible de modifier les propriétés de la variante suite à des mouvements d'inventaire. Vous devrez créer un nouvel objet pour le faire.
-apps/erpnext/erpnext/stock/doctype/item/item.py +713,Item variant {0} exists with same attributes,La variante de l'article {0} existe avec les mêmes caractéristiques
-DocType: Employee Loan,Repay from Salary,Rembourser avec le Salaire
-DocType: Leave Application,LAP/,LAP/
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +347,Requesting payment against {0} {1} for amount {2},Demande de Paiement pour {0} {1} pour le montant {2}
-DocType: Salary Slip,Salary Slip,Fiche de Paie
-DocType: Lead,Lost Quotation,Devis Perdu
-apps/erpnext/erpnext/utilities/user_progress.py +218,Student Batches,Lots d'Étudiants
-DocType: Pricing Rule,Margin Rate or Amount,Taux de Marge ou Montant
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48,'To Date' is required,'Date de Fin' est requise
-DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.","Générer les bordereaux des colis à livrer. Utilisé pour indiquer le numéro de colis, le contenu et son poids."
-DocType: Sales Invoice Item,Sales Order Item,Article de la Commande Client
-DocType: Salary Slip,Payment Days,Jours de Paiement
-DocType: Stock Settings,Convert Item Description to Clean HTML,Convertir la description de l&#39;élément pour nettoyer le code HTML
-DocType: Patient,Dormant,Dormant
-DocType: Salary Slip,Total Interest Amount,Montant total de l&#39;intérêt
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +125,Warehouses with child nodes cannot be converted to ledger,Les entrepôts avec nœuds enfants ne peuvent pas être convertis en livre
-DocType: BOM,Manage cost of operations,Gérer les coûts d'exploitation
-DocType: Accounts Settings,Stale Days,Journées Passées
-DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.","Lorsque certaines des transactions contrôlées sont ""Soumises"", une pop-up email s'ouvre automatiquement pour envoyer un email au ""Contact"" associé dans cette transaction, avec la transaction en pièce jointe. L'utilisateur peut ou peut ne pas envoyer l'email."
-apps/erpnext/erpnext/config/setup.py +14,Global Settings,Paramètres Globaux
-DocType: Crop,Row Spacing UOM,UOM d&#39;espacement des lignes
-DocType: Assessment Result Detail,Assessment Result Detail,Détails des Résultats d'Évaluation
-DocType: Employee Education,Employee Education,Formation de l'Employé
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53,Duplicate item group found in the item group table,Groupe d’articles en double trouvé dans la table des groupes d'articles
-DocType: Land Unit,Parent Land Unit,Unité Terre-Parent
-apps/erpnext/erpnext/public/js/controllers/transaction.js +1113,It is needed to fetch Item Details.,Nécessaire pour aller chercher les Détails de l'Article.
-DocType: Fertilizer,Fertilizer Name,Nom de l&#39;engrais
-DocType: Salary Slip,Net Pay,Salaire Net
-DocType: Cash Flow Mapping Accounts,Account,Compte
-apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217,Serial No {0} has already been received,N° de Série {0} a déjà été reçu
-,Requested Items To Be Transferred,Articles Demandés à Transférer
-DocType: Expense Claim,Vehicle Log,Journal du Véhicule
-DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),Présence de fièvre (temp&gt; 38.5 ° C / 101.3 ° F ou température soutenue&gt; 38 ° C / 100.4 ° F)
-DocType: Customer,Sales Team Details,Détails de l'Équipe des Ventes
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1351,Delete permanently?,Supprimer définitivement ?
-DocType: Expense Claim,Total Claimed Amount,Montant Total Réclamé
-apps/erpnext/erpnext/config/crm.py +17,Potential opportunities for selling.,Opportunités potentielles de vente.
-DocType: Shareholder,Folio no.,Folio no.
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246,Invalid {0},Invalide {0}
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90,Sick Leave,Congé Maladie
-DocType: Email Digest,Email Digest,Envoyer par Mail le Compte Rendu
-DocType: Delivery Note,Billing Address Name,Nom de l'Adresse de Facturation
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22,Department Stores,Grands Magasins
-,Item Delivery Date,Date de Livraison de l'Article
-DocType: Production Plan,Material Requested,Matériel demandé
-DocType: Warehouse,PIN,PIN
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116,Error '{0}' occured. Arguments {1}.,Une erreur &#39;{0}&#39; s&#39;est produite. Arguments {1}.
-DocType: Bin,Reserved Qty for sub contract,Qté réservée pour le sous-contrat
-DocType: Sales Invoice,Base Change Amount (Company Currency),Montant de Base à Rendre (Devise de la Société)
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304,No accounting entries for the following warehouses,Pas d’écritures comptables pour les entrepôts suivants
-apps/erpnext/erpnext/projects/doctype/project/project.js +111,Save the document first.,Enregistrez le document d'abord.
-apps/erpnext/erpnext/shopping_cart/cart.py +74,Only {0} in stock for item {1},Seulement {0} en stock pour l&#39;article {1}
-DocType: Account,Chargeable,Facturable
-DocType: Company,Change Abbreviation,Changer l'Abréviation
-DocType: Expense Claim Detail,Expense Date,Date de la Note de Frais
-DocType: Item,Max Discount (%),Réduction Max (%)
-apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30,Credit Days cannot be a negative number,Les jours de crédit ne peuvent pas être un nombre négatif
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70,Last Order Amount,Montant de la Dernière Commande
-DocType: Cash Flow Mapper,e.g Adjustments for:,par exemple des ajustements pour:
-apps/erpnext/erpnext/stock/doctype/item/item.py +274," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item","{0} Conserver l&#39;échantillon est basé sur le lot, s&#39;il vous plaît vérifier A Lot non pour conserver l&#39;échantillon de l&#39;article"
-DocType: Task,Is Milestone,Est un Jalon
-DocType: Delivery Stop,Email Sent To,Email Envoyé À
-DocType: Budget,Warn,Avertir
-apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81,Are you sure you want to unregister?,Êtes-vous sûr de vouloir vous désinscrire?
-DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.","Toute autre remarque, effort remarquable qui devrait aller dans les dossiers."
-DocType: Asset Maintenance,Manufacturing User,Chargé de Fabrication
-DocType: Purchase Invoice,Raw Materials Supplied,Matières Premières Fournies
-DocType: C-Form,Series,Séries
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +283,Currency of the price list {0} must be {1} or {2},La devise de la liste de prix {0} doit être {1} ou {2}
-DocType: Appraisal,Appraisal Template,Modèle d&#39;évaluation
-DocType: Soil Texture,Ternary Plot,Tracé ternaire
-DocType: Item Group,Item Classification,Classification de l'Article
-DocType: Driver,License Number,Numéro de licence
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131,Business Development Manager,Directeur Commercial
-DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,Objectif de la Visite d'Entretien
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19,Invoice Patient Registration,Enregistrement de la Facture du Patient
-DocType: Crop,Period,Période
-apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +18,General Ledger,Grand Livre
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33,Employee {0} on Leave on {1},Employé {0} en Congé le {1}
-apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,Voir Prospects
-DocType: Program Enrollment Tool,New Program,Nouveau Programme
-DocType: Item Attribute Value,Attribute Value,Valeur de l'Attribut
-,Itemwise Recommended Reorder Level,Renouvellement Recommandé par Article
-DocType: Salary Detail,Salary Detail,Détails du Salaire
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1043,Please select {0} first,Veuillez d’abord sélectionner {0}
-DocType: Appointment Type,Physician,Médecin
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +858,Batch {0} of Item {1} has expired.,Lot {0} de l'Article {1} a expiré.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11,Consultations,Consultations
-DocType: Sales Invoice,Commission,Commission
-apps/erpnext/erpnext/config/manufacturing.py +27,Time Sheet for manufacturing.,Feuille de Temps pour la Fabrication.
-apps/erpnext/erpnext/templates/pages/cart.html +37,Subtotal,Sous-Total
-DocType: Physician,Charges,Charges
-DocType: Salary Detail,Default Amount,Montant par Défaut
-DocType: Lab Test Template,Descriptive,Descriptif
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95,Warehouse not found in the system,L'entrepôt n'a pas été trouvé dans le système
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115,This Month's Summary,Résumé Mensuel
-DocType: Quality Inspection Reading,Quality Inspection Reading,Libellé du Contrôle de Qualité
-apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25,`Freeze Stocks Older Than` should be smaller than %d days.,`Geler les stocks datant de plus` doit être inférieur à %d jours.
-DocType: Tax Rule,Purchase Tax Template,Modèle de Taxes pour les Achats
-apps/erpnext/erpnext/utilities/user_progress.py +45,Set a sales goal you'd like to achieve for your company.,Définissez l'objectif de ventes que vous souhaitez atteindre pour votre entreprise.
-,Project wise Stock Tracking,Suivi des Stocks par Projet
-DocType: GST HSN Code,Regional,Régional
-apps/erpnext/erpnext/config/healthcare.py +40,Laboratory,Laboratoire
-DocType: Stock Entry Detail,Actual Qty (at source/target),Qté Réelle (à la source/cible)
-DocType: Item Customer Detail,Ref Code,Code de Réf.
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75,Customer Group is Required in POS Profile,Le Groupe de Clients est Requis dans le Profil POS
-apps/erpnext/erpnext/config/hr.py +12,Employee records.,Dossiers de l'Employé.
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +98,Please set Next Depreciation Date,Veuillez définir la Prochaine Date d’Amortissement
-DocType: HR Settings,Payroll Settings,Réglages de la Paie
-apps/erpnext/erpnext/config/accounts.py +146,Match non-linked Invoices and Payments.,Rapprocher les Factures non liées avec les Paiements.
-DocType: POS Settings,POS Settings,Paramètres PDV
-apps/erpnext/erpnext/templates/pages/cart.html +16,Place Order,Passer la Commande
-DocType: Email Digest,New Purchase Orders,Nouveaux Bons de Commande
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24,Root cannot have a parent cost center,Racine ne peut pas avoir un centre de coûts parent
-apps/erpnext/erpnext/public/js/stock_analytics.js +57,Select Brand...,Sélectionner une Marque ...
-apps/erpnext/erpnext/public/js/setup_wizard.js +32,Non Profit (beta),Non lucratif (bêta)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18,Training Events/Results,Événements de Formation/Résultats
-apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152,Accumulated Depreciation as on,Amortissement Cumulé depuis
-DocType: Sales Invoice,C-Form Applicable,Formulaire-C Applicable
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +438,Operation Time must be greater than 0 for Operation {0},Temps de l'Opération doit être supérieur à 0 pour l'Opération {0}
-apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +106,Warehouse is mandatory,L'entrepôt est obligatoire
-DocType: Shareholder,Address and Contacts,Adresse et Contacts
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67,Failed to create website,Échec de la création du site Web
-DocType: Soil Analysis,Mg/K,Mg / K
-DocType: UOM Conversion Detail,UOM Conversion Detail,Détails de Conversion de l'UDM
-apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924,Retention Stock Entry already created or Sample Quantity not provided,Saisie de stock de rétention déjà créée ou quantité d&#39;échantillon non fournie
-DocType: Program,Program Abbreviation,Abréviation du Programme
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +426,Production Order cannot be raised against a Item Template,Ordre de Production ne peut être créé avec un Modèle d’Article
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52,Charges are updated in Purchase Receipt against each item,Les frais sont mis à jour dans le Reçu d'Achat pour chaque article
-DocType: Warranty Claim,Resolved By,Résolu Par
-DocType: Bank Guarantee,Start Date,Date de Début
-apps/erpnext/erpnext/config/hr.py +75,Allocate leaves for a period.,Allouer des congés pour une période.
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Cheques and Deposits incorrectly cleared,Chèques et Dépôts incorrectement compensés
-apps/erpnext/erpnext/accounts/doctype/account/account.py +46,Account {0}: You can not assign itself as parent account,Compte {0}: Vous ne pouvez pas assigner un compte comme son propre parent
-DocType: Purchase Invoice Item,Price List Rate,Taux de la Liste des Prix
-apps/erpnext/erpnext/utilities/activation.py +72,Create customer quotes,Créer les devis client
-DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.","Afficher ""En stock"" ou ""Pas en stock"" basé sur le stock disponible dans cet entrepôt."
-apps/erpnext/erpnext/config/manufacturing.py +38,Bill of Materials (BOM),Liste de Matériaux (LDM)
-DocType: Item,Average time taken by the supplier to deliver,Délai moyen de livraison par le fournisseur
-DocType: Sample Collection,Collected By,Collecté par
-apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35,Assessment Result,Résultat de l'Évaluation
-DocType: Hotel Room Package,Hotel Room Package,Forfait chambre d&#39;hôtel
-apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13,Hours,Heures
-DocType: Project,Expected Start Date,Date de Début Prévue
-DocType: Purchase Invoice,04-Correction in Invoice,04-Correction dans la facture
-apps/erpnext/erpnext/stock/doctype/item/item.js +60,Variant Details Report,Rapport détaillé des variantes
-DocType: Setup Progress Action,Setup Progress Action,Action de Progression de l'Installation
-apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36,Buying Price List,Liste de prix d&#39;achat
-apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49,Remove item if charges is not applicable to that item,Retirer l'article si les charges ne lui sont pas applicables
-apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21,Please select Maintenance Status as Completed or remove Completion Date,Veuillez sélectionner le statut de maintenance comme terminé ou supprimer la date de fin
-DocType: Supplier,Default Payment Terms Template,Modèle de termes de paiement par défaut
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34,Transaction currency must be same as Payment Gateway currency,La devise de la Transaction doit être la même que la devise de la Passerelle de Paiement
-DocType: Payment Entry,Receive,Recevoir
-apps/erpnext/erpnext/templates/pages/rfq.html +75,Quotations: ,Devis :
-DocType: Maintenance Visit,Fully Completed,Entièrement Complété
-apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}% Complété
-DocType: Employee,Educational Qualification,Qualification pour l'Éducation
-DocType: Workstation,Operating Costs,Coûts d'Exploitation
-DocType: Budget,Action if Accumulated Monthly Budget Exceeded,Action si le Budget Mensuel Cumulé est Dépassé
-DocType: Subscription,Submit on creation,Soumettre à la Création
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +476,Currency for {0} must be {1},Devise pour {0} doit être {1}
-DocType: Asset,Disposal Date,Date d’Élimination
-DocType: Daily Work Summary Settings,"Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.","Les Emails seront envoyés à tous les Employés Actifs de la société à l'heure donnée, s'ils ne sont pas en vacances. Le résumé des réponses sera envoyé à minuit."
-DocType: Employee Leave Approver,Employee Leave Approver,Approbateur des Congés de l'Employé
-apps/erpnext/erpnext/stock/doctype/item/item.py +509,Row {0}: An Reorder entry already exists for this warehouse {1},Ligne {0} : Une écriture de Réapprovisionnement existe déjà pour cet entrepôt {1}
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99,"Cannot declare as lost, because Quotation has been made.","Impossible de déclarer comme perdu, parce que le Devis a été fait."
-apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16,Training Feedback,Retour d'Expérience sur la Formation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +495,Production Order {0} must be submitted,L'Ordre de Production {0} doit être soumis
-DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,Critères de Fiche d'Évaluation Fournisseur
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149,Please select Start Date and End Date for Item {0},Veuillez sélectionner la Date de Début et Date de Fin pour l'Article {0}
-apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55,Course is mandatory in row {0},Cours est obligatoire à la ligne {0}
-apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,La date de fin ne peut être antérieure à la date de début
-DocType: Supplier Quotation Item,Prevdoc DocType,DocPréc DocType
-DocType: Cash Flow Mapper,Section Footer,Pied de section
-apps/erpnext/erpnext/stock/doctype/item/item.js +275,Add / Edit Prices,Ajouter / Modifier Prix
-DocType: Batch,Parent Batch,Lot Parent
-DocType: Cheque Print Template,Cheque Print Template,Modèles d'Impression de Chèques
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36,Chart of Cost Centers,Tableau des Centres de Coûts
-DocType: Lab Test Template,Sample Collection,Collecte d'Échantillons
-,Requested Items To Be Ordered,Articles Demandés à Commander
-apps/erpnext/erpnext/public/js/hub/hub_page.js +137,My Orders,Mes Commandes
-DocType: Price List,Price List Name,Nom de la Liste de Prix
-DocType: BOM,Manufacturing,Fabrication
-,Ordered Items To Be Delivered,Articles Commandés à Livrer
-DocType: Account,Income,Revenus
-DocType: Industry Type,Industry Type,Secteur d'Activité
-apps/erpnext/erpnext/templates/includes/cart.js +150,Something went wrong!,Quelque chose a mal tourné !
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +106,Warning: Leave application contains following block dates,Attention : la demande de congé contient les dates bloquées suivantes
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Sales Invoice {0} has already been submitted,La Facture Vente {0} a déjà été transmise
-DocType: Supplier Scorecard Scoring Criteria,Score,Score
-apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25,Fiscal Year {0} does not exist,Exercice Fiscal {0} n'existe pas
-DocType: Asset Maintenance Log,Completion Date,Date d'Achèvement
-DocType: Purchase Invoice Item,Amount (Company Currency),Montant (Devise de la Société)
-DocType: Agriculture Analysis Criteria,Agriculture User,Utilisateur de l&#39;agriculture
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38,Valid till date cannot be before transaction date,La date de validité ne peut pas être avant la date de transaction
-apps/erpnext/erpnext/stock/stock_ledger.py +381,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,{0} unités de {1} nécessaires dans {2} sur {3} {4} pour {5} pour compléter cette transaction.
-DocType: Fee Schedule,Student Category,Catégorie Étudiant
-DocType: Announcement,Student,Étudiant
-apps/erpnext/erpnext/config/hr.py +238,Organization unit (department) master.,Base d'unité d'organisation (département).
-DocType: Shipping Rule,Shipping Rule Type,Type de règle d&#39;expédition
-apps/erpnext/erpnext/utilities/user_progress.py +236,Go to Rooms,Aller aux Salles
-apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75,Please enter message before sending,Veuillez entrer le message avant d'envoyer
-DocType: Purchase Invoice,DUPLICATE FOR SUPPLIER,DUPLICATA POUR LE FOURNISSEUR
-DocType: Email Digest,Pending Quotations,Devis en Attente
-apps/erpnext/erpnext/config/accounts.py +318,Point-of-Sale Profile,Profil de Point-De-Vente
-apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +24,{0} should be a value between 0 and 100,{0} devrait être une valeur comprise entre 0 et 100
-apps/erpnext/erpnext/assets/doctype/asset/asset.py +94,Next Depreciation Date cannot be before Available-for-use Date,La prochaine date d&#39;amortissement ne peut être antérieure à la date de disponibilité.
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156,Unsecured Loans,Prêts Non Garantis
-DocType: Cost Center,Cost Center Name,Nom du centre de coûts
-DocType: Student,B+,B +
-DocType: HR Settings,Max working hours against Timesheet,Heures de Travail Max pour une Feuille de Temps
-DocType: Maintenance Schedule Detail,Scheduled Date,Date Prévue
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +209,Total Paid Amt,Mnt Total Payé
-DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,Message de plus de 160 caractères sera découpé en plusieurs messages
-DocType: Purchase Receipt Item,Received and Accepted,Reçus et Acceptés
-DocType: Hub Settings,Company and Seller Profile,Profil de l&#39;entreprise et du vendeur
-,GST Itemised Sales Register,Registre de Vente Détaillé GST
-DocType: Soil Texture,Silt Loam,Limon de limon
-,Serial No Service Contract Expiry,Expiration du Contrat de Service du N° de Série
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,You cannot credit and debit same account at the same time,Vous ne pouvez pas créditer et débiter le même compte simultanément
-DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,Le pouls d'un adulte est compris entre 50 et 80 battements par minute.
-DocType: Naming Series,Help HTML,Aide HTML
-DocType: Student Group Creation Tool,Student Group Creation Tool,Outil de Création de Groupe d'Étudiants
-DocType: Item,Variant Based On,Variante Basée Sur
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53,Total weightage assigned should be 100%. It is {0},Le total des pondérations attribuées devrait être de 100 %. Il est {0}
-apps/erpnext/erpnext/utilities/user_progress.py +106,Your Suppliers,Vos Fournisseurs
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6,Please correct the,Veuillez corriger le
-apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80,Cannot set as Lost as Sales Order is made.,Impossible de définir comme perdu alors qu'un Bon de Commande a été créé.
-DocType: Request for Quotation Item,Supplier Part No,N° de Pièce du Fournisseur
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',Vous ne pouvez pas déduire lorsqu'une catégorie est pour 'Évaluation' ou 'Évaluation et Total'
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370,Received From,Reçu De
-DocType: Lead,Converted,Converti
-DocType: Item,Has Serial No,A un N° de Série
-DocType: Employee,Date of Issue,Date d'Émission
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}","D'après les Paramètres d'Achat, si Reçu d'Achat Requis == 'OUI', alors l'utilisateur doit d'abord créer un Reçu d'Achat pour l'article {0} pour pouvoir créer une Facture d'Achat"
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167,Row #{0}: Set Supplier for item {1},Ligne #{0} : Définir Fournisseur pour l’article {1}
-apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121,Row {0}: Hours value must be greater than zero.,Ligne {0} : La valeur des heures doit être supérieure à zéro.
-apps/erpnext/erpnext/stock/doctype/item/item.py +194,Website Image {0} attached to Item {1} cannot be found,Image pour le Site Web {0} attachée à l'Article {1} ne peut pas être trouvée
-DocType: Issue,Content Type,Type de Contenu
-DocType: Asset,Assets,Actifs
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17,Computer,Ordinateur
-DocType: Item,List this Item in multiple groups on the website.,Liste cet article dans plusieurs groupes sur le site.
-DocType: Payment Term,Due Date Based On,Date d&#39;échéance basée sur
-apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +85,Please set default customer group and territory in Selling Settings,Configurez le groupe de clients et le territoire par défaut dans les paramètres de vente
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209,{0} {1} does not exist,{0} {1} n'existe pas
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323,Please check Multi Currency option to allow accounts with other currency,Veuillez vérifier l'option Multi-Devises pour permettre les comptes avec une autre devise
-apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +87,Item: {0} does not exist in the system,Article : {0} n'existe pas dans le système
-apps/erpnext/erpnext/accounts/doctype/account/account.py +106,You are not authorized to set Frozen value,Vous n'êtes pas autorisé à définir des valeurs gelées
-DocType: Payment Reconciliation,Get Unreconciled Entries,Obtenir les Écritures non Réconcilliées
-DocType: Payment Reconciliation,From Invoice Date,De la Date de la Facture
-DocType: Healthcare Settings,Laboratory Settings,Paramètres de laboratoire
-apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97,Successfully Set Supplier,Définir avec succès le fournisseur
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75,Leave Encashment,Congés Accumulés à Encaisser
-apps/erpnext/erpnext/public/js/setup_wizard.js +114,What does it do?,Qu'est-ce que ça fait ?
-DocType: Crop,Byproducts,"Sous-produits, dérivé"
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +84,To Warehouse,À l'Entrepôt
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26,All Student Admissions,Toutes les Admissions des Étudiants
-,Average Commission Rate,Taux Moyen de la Commission
-DocType: Share Balance,No of Shares,Nombre d&#39;actions
-apps/erpnext/erpnext/stock/doctype/item/item.py +447,'Has Serial No' can not be 'Yes' for non-stock item,'A un Numéro de Série' ne peut pas être 'Oui' pour un article hors-stock
-apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +62,Select Status,Sélectionnez le Statut
-apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41,Attendance can not be marked for future dates,La présence ne peut pas être marquée pour les dates à venir
-DocType: Pricing Rule,Pricing Rule Help,Aide pour les Règles de Tarification
-DocType: School House,House Name,Nom de la Maison
-DocType: Fee Schedule,Total Amount per Student,Montant total par étudiant
-DocType: Purchase Taxes and Charges,Account Head,Compte Principal
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153,Electrical,Électrique
-apps/erpnext/erpnext/utilities/activation.py +100,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,Ajouter le reste de votre organisation en tant qu'utilisateurs. Vous pouvez aussi inviter des Clients sur votre portail en les ajoutant depuis les Contacts
-DocType: Stock Entry,Total Value Difference (Out - In),Différence Valeur Totale (Sor - En)
-DocType: Grant Application,Requested Amount,Quantité exigée
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348,Row {0}: Exchange Rate is mandatory,Ligne {0} : Le Taux de Change est obligatoire
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},ID de l'Utilisateur non défini pour l'Employé {0}
-DocType: Vehicle,Vehicle Value,Valeur du Véhicule
-DocType: Crop Cycle,Detected Diseases,Maladies détectées
-DocType: Stock Entry,Default Source Warehouse,Entrepôt Source par Défaut
-DocType: Item,Customer Code,Code Client
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +220,Birthday Reminder for {0},Rappel d'Anniversaire pour {0}
-DocType: Asset Maintenance Task,Last Completion Date,Dernière date d&#39;achèvement
-apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72,Days Since Last Order,Jours Depuis la Dernière Commande
-apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365,Debit To account must be a Balance Sheet account,Le compte de débit doit être un compte de Bilan
-DocType: Buying Settings,Naming Series,Nom de la Série
-DocType: Leave Block List,Leave Block List Name,Nom de la Liste de Blocage des Congés
-apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14,Insurance Start date should be less than Insurance End date,Date de Début d'Assurance devrait être antérieure à la Date de Fin d'Assurance
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,Actifs du Stock
-DocType: Timesheet,Production Detail,Détails de la Production
-DocType: Restaurant,Active Menu,Menu Actif
-DocType: Target Detail,Target Qty,Qté Cible
-DocType: Shopping Cart Settings,Checkout Settings,Réglages Règlement
-DocType: Student Attendance,Present,Présent
-apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37,Delivery Note {0} must not be submitted,Bon de Livraison {0} ne doit pas être soumis
-DocType: Notification Control,Sales Invoice Message,Message de la Facture de Vente
-apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27,Closing Account {0} must be of type Liability / Equity,Le Compte Clôturé {0} doit être de type Passif / Capitaux Propres
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +324,Salary Slip of employee {0} already created for time sheet {1},Fiche de Paie de l'employé {0} déjà créée pour la feuille de temps {1}
-DocType: Vehicle Log,Odometer,Odomètre
-DocType: Production Plan Item,Ordered Qty,Qté Commandée
-apps/erpnext/erpnext/stock/doctype/item/item.py +743,Item {0} is disabled,Article {0} est désactivé
-DocType: Stock Settings,Stock Frozen Upto,Stock Gelé Jusqu'au
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930,BOM does not contain any stock item,LDM ne contient aucun article en stock
-DocType: Chapter,Chapter Head,Chef de chapitre
-DocType: Payment Term,Month(s) after the end of the invoice month,Mois (s) après la fin du mois de la facture
-apps/erpnext/erpnext/config/projects.py +19,Project activity / task.,Activité du projet / tâche.
-DocType: Vehicle Log,Refuelling Details,Détails de Ravitaillement
-apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,Générer les Fiches de Paie
-apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +24,Lab result datetime cannot be before testing datetime,Le résultat de laboratoire datetime ne peut pas être avant de tester datetime
-DocType: POS Profile,Allow user to edit Discount,Autoriser l&#39;utilisateur à modifier
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55,Get customers from,Obtenez des clients de
-DocType: Production Plan Item,Include Exploded Items,Inclure les éléments éclatés
-apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45,"Buying must be checked, if Applicable For is selected as {0}","Achat doit être vérifié, si Applicable Pour {0} est sélectionné"
-apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,La remise doit être inférieure à 100
-DocType: Shipping Rule,Restrict to Countries,Restreindre aux pays
-DocType: Purchase Invoice,Write Off Amount (Company Currency),Montant de la Reprise (Devise Société)
-DocType: Sales Invoice Timesheet,Billing Hours,Heures Facturées
-DocType: Project,Total Sales Amount (via Sales Order),Montant total des ventes (via la commande client)
-apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +548,Default BOM for {0} not found,LDM par défaut {0} introuvable
-apps/erpnext/erpnext/stock/doctype/item/item.py +513,Row #{0}: Please set reorder quantity,Ligne #{0} : Veuillez définir la quantité de réapprovisionnement
-apps/erpnext/erpnext/public/js/pos/pos.html +20,Tap items to add them here,Choisissez des articles pour les ajouter ici
-DocType: Fees,Program Enrollment,Inscription au Programme
-DocType: Share Transfer,To Folio No,Pour Folio Non
-DocType: Landed Cost Voucher,Landed Cost Voucher,Référence de Coût au Débarquement
-apps/erpnext/erpnext/public/js/queries.js +39,Please set {0},Veuillez définir {0}
-apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37,{0} - {1} is inactive student,{0} - {1} est un étudiant inactif
-DocType: Employee,Health Details,Détails de Santé
-apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24,To create a Payment Request reference document is required,"Pour créer une Demande de Paiement, un document de référence est requis"
-DocType: Soil Texture,Sandy Clay,Sol argileux
-DocType: Grant Application,Assessment  Manager,Gestionnaire d&#39;évaluation
-DocType: Payment Entry,Allocate Payment Amount,Allouer le Montant du Paiement
-DocType: Employee External Work History,Salary,Salaire
-DocType: Serial No,Delivery Document Type,Type de Document de Livraison
-DocType: Sales Order,Partly Delivered,Livré en Partie
-DocType: Item Variant Settings,Do not update variants on save,Ne pas mettre à jour les variantes lors de la sauvegarde
-DocType: Email Digest,Receivables,Créances
-DocType: Lead Source,Lead Source,Source du Prospect
-DocType: Customer,Additional information regarding the customer.,Informations supplémentaires concernant le client.
-DocType: Quality Inspection Reading,Reading 5,Reading 5
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +231,"{0} {1} is associated with {2}, but Party Account is {3}","{0} {1} est associé à {2}, mais le compte tiers est {3}"
-apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7,View Lab Tests,Afficher les tests de laboratoire
-DocType: Purchase Invoice,Y,Y
-DocType: Maintenance Visit,Maintenance Date,Date de l'Entretien
-DocType: Purchase Invoice Item,Rejected Serial No,N° de Série Rejeté
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82,Year start date or end date is overlapping with {0}. To avoid please set company,Année de début ou de fin chevauche avec {0}. Pour l'éviter veuillez définir la société
-apps/erpnext/erpnext/selling/doctype/customer/customer.py +129,Please mention the Lead Name in Lead {0},Veuillez mentionner le nom du Prospect dans le Prospect {0}
-apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156,Start date should be less than end date for Item {0},La date de début doit être antérieure à la date de fin pour l'Article {0}
-DocType: Item,"Example: ABCD.#####
-If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.","Exemple:. ABCD ##### Si la série est définie et que le N° de série n'est pas mentionné dans les transactions, alors un numéro de série automatique sera créé basé sur cette série. Si vous voulez toujours mentionner explicitement les numéros de série pour ce produit. laissez ce champ vide."
-DocType: Upload Attendance,Upload Attendance,Charger Fréquentation
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +571,BOM and Manufacturing Quantity are required,LDM et Quantité de Fabrication sont nécessaires
-apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,Balance Agée 2
-DocType: SG Creation Tool Course,Max Strength,Force Max
-apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28,Installing presets,Installation de presets
-apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85,No Delivery Note selected for Customer {},Aucune note de livraison sélectionnée pour le client {}
-apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25,BOM replaced,LDM Remplacée
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1043,Select Items based on Delivery Date,Sélectionnez les articles en fonction de la Date de Livraison
-DocType: Grant Application,Has any past Grant Record,A un record de subvention passé
-,Sales Analytics,Analyse des Ventes
-apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127,Available {0},Disponible {0}
-,Prospects Engaged But Not Converted,Prospects Contactés mais non Convertis
-DocType: Manufacturing Settings,Manufacturing Settings,Paramètres de Fabrication
-apps/erpnext/erpnext/config/setup.py +56,Setting up Email,Configurer l'Email
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57,Guardian1 Mobile No,N° du Mobile du Tuteur 1
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106,Please enter default currency in Company Master,Veuillez entrer la devise par défaut dans les Données de Base de la Société
-DocType: Stock Entry Detail,Stock Entry Detail,Détails de l'Écriture de Stock
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109,Daily Reminders,Rappels Quotidiens
-DocType: Products Settings,Home Page is Products,La Page d'Accueil est Produits
-,Asset Depreciation Ledger,Livre d'Amortissements d'Actifs
-apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +90,Tax Rule Conflicts with {0},Règle de Taxation est en Conflit avec {0}
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25,New Account Name,Nouveau Nom de Compte
-DocType: Purchase Invoice Item,Raw Materials Supplied Cost,Coût des Matières Premières Fournies
-DocType: Selling Settings,Settings for Selling Module,Réglages pour le Module Vente
-DocType: Hotel Room Reservation,Hotel Room Reservation,Réservation de chambre d&#39;hôtel
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115,Customer Service,Service Client
-DocType: BOM,Thumbnail,Vignette
-DocType: Item Customer Detail,Item Customer Detail,Détail de l'Article Client
-apps/erpnext/erpnext/config/hr.py +50,Offer candidate a Job.,Proposer un Emploi au candidat
-DocType: Notification Control,Prompt for Email on Submission of,Demander l’Email lors de la Soumission de
-apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88,Total allocated leaves are more than days in the period,Le Total des feuilles attribuées est supérieur au nombre de jours dans la période
-DocType: Land Unit,Linked Soil Analysis,Analyse de sol liée
-DocType: Pricing Rule,Percentage,Pourcentage
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70,Item {0} must be a stock Item,L'article {0} doit être un article en stock
-DocType: Manufacturing Settings,Default Work In Progress Warehouse,Entrepôt de Travail en Cours par Défaut
-apps/erpnext/erpnext/config/accounts.py +288,Default settings for accounting transactions.,Paramètres par défaut pour les opérations comptables .
-DocType: Maintenance Visit,MV,MV
-DocType: Restaurant,Default Tax Template,Modèle de Taxes par Défaut
-apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66,{0} Students have been enrolled,{0} Les étudiants ont été inscrits
-DocType: Fees,Student Details,Détails de l'Étudiant
-DocType: Purchase Invoice Item,Stock Qty,Qté en Stock
-DocType: Employee Loan,Repayment Period in Months,Période de Remboursement en Mois
-apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26,Error: Not a valid id?,Erreur : Pas un identifiant valide ?
-DocType: Naming Series,Update Series Number,Mettre à Jour la Série
-DocType: Account,Equity,Capitaux Propres
-apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}: Compte {2} de type ‘Pertes et Profits’ non admis en Écriture d’Ouverture
-DocType: Sales Order,Printing Details,Détails d'Impression
-DocType: Task,Closing Date,Date de Clôture
-DocType: Sales Order Item,Produced Quantity,Quantité Produite
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126,Engineer,Ingénieur
-DocType: Journal Entry,Total Amount Currency,Montant Total en Devise
-apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38,Search Sub Assemblies,Rechercher les Sous-Ensembles
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171,Item Code required at Row No {0},Code de l'Article est requis à la Ligne No {0}
-DocType: GST Account,SGST Account,Compte SGST
-apps/erpnext/erpnext/utilities/user_progress.py +151,Go to Items,Aller aux Articles
-DocType: Sales Partner,Partner Type,Type de Partenaire
-DocType: Purchase Taxes and Charges,Actual,Réel
-DocType: Restaurant Menu,Restaurant Manager,Gérant de restaurant
-DocType: Authorization Rule,Customerwise Discount,Remise en fonction du Client
-apps/erpnext/erpnext/config/projects.py +41,Timesheet for tasks.,Feuille de Temps pour les tâches.
-DocType: Purchase Invoice,Against Expense Account,Pour le Compte de Charges
-DocType: Production Order,Production Order,Ordre de Production
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282,Installation Note {0} has already been submitted,Note d'Installation {0} à déjà été sousmise
-DocType: Bank Reconciliation,Get Payment Entries,Obtenir les Écritures de Paiement
-DocType: Quotation Item,Against Docname,Pour le docName
-DocType: SMS Center,All Employee (Active),Tous les Employés (Actifs)
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,Voir Maintenant
-DocType: BOM,Raw Material Cost,Coût de Matière Première
-DocType: Item Reorder,Re-Order Level,Niveau de Réapprovisionnement
-apps/erpnext/erpnext/projects/doctype/project/project.js +64,Gantt Chart,Diagramme de Gantt
-DocType: Crop Cycle,Cycle Type,Type de cycle
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99,Part-time,Temps-Partiel
-DocType: Employee,Applicable Holiday List,Liste de Vacances Valable
-DocType: Employee,Cheque,Chèque
-DocType: Training Event,Employee Emails,Emails de l'Employé
-apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +59,Series Updated,Série Mise à Jour
-apps/erpnext/erpnext/accounts/doctype/account/account.py +159,Report Type is mandatory,Le Type de Rapport est nécessaire
-DocType: Item,Serial Number Series,Séries de Numéros de Série
-apps/erpnext/erpnext/buying/utils.py +68,Warehouse is mandatory for stock Item {0} in row {1},L’entrepôt est obligatoire pour l'Article du stock {0} dans la ligne {1}
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45,Retail & Wholesale,Vente de Détail & en Gros
-DocType: Issue,First Responded On,Première Réponse Le
-DocType: Website Item Group,Cross Listing of Item in multiple groups,Liste Croisée d'Articles dans plusieurs groupes
-apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},La Date de Début et la Date de Fin de l'Exercice Fiscal sont déjà définies dans l'Année Fiscale {0}
-DocType: Projects Settings,Ignore User Time Overlap,Ignorer le chevauchement du temps utilisateur
-apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97,Clearance Date updated,Date de Compensation mise à jour
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +146,Split Batch,Lot Fractionné
-DocType: Stock Settings,Batch Identification,Identification par lots
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132,Successfully Reconciled,Réconcilié avec Succès
-DocType: Request for Quotation Supplier,Download PDF,Télécharger au Format PDF
-DocType: Production Order,Planned End Date,Date de Fin Prévue
-DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,Liste cachée maintenant la liste des contacts liés à l&#39;actionnaire
-apps/erpnext/erpnext/config/non_profit.py +63,Donor Type information.,Informations sur le type de donneur.
-DocType: Request for Quotation,Supplier Detail,Détails du Fournisseur
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100,Error in formula or condition: {0},Erreur dans la formule ou dans la condition : {0}
-apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +94,Invoiced Amount,Montant Facturé
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47,Criteria weights must add up to 100%,Le total des pondérations des critères doit être égal à 100%
-apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7,Attendance,Présence
-apps/erpnext/erpnext/public/js/pos/pos.html +104,Stock Items,Articles de Stock
-DocType: BOM,Materials,Matériels
-DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.","Si décochée, la liste devra être ajoutée à chaque département où elle doit être appliquée."
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111,Creating {0},Création de {0}
-apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28,Source and Target Warehouse cannot be same,Entrepôt Source et Destination ne peuvent pas être le même
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +573,Posting date and posting time is mandatory,La Date et l’heure de comptabilisation sont obligatoires
-apps/erpnext/erpnext/config/buying.py +76,Tax template for buying transactions.,Modèle de taxe pour les opérations d’achat.
-,Item Prices,Prix des Articles
-DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,En Toutes Lettres. Sera visible une fois que vous enregistrerez le Bon de Commande.
-DocType: Period Closing Voucher,Period Closing Voucher,Bon de Clôture de la Période
-DocType: Consultation,Review Details,Détails de l'Examen
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185,The shareholder does not belong to this company,L&#39;actionnaire n&#39;appartient pas à cette société
-DocType: Dosage Form,Dosage Form,Formulaire de Dosage
-apps/erpnext/erpnext/config/selling.py +67,Price List master.,Données de Base des Listes de Prix
-DocType: Task,Review Date,Date de Revue
-DocType: Company,Series for Asset Depreciation Entry (Journal Entry),Série pour la Dépréciation d'Actifs (Entrée de Journal)
-DocType: Membership,Member Since,Membre depuis
-DocType: Purchase Invoice,Advance Payments,Paiements Anticipés
-DocType: Purchase Taxes and Charges,On Net Total,Sur le Total Net
-apps/erpnext/erpnext/controllers/item_variant.py +92,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},Valeur pour l'attribut {0} doit être dans la gamme de {1} à {2} dans les incréments de {3} pour le poste {4}
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +175,Target warehouse in row {0} must be same as Production Order,L’Entrepôt cible à la ligne {0} doit être le même que dans l'Ordre de Production
-DocType: Restaurant Reservation,Waitlisted,En liste d'attente
-apps/erpnext/erpnext/accounts/doctype/account/account.py +124,Currency can not be changed after making entries using some other currency,Devise ne peut être modifiée après avoir fait des entrées en utilisant une autre devise
-DocType: Shipping Rule,Fixed,Fixé
-DocType: Vehicle Service,Clutch Plate,Plaque d'Embrayage
-DocType: Company,Round Off Account,Compte d’Arrondi
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Administrative Expenses,Charges Administratives
-apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18,Consulting,Consultant
-DocType: Customer Group,Parent Customer Group,Groupe Client Parent
-DocType: Journal Entry,Subscription,Abonnement
-DocType: Purchase Invoice,Contact Email,Email du Contact
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11,Fee Creation Pending,Création d'honoraires en attente
-DocType: Appraisal Goal,Score Earned,Score Gagné
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240,Notice Period,Période de Préavis
-DocType: Asset Category,Asset Category Name,Nom de Catégorie d'Actif
-apps/erpnext/erpnext/setup/doctype/territory/territory.js +13,This is a root territory and cannot be edited.,Il s’agit d’une région racine qui ne peut être modifiée.
-apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5,New Sales Person Name,Nouveau Nom de Commercial
-DocType: Packing Slip,Gross Weight UOM,UDM du Poids Brut
-DocType: Asset Maintenance Task,Preventive Maintenance,Maintenance préventive
-DocType: Delivery Note Item,Against Sales Invoice,Pour la Facture de Vente
-DocType: Purchase Invoice,07-Others,07-Autres
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151,Please enter serial numbers for serialized item ,Veuillez entrer les numéros de série pour l'élément sérialisé
-DocType: Bin,Reserved Qty for Production,Qté Réservée pour la Production
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43,EcritureNum,EcritureNum
-DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,Laisser désactivé si vous ne souhaitez pas considérer les lots en faisant des groupes basés sur les cours.
-DocType: Asset,Frequency of Depreciation (Months),Fréquence des Amortissements (Mois)
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500,Credit Account,Compte Créditeur
-DocType: Landed Cost Item,Landed Cost Item,Coût de l'Article au Débarquement
-apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57,Show zero values,Afficher les valeurs nulles
-DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Quantité de produit obtenue après fabrication / reconditionnement des quantités données de matières premières
-DocType: Lab Test,Test Group,Groupe de Test
-DocType: Payment Reconciliation,Receivable / Payable Account,Compte Débiteur / Créditeur
-DocType: Delivery Note Item,Against Sales Order Item,Pour l'Article de la Commande Client
-DocType: Company,Company Logo,Logo d&#39;entreprise
-apps/erpnext/erpnext/stock/doctype/item/item.py +708,Please specify Attribute Value for attribute {0},Veuillez spécifier une Valeur d’Attribut pour l'attribut {0}
-DocType: Item,Default Warehouse,Entrepôt par Défaut
-apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45,Budget cannot be assigned against Group Account {0},Budget ne peut pas être attribué pour le Compte de Groupe {0}
-DocType: Healthcare Settings,Patient Registration,Inscription du patient
-apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Please enter parent cost center,Veuillez entrer le centre de coût parent
-DocType: Delivery Note,Print Without Amount,Imprimer Sans Montant
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57,Depreciation Date,Date d’Amortissement
-DocType: Issue,Support Team,Équipe de Support
-apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36,Expiry (In Days),Expiration (En Jours)
-DocType: Appraisal,Total Score (Out of 5),Score Total (sur 5)
-DocType: Fee Structure,FS.,FS.
-DocType: Student Attendance Tool,Batch,Lot
-DocType: Donor,Donor Type,Type de donneur
-apps/erpnext/erpnext/stock/doctype/item/item.js +27,Balance,Solde
-apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66,Please select the Company,Veuillez sélectionner la société
-DocType: Room,Seating Capacity,Nombre de places
-DocType: Issue,ISS-,ISS-
-DocType: Lab Test Groups,Lab Test Groups,Groupes de test de laboratoire
-DocType: Project,Total Expense Claim (via Expense Claims),Total des Notes de Frais (via Notes de Frais)
-DocType: GST Settings,GST Summary,Résumé GST
-apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16,Please enable default incoming account before creating Daily Work Summary Group,Veuillez activer le compte entrant par défaut avant de créer le groupe de travail Résumé quotidien
-DocType: Assessment Result,Total Score,Score Total
-DocType: Journal Entry,Debit Note,Note de Débit
-DocType: Stock Entry,As per Stock UOM,Selon UDM du Stock
-apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,Non Expiré
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49,ValidDate,Date valide
-DocType: Student Log,Achievement,Réalisation
-DocType: Batch,Source Document Type,Type de Document Source
-apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24,Following course schedules were created,Les horaires de cours suivants ont été créés
-DocType: Journal Entry,Total Debit,Total Débit
-DocType: Manufacturing Settings,Default Finished Goods Warehouse,Entrepôt de Produits Finis par Défaut
-apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +124,Please select Patient,Veuillez sélectionner Patient
-apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76,Sales Person,Vendeur
-DocType: Hotel Room Package,Amenities,Équipements
-apps/erpnext/erpnext/config/accounts.py +233,Budget and Cost Center,Centre de Budget et Coûts
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65,Multiple default mode of payment is not allowed,De multiples modes de paiement par défaut ne sont pas autorisés
-apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5,for the,pour le
-,Appointment Analytics,Analyse des Rendez-Vous
-DocType: Vehicle Service,Half Yearly,Semestriel
-DocType: Lead,Blog Subscriber,Abonné au Blog
-DocType: Guardian,Alternate Number,Autre Numéro
-DocType: Healthcare Settings,Consultations in valid days,Consultations en Jours Ouvrés
-DocType: Assessment Plan Criteria,Maximum Score,Score Maximum
-apps/erpnext/erpnext/config/setup.py +83,Create rules to restrict transactions based on values.,Créer des règles pour restreindre les transactions basées sur les valeurs .
-DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,Comptes de cartographie des flux de trésorerie
-apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49, Group Roll No,N° de Rôle du Groupe
-DocType: Batch,Manufacturing Date,Date de fabrication
-apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9,Fee Creation Failed,La création des honoraires a échoué
-DocType: Opening Invoice Creation Tool,Create Missing Party,Créer une partie manquante
-DocType: Student Group Creation Tool,Leave blank if you make students groups per year,Laisser vide si vous faites des groupes d'étudiants par année
-DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si cochée, Le nombre total de Jours Ouvrés comprendra les vacances, ce qui réduira la valeur du Salaire Par Jour"
-DocType: Purchase Invoice,Total Advance,Total Avance
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27,Change Template Code,Modifier le Code du Modèle
-apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,La Date de Fin de Terme ne peut pas être antérieure à la Date de Début de Terme. Veuillez corriger les dates et essayer à nouveau.
-apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19,Quot Count,Compte de Devis
-,BOM Stock Report,Rapport de Stock de LDM
-DocType: Stock Reconciliation Item,Quantity Difference,Différence de Quantité
-DocType: Employee Advance,EA-,EA-
-DocType: Opportunity Item,Basic Rate,Taux de Base
-DocType: GL Entry,Credit Amount,Montant du Crédit
-DocType: Cheque Print Template,Signatory Position,Position Signataire
-apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173,Set as Lost,Définir comme Perdu
-DocType: Timesheet,Total Billable Hours,Total des Heures Facturables
-apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4,Payment Receipt Note,Bon de Réception du Paiement
-apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6,This is based on transactions against this Customer. See timeline below for details,Basé sur les transactions avec ce client. Voir la chronologie ci-dessous pour plus de détails
-apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},Ligne {0} : Le montant alloué {1} doit être inférieur ou égal au montant du Paiement {2}
-DocType: Program Enrollment Tool,New Academic Term,Nouveau terme académique
-,Course wise Assessment Report,Rapport d'Évaluation par Cours
-DocType: Purchase Invoice,Availed ITC State/UT Tax,État de taxe ITC / UT épuisé
-DocType: Tax Rule,Tax Rule,Règle de Taxation
-DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,Maintenir le Même Taux Durant le Cycle de Vente
-DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,Planifier les journaux de temps en dehors des Heures de Travail du Bureau.
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +120,Dr {0} does not have a Physician Schedule. Add it in Physician master,Le Dr {0} n'a pas d'emploi du temps. Ajoutez-en un dans ses données de base
-apps/erpnext/erpnext/public/js/pos/pos.html +87,Customers in Queue,Clients dans la File d'Attente
-DocType: Driver,Issuing Date,Date d&#39;émission
-DocType: Student,Nationality,Nationalité
-,Items To Be Requested,Articles À Demander
-DocType: Purchase Order,Get Last Purchase Rate,Obtenir le Dernier Tarif d'Achat
-DocType: Company,Company Info,Informations sur la Société
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1384,Select or add new customer,Sélectionner ou ajoutez nouveau client
-apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +171,Cost center is required to book an expense claim,Un centre de coût est requis pour comptabiliser une note de frais
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),Emplois des Ressources (Actifs)
-apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6,This is based on the attendance of this Employee,Basé sur la présence de cet Employé
-DocType: Assessment Result,Summary,Résumé
-apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112,Mark Attendance,Noter la Présence
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494,Debit Account,Compte de Débit
-DocType: Fiscal Year,Year Start Date,Date de Début de l'Exercice
-DocType: Attendance,Employee Name,Nom de l'Employé
-DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,Poste de commande de restaurant
-DocType: Purchase Invoice,Rounded Total (Company Currency),Total Arrondi (Devise Société)
-apps/erpnext/erpnext/accounts/doctype/account/account.py +96,Cannot covert to Group because Account Type is selected.,Conversion impossible en Groupe car le Type de Compte est sélectionné.
-apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260,{0} {1} has been modified. Please refresh.,{0} {1} a été modifié. Veuillez actualiser.
-DocType: Leave Block List,Stop users from making Leave Applications on following days.,Empêcher les utilisateurs de faire des Demandes de Congé les jours suivants.
-DocType: Asset Maintenance Team,Maintenance Team Members,Membres de l&#39;équipe de maintenance
-apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63,Purchase Amount,Montant de l'Achat
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261,Supplier Quotation {0} created,Devis Fournisseur {0} créé
-apps/erpnext/erpnext/accounts/report/financial_statements.py +101,End Year cannot be before Start Year,L'Année de Fin ne peut pas être avant l'Année de Début
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233,Employee Benefits,Avantages de l'Employé
-apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264,Packed quantity must equal quantity for Item {0} in row {1},La quantité emballée doit être égale à la quantité pour l'Article {0} à la ligne {1}
-DocType: Production Order,Manufactured Qty,Qté Fabriquée
-apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78,The shares don't exist with the {0},Les partages n&#39;existent pas avec le {0}
-apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64,Invoice Created,Facture Créée
-DocType: Asset,Out of Order,Hors service
-DocType: Purchase Receipt Item,Accepted Quantity,Quantité Acceptée
-DocType: Projects Settings,Ignore Workstation Time Overlap,Ignorer le chevauchement de temps de poste de travail
-apps/erpnext/erpnext/hr/doctype/employee/employee.py +242,Please set a default Holiday List for Employee {0} or Company {1},Veuillez définir une Liste de Vacances par défaut pour l'Employé {0} ou la Société {1}
-apps/erpnext/erpnext/accounts/party.py +31,{0}: {1} does not exists,{0} : {1} n’existe pas
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76,Select Batch Numbers,Sélectionnez les Numéros de Lot
-apps/erpnext/erpnext/config/accounts.py +12,Bills raised to Customers.,Factures émises pour des Clients.
-apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,ID du Projet
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},Ligne N° {0}: Le montant ne peut être supérieur au Montant en Attente pour la Note de Frais {1}. Le Montant en Attente est de {2}
-DocType: Assessment Plan,Schedule,Calendrier
-DocType: Account,Parent Account,Compte Parent
-apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266,Available,disponible
-DocType: Quality Inspection Reading,Reading 3,Reading 3
-,Hub,Hub
-DocType: GL Entry,Voucher Type,Type de Référence
-apps/erpnext/erpnext/accounts/page/pos/pos.js +1716,Price List not found or disabled,Liste de Prix introuvable ou desactivée
-DocType: Student Applicant,Approved,Approuvé
-apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15,Price,Prix
-apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +266,Employee relieved on {0} must be set as 'Left',Employé dégagé de {0} doit être défini comme 'Gauche'
-DocType: Hub Settings,Last Sync On,Dernière synchronisation le
-DocType: Guardian,Guardian,Tuteur
-DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,Créer un client ou un fournisseur manquant
-apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42,Appraisal {0} created for Employee {1} in the given date range,Évaluation {0} créée pour l'Employé {1} dans l'intervalle de dates donné
-DocType: Academic Term,Education,Education
-apps/erpnext/erpnext/public/js/pos/pos.html +78,Del,Supp
-DocType: Selling Settings,Campaign Naming By,Campagne Nommée Par
-DocType: Employee,Current Address Is,L'Adresse Actuelle est
-apps/erpnext/erpnext/utilities/user_progress.py +48,Monthly Sales Target (,Objectif de vente mensuel (
-apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9,modified,modifié
-apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43,"Optional. Sets company's default currency, if not specified.","Optionnel. Défini la devise par défaut de l'entreprise, si non spécifié."
-DocType: Sales Invoice,Customer GSTIN,GSTIN Client
-DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,"Liste des maladies détectées sur le terrain. Une fois sélectionné, il ajoutera automatiquement une liste de tâches pour faire face à la maladie"
-DocType: Asset Repair,Repair Status,État de réparation
-apps/erpnext/erpnext/config/accounts.py +67,Accounting journal entries.,Les écritures comptables.
-DocType: Delivery Note Item,Available Qty at From Warehouse,Qté Disponible Depuis l'Entrepôt
-DocType: POS Profile,Account for Change Amount,Compte pour le Rendu de Monnaie
-DocType: Purchase Invoice,input service,service d&#39;entrée
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},Ligne {0} : Tiers / Compte ne correspond pas à {1} / {2} en {3} {4}
-DocType: Maintenance Team Member,Maintenance Team Member,Membre de l&#39;équipe de maintenance
-DocType: Agriculture Analysis Criteria,Soil Analysis,Analyse du sol
-apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13,Course Code: ,Code du Cours:
-apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240,Please enter Expense Account,Veuillez entrer un Compte de Charges
-DocType: Account,Stock,Stock
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1068,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry","Ligne #{0} : Type de Document de Référence doit être un Bon de Commande, une Facture d'Achat ou une Écriture de Journal"
-DocType: Employee,Current Address,Adresse Actuelle
-DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified","Si l'article est une variante d'un autre article, alors la description, l'image, le prix, les taxes etc seront fixés à partir du modèle sauf si spécifiés explicitement"
-DocType: Serial No,Purchase / Manufacture Details,Achat / Fabrication Détails
-DocType: Assessment Group,Assessment Group,Groupe d'Évaluation
-apps/erpnext/erpnext/config/stock.py +329,Batch Inventory,Inventaire du Lot
-DocType: Employee,Contract End Date,Date de Fin de Contrat
-DocType: Sales Order,Track this Sales Order against any Project,Suivre cette Commande de Vente pour tous les Projets
-DocType: Sales Invoice Item,Discount and Margin,Remise et Marge
-DocType: Lab Test,Prescription,Ordonnance
-apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +98,Not Available,Indisponible
-DocType: Pricing Rule,Min Qty,Qté Min
-apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36,Disable Template,Désactiver le Modèle
-DocType: GL Entry,Transaction Date,Date de la Transaction
-DocType: Production Plan Item,Planned Qty,Qté Planifiée
-apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121,Total Tax,Total des Taxes
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +191,For Quantity (Manufactured Qty) is mandatory,Pour Quantité (Qté Fabriqué) est obligatoire
-DocType: Stock Entry,Default Target Warehouse,Entrepôt Cible par Défaut
-DocType: Purchase Invoice,Net Total (Company Currency),Total Net (Devise Société)
-apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,La Date de Fin d'Année ne peut pas être antérieure à la Date de Début d’Année. Veuillez corriger les dates et essayer à nouveau.
-DocType: Notification Control,Purchase Receipt Message,Message du Reçu d’Achat
-DocType: BOM,Scrap Items,Mettre au Rebut des Articles
-DocType: Production Order,Actual Start Date,Date de Début Réelle
-DocType: Sales Order,% of materials delivered against this Sales Order,% de matériaux livrés pour cette Commande Client
-apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62,Set default mode of payment,Définir le mode de paiement par défaut
-DocType: Grant Application,Withdrawn,Retiré
-DocType: Hub Settings,Hub Settings,Paramètres du Hub
-DocType: Project,Gross Margin %,Marge Brute %
-DocType: BOM,With Operations,Avec des Opérations
-apps/erpnext/erpnext/accounts/party.py +260,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,Des écritures comptables ont déjà été réalisées en devise {0} pour la société {1}. Veuillez sélectionner un compte de crédit ou de débit  en devise {0}.
-DocType: Asset,Is Existing Asset,Est Actif Existant
-DocType: Salary Detail,Statistical Component,Composante Statistique
-DocType: Warranty Claim,If different than customer address,Si différente de l'adresse du client
-DocType: Purchase Invoice,Without Payment of Tax,Sans Paiement de Taxe
-DocType: BOM Operation,BOM Operation,Opération LDM
-apps/erpnext/erpnext/config/stock.py +141,Fulfilment,Accomplissement
-DocType: Purchase Taxes and Charges,On Previous Row Amount,Le Montant de la Rangée Précédente
-DocType: Item,Has Expiry Date,A une date d'expiration
-apps/erpnext/erpnext/assets/doctype/asset/asset.js +282,Transfer Asset,Transfert d'Actifs
-DocType: POS Profile,POS Profile,Profil PDV
-DocType: Training Event,Event Name,Nom de l'Événement
-DocType: Physician,Phone (Office),Téléphone (Bureau)
-apps/erpnext/erpnext/hooks.py +151,Admission,Admission
-apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29,Admissions for {0},Admissions pour {0}
-apps/erpnext/erpnext/config/accounts.py +257,"Seasonality for setting budgets, targets etc.","Saisonnalité de l'établissement des budgets, des objectifs, etc."
-DocType: Supplier Scorecard Scoring Variable,Variable Name,Nom de la Variable
-apps/erpnext/erpnext/stock/get_item_details.py +144,"Item {0} is a template, please select one of its variants","L'article {0} est un modèle, veuillez sélectionner l'une de ses variantes"
-DocType: Asset,Asset Category,Catégorie d'Actif
-apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31,Net pay cannot be negative,Salaire Net ne peut pas être négatif
-DocType: Purchase Order,Advance Paid,Avance Payée
-DocType: Item,Item Tax,Taxe sur l'Article
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874,Material to Supplier,Du Matériel au Fournisseur
-DocType: Soil Texture,Loamy Sand,Sable limoneux
-DocType: Production Plan,Material Request Planning,Planification des demandes de matériel
-apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +630,Excise Invoice,Facture d'Accise
-apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16,Treshold {0}% appears more than once,Le seuil {0}% apparaît plus d'une fois
-DocType: Expense Claim,Employees Email Id,Identifiants Email des employés
-DocType: Employee Attendance Tool,Marked Attendance,Présence Validée
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138,Current Liabilities,Dettes Actuelles
-apps/erpnext/erpnext/config/selling.py +292,Send mass SMS to your contacts,Envoyer un SMS en masse à vos contacts
-DocType: Patient,A Positive,A Positif
-DocType: Program,Program Name,Nom du Programme
-DocType: Purchase Taxes and Charges,Consider Tax or Charge for,Tenir Compte de la Taxe et des Frais pour
-DocType: Driver,Driving License Category,Catégorie de permis de conduire
-apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158,No Reference,Aucune référence
-apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57,Actual Qty is mandatory,Qté Réelle est obligatoire
-apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0} est actuellement associé avec une fiche d'évaluation fournisseur {1}. Les bons de commande pour ce fournisseur doivent être édités avec précaution.
-DocType: Asset Maintenance Team,Asset Maintenance Team,Équipe de Maintenance des Actifs
-DocType: Employee Loan,Loan Type,Type de Prêt
-DocType: Scheduling Tool,Scheduling Tool,Outil de Planification
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180,Credit Card,Carte de Crédit
-DocType: BOM,Item to be manufactured or repacked,Article à manufacturer ou à réemballer
-DocType: Employee Education,Major/Optional Subjects,Sujets Principaux / En Option
-DocType: Sales Invoice Item,Drop Ship,Expédition Directe
-DocType: Driver,Suspended,Suspendu
-DocType: Training Event,Attendees,Participants
-DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children","Ici vous pouvez conserver les détails familiaux comme le nom et la profession des parents, le conjoint et les enfants"
-DocType: Academic Term,Term End Date,Date de Fin du Terme
-DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),Taxes et Frais Déductibles (Devise Société)
-DocType: Item Group,General Settings,Paramètres Généraux
-apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23,From Currency and To Currency cannot be same,La Devise de Base et la Devise de Cotation ne peuvent pas identiques
-DocType: Stock Entry,Repack,Ré-emballer
-apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,Vous devez sauvegarder le formulaire avant de continuer
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113,Please select the Company first,Veuillez sélectionner la Société en premier
-DocType: Item Attribute,Numeric Values,Valeurs Numériques
-apps/erpnext/erpnext/public/js/setup_wizard.js +56,Attach Logo,Joindre le Logo
-apps/erpnext/erpnext/stock/doctype/batch/batch.js +51,Stock Levels,Niveaux du Stocks
-DocType: Customer,Commission Rate,Taux de Commission
-apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187,Created {0} scorecards for {1} between: ,{0} fiches d'évaluations créées pour {1} entre:
-apps/erpnext/erpnext/stock/doctype/item/item.js +475,Make Variant,Faire une Variante
-apps/erpnext/erpnext/config/hr.py +87,Block leave applications by department.,Bloquer les demandes de congé par département
-apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +150,"Payment Type must be one of Receive, Pay and Internal Transfer","Type de Paiement doit être Recevoir, Payer ou Transfert Interne"
-apps/erpnext/erpnext/config/selling.py +179,Analytics,Analytique
-apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25,Cart is Empty,Le panier est Vide
-DocType: Vehicle,Model,Modèle
-DocType: Production Order,Actual Operating Cost,Coût d'Exploitation Réel
-DocType: Payment Entry,Cheque/Reference No,Chèque/N° de Référence
-DocType: Soil Texture,Clay Loam,Terreau d&#39;argile
-apps/erpnext/erpnext/accounts/doctype/account/account.py +81,Root cannot be edited.,La Racine ne peut pas être modifiée.
-DocType: Item,Units of Measure,Unités de Mesure
-DocType: Manufacturing Settings,Allow Production on Holidays,Autoriser la Fabrication pendant les Vacances
-DocType: Sales Invoice,Customer's Purchase Order Date,Date du Bon de Commande du Client
-apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163,Capital Stock,Capital Social
-DocType: Shopping Cart Settings,Show Public Attachments,Afficher les Pièces Jointes Publiques
-DocType: Packing Slip,Package Weight Details,Détails du Poids du Paquet
-DocType: Restaurant Reservation,Reservation Time,Heure de réservation
-DocType: Payment Gateway Account,Payment Gateway Account,Compte Passerelle de Paiement
-DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,"Le paiement terminé, rediriger l'utilisateur vers la page sélectionnée."
-DocType: Company,Existing Company,Société Existante
-DocType: Healthcare Settings,Result Emailed,Résultat envoyé par Email
-apps/erpnext/erpnext/controllers/buying_controller.py +87,"Tax Category has been changed to ""Total"" because all the Items are non-stock items","La Catégorie de Taxe a été changée à ""Total"" car tous les articles sont des articles hors stock"
-apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103,Please select a csv file,Veuillez sélectionner un fichier csv
-DocType: Student Leave Application,Mark as Present,Marquer comme Présent
-DocType: Supplier Scorecard,Indicator Color,Couleur de l'Indicateur
-DocType: Purchase Order,To Receive and Bill,À Recevoir et Facturer
-apps/erpnext/erpnext/controllers/buying_controller.py +455,Row #{0}: Reqd by Date cannot be before Transaction Date,La ligne # {0}: Reqd par date ne peut pas être antérieure à la date de la transaction
-apps/erpnext/erpnext/templates/pages/home.html +14,Featured Products,Produits Présentés
-apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136,Designer,Designer
-apps/erpnext/erpnext/config/selling.py +163,Terms and Conditions Template,Modèle des Termes et Conditions
-DocType: Serial No,Delivery Details,Détails de la Livraison
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495,Cost Center is required in row {0} in Taxes table for type {1},Le Centre de Coûts est requis à la ligne {0} dans le tableau des Taxes pour le type {1}
-DocType: Program,Program Code,Code du Programme
-DocType: Terms and Conditions,Terms and Conditions Help,Aide des Termes et Conditions
-,Item-wise Purchase Register,Registre des Achats par Article
-DocType: Driver,Expiry Date,Date d'expiration
-DocType: Healthcare Settings,Employee name and designation in print,Nom et désignation de l'employé sur l'imprimé
-,accounts-browser,navigateur-de-comptes
-apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368,Please select Category first,Veuillez d’abord sélectionner une Catégorie
-apps/erpnext/erpnext/config/projects.py +13,Project master.,Données de Base du Projet.
-apps/erpnext/erpnext/controllers/status_updater.py +209,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.","Pour permettre la sur-facturation ou la sur-commande, mettez à jour ""Indulgence"" dans les Paramètres de Stock ou dans l’Article."
-DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,"Ne plus afficher le symbole (tel que $, €...) à côté des montants."
-apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431, (Half Day),(Demi-Journée)
-DocType: Payment Term,Credit Days,Jours de Crédit
-apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145,Please select Patient to get Lab Tests,Veuillez sélectionner Patient pour obtenir des tests de laboratoire
-apps/erpnext/erpnext/utilities/activation.py +128,Make Student Batch,Créer un Lot d'Étudiant
-DocType: Fee Schedule,FRQ.,FRQ.
-DocType: Leave Type,Is Carry Forward,Est un Report
-apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841,Get Items from BOM,Obtenir les Articles depuis LDM
-apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Lead Time Days,Jours de Délai
-DocType: Cash Flow Mapping,Is Income Tax Expense,Est-ce que l&#39;impôt sur le revenu est
-apps/erpnext/erpnext/controllers/accounts_controller.py +620,Row #{0}: Posting Date must be same as purchase date {1} of asset {2},Ligne #{0} : La Date de Comptabilisation doit être la même que la date d'achat {1} de l’actif {2}
-DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,Vérifiez si l'Étudiant réside à la Résidence de l'Institut.
-apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125,Please enter Sales Orders in the above table,Veuillez entrer des Commandes Clients dans le tableau ci-dessus
-,Stock Summary,Résumé du Stock
-apps/erpnext/erpnext/config/assets.py +54,Transfer an asset from one warehouse to another,Transfert d'un actif d'un entrepôt à un autre
-DocType: Vehicle,Petrol,Essence
-apps/erpnext/erpnext/config/learn.py +217,Bill of Materials,Liste de Matériaux
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Row {0}: Party Type and Party is required for Receivable / Payable account {1},Ligne {0} : Le Type de Tiers et le Tiers sont requis pour le compte Débiteur / Créditeur {1}
-apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94,Ref Date,Date de Réf.
-DocType: Employee,Reason for Leaving,Raison du Départ
-DocType: BOM Operation,Operating Cost(Company Currency),Coût d'Exploitation (Devise Société)
-DocType: Employee Loan Application,Rate of Interest,Taux d'Intérêt
-DocType: Expense Claim Detail,Sanctioned Amount,Montant Approuvé
-DocType: Item,Shelf Life In Days,Durée de conservation en jours
-DocType: GL Entry,Is Opening,Écriture d'Ouverture
-apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196,Row {0}: Debit entry can not be linked with a {1},Ligne {0} : L’Écriture de Débit ne peut pas être lié à un {1}
-DocType: Journal Entry,Subscription Section,Section Abonnement
-apps/erpnext/erpnext/accounts/doctype/account/account.py +177,Account {0} does not exist,Compte {0} n'existe pas
-DocType: Training Event,Training Program,Programme de formation
-DocType: Account,Cash,Espèces
-DocType: Employee,Short biography for website and other publications.,Courte biographie pour le site web et d'autres publications.
+b'DocType: Employee',b'Salary Mode',b'Mode de R\xc3\xa9mun\xc3\xa9ration'
+b'DocType: Patient',b'Divorced',b'Divorc\xc3\xa9'
+b'DocType: Buying Settings',b'Allow Item to be added multiple times in a transaction',b'Autoriser un article \xc3\xa0 \xc3\xaatre ajout\xc3\xa9 plusieurs fois dans une transaction'
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33',b'Cancel Material Visit {0} before cancelling this Warranty Claim',"b""Annuler la Visite Mat\xc3\xa9rielle {0} avant d'annuler cette R\xc3\xa9clamation de Garantie"""
+b'apps/erpnext/erpnext/config/education.py +118',b'Assessment Reports',b'Rapports d&#39;\xc3\xa9valuation'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +19',b'Consumer Products',b'Produits de Consommation'
+b'DocType: Purchase Receipt',b'Subscription Detail',"b""D\xc3\xa9tail de l'Abonnement"""
+b'DocType: Supplier Scorecard',b'Notify Supplier',b'Notifier Fournisseur'
+b'DocType: Item',b'Customer Items',b'Articles du clients'
+b'DocType: Project',b'Costing and Billing',b'Co\xc3\xbbts et Facturation'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +48',b'Account {0}: Parent account {1} can not be a ledger',b'Compte {0}: Le Compte parent {1} ne peut pas \xc3\xaatre un grand livre'
+b'DocType: Item',b'Publish Item to hub.erpnext.com',b'Publier un Artice sur hub.erpnext.com'
+b'apps/erpnext/erpnext/config/setup.py +88',b'Email Notifications',b'Notifications par Email'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +26',b'Evaluation',b'\xc3\x89valuation'
+b'DocType: Item',b'Default Unit of Measure',b'Unit\xc3\xa9 de Mesure par D\xc3\xa9faut'
+b'DocType: SMS Center',b'All Sales Partner Contact',b'Tous les Contacts de Partenaires Commerciaux'
+b'DocType: Employee',b'Leave Approvers',b'Approbateurs de Cong\xc3\xa9s'
+b'DocType: Sales Partner',b'Dealer',b'Revendeur'
+b'DocType: Work Order',b'WO-',b'WO-'
+b'DocType: Consultation',b'Investigations',b'Enqu\xc3\xaates'
+b'DocType: Restaurant Order Entry',b'Click Enter To Add',b'Cliquez sur Entr\xc3\xa9e pour Ajouter'
+b'DocType: Employee',b'Rented',b'Lou\xc3\xa9'
+b'DocType: Purchase Order',b'PO-',b'PO-'
+b'DocType: Vehicle Service',b'Mileage',b'Kilom\xc3\xa9trage'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +253',b'Do you really want to scrap this asset?',b'Voulez-vous vraiment mettre cet actif au rebut ?'
+b'DocType: Drug Prescription',b'Update Schedule',b'Mettre \xc3\xa0 Jour le Calendrier'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +44',b'Select Default Supplier',b'S\xc3\xa9lectionner le Fournisseur par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +37',b'Currency is required for Price List {0}',b'Devise est n\xc3\xa9cessaire pour la liste de prix {0}'
+b'DocType: Sales Taxes and Charges Template',b'* Will be calculated in the transaction.',b'* Sera calcul\xc3\xa9 lors de la transaction.'
+b'DocType: Purchase Order',b'Customer Contact',b'Contact Client'
+b'DocType: Patient Appointment',b'Check availability',b'Voir les Disponibilit\xc3\xa9s'
+b'DocType: Job Applicant',b'Job Applicant',"b""Demandeur d'Emploi"""
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +6',b'This is based on transactions against this Supplier. See timeline below for details',b'Bas\xc3\xa9 sur les transactions avec ce fournisseur. Voir la chronologie ci-dessous pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +120',b'Legal',b'Juridique'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +191',b'Actual type tax cannot be included in Item rate in row {0}',"b""Le type de taxe r\xc3\xa9el ne peut pas \xc3\xaatre inclus dans le prix de l'Article \xc3\xa0 la ligne {0}"""
+b'DocType: Bank Guarantee',b'Customer',b'Client'
+b'DocType: Purchase Receipt Item',b'Required By',b'Requis Par'
+b'DocType: Delivery Note',b'Return Against Delivery Note',b'Retour contre Bon de Livraison'
+b'DocType: Purchase Order',b'% Billed',b'% Factur\xc3\xa9'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +43',b'Exchange Rate must be same as {0} {1} ({2})',b'Taux de Change doit \xc3\xaatre le m\xc3\xaame que {0} {1} ({2})'
+b'DocType: Sales Invoice',b'Customer Name',b'Nom du Client'
+b'DocType: Vehicle',b'Natural Gas',b'Gaz Naturel'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/company_setup.py +64',b'Bank account cannot be named as {0}',b'Compte Bancaire ne peut pas \xc3\xaatre nomm\xc3\xa9 {0}'
+b'DocType: Account',b'Heads (or groups) against which Accounting Entries are made and balances are maintained.',b'Titres (ou groupes) sur lequel les entr\xc3\xa9es comptables sont faites et les soldes sont maintenus.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +196',b'Outstanding for {0} cannot be less than zero ({1})',b'Solde pour {0} ne peut pas \xc3\xaatre inf\xc3\xa9rieur \xc3\xa0 z\xc3\xa9ro ({1})'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +348',b'There are no submitted Salary Slips to process.',"b""Il n'y a aucune Fiche de Paie \xc3\xa0 traiter."""
+b'DocType: Manufacturing Settings',b'Default 10 mins',b'10 minutes Par D\xc3\xa9faut'
+b'DocType: Leave Type',b'Leave Type Name',b'Nom du Type de Cong\xc3\xa9'
+b'apps/erpnext/erpnext/templates/pages/projects.js +62',b'Show open',b'Afficher ouverte'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +8',b'It is necessary to take this action today itself for the above mentioned recurring',"b""Il est n\xc3\xa9cessaire de faire cette action aujourd'hui pour les documents r\xc3\xa9currents mentionn\xc3\xa9s ci-dessus"""
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +156',b'Series Updated Successfully',b'Mise \xc3\xa0 jour des S\xc3\xa9ries R\xc3\xa9ussie'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +6',b'Checkout',b'R\xc3\xa8glement'
+b'DocType: Pricing Rule',b'Apply On',b'Appliquer Sur'
+b'DocType: Item Price',b'Multiple Item prices.',"b""Plusieurs Prix d'Articles."""
+,b'Purchase Order Items To Be Received',b'Articles \xc3\xa0 Recevoir du Bon de Commande'
+b'DocType: SMS Center',b'All Supplier Contact',b'Tous les Contacts Fournisseurs'
+b'DocType: Support Settings',b'Support Settings',b'R\xc3\xa9glages du Support'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +75',b'Expected End Date can not be less than Expected Start Date',b'Date de Fin Attendue ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 Date de D\xc3\xa9but Attendue'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +121',b'Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ',b'Ligne #{0} : Le Prix doit \xc3\xaatre le m\xc3\xaame que {1}: {2} ({3} / {4})'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +241',b'New Leave Application',b'Nouvelle Demande de Cong\xc3\xa9s'
+,b'Batch Item Expiry Status',"b""Statut d'Expiration d'Article du Lot"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +184',b'Bank Draft',b'Traite Bancaire'
+b'DocType: Membership',b'membership validaty section',b'section validaty d&#39;adh\xc3\xa9sion'
+b'DocType: Mode of Payment Account',b'Mode of Payment Account',b'Compte du Mode de Paiement'
+b'DocType: Consultation',b'Consultation',b'Consultation'
+b'DocType: Accounts Settings',b'Show Payment Schedule in Print',b'Afficher le calendrier de paiement dans Imprimer'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +19',b'Sales and Returns',b'Ventes et retours'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +56',b'Show Variants',b'Afficher les Variantes'
+b'DocType: Academic Term',b'Academic Term',b'Terme Acad\xc3\xa9mique'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +14',b'Material',b'Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +66',b'Making website',b'Faire un site web'
+b'DocType: Opening Invoice Creation Tool Item',b'Quantity',b'Quantit\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +546',b'Accounts table cannot be blank.',b'Le tableau de comptes ne peut \xc3\xaatre vide.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +154',b'Loans (Liabilities)',b'Pr\xc3\xaats (Passif)'
+b'DocType: Employee Education',b'Year of Passing',b'Ann\xc3\xa9e de Passage'
+b'DocType: Item',b'Country of Origin',"b""Pays d'Origine"""
+b'DocType: Soil Texture',b'Soil Texture Criteria',b'Crit\xc3\xa8res de texture du sol'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +25',b'In Stock',b'En Stock'
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +16',b'Primary Contact Details',b'D\xc3\xa9tails du contact principal'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +46',b'Open Issues',b'Ouvrir les Questions'
+b'DocType: Production Plan Item',b'Production Plan Item',b'Article du Plan de Production'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +149',b'User {0} is already assigned to Employee {1}',"b""Utilisateur {0} est d\xc3\xa9j\xc3\xa0 attribu\xc3\xa9 \xc3\xa0 l'Employ\xc3\xa9 {1}"""
+b'DocType: Lab Test Groups',b'Add new line',b'Ajouter une nouvelle ligne'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +31',b'Health Care',b'Soins de Sant\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +65',b'Delay in payment (Days)',b'Retard de paiement (jours)'
+b'DocType: Payment Terms Template Detail',b'Payment Terms Template Detail',b'D\xc3\xa9tail du mod\xc3\xa8le de conditions de paiement'
+b'DocType: Hotel Room Reservation',b'Guest Name',b'Nom de l&#39;invit\xc3\xa9'
+b'DocType: Lab Prescription',b'Lab Prescription',b'Prescription de laboratoire'
+,b'Delay Days',b'Jours de retard'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +26',b'Service Expense',b'Frais de Service'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +899',b'Serial Number: {0} is already referenced in Sales Invoice: {1}',b'Num\xc3\xa9ro de S\xc3\xa9rie: {0} est d\xc3\xa9j\xc3\xa0 r\xc3\xa9f\xc3\xa9renc\xc3\xa9 dans la Facture de Vente: {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +889',b'Invoice',b'Facture'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +145',b'Make Retention Stock Entry',b'Faire une entr\xc3\xa9e en stock de r\xc3\xa9tention'
+b'DocType: Purchase Invoice Item',b'Item Weight Details',b'D\xc3\xa9tails du poids de l&#39;article'
+b'DocType: Asset Maintenance Log',b'Periodicity',b'P\xc3\xa9riodicit\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +21',b'Fiscal Year {0} is required',b'Exercice Fiscal {0} est n\xc3\xa9cessaire'
+b'DocType: Crop Cycle',b'The minimum distance between rows of plants for optimum growth',b'La distance minimale entre les rang\xc3\xa9es de plantes pour une croissance optimale'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +21',b'Defense',b'D\xc3\xa9fense'
+b'DocType: Salary Component',b'Abbr',b'Abr\xc3\xa9'
+b'DocType: Appraisal Goal',b'Score (0-5)',b'Score (0-5)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +225',b'Row {0}: {1} {2} does not match with {3}',b'Ligne {0} : {1} {2} ne correspond pas \xc3\xa0 {3}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +77',b'Row # {0}:',b'Ligne # {0} :'
+b'DocType: Timesheet',b'Total Costing Amount',b'Montant Total des Co\xc3\xbbts'
+b'DocType: Delivery Note',b'Vehicle No',b'N\xc2\xb0 du V\xc3\xa9hicule'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +163',b'Please select Price List',b'Veuillez s\xc3\xa9lectionner une Liste de Prix'
+b'DocType: Accounts Settings',b'Currency Exchange Settings',b'Param\xc3\xa8tres d&#39;\xc3\xa9change de devises'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +94',b'Row #{0}: Payment document is required to complete the trasaction',b'Ligne #{0} : Document de paiement n\xc3\xa9cessaire pour compl\xc3\xa9ter la transaction'
+b'DocType: Work Order Operation',b'Work In Progress',b'Travaux En Cours'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +13',b'Please select date',b'Veuillez s\xc3\xa9lectionner une date'
+b'DocType: Daily Work Summary Group',b'Holiday List',b'Liste de Vacances'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +88',b'Please setup numbering series for Attendance via Setup &gt; Numbering Series',b'Veuillez configurer la s\xc3\xa9rie de num\xc3\xa9ros pour la pr\xc3\xa9sence via Setup&gt; S\xc3\xa9rie de num\xc3\xa9ros'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +127',b'Accountant',b'Comptable'
+b'DocType: Hub Settings',b'Selling Price List',b'Liste de prix de vente'
+b'DocType: Patient',b'Tobacco Current Use',b'Consommation actuelle de tabac'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +56',b'Selling Rate',b'Prix de vente'
+b'DocType: Cost Center',b'Stock User',b'Charg\xc3\xa9 des Stocks'
+b'DocType: Soil Analysis',b'(Ca+Mg)/K',b'(Ca + Mg) / K'
+b'DocType: Company',b'Phone No',b'N\xc2\xb0 de T\xc3\xa9l\xc3\xa9phone'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +239',b'New {0}: #{1}',b'Nouveau(elle) {0}: # {1}'
+b'DocType: Delivery Trip',b'Initial Email Notification Sent',b'Notification initiale par e-mail envoy\xc3\xa9e'
+,b'Sales Partners Commission',b'Commission des Partenaires de Vente'
+b'DocType: Soil Texture',b'Sandy Clay Loam',b'terreau de sol argileux'
+b'DocType: Purchase Invoice',b'Rounding Adjustment',b'Arrondi'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +46',b'Abbreviation cannot have more than 5 characters',"b""L'abbr\xc3\xa9viation ne peut pas avoir plus de 5 caract\xc3\xa8res"""
+b'DocType: Physician Schedule Time Slot',b'Physician Schedule Time Slot',b'Cr\xc3\xa9neaux Horaires du M\xc3\xa9decin'
+b'DocType: Payment Request',b'Payment Request',b'Requ\xc3\xaate de Paiement'
+b'DocType: Asset',b'Value After Depreciation',b'Valeur Apr\xc3\xa8s Amortissement'
+b'DocType: Student',b'O+',b'O+'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan_dashboard.py +8',b'Related',b'En Relation'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +43',"b""Attendance date can not be less than employee's joining date""","b""Date de pr\xc3\xa9sence ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date d'embauche de l'employ\xc3\xa9"""
+b'DocType: Grading Scale',b'Grading Scale Name',"b""Nom de l'\xc3\x89chelle de Notation"""
+b'DocType: Subscription',b'Repeat on Day',b'R\xc3\xa9p\xc3\xa9ter Chaque'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +41',b'This is a root account and cannot be edited.',"b""Il s'agit d'un compte racine qui ne peut \xc3\xaatre modifi\xc3\xa9."""
+b'DocType: Sales Invoice',b'Company Address',b'Adresse de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: BOM',b'Operations',b'Op\xc3\xa9rations'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38',b'Cannot set authorization on basis of Discount for {0}',"b""Impossible de d\xc3\xa9finir l'autorisation sur la base des Prix R\xc3\xa9duits pour {0}"""
+b'DocType: Rename Tool',"b'Attach .csv file with two columns, one for the old name and one for the new name'","b""Attacher un fichier .csv avec deux colonnes, une pour l'ancien nom et une pour le nouveau nom"""
+b'apps/erpnext/erpnext/accounts/utils.py +73',b'{0} {1} not in any active Fiscal Year.',b'{0} {1} dans aucun Exercice actif.'
+b'DocType: Packed Item',b'Parent Detail docname',b'Nom de Document du D\xc3\xa9tail Parent'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +69',"b'Reference: {0}, Item Code: {1} and Customer: {2}'","b'R\xc3\xa9f\xc3\xa9rence: {0}, Code de l&#39;article: {1} et Client: {2}'"
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Kg',b'Kg'
+b'apps/erpnext/erpnext/config/hr.py +45',b'Opening for a Job.',"b""Ouverture d'un Emploi."""
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +114',b'BOM is not specified for subcontracting item {0} at row {1}',b'La nomenclature n&#39;est pas sp\xc3\xa9cifi\xc3\xa9e pour l&#39;article de sous-traitance {0} sur la ligne {1}'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +149',b'{0} Result submittted',b'R\xc3\xa9sultat {0} soumis'
+b'DocType: Item Attribute',b'Increment',b'Incr\xc3\xa9ment'
+b'apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js +74',b'Timespan',b'P\xc3\xa9riode'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +58',b'Select Warehouse...',"b""S\xc3\xa9lectionner l'Entrep\xc3\xb4t ..."""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +6',b'Advertising',b'Publicit\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +22',b'Same Company is entered more than once',"b""La m\xc3\xaame Soci\xc3\xa9t\xc3\xa9 a \xc3\xa9t\xc3\xa9 entr\xc3\xa9e plus d'une fois"""
+b'DocType: Patient',b'Married',b'Mari\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/party.py +41',b'Not permitted for {0}',b'Non autoris\xc3\xa9 pour {0}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +593',b'Get items from',b'Obtenir les articles de'
+b'DocType: Price List',b'Price Not UOM Dependant',"b""Prix non d\xc3\xa9pendent d' UOM"""
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +467',b'Stock cannot be updated against Delivery Note {0}',b'Stock ne peut pas \xc3\xaatre mis \xc3\xa0 jour pour le Bon de Livraison {0}'
+b'apps/erpnext/erpnext/templates/pages/home.py +25',b'Product {0}',b'Produit {0}'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +43',b'No items listed',b'Aucun article r\xc3\xa9f\xc3\xa9renc\xc3\xa9'
+b'DocType: Asset Repair',b'Error Description',b'Erreur de description'
+b'DocType: Payment Reconciliation',b'Reconcile',b'R\xc3\xa9concilier'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +30',b'Grocery',b'\xc3\x89picerie'
+b'DocType: Quality Inspection Reading',b'Reading 1',b'Lecture 1'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +40',b'Pension Funds',b'Fonds de Pension'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +91',b'Next Depreciation Date cannot be before Purchase Date',b'La Date de l\xe2\x80\x99Amortissement Suivant ne peut pas \xc3\xaatre avant la Date d\xe2\x80\x99Achat'
+b'DocType: Crop',b'Perennial',b'Vivace'
+b'DocType: Consultation',b'Consultation Date',b'Date de Consultation'
+b'DocType: Accounts Settings',b'Use Custom Cash Flow Format',b'Utiliser le format de flux de tr\xc3\xa9sorerie personnalis\xc3\xa9'
+b'DocType: SMS Center',b'All Sales Person',b'Tous les Commerciaux'
+b'DocType: Monthly Distribution',b'**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.',b'**R\xc3\xa9partition Mensuelle** vous aide \xc3\xa0 diviser le Budget / la Cible sur plusieurs mois si vous avez de la saisonnalit\xc3\xa9 dans votre entreprise.'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1753',b'Not items found',"b""Pas d'objets trouv\xc3\xa9s"""
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +184',b'Salary Structure Missing',b'Grille des Salaires Manquante'
+b'DocType: Lead',b'Person Name',b'Nom de la Personne'
+b'DocType: Sales Invoice Item',b'Sales Invoice Item',b'Article de la Facture de Vente'
+b'DocType: Account',b'Credit',b'Cr\xc3\xa9dit'
+b'DocType: POS Profile',b'Write Off Cost Center',b'Centre de Co\xc3\xbbts des Reprises'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +117',"b'e.g. ""Primary School"" or ""University""'","b'e.g. ""\xc3\x89cole Primaire"" ou ""Universit\xc3\xa9""'"
+b'apps/erpnext/erpnext/config/stock.py +28',b'Stock Reports',b'Rapports de Stock'
+b'DocType: Warehouse',b'Warehouse Detail',"b""D\xc3\xa9tail de l'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +33',b'The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',"b""La Date de Fin de Terme ne peut pas \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 la Date de Fin de l'Ann\xc3\xa9e Acad\xc3\xa9mique \xc3\xa0 laquelle le terme est li\xc3\xa9 (Ann\xc3\xa9e Acad\xc3\xa9mique {}). Veuillez corriger les dates et essayer \xc3\xa0 nouveau."""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +269',"b'""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item'","b""'Est un Actif Immobilis\xc3\xa9\xe2\x80\x99 doit \xc3\xaatre coch\xc3\xa9 car il existe une entr\xc3\xa9e d\xe2\x80\x99Actif pour cet article"""
+b'DocType: Delivery Trip',b'Departure Time',b'Heure de d\xc3\xa9part'
+b'DocType: Vehicle Service',b'Brake Oil',b'Liquide de Frein'
+b'DocType: Tax Rule',b'Tax Type',b'Type de Taxe'
+,b'Completed Work Orders',b'Ordres de travail termin\xc3\xa9s'
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +581',b'Taxable Amount',b'Montant Taxable'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +160',b'You are not authorized to add or update entries before {0}',"b""Vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 ajouter ou faire une mise \xc3\xa0 jour des \xc3\xa9critures avant le {0}"""
+b'DocType: BOM',b'Item Image (if not slideshow)',"b""Image de l'Article (si ce n'est diaporama)"""
+b'DocType: Work Order Operation',b'(Hour Rate / 60) * Actual Operation Time',b'(Tarif Horaire / 60) * Temps R\xc3\xa9el d\xe2\x80\x99Op\xc3\xa9ration'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1103',b'Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry',b'Ligne {0}: Le Type de Document de R\xc3\xa9f\xc3\xa9rence doit \xc3\xaatre soit une Note de Frais soit une \xc3\x89criture de Journal'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +975',b'Select BOM',b'S\xc3\xa9lectionner LDM'
+b'DocType: SMS Log',b'SMS Log',b'Journal des SMS'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Delivered Items',b'Co\xc3\xbbt des Articles Livr\xc3\xa9s'
+b'apps/erpnext/erpnext/config/hr.py +127',b'Manage advance amount given to the Employee',b'G\xc3\xa9rer le montant anticip\xc3\xa9 donn\xc3\xa9 \xc3\xa0 l&#39;employ\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +38',b'The holiday on {0} is not between From Date and To Date',b'Le jour de vacances {0} n\xe2\x80\x99est pas compris entre la Date Initiale et la Date Finale'
+b'DocType: Student Log',b'Student Log',b'Journal des \xc3\x89tudiants'
+b'apps/erpnext/erpnext/config/buying.py +165',b'Templates of supplier standings.',b'Mod\xc3\xa8les de Classements Fournisseurs.'
+b'DocType: Lead',b'Interested',b'Int\xc3\xa9ress\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +216',b'Opening',b'Ouverture'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32',b'From {0} to {1}',b'Du {0} au {1}'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +234',b'Program: ',b'Programme:'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +50',b'Failed to setup taxes',b'\xc3\x89chec de la configuration des taxes'
+b'DocType: Item',b'Copy From Item Group',"b""Copier Depuis un Groupe d'Articles"""
+b'DocType: Delivery Trip',b'Delivery Notification',b'Notification de livraison'
+b'DocType: Journal Entry',b'Opening Entry',"b""\xc3\x89criture d'Ouverture"""
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +25',b'Account Pay Only',b'Compte B\xc3\xa9n\xc3\xa9ficiaire Seulement'
+b'DocType: Employee Loan',b'Repay Over Number of Periods',b'Rembourser Sur le Nombre de P\xc3\xa9riodes'
+b'DocType: Stock Entry',b'Additional Costs',b'Frais Suppl\xc3\xa9mentaires'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +138',b'Account with existing transaction can not be converted to group.',b'Un compte contenant une transaction ne peut pas \xc3\xaatre converti en groupe'
+b'DocType: Lead',b'Product Enquiry',"b""Demande d'Information Produit"""
+b'DocType: Education Settings',b'Validate Batch for Students in Student Group',b'Valider le Lot pour les \xc3\x89tudiants en Groupe \xc3\x89tudiant'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +35',b'No leave record found for employee {0} for {1}',b'Aucun cong\xc3\xa9 trouv\xc3\xa9 pour l\xe2\x80\x99employ\xc3\xa9 {0} pour {1}'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +23',b'Please enter company first',b'Veuillez d\xe2\x80\x99abord entrer une Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +365',b'Please select Company first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Employee Education',b'Under Graduate',b'Non Dipl\xc3\xb4m\xc3\xa9'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +27',b'Target On',b'Cible Sur'
+b'DocType: BOM',b'Total Cost',b'Co\xc3\xbbt Total'
+b'DocType: Soil Analysis',b'Ca/K',b'Ca / K'
+b'DocType: Journal Entry Account',b'Employee Loan',b'Pr\xc3\xaat Employ\xc3\xa9'
+b'DocType: Fee Schedule',b'Send Payment Request Email',b'Envoyer un Email de Demande de Paiement'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +268',b'Item {0} does not exist in the system or has expired',"b""L'article {0} n'existe pas dans le syst\xc3\xa8me ou a expir\xc3\xa9"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +44',b'Real Estate',b'Immobilier'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +1',b'Statement of Account',b'Relev\xc3\xa9 de Compte'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +41',b'Pharmaceuticals',b'M\xc3\xa9dicaments'
+b'DocType: Purchase Invoice Item',b'Is Fixed Asset',b'Est Immobilisation'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +273',"b'Available qty is {0}, you need {1}'","b'Qt\xc3\xa9 disponible est {0}, vous avez besoin de {1}'"
+b'DocType: Expense Claim Detail',b'Claim Amount',b'Montant R\xc3\xa9clam\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +653',b'Work Order has been {0}',b'Le bon de travail a \xc3\xa9t\xc3\xa9 {0}'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +56',b'Duplicate customer group found in the cutomer group table',b'Groupe de clients en double trouv\xc3\xa9 dans le tableau des groupes de clients'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +31',b'Supplier Type / Supplier',b'Fournisseur / Type de Fournisseur'
+b'DocType: Naming Series',b'Prefix',b'Pr\xc3\xa9fixe'
+b'apps/erpnext/erpnext/hr/email_alert/training_scheduled/training_scheduled.html +7',b'Event Location',"b""Lieu de l'\xc3\x89v\xc3\xa9nement"""
+b'DocType: Asset Settings',b'Asset Settings',b'Param\xc3\xa8tres de l&#39;actif'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +68',b'Consumable',b'Consommable'
+b'DocType: Student',b'B-',b'B-'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +98',b'Successfully unregistered.',b'D\xc3\xa9sinscription r\xc3\xa9ussie.'
+b'DocType: Assessment Result',b'Grade',b'Note'
+b'DocType: Restaurant Table',b'No of Seats',b'Nombre de Si\xc3\xa8ges'
+b'DocType: Subscription',"b'To add dynamic subject, use jinja tags like\n\n<div><pre><code>New {{ doc.doctype }} #{{ doc.name }}</code></pre></div>'","b'Pour ajouter un sujet dynamique, utilisez des tags jinja comme <div><pre> <code>New {{ doc.doctype }} #{{ doc.name }}</code> </pre> </div>'"
+b'DocType: Sales Invoice Item',b'Delivered By Supplier',b'Livr\xc3\xa9 par le Fournisseur'
+b'DocType: Asset Maintenance Task',b'Asset Maintenance Task',b'T\xc3\xa2che de Maintenance des Actifs'
+b'DocType: SMS Center',b'All Contact',b'Tout Contact'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +232',b'Annual Salary',b'Salaire Annuel'
+b'DocType: Daily Work Summary',b'Daily Work Summary',b'R\xc3\xa9capitulatif Quotidien de Travail'
+b'DocType: Period Closing Voucher',b'Closing Fiscal Year',"b""Cl\xc3\xb4ture de l'Exercice"""
+b'apps/erpnext/erpnext/accounts/party.py +392',b'{0} {1} is frozen',b'{0} {1} est gel\xc3\xa9e'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +140',b'Please select Existing Company for creating Chart of Accounts',b'Veuillez s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9 Existante pour cr\xc3\xa9er un Plan de Compte'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +80',b'Stock Expenses',b'Charges de Stock'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +111',b'Select Target Warehouse',"b""S\xc3\xa9lectionner l'Entrep\xc3\xb4t Cible"""
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.js +80',b'Please enter Preferred Contact Email',b'Veuillez entrer l\xe2\x80\x99Email de Contact Pr\xc3\xa9f\xc3\xa9rr\xc3\xa9'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxNum',b'CompAuxNum'
+b'DocType: Journal Entry',b'Contra Entry',b'Contre-passation'
+b'DocType: Journal Entry Account',b'Credit in Company Currency',b'Cr\xc3\xa9dit dans la Devise de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Lab Test UOM',b'Lab Test UOM',b'UDM de test de laboratoire'
+b'DocType: Delivery Note',b'Installation Status',"b""Etat de l'Installation"""
+b'DocType: BOM',b'Quality Inspection Template',b'Mod\xc3\xa8le d&#39;inspection de la qualit\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +135',b'Do you want to update attendance?<br>Present: {0}\\\n\t\t\t\t\t<br>Absent: {1}',b'Voulez-vous mettre \xc3\xa0 jour la fr\xc3\xa9quentation? <br> Pr\xc3\xa9sents: {0} \\ <br> Absent: {1}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +334',b'Accepted + Rejected Qty must be equal to Received quantity for Item {0}',"b""La Qt\xc3\xa9 Accept\xc3\xa9e + Rejet\xc3\xa9e doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 la quantit\xc3\xa9 Re\xc3\xa7ue pour l'Article {0}"""
+b'DocType: Request for Quotation',b'RFQ-',b'RFQ-'
+b'DocType: Item',b'Supply Raw Materials for Purchase',"b""Fournir les Mati\xc3\xa8res Premi\xc3\xa8res pour l'Achat"""
+b'DocType: Agriculture Analysis Criteria',b'Fertilizer',b'Engrais'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +152',b'At least one mode of payment is required for POS invoice.',b'Au moins un mode de paiement est n\xc3\xa9cessaire pour une facture de PDV'
+b'DocType: Products Settings',b'Show Products as a List',b'Afficher les Produits en Liste'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +532',b'Item {0} is not active or end of life has been reached',"b""L'article {0} n\xe2\x80\x99est pas actif ou sa fin de vie a \xc3\xa9t\xc3\xa9 atteinte"""
+b'DocType: Student Admission Program',b'Minimum Age',b'\xc3\x82ge Minimum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +190',b'Example: Basic Mathematics',b'Exemple : Math\xc3\xa9matiques de Base'
+b'DocType: Customer',b'Primary Address',b'Adresse principale'
+b'DocType: Production Plan',b'Material Request Detail',b'D\xc3\xa9tail de la demande de mat\xc3\xa9riel'
+b'DocType: Selling Settings',b'Default Quotation Validity Days',b'Validit\xc3\xa9 des jours de validit\xc3\xa9'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +800',"b'To include tax in row {0} in Item rate, taxes in rows {1} must also be included'","b""Pour inclure la taxe de la ligne {0} dans le prix de l'Article, les taxes des lignes {1} doivent \xc3\xa9galement \xc3\xaatre incluses"""
+b'apps/erpnext/erpnext/config/hr.py +223',b'Settings for HR Module',b'R\xc3\xa9glages pour le Module RH'
+b'DocType: SMS Center',b'SMS Center',b'Centre des SMS'
+b'DocType: Sales Invoice',b'Change Amount',b'Changer le Montant'
+b'DocType: GST Settings',b'Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.',b'D\xc3\xa9finir la valeur de facture pour B2C. B2CL et B2CS calcul\xc3\xa9s sur la base de cette valeur de facture.'
+b'DocType: BOM Update Tool',b'New BOM',b'Nouvelle LDM'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +36',b'Show only POS',b'Afficher uniquement les points de vente'
+b'DocType: Driver',b'Driving License Categories',b'Cat\xc3\xa9gories de permis de conduire'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +118',b'Please enter Delivery Date',b'Entrez la Date de Livraison'
+b'DocType: Depreciation Schedule',b'Make Depreciation Entry',"b""Cr\xc3\xa9er une \xc3\x89criture d'Amortissement"""
+b'DocType: Appraisal Template Goal',b'KRA',b'KRA'
+b'DocType: Lead',b'Request Type',b'Type de Demande'
+b'apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js +17',b'Make Employee',b'Cr\xc3\xa9er un Employ\xc3\xa9'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +14',b'Broadcasting',b'Radio/T\xc3\xa9l\xc3\xa9vision'
+b'apps/erpnext/erpnext/config/accounts.py +313',b'Setup mode of POS (Online / Offline)',b'Mode de configuration de POS (en ligne / hors ligne)'
+b'DocType: Manufacturing Settings',b'Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order',b'D\xc3\xa9sactive la cr\xc3\xa9ation de journaux de temps par rapport aux ordres de travail. Les op\xc3\xa9rations ne doivent pas \xc3\xaatre suivies par ordre de travail'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +191',b'Execution',b'Ex\xc3\xa9cution'
+b'apps/erpnext/erpnext/config/manufacturing.py +62',b'Details of the operations carried out.',b'D\xc3\xa9tails des op\xc3\xa9rations effectu\xc3\xa9es.'
+b'DocType: Asset Maintenance Log',b'Maintenance Status',"b""Statut d'Entretien"""
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +10',b'Membership Details',b'D\xc3\xa9tails de l&#39;adh\xc3\xa9sion'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +56',b'{0} {1}: Supplier is required against Payable account {2}',b'{0} {1} : Un Fournisseur est requis pour le Compte Cr\xc3\xa9diteur {2}'
+b'apps/erpnext/erpnext/config/selling.py +52',b'Items and Pricing',b'Articles et Prix'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +2',b'Total hours: {0}',"b""Nombre total d'heures : {0}"""
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43',b'From Date should be within the Fiscal Year. Assuming From Date = {0}',"b""La Date Initiale doit \xc3\xaatre dans l'Exercice Fiscal. En supposant Date Initiale = {0}"""
+b'DocType: Drug Prescription',b'Interval',b'Intervalle'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +253',b'Preference',b'Pr\xc3\xa9f\xc3\xa9rence'
+b'DocType: Grant Application',b'Individual',b'Individuel'
+b'DocType: Academic Term',b'Academics User',b'Utilisateur acad\xc3\xa9mique'
+b'DocType: Cheque Print Template',b'Amount In Figure',b'Montant En Chiffre'
+b'DocType: Employee Loan Application',b'Loan Info',b'Infos sur le Pr\xc3\xaat'
+b'apps/erpnext/erpnext/config/maintenance.py +12',b'Plan for maintenance visits.',b'Plan pour les visites de maintenance.'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Period',"b""P\xc3\xa9riode de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'DocType: Share Transfer',b'Share Transfer',b'Transfert de partage'
+b'DocType: POS Profile',b'Customer Groups',b'Groupes de Clients'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +51',b'Financial Statements',b'\xc3\x89tats Financiers'
+b'DocType: Guardian',b'Students',b'\xc3\x89tudiants'
+b'apps/erpnext/erpnext/config/selling.py +91',b'Rules for applying pricing and discount.',b'R\xc3\xa8gles pour l\xe2\x80\x99application des tarifs et des remises.'
+b'DocType: Daily Work Summary',b'Daily Work Summary Group',b'Groupe r\xc3\xa9sum\xc3\xa9 de travail quotidien'
+b'DocType: Physician Schedule',b'Time Slots',b'Cr\xc3\xa9neaux Horaires'
+b'apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14',b'Price List must be applicable for Buying or Selling',b'La Liste de Prix doit \xc3\xaatre applicable pour les Achats et les Ventes'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +79',b'Installation date cannot be before delivery date for Item {0}',"b""Date d'installation ne peut pas \xc3\xaatre avant la date de livraison pour l'Article {0}"""
+b'DocType: Pricing Rule',b'Discount on Price List Rate (%)',b'Remise sur la Liste des Prix (%)'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +112',b'Item Template',b'Mod\xc3\xa8le d&#39;article'
+b'apps/erpnext/erpnext/healthcare/setup.py +215',b'Biochemistry',b'Biochimie'
+b'DocType: Job Offer',b'Select Terms and Conditions',b'S\xc3\xa9lectionner les Termes et Conditions'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +72',b'Out Value',b'Valeur Sortante'
+b'DocType: Production Plan',b'Sales Orders',b'Commandes Clients'
+b'DocType: Purchase Taxes and Charges',b'Valuation',b'Valorisation'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +390',b'Set as Default',b'D\xc3\xa9finir par d\xc3\xa9faut'
+b'DocType: Production Plan',b'PLN-',b'PLN-'
+,b'Purchase Order Trends',b'Tendances des Bons de Commande'
+b'apps/erpnext/erpnext/utilities/user_progress.py +78',b'Go to Customers',b'Aller aux Clients'
+b'DocType: Hotel Room Reservation',b'Late Checkin',b'Arriv\xc3\xa9e tardive'
+b'apps/erpnext/erpnext/templates/emails/request_for_quotation.html +7',b'The request for quotation can be accessed by clicking on the following link',b'La demande de devis peut \xc3\xaatre consult\xc3\xa9e en cliquant sur le lien suivant'
+b'apps/erpnext/erpnext/config/hr.py +81',b'Allocate leaves for the year.',"b""Allouer des cong\xc3\xa9s pour l'ann\xc3\xa9e."""
+b'DocType: SG Creation Tool Course',b'SG Creation Tool Course',"b""Cours de Cr\xc3\xa9ation d'Outil SG"""
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +275',b'Insufficient Stock',b'Stock Insuffisant'
+b'DocType: Manufacturing Settings',b'Disable Capacity Planning and Time Tracking',b'D\xc3\xa9sactiver la Plannification de Capacit\xc3\xa9 et la Gestion du Temps'
+b'DocType: Email Digest',b'New Sales Orders',b'Nouvelles Commandes Client'
+b'DocType: Bank Guarantee',b'Bank Account',b'Compte Bancaire'
+b'DocType: Leave Type',b'Allow Negative Balance',b'Autoriser un Solde N\xc3\xa9gatif'
+b'apps/erpnext/erpnext/projects/doctype/project_type/project_type.py +13',"b""You cannot delete Project Type 'External'""","b""Vous ne pouvez pas supprimer le Type de Projet 'Externe'"""
+b'DocType: Employee',b'Create User',b'Cr\xc3\xa9er un Utilisateur'
+b'DocType: Selling Settings',b'Default Territory',b'R\xc3\xa9gion par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +53',b'Television',b'T\xc3\xa9l\xc3\xa9vision'
+b'DocType: Work Order Operation',"b""Updated via 'Time Log'""","b""Mis \xc3\xa0 jour via 'Journal du Temps'"""
+b'apps/erpnext/erpnext/controllers/taxes_and_totals.py +430',b'Advance amount cannot be greater than {0} {1}',"b""Montant de l'avance ne peut \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 {0} {1}"""
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalCode',b'JournalCode'
+b'DocType: Naming Series',b'Series List for this Transaction',b'Liste des S\xc3\xa9ries pour cette Transaction'
+b'DocType: Company',b'Enable Perpetual Inventory',"b""Autoriser l'Inventaire Perp\xc3\xa9tuel"""
+b'DocType: Company',b'Default Payroll Payable Account',b'Compte de Paie par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +51',b'Update Email Group',"b""Metter \xc3\xa0 jour le Groupe d'Email"""
+b'DocType: Sales Invoice',b'Is Opening Entry',b'Est \xc3\x89criture Ouverte'
+b'DocType: Lab Test Template',"b'If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. '","b""Si non coch\xc3\xa9e, l'article n'appara\xc3\xaetra pas dans la facture de vente, mais peut \xc3\xaatre utilis\xc3\xa9 dans la cr\xc3\xa9ation de test de groupe."""
+b'DocType: Customer Group',b'Mention if non-standard receivable account applicable',"b""Mentionner si le compte d\xc3\xa9biteur applicable n'est pas standard"""
+b'DocType: Course Schedule',b'Instructor Name',"b""Nom de l'Instructeur"""
+b'DocType: Supplier Scorecard',b'Criteria Setup',b'Configuration du Crit\xc3\xa8re'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +206',b'For Warehouse is required before Submit',b'Pour l\xe2\x80\x99Entrep\xc3\xb4t est requis avant de Soumettre'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +8',b'Received On',b'Re\xc3\xa7u Le'
+b'DocType: Sales Partner',b'Reseller',b'Revendeur'
+b'DocType: Codification Table',b'Medical Code',b'Code M\xc3\xa9dical'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +20',b'Please enter Company',b'Veuillez entrer une Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Delivery Note Item',b'Against Sales Invoice Item',"b""Pour l'Article de la Facture de Vente"""
+b'DocType: Agriculture Analysis Criteria',b'Linked Doctype',b'Doctype li\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +44',b'Net Cash from Financing',b'Tr\xc3\xa9sorerie Nette des Financements'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2375',"b'LocalStorage is full , did not save'","b'Le Stockage Local est plein, l\xe2\x80\x99enregistrement n\xe2\x80\x99a pas fonctionn\xc3\xa9'"
+b'DocType: Lead',b'Address & Contact',b'Adresse &amp; Contact'
+b'DocType: Leave Allocation',b'Add unused leaves from previous allocations',b'Ajouter les cong\xc3\xa9s inutilis\xc3\xa9s des pr\xc3\xa9c\xc3\xa9dentes allocations'
+b'DocType: Sales Partner',b'Partner website',b'Site Partenaire'
+b'DocType: Restaurant Order Entry',b'Add Item',b'Ajouter un Article'
+b'DocType: Lab Test',b'Custom Result',b'R\xc3\xa9sultat Personnalis\xc3\xa9'
+b'DocType: Delivery Stop',b'Contact Name',b'Nom du Contact'
+b'DocType: Course Assessment Criteria',b'Course Assessment Criteria',"b""Crit\xc3\xa8res d'\xc3\x89valuation du Cours"""
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +18',b'Tax Id: ',b'Num\xc3\xa9ro d&#39;identification fiscale'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +216',b'Student ID: ',b'Carte d&#39;\xc3\xa9tudiant:'
+b'DocType: POS Customer Group',b'POS Customer Group',b'Groupe Clients PDV'
+b'DocType: Land Unit',b'Land Unit describing various land assets',b'Parcelle d\xc3\xa9crivant divers biens fonciers'
+b'DocType: Cheque Print Template',b'Line spacing for amount in words',b'Espacement des lignes pour le montant en lettres'
+b'DocType: Vehicle',b'Additional Details',b'D\xc3\xa9tails Suppl\xc3\xa9mentaires'
+b'apps/erpnext/erpnext/templates/generators/bom.html +85',b'No description given',b'Aucune Description'
+b'apps/erpnext/erpnext/config/buying.py +13',b'Request for purchase.',"b""Demande d'Achat."""
+b'DocType: Lab Test',b'Submitted Date',b'Date Soumise'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py +6',b'This is based on the Time Sheets created against this project',b'Bas\xc3\xa9 sur les Feuilles de Temps cr\xc3\xa9\xc3\xa9es pour ce projet'
+,b'Open Work Orders',b'Ordres de travail ouverts'
+b'DocType: Payment Term',b'Credit Months',b'Mois de cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +409',b'Net Pay cannot be less than 0',b'Salaire Net ne peut pas \xc3\xaatre inf\xc3\xa9rieur \xc3\xa0 0'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',"b'To stop sending repetitive error notifications from the system, we have checked Disabled field in the subscription'","b'Pour arr\xc3\xaater d&#39;envoyer des notifications d&#39;erreurs r\xc3\xa9p\xc3\xa9titives du syst\xc3\xa8me, nous avons coch\xc3\xa9 la case Disabled dans l&#39;abonnement'"
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +121',b'Relieving Date must be greater than Date of Joining',b'La Date de Rel\xc3\xa8ve doit \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 la Date d\xe2\x80\x99Embauche'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +240',b'Leaves per Year',b'Cong\xc3\xa9s par Ann\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +130',"b""Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.""","b""Ligne {0} : Veuillez v\xc3\xa9rifier 'Est Avance' sur le compte {1} si c'est une avance."""
+b'apps/erpnext/erpnext/stock/utils.py +219',b'Warehouse {0} does not belong to company {1}',"b""L'entrep\xc3\xb4t {0} n'appartient pas \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 {1}"""
+b'DocType: Email Digest',b'Profit & Loss',b'Profits & Pertes'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Litre',b'Litre'
+b'DocType: Task',b'Total Costing Amount (via Time Sheet)',b'Montant Total des Co\xc3\xbbts (via Feuille de Temps)'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +76',b'Please setup Students under Student Groups',"b""Veuillez configurer les \xc3\x89tudiants sous des groupes d'\xc3\x89tudiants"""
+b'DocType: Item Website Specification',b'Item Website Specification',"b""Sp\xc3\xa9cification de l'Article sur le Site Web"""
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +449',b'Leave Blocked',b'Laisser Verrouill\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +740',b'Item {0} has reached its end of life on {1}',"b""L'article {0} a atteint sa fin de vie le {1}"""
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +83',b'Bank Entries',b'\xc3\x89critures Bancaires'
+b'DocType: Crop',b'Annual',b'Annuel'
+b'DocType: Stock Reconciliation Item',b'Stock Reconciliation Item',b'Article de R\xc3\xa9conciliation du Stock'
+b'DocType: Stock Entry',b'Sales Invoice No',b'N\xc2\xb0 de la Facture de Vente'
+b'DocType: Material Request Item',b'Min Order Qty',b'Qt\xc3\xa9 de Commande Min'
+b'DocType: Student Group Creation Tool Course',b'Student Group Creation Tool Course',"b""Cours sur l'Outil de Cr\xc3\xa9ation de Groupe d'\xc3\x89tudiants"""
+b'DocType: Lead',b'Do Not Contact',b'Ne Pas Contacter'
+b'apps/erpnext/erpnext/utilities/user_progress.py +210',b'People who teach at your organisation',b'Personnes qui enseignent dans votre organisation'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +135',b'Software Developer',b'Developeur Logiciel'
+b'DocType: Item',b'Minimum Order Qty',b'Qt\xc3\xa9 de Commande Minimum'
+b'DocType: Pricing Rule',b'Supplier Type',b'Type de Fournisseur'
+b'DocType: Course Scheduling Tool',b'Course Start Date',b'Date de D\xc3\xa9but du Cours'
+,b'Student Batch-Wise Attendance',"b""Pr\xc3\xa9sence par Lots d'\xc3\x89tudiants"""
+b'DocType: POS Profile',b'Allow user to edit Rate',"b""Autoriser l'utilisateur \xc3\xa0 modifier le Taux"""
+b'DocType: Item',b'Publish in Hub',b'Publier dans le Hub'
+b'DocType: Student Admission',b'Student Admission',b'Admission des \xc3\x89tudiants'
+,b'Terretory',b'Territoire'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +762',b'Item {0} is cancelled',b'Article {0} est annul\xc3\xa9'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1064',b'Material Request',b'Demande de Mat\xc3\xa9riel'
+b'DocType: Bank Reconciliation',b'Update Clearance Date',b'Mettre \xc3\xa0 Jour la Date de Compensation'
+,b'GSTR-2',b'GSTR-2'
+b'DocType: Item',b'Purchase Details',"b""D\xc3\xa9tails de l'Achat"""
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +407',"b""Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1}""","b""Article {0} introuvable dans la table 'Mati\xc3\xa8res Premi\xc3\xa8res Fournies' dans la Commande d'Achat {1}"""
+b'DocType: Salary Slip',b'Total Principal Amount',b'Montant total du capital'
+b'DocType: Student Guardian',b'Relation',b'Relation'
+b'DocType: Student Guardian',b'Mother',b'M\xc3\xa8re'
+b'DocType: Restaurant Reservation',b'Reservation End Time',b'Heure de fin de la r\xc3\xa9servation'
+b'DocType: Crop',b'Biennial',b'Biennal'
+b'apps/erpnext/erpnext/config/selling.py +18',b'Confirmed orders from Customers.',b'Commandes confirm\xc3\xa9es des clients.'
+b'DocType: Purchase Receipt Item',b'Rejected Quantity',b'Quantit\xc3\xa9 Rejet\xc3\xa9e'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.py +80',b'Payment request {0} created',b'Demande de paiement {0} cr\xc3\xa9\xc3\xa9e'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Open Orders',b'Commandes ouvertes'
+b'apps/erpnext/erpnext/healthcare/setup.py +255',b'Low Sensitivity',b'Faible Sensibilit\xc3\xa9'
+b'DocType: Notification Control',b'Notification Control',b'Contr\xc3\xb4le de Notification'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +17',b'Please confirm once you have completed your training',b'Veuillez confirmer une fois que vous avez termin\xc3\xa9 votre formation'
+b'DocType: Lead',b'Suggestions',b'Suggestions'
+b'DocType: Territory',b'Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.',"b""D\xc3\xa9finir des budgets par Groupes d'Articles sur ce Territoire. Vous pouvez \xc3\xa9galement inclure de la saisonnalit\xc3\xa9 en d\xc3\xa9finissant la R\xc3\xa9partition."""
+b'DocType: Payment Term',b'Payment Term Name',b'Nom du terme de paiement'
+b'DocType: Healthcare Settings',b'Create documents for sample collection',b'Cr\xc3\xa9er des documents pour la collecte d&#39;\xc3\xa9chantillons'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +276',b'Payment against {0} {1} cannot be greater than Outstanding Amount {2}',b'Paiement pour {0} {1} ne peut pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 Encours {2}'
+b'DocType: Shareholder',b'Address HTML',b'Adresse HTML'
+b'DocType: Lead',b'Mobile No.',b'N\xc2\xb0 Mobile.'
+b'DocType: Maintenance Schedule',b'Generate Schedule',b'Cr\xc3\xa9er un \xc3\x89ch\xc3\xa9ancier'
+b'DocType: Purchase Invoice Item',b'Expense Head',b'Compte de Charges'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +138',b'Please select Charge Type first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner le Type de Facturation'
+b'DocType: Crop',"b'You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. '","b'Vous pouvez d\xc3\xa9finir ici toutes les t\xc3\xa2ches \xc3\xa0 effectuer pour cette culture. Le champ de jour est utilis\xc3\xa9 pour mentionner le jour o\xc3\xb9 la t\xc3\xa2che doit \xc3\xaatre effectu\xc3\xa9e, 1 \xc3\xa9tant le 1er jour, etc.'"
+b'DocType: Student Group Student',b'Student Group Student',"b""\xc3\x89tudiant du Groupe d'\xc3\x89tudiants"""
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Latest',b'Dernier'
+b'DocType: Asset Maintenance Task',b'2 Yearly',b'2 ans'
+b'DocType: Education Settings',b'Education Settings',b'Param\xc3\xa8tres d&#39;\xc3\xa9ducation'
+b'DocType: Vehicle Service',b'Inspection',b'Inspection'
+b'DocType: Supplier Scorecard Scoring Standing',b'Max Grade',b'Note Maximale'
+b'DocType: Email Digest',b'New Quotations',b'Nouveaux Devis'
+b'DocType: HR Settings',b'Emails salary slip to employee based on preferred email selected in Employee',"b""Envoi des fiches de paie \xc3\xa0 l'employ\xc3\xa9 par Email en fonction de l'email s\xc3\xa9lectionn\xc3\xa9 dans la fiche Employ\xc3\xa9"""
+b'DocType: Employee',b'The first Leave Approver in the list will be set as the default Leave Approver',b'Le premier Approbateur de Cong\xc3\xa9 dans la liste sera d\xc3\xa9fini comme Approbateur par d\xc3\xa9faut'
+b'DocType: Tax Rule',b'Shipping County',b'Comt\xc3\xa9 de Livraison'
+b'apps/erpnext/erpnext/config/desktop.py +167',b'Learn',b'Apprendre'
+b'DocType: Asset',b'Next Depreciation Date',b'Date de l\xe2\x80\x99Amortissement Suivant'
+b'apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js +3',b'Activity Cost per Employee',"b""Co\xc3\xbbt de l'Activit\xc3\xa9 par Employ\xc3\xa9"""
+b'DocType: Accounts Settings',b'Settings for Accounts',b'R\xc3\xa9glages pour les Comptes'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +673',b'Supplier Invoice No exists in Purchase Invoice {0}',"b""N\xc2\xb0 de la Facture du Fournisseur existe dans la Facture d'Achat {0}"""
+b'apps/erpnext/erpnext/config/selling.py +118',b'Manage Sales Person Tree.',"b""G\xc3\xa9rer l'Arborescence des Vendeurs."""
+b'DocType: Job Applicant',b'Cover Letter',b'Lettre de Motivation'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +37',b'Outstanding Cheques and Deposits to clear',b'Ch\xc3\xa8ques et D\xc3\xa9p\xc3\xb4ts en suspens \xc3\xa0 compenser'
+b'DocType: Item',b'Synced With Hub',b'Synchronis\xc3\xa9 avec le Hub'
+b'DocType: Driver',b'Fleet Manager',b'Gestionnaire de Flotte'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +542',b'Row #{0}: {1} can not be negative for item {2}',b'Ligne #{0} : {1} ne peut pas \xc3\xaatre n\xc3\xa9gatif pour l\xe2\x80\x99article {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +59',b'Wrong Password',b'Mauvais Mot De Passe'
+b'DocType: Item',b'Variant Of',b'Variante De'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +406',"b""Completed Qty can not be greater than 'Qty to Manufacture'""","b'Qt\xc3\xa9 Termin\xc3\xa9e ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 ""Quantit\xc3\xa9 de Fabrication""'"
+b'DocType: Period Closing Voucher',b'Closing Account Head',b'Responsable du Compte Cl\xc3\xb4tur\xc3\xa9'
+b'DocType: Employee',b'External Work History',b'Historique de Travail Externe'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +111',b'Circular Reference Error',b'Erreur de R\xc3\xa9f\xc3\xa9rence Circulaire'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +206',b'Student Report Card',b'Carte de rapport d&#39;\xc3\xa9tudiant'
+b'DocType: Appointment Type',b'Is Inpatient',b'Est hospitalis\xc3\xa9'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +55',b'Guardian1 Name',b'Nom du Tuteur 1'
+b'DocType: Delivery Note',b'In Words (Export) will be visible once you save the Delivery Note.',b'En Toutes Lettres (Exportation) Sera visible une fois que vous enregistrerez le Bon de Livraison.'
+b'DocType: Cheque Print Template',b'Distance from left edge',b'Distance du bord gauche'
+b'apps/erpnext/erpnext/utilities/bot.py +29',b'{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2})',b'{0} unit\xc3\xa9s de [{1}] (#Formulaire/Article/{1}) trouv\xc3\xa9es dans [{2}] (#Formulaire/Entrep\xc3\xb4t/{2})'
+b'DocType: Lead',b'Industry',b'Industrie'
+b'DocType: Employee',b'Job Profile',"b""Profil de l'Emploi"""
+b'DocType: BOM Item',b'Rate & Amount',b'Taux et Montant'
+b'apps/erpnext/erpnext/setup/doctype/company/company_dashboard.py +6',b'This is based on transactions against this Company. See timeline below for details',b'Ceci est bas\xc3\xa9 sur les transactions contre cette Soci\xc3\xa9t\xc3\xa9. Voir le calendrier ci-dessous pour plus de d\xc3\xa9tails'
+b'DocType: Stock Settings',b'Notify by Email on creation of automatic Material Request',b'Notifier par Email lors de la cr\xc3\xa9ation automatique de la Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/healthcare/setup.py +259',b'Resistant',b'R\xc3\xa9sistant'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +77',b'Please set Hotel Room Rate on {}',b'Veuillez r\xc3\xa9gler le tarif de la chambre d&#39;h\xc3\xb4tel sur {}'
+b'DocType: Journal Entry',b'Multi Currency',b'Multi-Devise'
+b'DocType: Opening Invoice Creation Tool',b'Invoice Type',b'Type de Facture'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +939',b'Delivery Note',b'Bon de Livraison'
+b'DocType: Consultation',b'Encounter Impression',b'Impression de la Visite'
+b'apps/erpnext/erpnext/config/learn.py +82',b'Setting up Taxes',b'Configuration des Imp\xc3\xb4ts'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +134',b'Cost of Sold Asset',b'Co\xc3\xbbt des Immobilisations Vendus'
+b'DocType: Volunteer',b'Morning',b'Matin'
+b'apps/erpnext/erpnext/accounts/utils.py +350',b'Payment Entry has been modified after you pulled it. Please pull it again.',b'L\xe2\x80\x99\xc3\x89criture de Paiement a \xc3\xa9t\xc3\xa9 modifi\xc3\xa9 apr\xc3\xa8s que vous l\xe2\x80\x99ayez r\xc3\xa9cup\xc3\xa9r\xc3\xa9e. Veuillez la r\xc3\xa9cup\xc3\xa9rer \xc3\xa0 nouveau.'
+b'DocType: Program Enrollment Tool',b'New Student Batch',"b""Nouveau groupe d'\xc3\xa9tudiants"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +479',b'{0} entered twice in Item Tax',"b""{0} est entr\xc3\xa9 deux fois dans la Taxe de l'Article"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +113',b'Summary for this week and pending activities',b'R\xc3\xa9sum\xc3\xa9 de la semaine et des activit\xc3\xa9s en suspens'
+b'DocType: Student Applicant',b'Admitted',b'Admis'
+b'DocType: Workstation',b'Rent Cost',b'Co\xc3\xbbt de la Location'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81',b'Amount After Depreciation',b'Montant Apr\xc3\xa8s Amortissement'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97',b'Upcoming Calendar Events',b'Prochains \xc3\x89v\xc3\xa9nements du Calendrier'
+b'apps/erpnext/erpnext/public/js/templates/item_quick_entry.html +1',b'Variant Attributes',b'Attributs Variant'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +85',b'Please select month and year',"b""Veuillez s\xc3\xa9lectionner le mois et l'ann\xc3\xa9e"""
+b'DocType: Employee',b'Company Email',b'E-mail de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: GL Entry',b'Debit Amount in Account Currency',b'Montant D\xc3\xa9biteur en Devise du Compte'
+b'DocType: Supplier Scorecard',b'Scoring Standings',"b""Classement des Fiches d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +21',b'Order Value',b'Valeur de la Commande'
+b'apps/erpnext/erpnext/config/accounts.py +27',b'Bank/Cash transactions against party or for internal transfer',b'Transactions Bancaires/de Tr\xc3\xa9sorerie avec un tiers ou pour transfert interne'
+b'DocType: Shipping Rule',b'Valid for Countries',b'Valable pour les Pays'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +55',"b""This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set""",b'Cet Article est un Mod\xc3\xa8le et ne peut \xc3\xaatre utilis\xc3\xa9 dans les transactions. Les Attributs d\xe2\x80\x99Articles seront copi\xc3\xa9s dans les variantes sauf si \xe2\x80\x98Pas de Copie\xe2\x80\x99 est coch\xc3\xa9'
+b'DocType: Grant Application',b'Grant Application',b'Demande de subvention'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +69',b'Total Order Considered',b'Total de la Commande Consid\xc3\xa9r\xc3\xa9'
+b'apps/erpnext/erpnext/config/hr.py +243',"b'Employee designation (e.g. CEO, Director etc.).'","b'Intitul\xc3\xa9 de poste (e.g.  Directeur G\xc3\xa9n\xc3\xa9ral, Directeur...)'"
+b'DocType: Sales Invoice',"b""Rate at which Customer Currency is converted to customer's base currency""",b'Taux auquel la Devise Client est convertie en devise client de base'
+b'DocType: Course Scheduling Tool',b'Course Scheduling Tool',b'Outil de Planification des Cours'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +623',b'Row #{0}: Purchase Invoice cannot be made against an existing asset {1}',"b""Ligne #{0} : La Facture d'Achat ne peut \xc3\xaatre faite pour un actif existant {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +257',b'[Urgent] Error while creating recurring %s for %s',b'[Urgent] Erreur lors de la cr\xc3\xa9ation de %s r\xc3\xa9currents pour %s'
+b'DocType: Land Unit',b'LInked Analysis',b'Analyse reli\xc3\xa9e'
+b'DocType: Item Tax',b'Tax Rate',"b""Taux d'Imposition"""
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +73',b'Application period cannot be across two allocation records',b'La p\xc3\xa9riode d&#39;application ne peut pas \xc3\xaatre sur deux enregistrements d&#39;allocation'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +59',b'{0} already allocated for Employee {1} for period {2} to {3}',b'{0} d\xc3\xa9j\xc3\xa0 allou\xc3\xa9 pour l\xe2\x80\x99Employ\xc3\xa9 {1} pour la p\xc3\xa9riode {2} \xc3\xa0 {3}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +141',b'Purchase Invoice {0} is already submitted',b'La Facture d\xe2\x80\x99Achat {0} est d\xc3\xa9j\xc3\xa0 soumise'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +92',b'Row # {0}: Batch No must be same as {1} {2}',b'Ligne # {0} : Le N\xc2\xb0 de Lot doit \xc3\xaatre le m\xc3\xaame que {1} {2}'
+b'DocType: Material Request Plan Item',b'Material Request Plan Item',b'Objet du plan de demande de mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +52',b'Convert to non-Group',b'Convertir en non-groupe'
+b'DocType: Project Update',b'Good/Steady',b'Bon / stable'
+b'DocType: C-Form Invoice Detail',b'Invoice Date',b'Date de la Facture'
+b'DocType: GL Entry',b'Debit Amount',b'Montant du D\xc3\xa9bit'
+b'apps/erpnext/erpnext/accounts/party.py +248',b'There can only be 1 Account per Company in {0} {1}',b'Il ne peut y avoir qu\xe2\x80\x99un Compte par Soci\xc3\xa9t\xc3\xa9 dans {0} {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +426',b'Please see attachment',b'Veuillez voir la pi\xc3\xa8ce jointe'
+b'DocType: Purchase Order',b'% Received',b'% Re\xc3\xa7u'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +3',b'Create Student Groups',"b""Cr\xc3\xa9er des Groupes d'\xc3\x89tudiants"""
+b'DocType: Volunteer',b'Weekends',b'Fins de semaine'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Credit Note Amount',b'Montant de la Note de Cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +187',b'{0} ({1}) cannot be greater than planned quanitity ({2}) in Work Order {3}',b'{0} ({1}) ne peut pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 la quantit\xc3\xa9 planifi\xc3\xa9e ({2}) dans le bon de travail {3}'
+b'DocType: Setup Progress Action',b'Action Document',"b""Document d'Action"""
+b'DocType: Chapter Member',b'Website URL',b'URL de site web'
+,b'Finished Goods',b'Produits Finis'
+b'DocType: Delivery Note',b'Instructions',b'Instructions'
+b'DocType: Quality Inspection',b'Inspected By',b'Inspect\xc3\xa9 Par'
+b'DocType: Asset Maintenance Log',b'Maintenance Type',"b""Type d'Entretien"""
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +45',b'{0} - {1} is not enrolled in the Course {2}',"b""{0} - {1} n'est pas inscrit dans le Cours {2}"""
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +225',b'Student Name: ',b'Nom d&#39;\xc3\xa9tudiant:'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59',b'Serial No {0} does not belong to Delivery Note {1}',b'N\xc2\xb0 de S\xc3\xa9rie {0} ne fait pas partie du Bon de Livraison {1}'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +97',"b""There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.""","b'Il semble y avoir un probl\xc3\xa8me avec la configuration GoCardless du serveur. Ne vous inqui\xc3\xa9tez pas, en cas d&#39;\xc3\xa9chec, le montant sera rembours\xc3\xa9 sur votre compte.'"
+b'apps/erpnext/erpnext/templates/pages/demo.html +47',b'ERPNext Demo',b'Demo ERPNext'
+b'apps/erpnext/erpnext/public/js/utils/item_selector.js +20',b'Add Items',b'Ajouter des Articles'
+b'DocType: Item Quality Inspection Parameter',b'Item Quality Inspection Parameter',"b""Param\xc3\xa8tre d'Inspection de Qualit\xc3\xa9 de l'Article"""
+b'DocType: Depreciation Schedule',b'Schedule Date',b'Date du Calendrier'
+b'apps/erpnext/erpnext/config/hr.py +116',"b'Earnings, Deductions and other Salary components'","b'Revenus, Retenues, et autres composantes Salariales'"
+b'DocType: Packed Item',b'Packed Item',b'Article Emball\xc3\xa9'
+b'DocType: Job Offer Term',b'Job Offer Term',b'Terme de l&#39;offre d&#39;emploi'
+b'apps/erpnext/erpnext/config/buying.py +65',b'Default settings for buying transactions.',"b""Param\xc3\xa8tres par d\xc3\xa9faut pour les transactions d'achat."""
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +29',b'Activity Cost exists for Employee {0} against Activity Type - {1}',"b""Des Co\xc3\xbbts d'Activit\xc3\xa9 existent pour l'Employ\xc3\xa9 {0} pour le Type d'Activit\xc3\xa9 - {1}"""
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +15',b'Mandatory field - Get Students From',b'Champ Obligatoire - Obtenir des \xc3\xa9tudiants de'
+b'DocType: Program Enrollment',b'Enrolled courses',b'Cours Inscrits'
+b'DocType: Currency Exchange',b'Currency Exchange',b'Change de Devise'
+b'DocType: Opening Invoice Creation Tool Item',b'Item Name',"b""Nom d'Article"""
+b'DocType: Authorization Rule',b'Approving User  (above authorized value)',b'Utilisateur Approbateur (valeurs autoris\xc3\xa9es ci-dessus)'
+b'DocType: Email Digest',b'Credit Balance',b'Solde du Cr\xc3\xa9dit'
+b'DocType: Employee',b'Widowed',b'Veuf'
+b'DocType: Request for Quotation',b'Request for Quotation',"b""Appel d'Offre"""
+b'DocType: Healthcare Settings',b'Require Lab Test Approval',"b""N\xc3\xa9cessite l'Approbation du Test de Laboratoire"""
+b'DocType: Salary Slip Timesheet',b'Working Hours',b'Heures de Travail'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +59',b'Total Outstanding',b'Total en suspens'
+b'DocType: Naming Series',b'Change the starting / current sequence number of an existing series.',"b""Changer le num\xc3\xa9ro initial/actuel d'une s\xc3\xa9rie existante."""
+b'DocType: Dosage Strength',b'Strength',b'Force'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1534',b'Create a new Customer',b'Cr\xc3\xa9er un nouveau Client'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +59',"b'If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.'","b'Si plusieurs R\xc3\xa8gles de Prix continuent de pr\xc3\xa9valoir, les utilisateurs sont invit\xc3\xa9s \xc3\xa0 d\xc3\xa9finir manuellement la priorit\xc3\xa9 pour r\xc3\xa9soudre les conflits.'"
+b'apps/erpnext/erpnext/utilities/activation.py +90',b'Create Purchase Orders',"b""Cr\xc3\xa9er des Commandes d'Achat"""
+,b'Purchase Register',b'Registre des Achats'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +116',b'Patient not found',b'Patient non trouv\xc3\xa9'
+b'DocType: Scheduling Tool',b'Rechedule',b'Replanifier'
+b'DocType: Landed Cost Item',b'Applicable Charges',b'Frais Applicables'
+b'DocType: Workstation',b'Consumable Cost',b'Co\xc3\xbbt de Consommable'
+b'DocType: Purchase Receipt',b'Vehicle Date',b'Date du V\xc3\xa9hicule'
+b'DocType: Student Log',b'Medical',b'M\xc3\xa9dical'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +175',b'Reason for losing',b'Raison de perdre'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +52',b'Update Account Number',b'Mettre \xc3\xa0 jour le num\xc3\xa9ro'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +44',b'Lead Owner cannot be same as the Lead',b'Le Responsable du Prospect ne peut pas \xc3\xaatre identique au Prospect'
+b'apps/erpnext/erpnext/accounts/utils.py +356',b'Allocated amount can not greater than unadjusted amount',b'Le montant allou\xc3\xa9 ne peut pas \xc3\xaatre plus grand que le montant non ajust\xc3\xa9'
+b'DocType: Announcement',b'Receiver',b'R\xc3\xa9cepteur'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +83',b'Workstation is closed on the following dates as per Holiday List: {0}',b'Le bureau est ferm\xc3\xa9 aux dates suivantes selon la Liste de Vacances : {0}'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +32',b'Opportunities',b'Opportunit\xc3\xa9s'
+b'DocType: Lab Test Template',b'Single',b'Unique'
+b'DocType: Salary Slip',b'Total Loan Repayment',b'Total de Remboursement du Pr\xc3\xaat'
+b'DocType: Account',b'Cost of Goods Sold',b'Co\xc3\xbbt des marchandises vendues'
+b'DocType: Subscription',b'Yearly',b'Annuel'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230',b'Please enter Cost Center',b'Veuillez entrer un Centre de Co\xc3\xbbts'
+b'DocType: Drug Prescription',b'Dosage',b'Dosage'
+b'DocType: Journal Entry Account',b'Sales Order',b'Commande Client'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +69',b'Avg. Selling Rate',b'Moy. Taux de vente'
+b'DocType: Assessment Plan',b'Examiner Name',"b""Nom de l'Examinateur"""
+b'DocType: Lab Test Template',b'No Result',b'Aucun R\xc3\xa9sultat'
+b'DocType: Purchase Invoice Item',b'Quantity and Rate',b'Quantit\xc3\xa9 et Taux'
+b'DocType: Delivery Note',b'% Installed',b'% Install\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/user_progress.py +230',b'Classrooms/ Laboratories etc where lectures can be scheduled.',b'Les Salles de Classe / Laboratoires etc. o\xc3\xb9 des conf\xc3\xa9rences peuvent \xc3\xaatre programm\xc3\xa9es.'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46',b'Please enter company name first',"b""Veuillez d\xe2\x80\x99abord entrer le nom de l'entreprise"""
+b'DocType: Purchase Invoice',b'Supplier Name',b'Nom du Fournisseur'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +25',b'Read the ERPNext Manual',b'Lire le manuel d\xe2\x80\x99ERPNext'
+b'DocType: Purchase Invoice',b'01-Sales Return',b'01-Ventes Retour'
+b'DocType: Account',b'Is Group',b'Est un Groupe'
+b'DocType: Email Digest',b'Pending Purchase Orders',b'Bons de Commande en Attente'
+b'DocType: Stock Settings',b'Automatically Set Serial Nos based on FIFO',b'R\xc3\xa9gler Automatiquement les Nos de S\xc3\xa9rie bas\xc3\xa9s sur FIFO'
+b'DocType: Accounts Settings',b'Check Supplier Invoice Number Uniqueness',"b""V\xc3\xa9rifiez l'Unicit\xc3\xa9 du Num\xc3\xa9ro de Facture du Fournisseur"""
+b'apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js +34',b'Primary Address Details',b'D\xc3\xa9tails de l&#39;adresse principale'
+b'DocType: Vehicle Service',b'Oil Change',b'Vidange'
+b'DocType: Asset Maintenance Log',b'Asset Maintenance Log',b'Journal de Maintenance des Actifs'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57',"b""'To Case No.' cannot be less than 'From Case No.'""","b""'Au Cas N\xc2\xb0\xe2\x80\x99 ne peut pas \xc3\xaatre inf\xc3\xa9rieur \xc3\xa0 \xe2\x80\x98Du Cas N\xc2\xb0\xe2\x80\x99"""
+b'DocType: Chapter',b'Non Profit',b'\xc3\x80 But Non Lucratif'
+b'DocType: Production Plan',b'Not Started',b'Non Commenc\xc3\xa9'
+b'DocType: Lead',b'Channel Partner',b'Partenaire de Canal'
+b'DocType: Account',b'Old Parent',b'Grand Parent'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +19',b'Mandatory field - Academic Year',b'Champ Obligatoire - Ann\xc3\xa9e Acad\xc3\xa9mique'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +220',b'{0} {1} is not associated with {2} {3}',b'{0} {1} n&#39;est pas associ\xc3\xa9 \xc3\xa0 {2} {3}'
+b'DocType: Notification Control',b'Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.',"b""Personnaliser le texte d'introduction qui fera partie de cet Email. Chaque transaction a une introduction s\xc3\xa9par\xc3\xa9e."""
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +176',b'Please set default payable account for the company {0}',b'Veuillez d\xc3\xa9finir le compte cr\xc3\xa9diteur par d\xc3\xa9faut pour la soci\xc3\xa9t\xc3\xa9 {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +511',b'Transaction not allowed against stopped Work Order {0}',b'La transaction n&#39;est pas autoris\xc3\xa9e sur l&#39;ordre de travail arr\xc3\xaat\xc3\xa9 {0}'
+b'DocType: Setup Progress Action',b'Min Doc Count',b'Compte de Document Minimum'
+b'apps/erpnext/erpnext/config/manufacturing.py +84',b'Global settings for all manufacturing processes.',b'Param\xc3\xa8tres globaux pour tous les processus de fabrication.'
+b'DocType: Accounts Settings',b'Accounts Frozen Upto',"b""Comptes Gel\xc3\xa9s Jusqu'au"""
+b'DocType: SMS Log',b'Sent On',b'Envoy\xc3\xa9 le'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +700',b'Attribute {0} selected multiple times in Attributes Table',b'Attribut {0} s\xc3\xa9lectionn\xc3\xa9 \xc3\xa0 plusieurs reprises dans le Tableau des Attributs'
+b'DocType: HR Settings',b'Employee record is created using selected field. ',"b""Le dossier de l'employ\xc3\xa9 est cr\xc3\xa9\xc3\xa9 en utilisant le champ s\xc3\xa9lectionn\xc3\xa9."""
+b'DocType: Sales Order',b'Not Applicable',b'Non Applicable'
+b'apps/erpnext/erpnext/config/hr.py +70',b'Holiday master.',b'Donn\xc3\xa9es de Base des Vacances'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +85',b'Opening Invoice Item',b'Ouverture d&#39;un poste de facture'
+b'DocType: Request for Quotation Item',b'Required Date',b'Date Requise'
+b'DocType: Delivery Note',b'Billing Address',b'Adresse de Facturation'
+b'DocType: BOM',b'Costing',b'Co\xc3\xbbt'
+b'DocType: Tax Rule',b'Billing County',b'D\xc3\xa9partement de Facturation'
+b'DocType: Purchase Taxes and Charges',"b'If checked, the tax amount will be considered as already included in the Print Rate / Print Amount'","b""Si coch\xc3\xa9e, le montant de la taxe sera consid\xc3\xa9r\xc3\xa9 comme d\xc3\xa9j\xc3\xa0 inclus dans le Taux d'Impression / Prix d'Impression"""
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceRef',b'PieceRef'
+b'DocType: Request for Quotation',b'Message for Supplier',b'Message pour le Fournisseur'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +40',b'Work Order',b'Ordre de travail'
+b'DocType: Driver',b'DRIVER-.#####',b'CHAUFFEUR-.#####'
+b'DocType: Sales Invoice',b'Total Qty',b'Qt\xc3\xa9 Totale'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +62',b'Guardian2 Email ID',b'ID Email du Tuteur2'
+b'DocType: Item',b'Show in Website (Variant)',b'Afficher dans le Website (Variant)'
+b'DocType: Employee',b'Health Concerns',b'Probl\xc3\xa8mes de Sant\xc3\xa9'
+b'DocType: Payroll Entry',b'Select Payroll Period',b'S\xc3\xa9lectionner la P\xc3\xa9riode de Paie'
+b'DocType: Purchase Invoice',b'Unpaid',b'Impay\xc3\xa9'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +49',b'Reserved for sale',b'R\xc3\xa9serv\xc3\xa9 \xc3\xa0 la Vente'
+b'DocType: Packing Slip',b'From Package No.',b'Du N\xc2\xb0 de Colis'
+b'DocType: Item Attribute',b'To Range',b'Au Rang'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29',b'Securities and Deposits',b'Titres et D\xc3\xa9p\xc3\xb4ts'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +46',"b""Can't change valuation method, as there are transactions against some items which does not have it's own valuation method""","b'Impossible de modifier la m\xc3\xa9thode de valorisation, car il existe des transactions sur certains articles ne poss\xc3\xa8dant pas leur propre m\xc3\xa9thode de valorisation'"
+b'DocType: Student Report Generation Tool',b'Attended by Parents',b'Assist\xc3\xa9 par les parents'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +82',b'Total leaves allocated is mandatory',b'Total des Cong\xc3\xa9s attribu\xc3\xa9s est obligatoire'
+b'DocType: Patient',b'AB Positive',b'AB Positif'
+b'DocType: Job Opening',b'Description of a Job Opening',"b""Description d'une Nouvelle Offre d\xe2\x80\x99Emploi"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +110',b'Pending activities for today',"b""Activit\xc3\xa9s en Attente pour aujourd'hui"""
+b'apps/erpnext/erpnext/config/hr.py +24',b'Attendance record.',b'Registre des pr\xc3\xa9sences.'
+b'DocType: Salary Structure',b'Salary Component for timesheet based payroll.',b'Composante Salariale pour la r\xc3\xa9mun\xc3\xa9ration bas\xc3\xa9e sur la feuille de temps'
+b'DocType: Sales Order Item',b'Used for Production Plan',b'Utilis\xc3\xa9 pour Plan de Production'
+b'DocType: Employee Loan',b'Total Payment',b'Paiement Total'
+b'DocType: Manufacturing Settings',b'Time Between Operations (in mins)',b'Temps entre les op\xc3\xa9rations (en min)'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +132',b'{0} {1} is cancelled so the action cannot be completed',"b""{0} {1} est annul\xc3\xa9, donc l'action ne peut pas \xc3\xaatre compl\xc3\xa9t\xc3\xa9e"""
+b'DocType: Customer',b'Buyer of Goods and Services.',b'Acheteur des Biens et Services.'
+b'DocType: Journal Entry',b'Accounts Payable',b'Comptes Cr\xc3\xa9diteurs'
+b'DocType: Patient',b'Allergies',b'Allergies'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +33',b'The selected BOMs are not for the same item',b'Les LDMs s\xc3\xa9lectionn\xc3\xa9es ne sont pas pour le m\xc3\xaame article'
+b'DocType: Supplier Scorecard Standing',b'Notify Other',b'Notifier Autre'
+b'DocType: Vital Signs',b'Blood Pressure (systolic)',b'Pression Art\xc3\xa9rielle (Systolique)'
+b'DocType: Pricing Rule',b'Valid Upto',"b""Valide Jusqu'au"""
+b'DocType: Training Event',b'Workshop',b'Atelier'
+b'DocType: Supplier Scorecard Scoring Standing',b'Warn Purchase Orders',b'Avertir lors de Bons de Commande'
+b'apps/erpnext/erpnext/utilities/user_progress.py +67',b'List a few of your customers. They could be organizations or individuals.',b'Listez quelques-uns de vos clients. Ils peuvent \xc3\xaatre des entreprise ou des individus.'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +23',b'Enough Parts to Build',b'Pi\xc3\xa8ces Suffisantes pour Construire'
+b'DocType: POS Profile User',b'POS Profile User',b'Utilisateur du profil PDV'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +128',b'Direct Income',b'Revenu Direct'
+b'DocType: Patient Appointment',b'Date TIme',b'Date Heure'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45',"b'Can not filter based on Account, if grouped by Account'","b'Impossible de filtrer sur le Compte , si les lignes sont regroup\xc3\xa9es par Compte'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +130',b'Administrative Officer',b'Agent Administratif'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +39',b'Setting up company and taxes',b'Cr\xc3\xa9ation d&#39;entreprise et taxes'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +22',b'Please select Course',b'Veuillez s\xc3\xa9lectionner un Cours'
+b'DocType: Codification Table',b'Codification Table',b'Tableau de Codifications'
+b'DocType: Timesheet Detail',b'Hrs',b'Hrs'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +349',b'Please select Company',b'Veuillez s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Stock Entry Detail',b'Difference Account',b'Compte d\xe2\x80\x99\xc3\x89cart'
+b'DocType: Purchase Invoice',b'Supplier GSTIN',b'GSTIN du Fournisseur'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +47',b'Cannot close task as its dependant task {0} is not closed.',"b""Impossible de fermer une t\xc3\xa2che si t\xc3\xa2che d\xc3\xa9pendante {0} n'est pas ferm\xc3\xa9e."""
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +435',b'Please enter Warehouse for which Material Request will be raised',b'Veuillez entrer l\xe2\x80\x99Entrep\xc3\xb4t pour lequel une Demande de Mat\xc3\xa9riel sera faite'
+b'DocType: Work Order',b'Additional Operating Cost',"b""Co\xc3\xbbt d'Exploitation Suppl\xc3\xa9mentaires"""
+b'DocType: Lab Test Template',b'Lab Routine',b'Routine de laboratoire'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +20',b'Cosmetics',b'Produits de Beaut\xc3\xa9'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +18',b'Please select Completion Date for Completed Asset Maintenance Log',b'Veuillez s\xc3\xa9lectionner la date d&#39;ach\xc3\xa8vement pour le journal de maintenance des actifs termin\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +552',"b'To merge, following properties must be same for both items'","b'Pour fusionner, les propri\xc3\xa9t\xc3\xa9s suivantes doivent \xc3\xaatre les m\xc3\xaames pour les deux articles'"
+b'DocType: Shipping Rule',b'Net Weight',b'Poids Net'
+b'DocType: Employee',b'Emergency Phone',"b""T\xc3\xa9l\xc3\xa9phone d'Urgence"""
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +82',b'{0} {1} does not exist.',b'{0} {1} n&#39;existe pas'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +29',b'Buy',b'Acheter'
+,b'Serial No Warranty Expiry',b'Expiration de Garantie du N\xc2\xb0 de S\xc3\xa9rie'
+b'DocType: Sales Invoice',b'Offline POS Name',b'Nom du PDV Hors-ligne`'
+b'apps/erpnext/erpnext/utilities/user_progress.py +180',b'Student Application',b'Candidature \xc3\x89tudiante'
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +20',b'Please define grade for Threshold 0%',b'Veuillez d\xc3\xa9finir une note pour le Seuil 0%'
+b'DocType: Sales Order',b'To Deliver',b'\xc3\x80 Livrer'
+b'DocType: Purchase Invoice Item',b'Item',b'Article'
+b'apps/erpnext/erpnext/healthcare/setup.py +256',b'High Sensitivity',b'Haute Sensibilit\xc3\xa9'
+b'apps/erpnext/erpnext/config/non_profit.py +48',b'Volunteer Type information.',b'Volontaire Type d&#39;information.'
+b'DocType: Cash Flow Mapping Template',b'Cash Flow Mapping Template',b'Mod\xc3\xa8le de cartographie des flux de tr\xc3\xa9sorerie'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2555',b'Serial no item cannot be a fraction',"b""N\xc2\xb0 de s\xc3\xa9rie de l'article ne peut pas \xc3\xaatre une fraction"""
+b'DocType: Journal Entry',b'Difference (Dr - Cr)',b'\xc3\x89cart (Dr - Cr )'
+b'DocType: Account',b'Profit and Loss',b'Pertes et Profits'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +104',"b'Not permitted, configure Lab Test Template as required'","b'Non autoris\xc3\xa9, configurez le mod\xc3\xa8le de test de laboratoire au besoin'"
+b'DocType: Patient',b'Risk Factors',b'Facteurs de Risque'
+b'DocType: Patient',b'Occupational Hazards and Environmental Factors',b'Dangers Professionnels et Facteurs Environnementaux'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239',b'Stock Entries already created for Work Order ',b'Entr\xc3\xa9es de stock d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9es pour l&#39;ordre de travail'
+b'DocType: Vital Signs',b'Respiratory rate',b'Fr\xc3\xa9quence Respiratoire'
+b'apps/erpnext/erpnext/config/stock.py +334',b'Managing Subcontracting',b'Gestion de la Sous-traitance'
+b'DocType: Vital Signs',b'Body Temperature',b'Temp\xc3\xa9rature Corporelle'
+b'DocType: Project',b'Project will be accessible on the website to these users',b'Le Projet sera accessible sur le site web \xc3\xa0 ces utilisateurs'
+b'DocType: Detected Disease',b'Disease',b'Maladie'
+b'apps/erpnext/erpnext/config/projects.py +29',b'Define Project type.',b'D\xc3\xa9finir le Type de Projet.'
+b'DocType: Supplier Scorecard',b'Weighting Function',b'Fonction de Pond\xc3\xa9ration'
+b'DocType: Physician',b'OP Consulting Charge',b'Honoraires de Consulations Externe'
+b'apps/erpnext/erpnext/utilities/user_progress.py +28',b'Setup your ',b'Configurez votre'
+b'DocType: Student Report Generation Tool',b'Show Marks',b'Afficher les marques'
+b'DocType: Quotation',"b""Rate at which Price list currency is converted to company's base currency""",b'Taux auquel la devise de la Liste de prix est convertie en devise soci\xc3\xa9t\xc3\xa9 de base'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +70',b'Account {0} does not belong to company: {1}',"b""Le compte {0} n'appartient pas \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 : {1}"""
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +52',b'Abbreviation already used for another company',b'Abr\xc3\xa9viation d\xc3\xa9j\xc3\xa0 utilis\xc3\xa9e pour une autre soci\xc3\xa9t\xc3\xa9'
+b'DocType: Selling Settings',b'Default Customer Group',b'Groupe de Clients par D\xc3\xa9faut'
+b'DocType: Asset Repair',b'ARLOG-',b'ARLOG-'
+b'DocType: Global Defaults',"b""If disable, 'Rounded Total' field will not be visible in any transaction""","b""Si coch\xc3\xa9, le champ 'Total Arrondi' ne sera visible dans aucune transaction."""
+b'DocType: BOM',b'Operating Cost',"b""Co\xc3\xbbt d'Exploitation"""
+b'DocType: Crop',b'Produced Items',b'Articles produits'
+b'DocType: Sales Order Item',b'Gross Profit',b'B\xc3\xa9n\xc3\xa9fice Brut'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +49',b'Increment cannot be 0',b'Incr\xc3\xa9ment ne peut pas \xc3\xaatre 0'
+b'DocType: Company',b'Delete Company Transactions',b'Supprimer les Transactions de la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +364',b'Reference No and Reference Date is mandatory for Bank transaction',b'Le N\xc2\xb0 de R\xc3\xa9f\xc3\xa9rence et la Date de R\xc3\xa9f\xc3\xa9rence sont n\xc3\xa9cessaires pour une Transaction Bancaire'
+b'DocType: Purchase Receipt',b'Add / Edit Taxes and Charges',b'Ajouter / Modifier Taxes et Charges'
+b'DocType: Payment Entry Reference',b'Supplier Invoice No',b'N\xc2\xb0 de Facture du Fournisseur'
+b'DocType: Territory',b'For reference',b'Pour r\xc3\xa9f\xc3\xa9rence'
+b'DocType: Healthcare Settings',b'Appointment Confirmation',b'Confirmation de Rendez-Vous'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +158',"b'Cannot delete Serial No {0}, as it is used in stock transactions'","b""Impossible de supprimer les N\xc2\xb0 de s\xc3\xa9rie {0}, s'ils sont dans les mouvements de stock"""
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +256',b'Closing (Cr)',b'Fermeture (Cr)'
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +1',b'Hello',b'Bonjour'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +118',b'Move Item',"b""D\xc3\xa9placer l'Article"""
+b'DocType: Serial No',b'Warranty Period (Days)',b'P\xc3\xa9riode de Garantie (Jours)'
+b'DocType: Installation Note Item',b'Installation Note Item',"b""Article Remarque d'Installation"""
+b'DocType: Production Plan Item',b'Pending Qty',b'Qt\xc3\xa9 en Attente'
+b'DocType: Budget',b'Ignore',b'Ignorer'
+b'apps/erpnext/erpnext/accounts/party.py +396',b'{0} {1} is not active',"b""{0} {1} n'est pas actif"""
+b'apps/erpnext/erpnext/config/accounts.py +272',b'Setup cheque dimensions for printing',"b""Configurez les dimensions du ch\xc3\xa8que pour l'impression"""
+b'DocType: Salary Slip',b'Salary Slip Timesheet',b'Feuille de Temps de la Fiche de Paie'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +160',b'Supplier Warehouse mandatory for sub-contracted Purchase Receipt',"b""Entrep\xc3\xb4t Fournisseur obligatoire pour les Re\xc3\xa7us d'Achat sous-trait\xc3\xa9s"""
+b'DocType: Pricing Rule',b'Valid From',b'Valide \xc3\xa0 Partir de'
+b'DocType: Sales Invoice',b'Total Commission',b'Total de la Commission'
+b'DocType: Pricing Rule',b'Sales Partner',b'Partenaire Commercial'
+b'apps/erpnext/erpnext/config/buying.py +150',b'All Supplier scorecards.',"b""Toutes les Fiches d'\xc3\x89valuation Fournisseurs."""
+b'DocType: Buying Settings',b'Purchase Receipt Required',b'Re\xc3\xa7u d\xe2\x80\x99Achat Requis'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +188',b'Target warehouse in row {0} must be same as Work Order',b'L&#39;entrep\xc3\xb4t cible dans la ligne {0} doit \xc3\xaatre identique \xc3\xa0 l&#39;ordre de travail'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +155',b'Valuation Rate is mandatory if Opening Stock entered',b'Le Taux de Valorisation est obligatoire si un Stock Initial est entr\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +143',b'No records found in the Invoice table',b'Aucun enregistrement trouv\xc3\xa9 dans la table Facture'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +34',b'Please select Company and Party Type first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9 et le Type de Tiers'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +31',"b'Already set default in pos profile {0} for user {1}, kindly disabled default'","b'D\xc3\xa9j\xc3\xa0 d\xc3\xa9fini par d\xc3\xa9faut dans le profil pos {0} pour l&#39;utilisateur {1}, aimablement d\xc3\xa9sactiv\xc3\xa9 par d\xc3\xa9faut'"
+b'apps/erpnext/erpnext/config/accounts.py +293',b'Financial / accounting year.',b'Exercice comptable / financier'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js +9',b'Accumulated Values',b'Valeurs Accumul\xc3\xa9es'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +162',"b'Sorry, Serial Nos cannot be merged'","b'D\xc3\xa9sol\xc3\xa9, les N\xc2\xb0 de S\xc3\xa9rie ne peut pas \xc3\xaatre fusionn\xc3\xa9s'"
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +72',b'Territory is Required in POS Profile',b'Le Territoire est Requis dans le Profil PDV'
+b'DocType: Supplier',b'Prevent RFQs',"b""Interdire les Appels d'Offres"""
+b'apps/erpnext/erpnext/utilities/activation.py +83',b'Make Sales Order',b'Cr\xc3\xa9er une Commande Client'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +168',b'Salary Slip submitted for period from {0} to {1}',b'Salaire soumis pour la p\xc3\xa9riode du {0} au {1}'
+b'DocType: Project Task',b'Project Task',b'T\xc3\xa2che du Projet'
+,b'Lead Id',b'Id du Prospect'
+b'DocType: C-Form Invoice Detail',b'Grand Total',b'Total TTC'
+b'DocType: Assessment Plan',b'Course',b'Cours'
+b'DocType: Timesheet',b'Payslip',b'Fiche de Paie'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +4',b'Item Cart',b'Article du Panier'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +38',b'Fiscal Year Start Date should not be greater than Fiscal Year End Date',"b""La Date de D\xc3\xa9but ne doit pas \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 la Date de Fin de l'Exercice Fiscal"""
+b'DocType: Issue',b'Resolution',b'R\xc3\xa9solution'
+b'DocType: C-Form',b'IV',b'IV'
+b'apps/erpnext/erpnext/templates/pages/order.html +76',b'Delivered: {0}',b'Livr\xc3\xa9: {0}'
+b'DocType: Expense Claim',b'Payable Account',b'Comptes Cr\xc3\xa9diteurs'
+b'DocType: Payment Entry',b'Type of Payment',b'Type de Paiement'
+b'DocType: Sales Order',b'Billing and Delivery Status',b'Facturation et Statut de Livraison'
+b'DocType: Job Applicant',b'Resume Attachment',b'Reprendre la Pi\xc3\xa8ce Jointe'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58',b'Repeat Customers',b'Clients R\xc3\xa9currents'
+b'DocType: Leave Control Panel',b'Allocate',b'Allouer'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +108',b'Create Variant',b'Cr\xc3\xa9er une variante'
+b'DocType: Sales Invoice',b'Shipping Bill Date',b'Date de facturation'
+b'DocType: Production Plan',b'Production Plan',b'Plan de production'
+b'DocType: Opening Invoice Creation Tool',b'Opening Invoice Creation Tool',b'Ouverture de l&#39;outil de cr\xc3\xa9ation de facture'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +853',b'Sales Return',b'Retour de Ventes'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +96',"b""Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period""",b'Remarque : Le total des cong\xc3\xa9s allou\xc3\xa9s {0} ne doit pas \xc3\xaatre inf\xc3\xa9rieur aux cong\xc3\xa9s d\xc3\xa9j\xc3\xa0 approuv\xc3\xa9s {1} pour la p\xc3\xa9riode'
+,b'Total Stock Summary',"b""R\xc3\xa9capitulatif de l'Inventaire Total"""
+b'DocType: Announcement',b'Posted By',b'Post\xc3\xa9 par'
+b'DocType: Item',b'Delivered by Supplier (Drop Ship)',b'Livr\xc3\xa9 par le Fournisseur (Exp\xc3\xa9dition Directe)'
+b'DocType: Healthcare Settings',b'Confirmation Message',b'Message de Confirmation'
+b'apps/erpnext/erpnext/config/crm.py +12',b'Database of potential customers.',b'Base de donn\xc3\xa9es de clients potentiels.'
+b'DocType: Authorization Rule',b'Customer or Item',b'Client ou Article'
+b'apps/erpnext/erpnext/config/selling.py +28',b'Customer database.',b'Base de donn\xc3\xa9es Clients.'
+b'DocType: Quotation',b'Quotation To',b'Devis Pour'
+b'DocType: Lead',b'Middle Income',b'Revenu Interm\xc3\xa9diaire'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +228',b'Opening (Cr)',b'Ouverture (Cr)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +872',b'Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.',b'L\xe2\x80\x99Unit\xc3\xa9 de Mesure par D\xc3\xa9faut pour l\xe2\x80\x99Article {0} ne peut pas \xc3\xaatre modifi\xc3\xa9e directement parce que vous avez d\xc3\xa9j\xc3\xa0 fait une (des) transaction (s) avec une autre unit\xc3\xa9 de mesure. Vous devez cr\xc3\xa9er un nouvel article pour utiliser une UDM par d\xc3\xa9faut diff\xc3\xa9rente.'
+b'apps/erpnext/erpnext/accounts/utils.py +354',b'Allocated amount can not be negative',b'Le montant allou\xc3\xa9 ne peut \xc3\xaatre n\xc3\xa9gatif'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +11',b'Please set the Company',b'Veuillez d\xc3\xa9finir la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Share Balance',b'Share Balance',b'Partager le solde'
+b'DocType: Purchase Order Item',b'Billed Amt',b'Mnt Factur\xc3\xa9'
+b'DocType: Training Result Employee',b'Training Result Employee',b'R\xc3\xa9sultat de la Formation \xe2\x80\x93 Employ\xc3\xa9'
+b'DocType: Warehouse',b'A logical Warehouse against which stock entries are made.',b'Un Entrep\xc3\xb4t logique dans lequel les entr\xc3\xa9es en stock sont faites.'
+b'DocType: Repayment Schedule',b'Principal Amount',b'Montant Principal'
+b'DocType: Employee Loan Application',b'Total Payable Interest',b'Total des Int\xc3\xa9r\xc3\xaats Cr\xc3\xa9diteurs'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +57',b'Total Outstanding: {0}',b'Total en Attente: {0}'
+b'DocType: Sales Invoice Timesheet',b'Sales Invoice Timesheet',b'Feuille de Temps de la Facture de Vente'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +118',b'Reference No & Reference Date is required for {0}',b'N\xc2\xb0 et Date de R\xc3\xa9f\xc3\xa9rence sont n\xc3\xa9cessaires pour {0}'
+b'DocType: Payroll Entry',b'Select Payment Account to make Bank Entry',"b""S\xc3\xa9lectionner Compte de Cr\xc3\xa9dit pour faire l'\xc3\x89criture Bancaire"""
+b'DocType: Hotel Settings',b'Default Invoice Naming Series',b'S\xc3\xa9rie de d\xc3\xa9nomination de facture par d\xc3\xa9faut'
+b'apps/erpnext/erpnext/utilities/activation.py +136',"b'Create Employee records to manage leaves, expense claims and payroll'","b'Cr\xc3\xa9er des dossiers Employ\xc3\xa9s pour g\xc3\xa9rer les cong\xc3\xa9s, les notes de frais et la paie'"
+b'DocType: Restaurant Reservation',b'Restaurant Reservation',b'R\xc3\xa9servation de restaurant'
+b'DocType: Land Unit',b'Land Unit Name',b'Nom de la parcelle'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +190',b'Proposal Writing',b'R\xc3\xa9daction de Propositions'
+b'DocType: Payment Entry Deduction',b'Payment Entry Deduction',b'D\xc3\xa9duction d\xe2\x80\x99\xc3\x89criture de Paiement'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +14',b'Wrapping up',b'Emballer'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +35',b'Notify Customers via Email',b'Avertir les clients par courrier \xc3\xa9lectronique'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +35',b'Another Sales Person {0} exists with the same Employee id',"b""Un autre Commercial {0} existe avec le m\xc3\xaame ID d'Employ\xc3\xa9"""
+b'DocType: Employee Advance',b'Claimed Amount',b'Montant r\xc3\xa9clam\xc3\xa9'
+b'apps/erpnext/erpnext/config/education.py +180',b'Masters',b'Donn\xc3\xa9es de Base'
+b'DocType: Assessment Plan',b'Maximum Assessment Score',b'Score d&#39;\xc3\xa9valuation maximale'
+b'apps/erpnext/erpnext/config/accounts.py +138',b'Update Bank Transaction Dates',b'Mettre \xc3\xa0 jour les Dates de Transation Bancaire'
+b'apps/erpnext/erpnext/config/projects.py +41',b'Time Tracking',b'Suivi du Temps'
+b'DocType: Purchase Invoice',b'DUPLICATE FOR TRANSPORTER',b'DUPLICATA POUR LE TRANSPORTEUR'
+b'apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py +49',b'Row {0}# Paid Amount cannot be greater than requested advance amount',b'La ligne {0} # Montant pay\xc3\xa9 ne peut pas \xc3\xaatre sup\xc3\xa9rieure au montant de l&#39;avance demand\xc3\xa9e'
+b'DocType: Fiscal Year Company',b'Fiscal Year Company',b'Soci\xc3\xa9t\xc3\xa9 de l\xe2\x80\x99Exercice Fiscal'
+b'DocType: Packing Slip Item',b'DN Detail',b'D\xc3\xa9tail du Bon de Livraison'
+b'DocType: Training Event',b'Conference',b'Conf\xc3\xa9rence'
+b'DocType: Timesheet',b'Billed',b'Factur\xc3\xa9'
+b'DocType: Batch',b'Batch Description',b'Description du Lot'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js +12',b'Creating student groups',b'Cr\xc3\xa9er des groupes d&#39;\xc3\xa9tudiants'
+b'apps/erpnext/erpnext/accounts/utils.py +727',"b'Payment Gateway Account not created, please create one manually.'","b'Le Compte Passerelle de Paiement n\xe2\x80\x99existe pas, veuillez en cr\xc3\xa9er un manuellement.'"
+b'DocType: Supplier Scorecard',b'Per Year',b'Par An'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +51',b'Not eligible for the admission in this program as per DOB',"b""Non admissible \xc3\xa0 l'admission dans ce programme d'apr\xc3\xa8s sa date de naissance"""
+b'DocType: Sales Invoice',b'Sales Taxes and Charges',b'Taxes et Frais de Vente'
+b'DocType: Employee',b'Organization Profile',"b""Profil de l'Organisation"""
+b'DocType: Vital Signs',b'Height (In Meter)',b'Hauteur (en M\xc3\xa8tres)'
+b'DocType: Student',b'Sibling Details',b'D\xc3\xa9tails Fr\xc3\xa8res et S\xc5\x93urs'
+b'DocType: Vehicle Service',b'Vehicle Service',b'Entretien du V\xc3\xa9hicule'
+b'apps/erpnext/erpnext/config/setup.py +101',b'Automatically triggers the feedback request based on conditions.',"b""D\xc3\xa9clencher automatiquement la demande de retour d'exp\xc3\xa9rience en fonction des conditions."""
+b'DocType: Employee',b'Reason for Resignation',b'Raison de la D\xc3\xa9mission'
+b'apps/erpnext/erpnext/config/hr.py +152',b'Template for performance appraisals.',"b""Mod\xc3\xa8le pour l'\xc3\xa9valuation de la performance."""
+b'DocType: Sales Invoice',b'Credit Note Issued',b'Note de Cr\xc3\xa9dit \xc3\x89mise'
+b'DocType: Project Task',b'Weight',b'Poids'
+b'DocType: Payment Reconciliation',b'Invoice/Journal Entry Details',"b""D\xc3\xa9tails de Facture / Journal d'\xc3\x89criture"""
+b'apps/erpnext/erpnext/accounts/utils.py +83',"b""{0} '{1}' not in Fiscal Year {2}""","b""{0} '{1}' n'est pas dans l\xe2\x80\x99Exercice {2}"""
+b'DocType: Buying Settings',b'Settings for Buying Module',"b""R\xc3\xa9glages pour le Module d'Achats"""
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +21',b'Asset {0} does not belong to company {1}',"b""L'actif {0} ne fait pas partie \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 {1}"""
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +70',b'Please enter Purchase Receipt first',"b""Veuillez d\xe2\x80\x99abord entrer un Re\xc3\xa7u d'Achat"""
+b'DocType: Buying Settings',b'Supplier Naming By',b'Nomenclature de Fournisseur Par'
+b'DocType: Activity Type',b'Default Costing Rate',b'Co\xc3\xbbt de Revient par D\xc3\xa9faut'
+b'DocType: Maintenance Schedule',b'Maintenance Schedule',"b""\xc3\x89ch\xc3\xa9ancier d'Entretien"""
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +36',"b'Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.'","b'Les R\xc3\xa8gles de Tarification sont ensuite filtr\xc3\xa9es en fonction des Clients, des Groupes de Clients, des R\xc3\xa9gions, des Fournisseurs, des Groupes de Fournisseurs, des Campagnes, des Partenaires Commerciaux, etc.'"
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +29',b'Net Change in Inventory',b'Variation Nette des Stocks'
+b'apps/erpnext/erpnext/config/hr.py +162',b'Employee Loan Management',b'Gestion des Pr\xc3\xaats des Employ\xc3\xa9s'
+b'DocType: Employee',b'Passport Number',b'Num\xc3\xa9ro de Passeport'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +60',b'Relation with Guardian2',b'Relation avec Tuteur2'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +124',b'Manager',b'Directeur'
+b'DocType: Payment Entry',b'Payment From / To',b'Paiement De / \xc3\x80'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +170',b'New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0}',"b""Nouvelle limite de cr\xc3\xa9dit est inf\xc3\xa9rieure \xc3\xa0 l'encours actuel pour le client. Limite de cr\xc3\xa9dit doit \xc3\xaatre au moins de {0}"""
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +428',b'Please set account in Warehouse {0}',b'Veuillez d\xc3\xa9finir un compte dans l&#39;entrep\xc3\xb4t {0}'
+b'apps/erpnext/erpnext/controllers/trends.py +39',"b""'Based On' and 'Group By' can not be same""","b""'Bas\xc3\xa9 sur' et 'Group\xc3\xa9 par' ne peuvent pas \xc3\xaatre identiques"""
+b'DocType: Sales Person',b'Sales Person Targets',b'Objectifs des Commerciaux'
+b'DocType: Installation Note',b'IN-',b'DANS-'
+b'DocType: Work Order Operation',b'In minutes',b'En Minutes'
+b'DocType: Issue',b'Resolution Date',b'Date de R\xc3\xa9solution'
+b'DocType: Lab Test Template',b'Compound',b'Compos\xc3\xa9'
+b'DocType: Student Batch Name',b'Batch Name',b'Nom du Lot'
+b'DocType: Fee Validity',b'Max number of visit',b'Nombre maximum de visites'
+,b'Hotel Room Occupancy',b'Occupation de la chambre de l&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +358',b'Timesheet created:',b'Feuille de Temps cr\xc3\xa9\xc3\xa9e :'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +931',b'Please set default Cash or Bank account in Mode of Payment {0}',b'Veuillez d\xc3\xa9finir un compte de Caisse ou de Banque par d\xc3\xa9faut pour le Mode de Paiement {0}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +24',b'Enroll',b'Inscrire'
+b'DocType: GST Settings',b'GST Settings',b'Param\xc3\xa8tres GST'
+b'DocType: Selling Settings',b'Customer Naming By',b'Client Nomm\xc3\xa9 par'
+b'DocType: Student Leave Application',b'Will show the student as Present in Student Monthly Attendance Report',"b""Affichera l'\xc3\xa9tudiant comme Pr\xc3\xa9sent dans le Rapport Mensuel de Pr\xc3\xa9sence des \xc3\x89tudiants"""
+b'DocType: Depreciation Schedule',b'Depreciation Amount',"b""Montant d'Amortissement"""
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +56',b'Convert to Group',b'Convertir en Groupe'
+b'DocType: Delivery Trip',b'TOUR-.#####',b'TOUR-.#####'
+b'DocType: Activity Cost',b'Activity Type',b'Type d&#39;activit\xc3\xa9'
+b'DocType: Request for Quotation',b'For individual supplier',b'Pour un fournisseur individuel'
+b'DocType: BOM Operation',b'Base Hour Rate(Company Currency)',b'Taux Horaire de Base (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47',b'Delivered Amount',b'Montant Livr\xc3\xa9'
+b'DocType: Quotation Item',b'Item Balance',"b""Solde de l'Article"""
+b'DocType: Sales Invoice',b'Packing List',b'Liste de Colisage'
+b'apps/erpnext/erpnext/config/buying.py +28',b'Purchase Orders given to Suppliers.',b'Bons de Commande donn\xc3\xa9s aux Fournisseurs'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +43',b'Publishing',b'\xc3\x89dition'
+b'DocType: Accounts Settings',b'Report Settings',b'Param\xc3\xa8tres de rapport'
+b'DocType: Activity Cost',b'Projects User',b'Utilisateur/Intervenant Projets'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Consumed',b'Consomm\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +158',b'{0}: {1} not found in Invoice Details table',b'{0} : {1} introuvable dans la table de D\xc3\xa9tails de la Facture'
+b'DocType: Asset',b'Asset Owner Company',"b""Soci\xc3\xa9t\xc3\xa9 Propri\xc3\xa9taire de l'Actif"""
+b'DocType: Company',b'Round Off Cost Center',b'Centre de Co\xc3\xbbts d\xe2\x80\x99Arrondi'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +242',b'Maintenance Visit {0} must be cancelled before cancelling this Sales Order',"b""La Visite d'Entretien {0} doit \xc3\xaatre annul\xc3\xa9e avant d'annuler cette Commande Client"""
+b'DocType: Asset Maintenance Log',b'AML-',b'AML-'
+b'DocType: Item',b'Material Transfer',b'Transfert de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py +24',b'Could not find path for ',b'Impossible de trouver un chemin pour'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +221',b'Opening (Dr)',b'Ouverture (Dr)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +39',b'Posting timestamp must be after {0}',b'Horodatage de Publication doit \xc3\xaatre apr\xc3\xa8s {0}'
+b'apps/erpnext/erpnext/config/accounts.py +39',b'To make recurring documents',b'Pour faire des documents r\xc3\xa9currents'
+,b'GST Itemised Purchase Register',"b""Registre d'Achat D\xc3\xa9taill\xc3\xa9 GST"""
+b'DocType: Course Scheduling Tool',b'Reschedule',b'Reporter'
+b'DocType: Employee Loan',b'Total Interest Payable',b'Total des Int\xc3\xa9r\xc3\xaats \xc3\xa0 Payer'
+b'DocType: Landed Cost Taxes and Charges',b'Landed Cost Taxes and Charges',b'Taxes et Frais du Co\xc3\xbbt au D\xc3\xa9barquement'
+b'DocType: Work Order Operation',b'Actual Start Time',b'Heure de D\xc3\xa9but R\xc3\xa9elle'
+b'DocType: BOM Operation',b'Operation Time',"b""Heure de l'Op\xc3\xa9ration"""
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +316',b'Finish',b'Terminer'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +412',b'Base',b'Base'
+b'DocType: Timesheet',b'Total Billed Hours',b'Total des Heures Factur\xc3\xa9es'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1530',b'Write Off Amount',b'Montant de la Reprise'
+b'DocType: Leave Block List Allow',b'Allow User',"b""Autoriser l'Utilisateur"""
+b'DocType: Journal Entry',b'Bill No',b'Num\xc3\xa9ro de Facture'
+b'DocType: Company',b'Gain/Loss Account on Asset Disposal',b'Compte de Cessions des Immobilisations'
+b'DocType: Vehicle Log',b'Service Details',b'D\xc3\xa9tails du Service'
+b'DocType: Subscription',b'Quarterly',b'Trimestriel'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +47',b'EcritureLib',b'EcritureLib'
+b'DocType: Lab Test Template',b'Grouped',b'Group\xc3\xa9'
+b'DocType: Selling Settings',b'Delivery Note Required',b'Bon de Livraison Requis'
+b'DocType: Bank Guarantee',b'Bank Guarantee Number',b'Num\xc3\xa9ro de Garantie Bancaire'
+b'DocType: Assessment Criteria',b'Assessment Criteria',"b""Crit\xc3\xa8res d'\xc3\x89valuation"""
+b'DocType: BOM Item',b'Basic Rate (Company Currency)',b'Taux de Base (Devise de la Soci\xc3\xa9t\xc3\xa9 )'
+b'DocType: Student Attendance',b'Student Attendance',b'Pr\xc3\xa9sence des \xc3\x89tudiants'
+b'DocType: Sales Invoice Timesheet',b'Time Sheet',b'Feuille de Temps'
+b'DocType: Manufacturing Settings',b'Backflush Raw Materials Based On',b'Enregistrer les Mati\xc3\xa8res Premi\xc3\xa8res sur la Base de'
+b'DocType: Sales Invoice',b'Port Code',b'Code du port'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +957',b'Reserve Warehouse',b'Entrep\xc3\xb4t de r\xc3\xa9serve'
+b'DocType: Lead',b'Lead is an Organization',b'Le prospect est une organisation'
+b'DocType: Guardian Interest',b'Interest',b'Int\xc3\xa9r\xc3\xaat'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +10',b'Pre Sales',b'Pr\xc3\xa9vente'
+b'DocType: Instructor Log',b'Other Details',b'Autres D\xc3\xa9tails'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +18',b'Suplier',b'Fournisseur'
+b'DocType: Lab Test',b'Test Template',b'Mod\xc3\xa8le de Test'
+b'DocType: Restaurant Order Entry Item',b'Served',b'Servi'
+b'apps/erpnext/erpnext/config/non_profit.py +13',b'Chapter information.',b'Informations sur le chapitre'
+b'DocType: Account',b'Accounts',b'Comptes'
+b'DocType: Vehicle',b'Odometer Value (Last)',b'Valeur Compteur Kilom\xc3\xa9trique (Dernier)'
+b'apps/erpnext/erpnext/config/buying.py +160',b'Templates of supplier scorecard criteria.',"b""Mod\xc3\xa8les de Crit\xc3\xa8res de  Fiche d'\xc3\x89valuation Fournisseur."""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +109',b'Marketing',b'Marketing'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +303',b'Payment Entry is already created',b'L\xe2\x80\x99\xc3\x89criture de Paiement est d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9e'
+b'DocType: Request for Quotation',b'Get Suppliers',b'Obtenir des Fournisseurs'
+b'DocType: Purchase Receipt Item Supplied',b'Current Stock',b'Stock Actuel'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +610',b'Row #{0}: Asset {1} does not linked to Item {2}',"b""Ligne #{0} : L\xe2\x80\x99Actif {1} n\xe2\x80\x99est pas li\xc3\xa9 \xc3\xa0 l'Article {2}"""
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +15',b'Please setup Instructor Naming System in Education &gt; Education Settings',b'Veuillez configurer le syst\xc3\xa8me de nommage de l&#39;instructeur dans Education&gt; Param\xc3\xa8tres de l&#39;\xc3\xa9ducation'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +394',b'Preview Salary Slip',b'Aper\xc3\xa7u Fiche de Salaire'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +54',b'Account {0} has been entered multiple times',b'Le compte {0} a \xc3\xa9t\xc3\xa9 entr\xc3\xa9 plusieurs fois'
+b'DocType: Account',b'Expenses Included In Valuation',b'Charges Incluses dans la Valorisation'
+b'apps/erpnext/erpnext/non_profit/doctype/membership/membership.py +37',b'You can only renew if your membership expires within 30 days',b'Vous ne pouvez renouveler que si votre abonnement expire dans les 30 jours'
+b'DocType: Land Unit',b'Longitude',b'Longitude'
+,b'Absent Student Report',b'Rapport des Absences'
+b'DocType: Crop',b'Crop Spacing UOM',b'UOM d&#39;espacement des cultures'
+b'DocType: Accounts Settings',b'Only select if you have setup Cash Flow Mapper documents',b'Ne s\xc3\xa9lectionnez que si vous avez configur\xc3\xa9 les documents Cash Flow Mapper'
+b'DocType: Email Digest',b'Next email will be sent on:',b'Le prochain Email sera envoy\xc3\xa9 le :'
+b'DocType: Supplier Scorecard',b'Per Week',b'Par Semaine'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +666',b'Item has variants.',"b""L'article a des variantes."""
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +154',b'Total Student',b'\xc3\x89tudiants total'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +65',b'Item {0} not found',b'Article {0} introuvable'
+b'DocType: Bin',b'Stock Value',b'Valeur du Stock'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +239',b'Company {0} does not exist',"b""Soci\xc3\xa9t\xc3\xa9 {0} n'existe pas"""
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +40',b'{0} has fee validity till {1}',"b""{0} a des frais valides jusqu'\xc3\xa0 {1}"""
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +54',b'Tree Type',"b""Type d'Arbre"""
+b'DocType: BOM Explosion Item',b'Qty Consumed Per Unit',b'Qt\xc3\xa9 Consomm\xc3\xa9e Par Unit\xc3\xa9'
+b'DocType: GST Account',b'IGST Account',b'Compte IGST'
+b'DocType: Serial No',b'Warranty Expiry Date',"b""Date d'Expiration de la Garantie"""
+b'DocType: Material Request Item',b'Quantity and Warehouse',b'Quantit\xc3\xa9 et Entrep\xc3\xb4t'
+b'DocType: Hub Settings',b'Unregister',b'Annuler l&#39;inscription'
+b'DocType: Sales Invoice',b'Commission Rate (%)',b'Taux de Commission (%)'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +24',b'Please select Program',b'Veuillez s\xc3\xa9lectionner un Programme'
+b'DocType: Project',b'Estimated Cost',b'Co\xc3\xbbt Estim\xc3\xa9'
+b'DocType: Purchase Order',b'Link to material requests',b'Lien vers les demandes de mat\xc3\xa9riaux'
+b'DocType: Hub Settings',b'Publish',b'Publier'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +7',b'Aerospace',b'A\xc3\xa9rospatial'
+,b'Fichier des Ecritures Comptables [FEC]',b'Fichier des Ecritures Comptables [FEC]'
+b'DocType: Journal Entry',b'Credit Card Entry',b'\xc3\x89criture de Carte de Cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/config/accounts.py +57',b'Company and Accounts',b'Soci\xc3\xa9t\xc3\xa9 et Comptes'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +70',b'In Value',b'En Valeur'
+b'DocType: Asset Settings',b'Depreciation Options',b'Options d&#39;amortissement'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +35',b'Invalid Posting Time',b'Heure de publication non valide'
+b'DocType: Lead',b'Campaign Name',b'Nom de la Campagne'
+b'DocType: Hotel Room',b'Capacity',b'Capacit\xc3\xa9'
+b'DocType: Selling Settings',b'Close Opportunity After Days',b'Fermer Opportunit\xc3\xa9 Apr\xc3\xa8s Jours'
+,b'Reserved',b'R\xc3\xa9serv\xc3\xa9'
+b'DocType: Driver',b'License Details',b'D\xc3\xa9tails de la licence'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +85',b'The field From Shareholder cannot be blank',b'Le champ De l&#39;actionnaire ne peut pas \xc3\xaatre vide'
+b'DocType: Purchase Order',b'Supply Raw Materials',b'Fournir les Mati\xc3\xa8res Premi\xc3\xa8res'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10',b'Current Assets',b'Actifs Actuels'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +121',b'{0} is not a stock Item',"b""{0} n'est pas un Article de stock"""
+b'apps/erpnext/erpnext/hr/email_alert/training_feedback/training_feedback.html +6',"b""Please share your feedback to the training by clicking on 'Training Feedback' and then 'New'""","b""Partagez vos commentaires sur la formation en cliquant sur 'Retour d'Exp\xc3\xa9rience de la formation', puis 'Nouveau'"""
+b'DocType: Mode of Payment Account',b'Default Account',b'Compte par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +273',b'Please select Sample Retention Warehouse in Stock Settings first',b'Veuillez d&#39;abord s\xc3\xa9lectionner Sample Retention Warehouse dans Stock Settings'
+b'DocType: Payment Entry',b'Received Amount (Company Currency)',b'Montant Re\xc3\xa7u (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +192',b'Lead must be set if Opportunity is made from Lead',"b""Un prospect doit \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9 si l'Opportunit\xc3\xa9 est cr\xc3\xa9\xc3\xa9e \xc3\xa0 partir d\xe2\x80\x99un Prospect"""
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +136',b'Payment Cancelled. Please check your GoCardless Account for more details',b'Paiement annul\xc3\xa9 Veuillez v\xc3\xa9rifier votre compte GoCardless pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +29',b'Please select weekly off day',b'Veuillez s\xc3\xa9lectionnez les jours de cong\xc3\xa9 hebdomadaires'
+b'DocType: Patient',b'O Negative',b'O N\xc3\xa9gatif'
+b'DocType: Work Order Operation',b'Planned End Time',b'Heure de Fin Pr\xc3\xa9vue'
+,b'Sales Person Target Variance Item Group-Wise',"b""Variance d'Objectifs des Commerciaux par Groupe d'Articles"""
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +93',b'Account with existing transaction cannot be converted to ledger',b'Un compte contenant une transaction ne peut pas \xc3\xaatre converti en grand livre'
+b'apps/erpnext/erpnext/config/non_profit.py +33',b'Memebership Type Details',b'Memebership Type D\xc3\xa9tails'
+b'DocType: Delivery Note',"b""Customer's Purchase Order No""",b'Num\xc3\xa9ro bon de commande du client'
+b'DocType: Budget',b'Budget Against',b'Budget Pour'
+b'DocType: Employee',b'Cell Number',b'Num\xc3\xa9ro de T\xc3\xa9l\xc3\xa9phone'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +450',"b""There's no employee for the given criteria. Check that Salary Slips have not already been created.""",b'Il n&#39;y a pas d&#39;employ\xc3\xa9 pour les crit\xc3\xa8res donn\xc3\xa9s. V\xc3\xa9rifiez que les bordereaux de salaire n&#39;ont pas d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9s.'
+b'apps/erpnext/erpnext/stock/reorder_item.py +194',b'Auto Material Requests Generated',b'Demandes de Mat\xc3\xa9riel G\xc3\xa9n\xc3\xa9r\xc3\xa9es Automatiquement'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7',b'Lost',b'Perdu'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +152',"b""You can not enter current voucher in 'Against Journal Entry' column""","b""Vous ne pouvez pas entrer le bon actuel dans la colonne 'Pour l'\xc3\x89criture de Journal'"""
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +50',b'Reserved for manufacturing',b'R\xc3\xa9serv\xc3\xa9 pour la Fabrication'
+b'DocType: Soil Texture',b'Sand',b'Le sable'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +25',b'Energy',b'\xc3\x89nergie'
+b'DocType: Opportunity',b'Opportunity From',b'Opportunit\xc3\xa9 De'
+b'apps/erpnext/erpnext/config/hr.py +98',b'Monthly salary statement.',b'Fiche de paie mensuelle.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +887',b'Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.',"b""Ligne {0}: {1} Num\xc3\xa9ros de s\xc3\xa9rie requis pour l'article {2}. Vous en avez fourni {3}."""
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +79',b'Please select a table',b'Veuillez s\xc3\xa9lectionner une table'
+b'DocType: BOM',b'Website Specifications',b'Sp\xc3\xa9cifications du Site Web'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +78',"b""{0} is an invalid email address in 'Recipients'""","b""{0} est une adresse e-mail invalide dans 'Destinataires'"""
+b'DocType: Special Test Items',b'Particulars',b'Particularit\xc3\xa9s'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +24',b'{0}: From {0} of type {1}',b'{0} : Du {0} de type {1}'
+b'DocType: Warranty Claim',b'CI-',b'CI-'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +300',b'Row {0}: Conversion Factor is mandatory',b'Ligne {0} : Le Facteur de Conversion est obligatoire'
+b'DocType: Student',b'A+',b'A +'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +344',"b'Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}'","b'Plusieurs R\xc3\xa8gles de Prix existent avec les m\xc3\xaames crit\xc3\xa8res, veuillez r\xc3\xa9soudre les conflits en attribuant des priorit\xc3\xa9s. R\xc3\xa8gles de Prix : {0}'"
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +519',b'Cannot deactivate or cancel BOM as it is linked with other BOMs',"b""D\xc3\xa9sactivation ou annulation de la LDM impossible car elle est li\xc3\xa9e avec d'autres LDMs"""
+b'DocType: Asset',b'Maintenance',b'Entretien'
+b'DocType: Item Attribute Value',b'Item Attribute Value',"b""Valeur de l'Attribut de l'Article"""
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +406',b'Please Update your Project Status',b'Veuillez mettre \xc3\xa0 jour votre statut de projet'
+b'DocType: Item',b'Maximum sample quantity that can be retained',b'Quantit\xc3\xa9 maximale d&#39;\xc3\xa9chantillon pouvant \xc3\xaatre conserv\xc3\xa9e'
+b'DocType: Project Update',b'How is the Project Progressing Right Now?',b'Comment le projet progresse-t-il maintenant?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +418',b'Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3}',b'La ligne {0} # article {1} ne peut pas \xc3\xaatre transf\xc3\xa9r\xc3\xa9e plus de {2} par commande d&#39;achat {3}'
+b'apps/erpnext/erpnext/config/selling.py +158',b'Sales campaigns.',b'Campagnes de vente.'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +117',b'Make Timesheet',b'Cr\xc3\xa9er une Feuille de Temps'
+b'DocType: Sales Taxes and Charges Template',"b'Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.'","b'Mod\xc3\xa8le de la taxe standard qui peut \xc3\xaatre appliqu\xc3\xa9 \xc3\xa0 toutes les Op\xc3\xa9rations d\'Achat. Ce mod\xc3\xa8le peut contenir la liste des titres d\'imp\xc3\xb4ts ainsi que d\'autres titre de charges comme ""Livraison"", ""Assurance"", ""Gestion"", etc. \n\n#### Remarque \n\nLe taux d\'imposition que vous d\xc3\xa9finissez ici sera le taux d\'imposition standard pour tous les **Articles**. S\'il y a des **Articles** qui ont des taux diff\xc3\xa9rents, ils doivent \xc3\xaatre ajout\xc3\xa9s dans la table **Taxe de l\'Article** dans les donn\xc3\xa9es de base **Article**.\n\n#### Description des Colonnes\n\n1. Type de Calcul : \n    - Cela peut \xc3\xaatre le **Total Net** (qui est la somme des montants de base).\n    - **Total / Montant Sur la Ligne Pr\xc3\xa9c\xc3\xa9dente** (pour les taxes ou frais accumul\xc3\xa9s). Si vous s\xc3\xa9lectionnez cette option, la taxe sera appliqu\xc3\xa9e en pourcentage du montant ou du total de la ligne pr\xc3\xa9c\xc3\xa9dente (dans la table d\'imp\xc3\xb4ts).\n    - **R\xc3\xa9el** (comme mentionn\xc3\xa9).\n2. Titre du Compte : Le journal comptable dans lequel cette taxe sera comptabilis\xc3\xa9e\n3. Centre de Co\xc3\xbbt : Si la taxe / redevance est un revenu (comme la livraison) ou une charge, elle doit \xc3\xaatre comptabilis\xc3\xa9e dans un Centre de Co\xc3\xbbts.\n4. Description : Description de la taxe (qui sera imprim\xc3\xa9e sur les factures / devis).\n5. Taux : Le taux d\'imposition.\n6. Montant : Le montant de la taxe.\n7. Total : Total accumul\xc3\xa9 \xc3\xa0 ce point.\n8. Entrez la Ligne : Si elle est bas\xc3\xa9e sur ""Total de la Ligne Pr\xc3\xa9c\xc3\xa9dente"" vous pouvez s\xc3\xa9lectionner le num\xc3\xa9ro de la ligne qui sera pris comme base pour ce calcul (par d\xc3\xa9faut la ligne pr\xc3\xa9c\xc3\xa9dente).\n9. Consid\xc3\xa9rez Taxe ou Charge pour : Dans cette section, vous pouvez sp\xc3\xa9cifier si la taxe / redevance est seulement pour la valorisation (pas une partie du total) ou seulement pour le total (n\'ajoute pas de la valeur \xc3\xa0 l\'article) ou pour les deux.\n10. Ajouter ou D\xc3\xa9duire : Ce que vous voulez ajouter ou d\xc3\xa9duire de la taxe.'"
+b'DocType: Employee',b'Bank A/C No.',b'N\xc2\xb0 de Compte Bancaire'
+b'DocType: Bank Guarantee',b'Project',b'Projet'
+b'DocType: Quality Inspection Reading',b'Reading 7',b'Lecture 7'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +9',b'Partially Ordered',b'Partiellement Ordonn\xc3\xa9'
+b'DocType: Lab Test',b'Lab Test',b'Test de laboratoire'
+b'DocType: Student Report Generation Tool',b'Student Report Generation Tool',b'Outil de g\xc3\xa9n\xc3\xa9ration de rapports d&#39;\xc3\xa9tudiants'
+b'DocType: Expense Claim Detail',b'Expense Claim Type',b'Type de Note de Frais'
+b'DocType: Shopping Cart Settings',b'Default settings for Shopping Cart',"b""Param\xc3\xa8tres par d\xc3\xa9faut pour le Panier d'Achat"""
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +27',b'Add Timeslots',b'Ajouter des Cr\xc3\xa9neaux'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +138',b'Asset scrapped via Journal Entry {0}',b'Actif mis au rebut via \xc3\x89criture de Journal {0}'
+b'DocType: Employee Loan',b'Interest Income Account',"b""Compte d'Int\xc3\xa9r\xc3\xaats Cr\xc3\xa9diteurs"""
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py +58',b'Review Invitation Sent',b'Examiner l&#39;invitation envoy\xc3\xa9e'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +13',b'Biotechnology',b'Biotechnologie'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +109',b'Office Maintenance Expenses',"b""Charges d'Entretien de Bureau"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +54',b'Go to ',b'Aller \xc3\xa0'
+b'apps/erpnext/erpnext/config/learn.py +47',b'Setting up Email Account',b'Configuration du Compte Email'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +21',b'Please enter Item first',"b""Veuillez d\xe2\x80\x99abord entrer l'Article"""
+b'DocType: Asset Repair',b'Downtime',b'Temps d&#39;arr\xc3\xaat'
+b'DocType: Account',b'Liability',b'Passif'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +220',b'Sanctioned Amount cannot be greater than Claim Amount in Row {0}.',b'Le Montant Approuv\xc3\xa9 ne peut pas \xc3\xaatre sup\xc3\xa9rieur au Montant R\xc3\xa9clam\xc3\xa9 \xc3\xa0 la ligne {0}.'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +11',b'Academic Term: ',b'Terme acad\xc3\xa9mique'
+b'DocType: Salary Detail',b'Do not include in total',b'Ne pas inclure au total'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +206',b'Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series',b'Veuillez d\xc3\xa9finir la s\xc3\xa9rie de d\xc3\xa9nomination pour {0} via Configuration&gt; Param\xc3\xa8tres&gt; Naming Series'
+b'DocType: Company',b'Default Cost of Goods Sold Account',b'Compte de Co\xc3\xbbts des Marchandises Vendues par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1019',b'Sample quantity {0} cannot be more than received quantity {1}',b'La quantit\xc3\xa9 d&#39;\xc3\xa9chantillon {0} ne peut pas d\xc3\xa9passer la quantit\xc3\xa9 re\xc3\xa7ue {1}'
+b'apps/erpnext/erpnext/stock/get_item_details.py +369',b'Price List not selected',b'Liste des Prix non s\xc3\xa9lectionn\xc3\xa9e'
+b'DocType: Employee',b'Family Background',b'Ant\xc3\xa9c\xc3\xa9dents Familiaux'
+b'DocType: Request for Quotation Supplier',b'Send Email',b'Envoyer un Email'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +228',b'Warning: Invalid Attachment {0}',b'Attention : Pi\xc3\xa8ce jointe non valide {0}'
+b'DocType: Item',b'Max Sample Quantity',b'Quantit\xc3\xa9 maximum d&#39;\xc3\xa9chantillon'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +766',b'No Permission',b'Aucune Autorisation'
+b'DocType: Vital Signs',b'Heart Rate / Pulse',b'Fr\xc3\xa9quence Cardiaque / Pouls'
+b'DocType: Company',b'Default Bank Account',b'Compte Bancaire par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +59',"b'To filter based on Party, select Party Type first'","b'Pour filtrer en fonction du Tiers, s\xc3\xa9lectionnez d\xe2\x80\x99abord le Type de Tiers'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +48',"b""'Update Stock' can not be checked because items are not delivered via {0}""","b""'Mettre \xc3\xa0 Jour le Stock' ne peut pas \xc3\xaatre coch\xc3\xa9 car les articles ne sont pas livr\xc3\xa9s par {0}"""
+b'DocType: Vehicle',b'Acquisition Date',"b""Date d'Aquisition"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Nos',b'N\xc2\xb0'
+b'DocType: Item',b'Items with higher weightage will be shown higher',b'Articles avec poids sup\xc3\xa9rieur seront affich\xc3\xa9s en haut'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +14',b'Lab Tests and Vital Signs',b'Tests de laboratoire et signes vitaux'
+b'DocType: Bank Reconciliation Detail',b'Bank Reconciliation Detail',b'D\xc3\xa9tail de la R\xc3\xa9conciliation Bancaire'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +614',b'Row #{0}: Asset {1} must be submitted',b'Ligne #{0} : L\xe2\x80\x99Article {1} doit \xc3\xaatre soumis'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +40',b'No employee found',b'Aucun employ\xc3\xa9 trouv\xc3\xa9'
+b'DocType: Subscription',b'Stopped',b'Arr\xc3\xaat\xc3\xa9'
+b'DocType: Item',b'If subcontracted to a vendor',b'Si sous-trait\xc3\xa9 \xc3\xa0 un fournisseur'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +111',b'Student Group is already updated.',"b""Le Groupe d'\xc3\x89tudiants est d\xc3\xa9j\xc3\xa0 mis \xc3\xa0 jour."""
+b'apps/erpnext/erpnext/config/projects.py +18',b'Project Update.',b'Mise \xc3\xa0 jour du projet'
+b'DocType: SMS Center',b'All Customer Contact',b'Tout Contact Client'
+b'DocType: Land Unit',b'Tree Details',b'D\xc3\xa9tails de l\xe2\x80\x99Arbre'
+b'DocType: Training Event',b'Event Status',"b""Statut de l'\xc3\x89v\xc3\xa9nement"""
+b'DocType: Volunteer',b'Availability Timeslot',b'D\xc3\xa9lai de disponibilit\xc3\xa9'
+,b'Support Analytics',b'Analyse du Support'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +365',"b'If you have any questions, please get back to us.'","b'Si vous avez des questions, veuillez revenir vers nous.'"
+b'DocType: Cash Flow Mapper',b'Cash Flow Mapper',b'Mappeur de flux de tr\xc3\xa9sorerie'
+b'DocType: Item',b'Website Warehouse',b'Entrep\xc3\xb4t du Site Seb'
+b'DocType: Payment Reconciliation',b'Minimum Invoice Amount',b'Montant Minimum de Facturation'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +111',b'{0} {1}: Cost Center {2} does not belong to Company {3}',b'{0} {1} : Le Centre de Co\xc3\xbbts {2} ne fait pas partie de la Soci\xc3\xa9t\xc3\xa9 {3}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +92',b'Upload your letter head (Keep it web friendly as 900px by 100px)',b'T\xc3\xa9l\xc3\xa9chargez votre t\xc3\xaate de lettre (Gardez-le web comme 900px par 100px)'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +88',b'{0} {1}: Account {2} cannot be a Group',b'{0} {1} : Compte {2} ne peut pas \xc3\xaatre un Groupe'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63',"b""Item Row {idx}: {doctype} {docname} does not exist in above '{doctype}' table""","b""Ligne d'Article {idx}: {doctype} {docname} n'existe pas dans la table '{doctype}' ci-dessus"""
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +295',b'Timesheet {0} is already completed or cancelled',b'La Feuille de Temps {0} est d\xc3\xa9j\xc3\xa0 termin\xc3\xa9e ou annul\xc3\xa9e'
+b'apps/erpnext/erpnext/templates/pages/projects.html +42',b'No tasks',b'Aucune t\xc3\xa2che'
+b'DocType: Item Variant Settings',b'Copy Fields to Variant',b'Copier les Champs dans une Variante'
+b'DocType: Asset',b'Opening Accumulated Depreciation',"b""Amortissement Cumul\xc3\xa9 d'Ouverture"""
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49',b'Score must be less than or equal to 5',b'Score doit \xc3\xaatre inf\xc3\xa9rieur ou \xc3\xa9gal \xc3\xa0 5'
+b'DocType: Program Enrollment Tool',b'Program Enrollment Tool',b'Outil d\xe2\x80\x99Inscription au Programme'
+b'apps/erpnext/erpnext/config/accounts.py +335',b'C-Form records',b'Enregistrements Formulaire-C'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +73',b'The shares already exist',b'Les actions existent d\xc3\xa9j\xc3\xa0'
+b'apps/erpnext/erpnext/config/selling.py +316',b'Customer and Supplier',b'Clients et Fournisseurs'
+b'DocType: Email Digest',b'Email Digest Settings',b'Param\xc3\xa8tres pour le Compte Rendu par Email'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +367',b'Thank you for your business!',b'Merci pour votre entreprise !'
+b'apps/erpnext/erpnext/config/support.py +12',b'Support queries from customers.',b'Demande de support des clients'
+b'DocType: Setup Progress Action',b'Action Doctype',b'Doctype Action'
+b'DocType: HR Settings',b'Retirement Age',b'\xc3\x82ge de la Retraite'
+b'DocType: Bin',b'Moving Average Rate',b'Taux Mobile Moyen'
+b'DocType: Production Plan',b'Select Items',b'S\xc3\xa9lectionner les Articles'
+b'DocType: Share Transfer',b'To Shareholder',b'Pour l&#39;actionnaire'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +372',b'{0} against Bill {1} dated {2}',b'{0} pour la Facture {1} du {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Institution',"b""Configurer l'Institution"""
+b'DocType: Program Enrollment',b'Vehicle/Bus Number',b'Num\xc3\xa9ro de V\xc3\xa9hicule/Bus'
+b'apps/erpnext/erpnext/education/doctype/course/course.js +17',b'Course Schedule',b'Horaire du Cours'
+b'DocType: Request for Quotation Supplier',b'Quote Status',b'Statut du Devis'
+b'DocType: GoCardless Settings',b'Webhooks Secret',b'Webhooks Secret'
+b'DocType: Maintenance Visit',b'Completion Status',"b""\xc3\x89tat d'Ach\xc3\xa8vement"""
+b'DocType: Daily Work Summary Group',b'Select Users',b'S\xc3\xa9lectionner les utilisateurs'
+b'DocType: Hotel Room Pricing Item',b'Hotel Room Pricing Item',b'Objet de prix de chambre d&#39;h\xc3\xb4tel'
+b'DocType: HR Settings',b'Enter retirement age in years',"b""Entrez l'\xc3\xa2ge de la retraite en ann\xc3\xa9es"""
+b'DocType: Crop',b'Target Warehouse',b'Entrep\xc3\xb4t Cible'
+b'DocType: Payroll Employee Detail',b'Payroll Employee Detail',"b""D\xc3\xa9tails de la paye de l'employ\xc3\xa9"""
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +128',b'Please select a warehouse',b'Veuillez s\xc3\xa9lectionner un entrep\xc3\xb4t'
+b'DocType: Cheque Print Template',b'Starting location from left edge',b'Position initiale depuis bord gauche'
+b'DocType: Item',b'Allow over delivery or receipt upto this percent',"b""Autoriser le d\xc3\xa9passement des capacit\xc3\xa9s livraison ou de r\xc3\xa9ception jusqu'\xc3\xa0 ce pourcentage"""
+b'DocType: Stock Entry',b'STE-',b'STE-'
+b'DocType: Upload Attendance',b'Import Attendance',b'Importer Participation'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +124',b'All Item Groups',"b""Tous les Groupes d'Articles"""
+b'apps/erpnext/erpnext/config/setup.py +89',b'Automatically compose message on submission of transactions.',b'Composer automatiquement un message sur la soumission de transactions .'
+b'DocType: Work Order',b'Item To Manufacture',b'Article \xc3\xa0 Fabriquer'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteLib',b'CompteLib'
+b'apps/erpnext/erpnext/buying/utils.py +80',b'{0} {1} status is {2}',b'Le Statut de {0} {1} est {2}'
+b'DocType: Water Analysis',b'Collection Temperature ',b'Temp\xc3\xa9rature de collecte'
+b'DocType: Employee',b'Provide Email Address registered in company',"b""Fournir l'Adresse Email enregistr\xc3\xa9e dans la soci\xc3\xa9t\xc3\xa9"""
+b'DocType: Shopping Cart Settings',b'Enable Checkout',b'Activer Caisse'
+b'apps/erpnext/erpnext/config/learn.py +202',b'Purchase Order to Payment',b'Du Bon de Commande au Paiement'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +48',b'Projected Qty',b'Qt\xc3\xa9 Projet\xc3\xa9e'
+b'DocType: Sales Invoice',b'Payment Due Date',"b""Date d'\xc3\x89ch\xc3\xa9ance de Paiement"""
+b'DocType: Drug Prescription',b'Interval UOM',"b""UDM d'Intervalle"""
+b'DocType: Customer',"b'Reselect, if the chosen address is edited after save'","b'Res\xc3\xa9lectionner, si l&#39;adresse choisie est \xc3\xa9dit\xc3\xa9e apr\xc3\xa8s sauvegarde'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +522',b'Item Variant {0} already exists with same attributes',"b""La Variante de l'Article {0} existe d\xc3\xa9j\xc3\xa0 avec les m\xc3\xaames caract\xc3\xa9ristiques"""
+b'DocType: Item',b'Hub Publishing Details',b'D\xc3\xa9tails Publi\xc3\xa9s sur le Hub'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +117',"b""'Opening'""","b""'Ouverture'"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +130',b'Open To Do',b'Ouvrir To Do'
+b'DocType: Notification Control',b'Delivery Note Message',b'Message du Bon de Livraison'
+b'DocType: Lab Test Template',b'Result Format',b'Format du R\xc3\xa9sultat'
+b'DocType: Expense Claim',b'Expenses',b'Charges'
+b'DocType: Item Variant Attribute',b'Item Variant Attribute',"b""Attribut de Variante de l'Article"""
+,b'Purchase Receipt Trends',"b""Tendances des Re\xc3\xa7us d'Achats"""
+b'DocType: Payroll Entry',b'Bimonthly',b'Bimensuel'
+b'DocType: Vehicle Service',b'Brake Pad',b'Plaquettes de Frein'
+b'DocType: Fertilizer',b'Fertilizer Contents',b'Contenu de l&#39;engrais'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +119',b'Research & Development',b'Recherche & D\xc3\xa9veloppement'
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +20',b'Amount to Bill',b'Montant \xc3\xa0 Facturer'
+b'DocType: Company',b'Registration Details',b'Informations L\xc3\xa9gales'
+b'DocType: Timesheet',b'Total Billed Amount',b'Montant Total Factur\xc3\xa9'
+b'DocType: Item Reorder',b'Re-Order Qty',b'Qt\xc3\xa9 de R\xc3\xa9approvisionnement'
+b'DocType: Leave Block List Date',b'Leave Block List Date',b'Date de la Liste de Blocage des Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +94',b'BOM #{0}: Raw material cannot be same as main Item',"b""LDM # {0}: La mati\xc3\xa8re premi\xc3\xa8re ne peut pas \xc3\xaatre identique \xc3\xa0 l'article principal"""
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +92',b'Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges',b'Total des Frais Applicables dans la Table des Articles de Re\xc3\xa7us d\xe2\x80\x99Achat doit \xc3\xaatre \xc3\xa9gal au Total des Taxes et Frais'
+b'DocType: Sales Team',b'Incentives',b'Incitations'
+b'DocType: SMS Log',b'Requested Numbers',b'Num\xc3\xa9ros Demand\xc3\xa9s'
+b'DocType: Volunteer',b'Evening',b'Soir'
+b'DocType: Customer',b'Bypass credit limit check at Sales Order',b'Contr\xc3\xb4le de limite de cr\xc3\xa9dit de contournement \xc3\xa0 la commande client'
+b'apps/erpnext/erpnext/config/hr.py +147',b'Performance appraisal.',b'\xc3\x89valuation des Performances.'
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +100',"b""Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart""","b""Activation de 'Utiliser pour Panier', comme le Panier est activ\xc3\xa9 et qu'il devrait y avoir au moins une R\xc3\xa8gle de Taxes pour le Panier"""
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +412',"b'Payment Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.'","b'L\xe2\x80\x99\xc3\x89criture de Paiement {0} est li\xc3\xa9e \xc3\xa0 la Commande {1}, v\xc3\xa9rifiez si elle doit \xc3\xaatre r\xc3\xa9cup\xc3\xa9r\xc3\xa9e comme une avance dans cette facture.'"
+b'DocType: Sales Invoice Item',b'Stock Details',b'D\xc3\xa9tails du Stock'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29',b'Project Value',b'Valeur du Projet'
+b'apps/erpnext/erpnext/config/selling.py +326',b'Point-of-Sale',b'Point-de-Vente'
+b'DocType: Fee Schedule',b'Fee Creation Status',b'Statut de cr\xc3\xa9ation des honoraires'
+b'DocType: Vehicle Log',b'Odometer Reading',b'Relev\xc3\xa9 du Compteur Kilom\xc3\xa9trique'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +116',"b""Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'""","b""Le solde du compte est d\xc3\xa9j\xc3\xa0 Cr\xc3\xa9diteur, vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 mettre en 'Solde Doit \xc3\x8atre' comme 'D\xc3\xa9biteur'"""
+b'DocType: Account',b'Balance must be',b'Solde doit \xc3\xaatre'
+b'DocType: Hub Settings',b'Publish Pricing',b'Publier la Tarification'
+b'DocType: Notification Control',b'Expense Claim Rejected Message',b'Message de Note de Frais Rejet\xc3\xa9e'
+,b'Available Qty',b'Qt\xc3\xa9 Disponible'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Total',b'Le Total de la Rang\xc3\xa9e Pr\xc3\xa9c\xc3\xa9dente'
+b'DocType: Purchase Invoice Item',b'Rejected Qty',b'Qt\xc3\xa9 Rejet\xc3\xa9e'
+b'DocType: Setup Progress Action',b'Action Field',"b""Champ d'Action"""
+b'DocType: Healthcare Settings',b'Manage Customer',b'Gestion Client'
+b'DocType: Delivery Trip',b'Delivery Stops',b'Arr\xc3\xaats de Livraison'
+b'DocType: Salary Slip',b'Working Days',b'Jours Ouvrables'
+b'DocType: Serial No',b'Incoming Rate',"b""Taux d'Entr\xc3\xa9e"""
+b'DocType: Packing Slip',b'Gross Weight',b'Poids Brut'
+,b'Final Assessment Grades',b'Niveaux d&#39;\xc3\xa9valuation finale'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +47',b'Enable Hub',b'Activer le Hub'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +110',b'The name of your company for which you are setting up this system.',"b""Le nom de l'entreprise pour laquelle vous configurez ce syst\xc3\xa8me."""
+b'DocType: HR Settings',b'Include holidays in Total no. of Working Days',b'Inclure les vacances dans le nombre total de Jours Ouvr\xc3\xa9s'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py +108',b'Setup your Institute in ERPNext',b'Configurez votre institut dans ERPNext'
+b'DocType: Agriculture Analysis Criteria',b'Plant Analysis',b'Analyse des plantes'
+b'DocType: Job Applicant',b'Hold',b'Tenir'
+b'DocType: Project Update',b'Progress Details',b'D\xc3\xa9tails du progr\xc3\xa8s'
+b'DocType: Employee',b'Date of Joining',"b""Date d'Embauche"""
+b'DocType: Naming Series',b'Update Series',b'Mettre \xc3\xa0 Jour les S\xc3\xa9ries'
+b'DocType: Supplier Quotation',b'Is Subcontracted',b'Est sous-trait\xc3\xa9'
+b'DocType: Restaurant Table',b'Minimum Seating',b'Si\xc3\xa8ges Minimum'
+b'DocType: Item Attribute',b'Item Attribute Values',"b""Valeurs de l'Attribut de l'Article"""
+b'DocType: Examination Result',b'Examination Result',"b""R\xc3\xa9sultat d'Examen"""
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +845',b'Purchase Receipt',b'Re\xc3\xa7u d\xe2\x80\x99Achat'
+,b'Received Items To Be Billed',b'Articles Re\xc3\xa7us \xc3\xa0 Facturer'
+b'apps/erpnext/erpnext/config/accounts.py +303',b'Currency exchange rate master.',b'Donn\xc3\xa9es de base des Taux de Change'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +209',b'Reference Doctype must be one of {0}',b'Doctype de la R\xc3\xa9f\xc3\xa9rence doit \xc3\xaatre parmi {0}'
+b'apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js +46',b'Filter Total Zero Qty',b'Filtre Total Z\xc3\xa9ro Qt\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +341',b'Unable to find Time Slot in the next {0} days for Operation {1}',"b""Impossible de trouver le Cr\xc3\xa9neau Horaires dans les {0} prochains jours pour l'Op\xc3\xa9ration {1}"""
+b'DocType: Work Order',b'Plan material for sub-assemblies',b'Plan de mat\xc3\xa9riaux pour les sous-ensembles'
+b'apps/erpnext/erpnext/config/selling.py +97',b'Sales Partners and Territory',b'Partenaires Commerciaux et R\xc3\xa9gions'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +600',b'BOM {0} must be active',b'LDM {0} doit \xc3\xaatre active'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +414',b'No Items available for transfer',b'Aucun article disponible pour le transfert'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +218',b'Closing (Opening + Total)',b'Fermeture (ouverture + total)'
+b'DocType: Journal Entry',b'Depreciation Entry',b'Ecriture d\xe2\x80\x99Amortissement'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32',b'Please select the document type first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner le type de document'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +65',b'Cancel Material Visits {0} before cancelling this Maintenance Visit',"b""Annuler les Visites Mat\xc3\xa9rielles {0} avant d'annuler cette Visite de Maintenance"""
+b'DocType: Crop Cycle',b'ISO 8016 standard',b'Norme ISO 8016'
+b'DocType: Pricing Rule',b'Rate or Discount',b'Taux ou rabais'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +213',b'Serial No {0} does not belong to Item {1}',"b""N\xc2\xb0 de S\xc3\xa9rie {0} n'appartient pas \xc3\xa0 l'Article {1}"""
+b'DocType: Purchase Receipt Item Supplied',b'Required Qty',b'Qt\xc3\xa9 Requise'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +126',b'Warehouses with existing transaction can not be converted to ledger.',b'Les entrep\xc3\xb4ts avec des transactions existantes ne peuvent pas \xc3\xaatre convertis en livre.'
+b'DocType: Bank Reconciliation',b'Total Amount',b'Montant Total'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +32',b'Internet Publishing',b'Publication Internet'
+b'DocType: Prescription Duration',b'Number',b'Nombre'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +25',b'Creating {0} Invoice',b'Cr\xc3\xa9ation de {0} facture'
+b'DocType: Medical Code',b'Medical Code Standard',b'Standard du code m\xc3\xa9dical'
+b'DocType: Soil Texture',b'Clay Composition (%)',b'Composition d&#39;argile (%)'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +81',b'Please save before assigning task.',b'Veuillez sauvegarder avant d&#39;assigner une t\xc3\xa2che.'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +74',b'Balance Value',b'Valeur du Solde'
+b'DocType: Lab Test',b'Lab Technician',b'Technicien de laboratoire'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38',b'Sales Price List',b'Liste de Prix de Vente'
+b'DocType: Healthcare Settings',"b'If checked, a customer will be created, mapped to Patient.\nPatient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.'","b'Si coch\xc3\xa9e, un client sera cr\xc3\xa9\xc3\xa9 et li\xc3\xa9 au patient. Les factures de patients seront cr\xc3\xa9\xc3\xa9es sur ce client. Vous pouvez \xc3\xa9galement s\xc3\xa9lectionner un Client existant tout en cr\xc3\xa9ant un Patient.'"
+b'DocType: Bank Reconciliation',b'Account Currency',b'Compte Devise'
+b'DocType: Lab Test',b'Sample ID',"b""ID de l'\xc3\x89chantillon"""
+b'apps/erpnext/erpnext/accounts/general_ledger.py +167',b'Please mention Round Off Account in Company',b'Veuillez indiquer le Compte d\xe2\x80\x99Arrondi de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Purchase Receipt',b'Range',b'Plage'
+b'DocType: Supplier',b'Default Payable Accounts',b'Comptes Cr\xc3\xa9diteur par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +49',b'Employee {0} is not active or does not exist',"b""L'employ\xc3\xa9 {0} n'est pas actif, ou n'existe pas"""
+b'DocType: Fee Structure',b'Components',b'Composants'
+b'DocType: Item Barcode',b'Item Barcode',b'Code barre article'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +329',b'Please enter Asset Category in Item {0}',"b""Veuillez entrer une Cat\xc3\xa9gorie d'Actif dans la rubrique {0}"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +661',b'Item Variants {0} updated',"b""Variantes de l'Article {0} mises \xc3\xa0 jour"""
+b'DocType: Quality Inspection Reading',b'Reading 6',b'Lecture 6'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +9',"b'to be generated. If delayed, you will have to manually change the ""Repeat on Day of Month"" field\nof this'","b'\xc3\xa0 g\xc3\xa9n\xc3\xa9rer. Si vous \xc3\xaates retard\xc3\xa9, vous devrez modifier manuellement le champ &quot;R\xc3\xa9p\xc3\xa9ter le jour du mois&quot; de ceci'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +961',b'Cannot {0} {1} {2} without any negative outstanding invoice',b'Can not {0} {1} {2} sans aucune facture impay\xc3\xa9e n\xc3\xa9gative'
+b'DocType: Share Transfer',b'From Folio No',b'De Folio No'
+b'DocType: Purchase Invoice Advance',b'Purchase Invoice Advance',b'Avance sur Facture d\xe2\x80\x99Achat'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +199',b'Row {0}: Credit entry can not be linked with a {1}',b'Ligne {0} : L\xe2\x80\x99\xc3\x89criture de cr\xc3\xa9dit ne peut pas \xc3\xaatre li\xc3\xa9e \xc3\xa0 un {1}'
+b'apps/erpnext/erpnext/config/accounts.py +246',b'Define budget for a financial year.',b'D\xc3\xa9finir le budget pour un exercice.'
+b'DocType: Lead',b'LEAD-',b'LEAD-'
+b'DocType: Employee',b'Permanent Address Is',b'L\xe2\x80\x99Adresse Permanente Est'
+b'DocType: Work Order Operation',b'Operation completed for how many finished goods?',b'Op\xc3\xa9ration termin\xc3\xa9e pour combien de produits finis ?'
+b'DocType: Payment Terms Template',b'Payment Terms Template',b'Mod\xc3\xa8le de termes de paiement'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +51',b'The Brand',b'La Marque'
+b'DocType: Employee',b'Exit Interview Details',b'Entretient de D\xc3\xa9part'
+b'DocType: Item',b'Is Purchase Item',"b""Est Article d'Achat"""
+b'DocType: Journal Entry Account',b'Purchase Invoice',b'Facture d\xe2\x80\x99Achat'
+b'DocType: Stock Ledger Entry',b'Voucher Detail No',b'D\xc3\xa9tail de la R\xc3\xa9f\xc3\xa9rence N\xc2\xb0'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +789',b'New Sales Invoice',b'Nouvelle Facture de Vente'
+b'DocType: Stock Entry',b'Total Outgoing Value',b'Valeur Sortante Totale'
+b'DocType: Physician',b'Appointments',b'Rendez-Vous'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +223',b'Opening Date and Closing Date should be within same Fiscal Year',"b""Date d'Ouverture et Date de Cl\xc3\xb4ture devraient \xc3\xaatre dans le m\xc3\xaame Exercice"""
+b'DocType: Lead',b'Request for Information',b'Demande de Renseignements'
+,b'LeaderBoard',b'Classement'
+b'DocType: Sales Invoice Item',b'Rate With Margin (Company Currency)',b'Taux avec marge (devise de l&#39;entreprise)'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +802',b'Sync Offline Invoices',b'Synchroniser les Factures hors-ligne'
+b'DocType: Payment Request',b'Paid',b'Pay\xc3\xa9'
+b'DocType: Program Fee',b'Program Fee',b'Frais du Programme'
+b'DocType: BOM Update Tool',"b'Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.\nIt also updates latest price in all the BOMs.'","b'Remplacez une LDM particuli\xc3\xa8re dans toutes les LDM o\xc3\xb9 elles est utilis\xc3\xa9e. Cela remplacera le lien vers l\'ancienne LDM, mettra \xc3\xa0 jour les co\xc3\xbbts et r\xc3\xa9g\xc3\xa9n\xc3\xa9rera le tableau ""Article Explos\xc3\xa9 de LDM"" selon la nouvelle LDM. Cela mettra \xc3\xa9galement \xc3\xa0 jour les prix les plus r\xc3\xa9cents dans toutes les LDMs.'"
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +447',b'The following Work Orders were created:',b'Les ordres de travail suivants ont \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9s:'
+b'DocType: Salary Slip',b'Total in words',b'Total En Toutes Lettres'
+b'DocType: Material Request Item',b'Lead Time Date',b'Date du D\xc3\xa9lai'
+,b'Employee Advance Summary',b'R\xc3\xa9capitulatif des avancements'
+b'DocType: Asset',b'Available-for-use Date',b'Disponible pour l&#39;utilisation Date'
+b'DocType: Guardian',b'Guardian Name',b'Nom du Tuteur'
+b'DocType: Cheque Print Template',b'Has Print Format',"b""A un Format d'Impression"""
+b'DocType: Employee Loan',b'Sanctioned',b'Sanctionn\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +75',b' is mandatory. Maybe Currency Exchange record is not created for ',"b""est obligatoire. Peut-\xc3\xaatre que le Taux de Change n'est pas cr\xc3\xa9\xc3\xa9 pour"""
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +139',b'Row #{0}: Please specify Serial No for Item {1}',"b""Ligne # {0} : Veuillez Indiquer le N\xc2\xb0 de s\xc3\xa9rie pour l'article {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +54',b'Supplier &gt; Supplier Type',b'Fournisseur&gt; Type de fournisseur'
+b'DocType: Crop Cycle',b'Crop Cycle',b'Cycle de r\xc3\xa9colte'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +633',"b""For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.""","b'Pour les articles ""Ensembles de Produits"", l\xe2\x80\x99Entrep\xc3\xb4t, le N\xc2\xb0 de S\xc3\xa9rie et le N\xc2\xb0 de Lot proviendront de la table ""Liste de Colisage"". Si l\xe2\x80\x99Entrep\xc3\xb4t et le N\xc2\xb0 de Lot sont les m\xc3\xaames pour tous les produits colis\xc3\xa9s d\xe2\x80\x99un m\xc3\xaame article \'Produit Group\xc3\xa9\', ces valeurs peuvent \xc3\xaatre entr\xc3\xa9es dans la table principale de l\xe2\x80\x99article et elles seront copi\xc3\xa9es dans la table ""Liste de Colisage"".'"
+b'DocType: Student Admission',b'Publish on website',b'Publier sur le site web'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +651',b'Supplier Invoice Date cannot be greater than Posting Date',b'Fournisseur Date de la Facture du Fournisseur ne peut pas \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 Date de Publication'
+b'DocType: Purchase Invoice Item',b'Purchase Order Item',b'Article du Bon de Commande'
+b'DocType: Agriculture Task',b'Agriculture Task',b'T\xc3\xa2che d&#39;agriculture'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132',b'Indirect Income',b'Revenu Indirect'
+b'DocType: Student Attendance Tool',b'Student Attendance Tool',b'Outil de Pr\xc3\xa9sence des \xc3\x89tudiants'
+b'DocType: Restaurant Menu',b'Price List (Auto created)',b'Liste de prix (cr\xc3\xa9\xc3\xa9e automatiquement)'
+b'DocType: Cheque Print Template',b'Date Settings',b'Param\xc3\xa8tres de Date'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +48',b'Variance',b'Variance'
+,b'Company Name',b'Nom de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: SMS Center',b'Total Message(s)',b'Total des Messages'
+b'DocType: Share Balance',b'Purchased',b'Achet\xc3\xa9'
+b'DocType: Item Variant Settings',b'Rename Attribute Value in Item Attribute.',b'Renommez la valeur de l&#39;attribut dans l&#39;attribut de l&#39;\xc3\xa9l\xc3\xa9ment.'
+b'DocType: Purchase Invoice',b'Additional Discount Percentage',b'Pourcentage de r\xc3\xa9duction suppl\xc3\xa9mentaire'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +24',b'View a list of all the help videos',"b""Afficher la liste de toutes les vid\xc3\xa9os d'aide"""
+b'DocType: Agriculture Analysis Criteria',b'Soil Texture',b'Texture du sol'
+b'DocType: Bank Reconciliation',b'Select account head of the bank where cheque was deposited.',b'S\xc3\xa9lectionner le compte principal de la banque o\xc3\xb9 le ch\xc3\xa8que a \xc3\xa9t\xc3\xa9 d\xc3\xa9pos\xc3\xa9.'
+b'DocType: Selling Settings',b'Allow user to edit Price List Rate in transactions',"b""Autoriser l'utilisateur l'\xc3\xa9dition de la Liste des Prix lors des transactions"""
+b'DocType: Pricing Rule',b'Max Qty',b'Qt\xc3\xa9 Max'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js +25',b'Print Report Card',b'Imprimer le rapport'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +30',"b'Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \\\n\t\t\t\t\t\tPlease enter a valid Invoice'","b""Ligne {0} : La Facture {1} est invalide, elle a peut-\xc3\xaatre \xc3\xa9t\xc3\xa9 annul\xc3\xa9e ou n'existe pas. \\ Veuillez entrer une Facture valide"""
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132',b'Row {0}: Payment against Sales/Purchase Order should always be marked as advance',b'Ligne {0} : Paiements contre Commandes Client / Fournisseur doivent toujours \xc3\xaatre marqu\xc3\xa9s comme des avances'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +16',b'Chemical',b'Chimique'
+b'DocType: Salary Component Account',b'Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.',b'Le compte par d\xc3\xa9faut de Banque / Caisse sera automatiquement mis \xc3\xa0 jour dans l\xe2\x80\x99\xc3\xa9criture de Journal de Salaire lorsque ce mode est s\xc3\xa9lectionn\xc3\xa9.'
+b'DocType: BOM',b'Raw Material Cost(Company Currency)',b'Co\xc3\xbbt des Mati\xc3\xa8res Premi\xc3\xa8res (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +88',b'Row # {0}: Rate cannot be greater than the rate used in {1} {2}',b'Ligne # {0}: Le Taux ne peut pas \xc3\xaatre sup\xc3\xa9rieur au taux utilis\xc3\xa9 dans {1} {2}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Meter',b'M\xc3\xa8tre'
+b'DocType: Workstation',b'Electricity Cost',"b""Co\xc3\xbbt de l'\xc3\x89lectricit\xc3\xa9"""
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +23',b'Lab testing datetime cannot be before collection datetime',b'Le test de laboratoire datetime ne peut pas \xc3\xaatre effectu\xc3\xa9 avant la date de collecte'
+b'DocType: HR Settings',"b""Don't send Employee Birthday Reminders""","b""Ne pas envoyer de rappel pour le Jour d'Anniversaire des Employ\xc3\xa9s"""
+b'DocType: Expense Claim',b'Total Advance Amount',b'Montant total de l&#39;avance'
+b'DocType: Delivery Stop',b'Estimated Arrival',b'Arriv\xc3\xa9e estim\xc3\xa9e'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +34',b'Save Settings',b'Enregistrer les param\xc3\xa8tres'
+b'DocType: Delivery Stop',b'Notified by Email',b'Notifi\xc3\xa9 par courriel'
+b'DocType: Item',b'Inspection Criteria',"b""Crit\xc3\xa8res d'Inspection"""
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js +14',b'Transfered',b'Transf\xc3\xa9r\xc3\xa9'
+b'DocType: BOM Website Item',b'BOM Website Item',b'Article de LDM du Site Internet'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +52',b'Upload your letter head and logo. (you can edit them later).',b'Charger votre en-t\xc3\xaate et logo. (vous pouvez les modifier ult\xc3\xa9rieurement).'
+b'DocType: Timesheet Detail',b'Bill',b'Facture'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +88',b'Next Depreciation Date is entered as past date',b'La Date de l\xe2\x80\x99Amortissement Suivant est obligatoire pour un nouvel Actif'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +208',b'White',b'Blanc'
+b'DocType: SMS Center',b'All Lead (Open)',b'Toutes les pistes (Ouvertes)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +270',b'Row {0}: Qty not available for {4} in warehouse {1} at posting time of the entry ({2} {3})',"b""Ligne {0} : Qt\xc3\xa9 non disponible pour {4} dans l'entrep\xc3\xb4t {1} au moment de la comptabilisation de l\xe2\x80\x99\xc3\xa9criture ({2} {3})"""
+b'apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py +18',b'You can only select a maximum of one option from the list of check boxes.',b'Vous pouvez s\xc3\xa9lectionner au maximum une option dans la liste des cases \xc3\xa0 cocher.'
+b'DocType: Purchase Invoice',b'Get Advances Paid',b'Obtenir Acomptes Pay\xc3\xa9s'
+b'DocType: Item',b'Automatically Create New Batch',b'Cr\xc3\xa9er un Nouveau Lot Automatiquement'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +635',b'Assigning {0} to {1} (row {2})',b'Affectation de {0} \xc3\xa0 {1} (ligne {2})'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Make ',b'Faire'
+b'DocType: Student Admission',b'Admission Start Date',"b""Date de D\xc3\xa9but de l'Admission"""
+b'DocType: Journal Entry',b'Total Amount in Words',b'Montant Total En Toutes Lettres'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js +29',b'New Employee',b'Nouvel employ\xc3\xa9'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7',"b""There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.""","b""Il y a eu une erreur. Une raison probable pourrait \xc3\xaatre que vous n'avez pas enregistr\xc3\xa9 le formulaire. Veuillez contacter support@erpnext.com si le probl\xc3\xa8me persiste."""
+b'apps/erpnext/erpnext/templates/pages/cart.html +5',b'My Cart',b'Mon Panier'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +130',b'Order Type must be one of {0}',"b""Type de Commande doit \xc3\xaatre l'un des {0}"""
+b'DocType: Lead',b'Next Contact Date',b'Date du Prochain Contact'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +36',b'Opening Qty',"b""Quantit\xc3\xa9 d'Ouverture"""
+b'DocType: Healthcare Settings',b'Appointment Reminder',b'Rappel de Rendez-Vous'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +478',b'Please enter Account for Change Amount',b'Veuillez entrez un Compte pour le Montant de Change'
+b'DocType: Program Enrollment Tool Student',b'Student Batch Name',"b""Nom du Lot d'\xc3\x89tudiants"""
+b'DocType: Consultation',b'Doctor',b'Docteur'
+b'DocType: Holiday List',b'Holiday List Name',b'Nom de la Liste de Vacances'
+b'DocType: Repayment Schedule',b'Balance Loan Amount',b'Solde du Montant du Pr\xc3\xaat'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +14',b'Schedule Course',b'Cours Calendrier'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +236',b'Stock Options',b'Options du Stock'
+b'DocType: Buying Settings',b'Disable Fetching Last Purchase Details in Purchase Order',b'D\xc3\xa9sactiver la r\xc3\xa9cup\xc3\xa9ration des derniers d\xc3\xa9tails d&#39;achat dans la commande d&#39;achat'
+b'DocType: Journal Entry Account',b'Expense Claim',b'Note de Frais'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +267',b'Do you really want to restore this scrapped asset?',b'Voulez-vous vraiment restaurer cet actif mis au rebut ?'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +381',b'Qty for {0}',b'Qt\xc3\xa9 pour {0}'
+b'DocType: Leave Application',b'Leave Application',b'Demande de Cong\xc3\xa9s'
+b'DocType: Patient',b'Patient Relation',b'Relation patient'
+b'apps/erpnext/erpnext/config/hr.py +80',b'Leave Allocation Tool',b'Outil de R\xc3\xa9partition des Cong\xc3\xa9s'
+b'DocType: Item',b'Hub Category to Publish',b'Cat\xc3\xa9gorie du Hub \xc3\xa0 publier'
+b'DocType: Leave Block List',b'Leave Block List Dates',b'Dates de la Liste de Blocage des Cong\xc3\xa9s'
+b'DocType: Sales Invoice',b'Billing Address GSTIN',b'Adresse de Facturation GSTIN'
+b'DocType: Assessment Plan',b'Evaluate',b'\xc3\x89valuer'
+b'DocType: Workstation',b'Net Hour Rate',b'Taux Horaire Net'
+b'DocType: Landed Cost Purchase Receipt',b'Landed Cost Purchase Receipt',"b""Re\xc3\xa7u d'Achat du Co\xc3\xbbt au D\xc3\xa9barquement"""
+b'DocType: Company',b'Default Terms',b'Termes et Conditions par D\xc3\xa9faut'
+b'DocType: Supplier Scorecard Period',b'Criteria',b'Crit\xc3\xa8re'
+b'DocType: Packing Slip Item',b'Packing Slip Item',b'Article Emball\xc3\xa9'
+b'DocType: Purchase Invoice',b'Cash/Bank Account',b'Compte Caisse/Banque'
+b'apps/erpnext/erpnext/public/js/queries.js +96',b'Please specify a {0}',b'Veuillez sp\xc3\xa9cifier un {0}'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +73',b'Removed items with no change in quantity or value.',b'Les articles avec aucune modification de quantit\xc3\xa9 ou de valeur ont \xc3\xa9t\xc3\xa9s retir\xc3\xa9s.'
+b'DocType: Delivery Note',b'Delivery To',b'Livraison \xc3\xa0'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +415',b'Variant creation has been queued.',b'La cr\xc3\xa9ation de variantes a \xc3\xa9t\xc3\xa9 plac\xc3\xa9e en file d&#39;attente.'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +100',b'Work Summary for {0}',b'R\xc3\xa9sum\xc3\xa9 des travaux pour {0}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +696',b'Attribute table is mandatory',"b""Table d'Attribut est obligatoire"""
+b'DocType: Production Plan',b'Get Sales Orders',b'Obtenir les Commandes Client'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +68',b'{0} can not be negative',b'{0} ne peut pas \xc3\xaatre n\xc3\xa9gatif'
+b'DocType: Training Event',b'Self-Study',b'Autoformation'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +27',b'Soil compositions do not add up to 100',b'Les compositions de sol ne totalisent pas 100'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +558',b'Discount',b'Remise'
+b'DocType: Membership',b'Membership',b'Adh\xc3\xa9sion'
+b'DocType: Asset',b'Total Number of Depreciations',b'Nombre Total d\xe2\x80\x99Amortissements'
+b'DocType: Sales Invoice Item',b'Rate With Margin',b'Tarif Avec Marge'
+b'DocType: Workstation',b'Wages',b'Salaires'
+b'DocType: Asset Maintenance',b'Maintenance Manager Name',b'Nom du responsable de la maintenance'
+b'DocType: Agriculture Task',b'Urgent',b'Urgent'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +174',b'Please specify a valid Row ID for row {0} in table {1}',b'Veuillez sp\xc3\xa9cifier un N\xc2\xb0 de Ligne valide pour la ligne {0} de la table {1}'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +84',b'Unable to find variable: ',b'Impossible de trouver une variable:'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +794',b'Please select a field to edit from numpad',b'Veuillez s\xc3\xa9lectionner un champ \xc3\xa0 modifier sur le pav\xc3\xa9 num\xc3\xa9rique'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +264',b'Cannot be a fixed asset item as Stock Ledger is created.',b'Ne peut pas \xc3\xaatre un article immobilis\xc3\xa9 car un Journal de Stock a \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9.'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +23',b'Go to the Desktop and start using ERPNext',b'Acc\xc3\xa9dez au bureau et commencez \xc3\xa0 utiliser ERPNext'
+b'DocType: Item',b'Manufacturer',b'Fabricant'
+b'DocType: Landed Cost Item',b'Purchase Receipt Item',b'Article du Re\xc3\xa7u d\xe2\x80\x99Achat'
+b'DocType: Purchase Receipt',b'PREC-RET-',b'PREC-RET-'
+b'DocType: POS Profile',b'Sales Invoice Payment',b'Paiement de la Facture de Vente'
+b'DocType: Quality Inspection Template',b'Quality Inspection Template Name',b'Nom du mod\xc3\xa8le d&#39;inspection de la qualit\xc3\xa9'
+b'DocType: Project',b'First Email',b'Premier Email'
+b'DocType: Production Plan Item',b'Reserved Warehouse in Sales Order / Finished Goods Warehouse',b'Entrep\xc3\xb4t R\xc3\xa9serv\xc3\xa9 aux Commandes Clients / Entrep\xc3\xb4t de Produits Finis'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +71',b'Selling Amount',b'Montant de Vente'
+b'DocType: Repayment Schedule',b'Interest Amount',"b""Montant d'Int\xc3\xa9r\xc3\xaats"""
+b'DocType: Serial No',b'Creation Document No',b'N\xc2\xb0 du Document de Cr\xc3\xa9ation'
+b'DocType: Share Transfer',b'Issue',b'Question'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation_dashboard.py +11',b'Records',b'Dossiers'
+b'DocType: Asset',b'Scrapped',b'Mis au Rebut'
+b'DocType: Purchase Invoice',b'Returns',b'Retours'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +42',b'WIP Warehouse',b'Entrep\xc3\xb4t (Travaux en Cours)'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +195',b'Serial No {0} is under maintenance contract upto {1}',"b""N\xc2\xb0 de S\xc3\xa9rie {0} est sous contrat de maintenance jusqu'\xc3\xa0 {1}"""
+b'apps/erpnext/erpnext/config/hr.py +35',b'Recruitment',b'Recrutement'
+b'DocType: Lead',b'Organization Name',"b""Nom de l'Organisation"""
+b'DocType: Tax Rule',b'Shipping State',b'\xc3\x89tat de livraison'
+,b'Projected Quantity as Source',b'Quantit\xc3\xa9 Projet\xc3\xa9e comme Source'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61',"b""Item must be added using 'Get Items from Purchase Receipts' button""","b""L'article doit \xc3\xaatre ajout\xc3\xa9 \xc3\xa0 l'aide du bouton 'Obtenir des \xc3\xa9l\xc3\xa9ments de Re\xc3\xa7us d'Achat'"""
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +858',b'Delivery Trip',b'Livraison'
+b'DocType: Student',b'A-',b'A-'
+b'DocType: Share Transfer',b'Transfer Type',b'Type de transfert'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117',b'Sales Expenses',b'Frais de Vente'
+b'DocType: Consultation',b'Diagnosis',b'Diagnostique'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +18',b'Standard Buying',b'Achat Standard'
+b'DocType: GL Entry',b'Against',b'Contre'
+b'DocType: Item',b'Default Selling Cost Center',b'Centre de Co\xc3\xbbt Vendeur par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +85',b'Disc',b'Rem'
+b'DocType: Sales Partner',b'Implementation Partner',"b""Partenaire d'Impl\xc3\xa9mentation"""
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1624',b'ZIP Code',b'Code Postal'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +252',b'Sales Order {0} is {1}',b'Commande Client {0} est {1}'
+b'DocType: Opportunity',b'Contact Info',b'Information du Contact'
+b'apps/erpnext/erpnext/config/stock.py +319',b'Making Stock Entries',b'Faire des \xc3\x89critures de Stock'
+b'DocType: Packing Slip',b'Net Weight UOM',b'UDM Poids Net'
+b'DocType: Item',b'Default Supplier',b'Fournisseur par D\xc3\xa9faut'
+b'DocType: Manufacturing Settings',b'Over Production Allowance Percentage',"b""Pourcentage d'Allocation en cas de Surproduction"""
+b'DocType: Employee Loan',b'Repayment Schedule',b'\xc3\x89ch\xc3\xa9ancier de Remboursement'
+b'DocType: Shipping Rule Condition',b'Shipping Rule Condition',b'Condition de la R\xc3\xa8gle de Livraison'
+b'DocType: Holiday List',b'Get Weekly Off Dates',b'Obtenir les Dates de Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +33',b'End Date can not be less than Start Date',b'La date de Fin ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de D\xc3\xa9but'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +337',"b""Invoice can't be made for zero billing hour""",b'La facture ne peut pas \xc3\xaatre faite pour une heure de facturation nulle'
+b'DocType: Sales Person',b'Select company name first.',"b""S\xc3\xa9lectionner d'abord le nom de la soci\xc3\xa9t\xc3\xa9."""
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +189',b'Email sent to {0}',b'Email envoy\xc3\xa9 \xc3\xa0 {0}'
+b'apps/erpnext/erpnext/config/buying.py +23',b'Quotations received from Suppliers.',b'Devis re\xc3\xa7us des Fournisseurs.'
+b'apps/erpnext/erpnext/config/manufacturing.py +74',b'Replace BOM and update latest price in all BOMs',b'Remplacer la LDM et actualiser les prix les plus r\xc3\xa9cents dans toutes les LDMs'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +27',b'To {0} | {1} {2}',b'\xc3\x80 {0} | {1} {2}'
+b'DocType: Delivery Trip',b'Driver Name',b'Nom du conducteur'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40',b'Average Age',b'\xc3\x82ge Moyen'
+b'DocType: Education Settings',b'Attendance Freeze Date',b'Date du Gel des Pr\xc3\xa9sences'
+b'apps/erpnext/erpnext/utilities/user_progress.py +110',b'List a few of your suppliers. They could be organizations or individuals.',b'Listez quelques-uns de vos fournisseurs. Ils peuvent \xc3\xaatre des entreprises ou des individus.'
+b'apps/erpnext/erpnext/templates/pages/home.html +31',b'View All Products',b'Voir Tous Les Produits'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +20',b'Minimum Lead Age (Days)',b'\xc3\x82ge Minimum du Prospect (Jours)'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +60',b'All BOMs',b'Toutes les LDM'
+b'apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py +35',b'Hotel Rooms of type {0} are unavailable on {1}',b'Les chambres d&#39;h\xc3\xb4tel de type {0} sont indisponibles le {1}'
+b'DocType: Patient',b'Default Currency',b'Devise par D\xc3\xa9faut'
+b'DocType: Expense Claim',b'From Employee',"b""De l'Employ\xc3\xa9"""
+b'DocType: Driver',b'Cellphone Number',b'Num\xc3\xa9ro de t\xc3\xa9l\xc3\xa9phone portable'
+b'DocType: Project',b'Monitor Progress',b'Surveiller les progr\xc3\xa8s'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +472',b'Warning: System will not check overbilling since amount for Item {0} in {1} is zero',"b""Attention : Le syst\xc3\xa8me ne v\xc3\xa9rifie pas la surfacturation car le montant pour l'Article {0} dans {1} est nul"""
+b'DocType: Journal Entry',b'Make Difference Entry',"b""Cr\xc3\xa9er l'\xc3\x89criture par Diff\xc3\xa9rence"""
+b'DocType: Upload Attendance',b'Attendance From Date',b'Pr\xc3\xa9sence Depuis'
+b'DocType: Appraisal Template Goal',b'Key Performance Area',b'Domaine Essentiel de Performance'
+b'DocType: Program Enrollment',b'Transportation',b'Transport'
+b'apps/erpnext/erpnext/controllers/item_variant.py +94',b'Invalid Attribute',b'Attribut Invalide'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +240',b'{0} {1} must be submitted',b'{0} {1} doit \xc3\xaatre soumis'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +159',b'Quantity must be less than or equal to {0}',b'La quantit\xc3\xa9 doit \xc3\xaatre inf\xc3\xa9rieure ou \xc3\xa9gale \xc3\xa0 {0}'
+b'DocType: SMS Center',b'Total Characters',b'Nombre de Caract\xc3\xa8res'
+b'DocType: Employee Advance',b'Claimed',b'R\xc3\xa9clam\xc3\xa9'
+b'DocType: Crop',b'Row Spacing',b'\xc3\x89cartement des rangs'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +164',b'Please select BOM in BOM field for Item {0}',b'Veuillez s\xc3\xa9lectionner une LDM dans le champ LDM pour l\xe2\x80\x99Article {0}'
+b'DocType: C-Form Invoice Detail',b'C-Form Invoice Detail',b'Formulaire-C D\xc3\xa9tail de la Facture'
+b'DocType: Payment Reconciliation Invoice',b'Payment Reconciliation Invoice',b'Facture de R\xc3\xa9conciliation des Paiements'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +38',b'Contribution %',b'Contribution %'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +215',"b""As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}""","b""D'apr\xc3\xa8s les Param\xc3\xa8tres d'Achat, si Bon de Commande Requis == 'OUI', alors l'utilisateur doit d'abord cr\xc3\xa9er un Bon de Commande pour l'article {0} pour pouvoir cr\xc3\xa9er une Facture d'Achat"""
+b'DocType: Company',b'Company registration numbers for your reference. Tax numbers etc.',"b""Num\xc3\xa9ro d'immatriculation de la Soci\xc3\xa9t\xc3\xa9 pour votre r\xc3\xa9f\xc3\xa9rence. Num\xc3\xa9ros de taxes, etc."""
+b'DocType: Sales Partner',b'Distributor',b'Distributeur'
+b'DocType: Shopping Cart Shipping Rule',b'Shopping Cart Shipping Rule',b'R\xc3\xa8gles de Livraison du Panier'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +71',"b""Please set 'Apply Additional Discount On'""",b'Veuillez d\xc3\xa9finir \xe2\x80\x98Appliquer R\xc3\xa9duction Suppl\xc3\xa9mentaire Sur \xe2\x80\x98'
+,b'Ordered Items To Be Billed',b'Articles Command\xc3\xa9s \xc3\x80 Facturer'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +46',b'From Range has to be less than To Range',b'La Plage Initiale doit \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 la Plage Finale'
+b'DocType: Global Defaults',b'Global Defaults',b'Valeurs par D\xc3\xa9faut Globales'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +230',b'Project Collaboration Invitation',b'Invitation de Collaboration \xc3\xa0 un Projet'
+b'DocType: Salary Slip',b'Deductions',b'D\xc3\xa9ductions'
+b'DocType: Leave Allocation',b'LAL/',b'LAL/'
+b'DocType: Setup Progress Action',b'Action Name',"b""Nom de l'Action"""
+b'apps/erpnext/erpnext/public/js/financial_statements.js +75',b'Start Year',b'Ann\xc3\xa9e de D\xc3\xa9but'
+b'apps/erpnext/erpnext/regional/india/utils.py +25',b'First 2 digits of GSTIN should match with State number {0}',"b""Les 2 premiers chiffres du GSTIN doivent correspondre au num\xc3\xa9ro de l'\xc3\x89tat {0}"""
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68',b'PDC/LC',b'PDC / LC'
+b'DocType: Purchase Invoice',"b""Start date of current invoice's period""",b'Date de d\xc3\xa9but de la p\xc3\xa9riode de facturation en cours'
+b'DocType: Salary Slip',b'Leave Without Pay',b'Cong\xc3\xa9 Sans Solde'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +385',b'Capacity Planning Error',b'Erreur de Planification de Capacit\xc3\xa9'
+,b'Trial Balance for Party',b'Balance Auxiliaire'
+b'DocType: Lead',b'Consultant',b'Consultant'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +356',b'Parents Teacher Meeting Attendance',b'Participation des parents \xc3\xa0 la r\xc3\xa9union des enseignants'
+b'DocType: Salary Slip',b'Earnings',b'B\xc3\xa9n\xc3\xa9fices'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +441',b'Finished Item {0} must be entered for Manufacture type entry',b'Le Produit Fini {0} doit \xc3\xaatre saisi pour une \xc3\xa9criture de type de Fabrication'
+b'apps/erpnext/erpnext/config/learn.py +87',b'Opening Accounting Balance',"b""Solde d'Ouverture de Comptabilit\xc3\xa9"""
+,b'GST Sales Register',b'Registre de Vente GST'
+b'DocType: Sales Invoice Advance',b'Sales Invoice Advance',b'Avance sur Facture de Vente'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +552',b'Nothing to request',b'Aucune requ\xc3\xaate \xc3\xa0 effectuer'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +18',b'Select your Domains',b'S\xc3\xa9lectionnez vos domaines'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +34',"b""Another Budget record '{0}' already exists against {1} '{2}' for fiscal year {3}""","b""Un autre enregistrement de Budget '{0}' existe d\xc3\xa9j\xc3\xa0 pour {1} '{2}' pour l'exercice {3}"""
+b'DocType: Item Variant Settings',b'Fields will be copied over only at time of creation.',b'Les champs seront copi\xc3\xa9s uniquement au moment de la cr\xc3\xa9ation.'
+b'DocType: Setup Progress Action',b'Domains',b'Domaines'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +41',"b""'Actual Start Date' can not be greater than 'Actual End Date'""","b'""Date de D\xc3\xa9but R\xc3\xa9elle"" ne peut \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 ""Date de Fin R\xc3\xa9elle""'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +117',b'Management',b'Gestion'
+b'DocType: Cheque Print Template',b'Payer Settings',b'Param\xc3\xa8tres du Payeur'
+b'DocType: Item Attribute Value',"b'This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""'","b'Ce sera ajout\xc3\xa9e au Code de la Variante de l\'Article. Par exemple, si votre abr\xc3\xa9viation est \xc2\xabSM\xc2\xbb, et le code de l\'article est ""T-SHIRT"", le code de l\'article de la variante sera ""T-SHIRT-SM""'"
+b'DocType: Salary Slip',b'Net Pay (in words) will be visible once you save the Salary Slip.',b'Salaire Net (en lettres) sera visible une fois que vous aurez enregistr\xc3\xa9 la Fiche de Paie.'
+b'DocType: Purchase Invoice',b'Is Return',b'Est un Retour'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',b'Caution',b'Mise en Garde'
+b'apps/erpnext/erpnext/agriculture/doctype/disease/disease.py +17',"b""Start day is greater than end day in task '{0}'""",b'Le jour de d\xc3\xa9but est sup\xc3\xa9rieur au jour de fin de la t\xc3\xa2che &#39;{0}&#39;'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +815',b'Return / Debit Note',b'Retour / Note de D\xc3\xa9bit'
+b'DocType: Price List Country',b'Price List Country',b'Pays de la Liste des Prix'
+b'DocType: Item',b'UOMs',b'UDMs'
+b'apps/erpnext/erpnext/stock/utils.py +212',b'{0} valid serial nos for Item {1}',"b""{0} num\xc3\xa9ro de s\xc3\xa9rie valide pour l'objet {1}"""
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57',b'Item Code cannot be changed for Serial No.',"b""Code de l'Article ne peut pas \xc3\xaatre modifi\xc3\xa9 pour le Num\xc3\xa9ro de S\xc3\xa9rie"""
+b'DocType: Purchase Invoice Item',b'UOM Conversion Factor',"b""Facteur de Conversion de l'UDM"""
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +40',b'Please enter Item Code to get Batch Number',"b""Veuillez entrer le Code d'Article pour obtenir le Num\xc3\xa9ro de Lot"""
+b'DocType: Stock Settings',b'Default Item Group',"b""Groupe d'\xc3\x89l\xc3\xa9ments par D\xc3\xa9faut"""
+b'DocType: Employee Loan',b'Partially Disbursed',b'Partiellement D\xc3\xa9caiss\xc3\xa9'
+b'apps/erpnext/erpnext/config/non_profit.py +73',b'Grant information.',b'Accorder des informations.'
+b'apps/erpnext/erpnext/config/buying.py +38',b'Supplier database.',b'Base de donn\xc3\xa9es fournisseurs.'
+b'DocType: Account',b'Balance Sheet',b'Bilan'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +750',"b""Cost Center For Item with Item Code '""","b""Centre de Co\xc3\xbbts Pour Article ayant un Code Article '"""
+b'DocType: Fee Validity',b'Valid Till',"b""Valable Jusqu'au"""
+b'DocType: Student Report Generation Tool',b'Total Parents Teacher Meeting',b'R\xc3\xa9union des enseignants Total Parents'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2516',"b'Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.'",b'Le Mode de Paiement n\xe2\x80\x99est pas configur\xc3\xa9. Veuillez v\xc3\xa9rifier si le compte a \xc3\xa9t\xc3\xa9 r\xc3\xa9gl\xc3\xa9 sur Mode de Paiement ou sur Profil de Point de Vente.'
+b'apps/erpnext/erpnext/buying/utils.py +74',b'Same item cannot be entered multiple times.',b'Le m\xc3\xaame article ne peut pas \xc3\xaatre entr\xc3\xa9 plusieurs fois.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +30',"b'Further accounts can be made under Groups, but entries can be made against non-Groups'","b""D'autres comptes individuels peuvent \xc3\xaatre cr\xc3\xa9\xc3\xa9s dans les groupes, mais les \xc3\xa9critures ne peuvent \xc3\xaatre faites que sur les comptes individuels"""
+b'DocType: Lead',b'Lead',b'Prospect'
+b'DocType: Email Digest',b'Payables',b'Dettes'
+b'DocType: Course',b'Course Intro',b'Intro du Cours'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +105',b'Stock Entry {0} created',b'\xc3\x89criture de Stock {0} cr\xc3\xa9\xc3\xa9e'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +306',b'Row #{0}: Rejected Qty can not be entered in Purchase Return',b'Ligne #{0} : Qt\xc3\xa9 Rejet\xc3\xa9e ne peut pas \xc3\xaatre entr\xc3\xa9e dans le Retour d\xe2\x80\x99Achat'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +182',b'Changing Customer Group for the selected Customer is not allowed.',b'Le changement de groupe de clients pour le client s\xc3\xa9lectionn\xc3\xa9 n&#39;est pas autoris\xc3\xa9.'
+,b'Purchase Order Items To Be Billed',b'Articles \xc3\xa0 Facturer du Bon de Commande'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +63',b'Updating estimated arrival times.',b'Mise \xc3\xa0 jour des heures d&#39;arriv\xc3\xa9e estim\xc3\xa9es.'
+b'DocType: Program Enrollment Tool',b'Enrollment Details',b'D\xc3\xa9tails d&#39;inscription'
+b'DocType: Purchase Invoice Item',b'Net Rate',b'Taux Net'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +152',b'Please select a customer',b'Veuillez s\xc3\xa9lectionner un Client'
+b'DocType: Purchase Invoice Item',b'Purchase Invoice Item',"b""Article de la Facture d'Achat"""
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +58',b'Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts',"b""\xc3\x89critures du Journal du Stock et \xc3\x89critures du Grand Livre sont republi\xc3\xa9es pour les Re\xc3\xa7us d'Achat s\xc3\xa9lectionn\xc3\xa9s"""
+b'DocType: Student Report Generation Tool',b'Assessment Terms',b'Conditions d&#39;\xc3\xa9valuation'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +8',b'Item 1',b'Article 1'
+b'DocType: Holiday',b'Holiday',b'Vacances'
+b'DocType: Support Settings',b'Close Issue After Days',b'Fermer Probl\xc3\xa8me Apr\xc3\xa8s Jours'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all branches',b'Laisser vide pour toutes les branches'
+b'DocType: Bank Guarantee',b'Validity in Days',b'Validit\xc3\xa9 en Jours'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +21',b'C-form is not applicable for Invoice: {0}',"b""Formulaire-C n'est pas applicable pour la Facture: {0}"""
+b'DocType: Payment Reconciliation',b'Unreconciled Payment Details',b'D\xc3\xa9tails des Paiements Non R\xc3\xa9concili\xc3\xa9s'
+b'apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py +6',b'Member Activity',b'Activit\xc3\xa9 des membres'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +20',b'Order Count',b'Compte de Commandes'
+b'DocType: Global Defaults',b'Current Fiscal Year',b'Exercice en Cours'
+b'DocType: Purchase Order',b'Group same items',b'Groupe les \xc3\xa9l\xc3\xa9ments identiques'
+b'DocType: Purchase Invoice',b'Disable Rounded Total',b'D\xc3\xa9sactiver le Total Arrondi'
+b'DocType: Employee Loan Application',b'Repayment Info',b'Infos de Remboursement'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +448',"b""'Entries' cannot be empty""","b""'Entr\xc3\xa9es' ne peuvent pas \xc3\xaatre vides"""
+b'DocType: Maintenance Team Member',b'Maintenance Role',b'R\xc3\xb4le de maintenance'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +92',b'Duplicate row {0} with same {1}',b'Ligne {0} en double avec le m\xc3\xaame {1}'
+,b'Trial Balance',b'Balance G\xc3\xa9n\xc3\xa9rale'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +443',b'Fiscal Year {0} not found',b'Exercice Fiscal {0} introuvable'
+b'apps/erpnext/erpnext/config/hr.py +309',b'Setting up Employees',b'Configuration des Employ\xc3\xa9s'
+b'DocType: Sales Order',b'SO-',b'SO-'
+b'DocType: Hotel Room Reservation',b'Hotel Reservation User',b'Utilisateur de r\xc3\xa9servation d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +158',b'Please select prefix first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner un pr\xc3\xa9fixe'
+b'DocType: Student',b'O-',b'O-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +189',b'Research',b'Recherche'
+b'DocType: Maintenance Visit Purpose',b'Work Done',b'Travaux Effectu\xc3\xa9s'
+b'apps/erpnext/erpnext/controllers/item_variant.py +35',b'Please specify at least one attribute in the Attributes table',b'Veuillez sp\xc3\xa9cifier au moins un attribut dans la table Attributs'
+b'DocType: Announcement',b'All Students',b'Tous les Etudiants'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +45',b'Item {0} must be a non-stock item',"b""L'article {0} doit \xc3\xaatre un article hors stock"""
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +18',b'View Ledger',b'Voir le Livre'
+b'DocType: Grading Scale',b'Intervals',b'Intervalles'
+b'apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41',b'Earliest',b'Au plus t\xc3\xb4t'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +526',"b'An Item Group exists with same name, please change the item name or rename the item group'","b""Un Groupe d'Article existe avec le m\xc3\xaame nom, veuillez changer le nom de l'article ou renommer le groupe d'article"""
+b'DocType: Crop Cycle',b'Less than a year',b'Moins d&#39;un an'
+b'apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py +52',b'Student Mobile No.',"b""N\xc2\xb0 de Mobile de l'\xc3\x89tudiant"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +105',b'Rest Of The World',b'Reste du Monde'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +81',b'The Item {0} cannot have Batch',"b""L'Article {0} ne peut \xc3\xaatre en Lot"""
+b'DocType: Crop',b'Yield UOM',b'UOM de rendement'
+,b'Budget Variance Report',b'Rapport d\xe2\x80\x99\xc3\x89carts de Budget'
+b'DocType: Salary Slip',b'Gross Pay',b'Salaire Brut'
+b'DocType: Item',b'Is Item from Hub',b'Est un article sur le Hub'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +118',b'Row {0}: Activity Type is mandatory.',"b""Ligne {0} : Le Type d'Activit\xc3\xa9 est obligatoire."""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +166',b'Dividends Paid',b'Dividendes Pay\xc3\xa9s'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +36',b'Accounting Ledger',b'Livre des Comptes'
+b'DocType: Stock Reconciliation',b'Difference Amount',b'\xc3\x89cart de Montant'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +107',b'Dr {0} on Leave on {1}',b'Dr {0} en cong\xc3\xa9 le {1}'
+b'DocType: Purchase Invoice',b'Reverse Charge',b'Autoliquidation'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +172',b'Retained Earnings',b'B\xc3\xa9n\xc3\xa9fices Non R\xc3\xa9partis'
+b'DocType: Purchase Invoice',b'05-Change in POS',b'05-Changement de POS'
+b'DocType: Vehicle Log',b'Service Detail',b'D\xc3\xa9tails du Service'
+b'DocType: BOM',b'Item Description',"b""Description de l'Article"""
+b'DocType: Student Sibling',b'Student Sibling',"b""Fr\xc3\xa8re et S\xc5\x93ur de l'\xc3\x89tudiant"""
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py +18',b'Payment Mode',b'Mode de paiement'
+b'DocType: Purchase Invoice',b'Supplied Items',b'Articles Fournis'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +85',b'Please set an active menu for Restaurant {0}',b'Veuillez d\xc3\xa9finir un menu actif pour le restaurant {0}'
+b'DocType: Student',b'STUD.',b'STUD.'
+b'DocType: Work Order',b'Qty To Manufacture',b'Quantit\xc3\xa9 \xc3\x80 Fabriquer'
+b'DocType: Email Digest',b'New Income',b'Nouveaux Revenus'
+b'DocType: Buying Settings',b'Maintain same rate throughout purchase cycle',"b""Maintenir le m\xc3\xaame taux durant le cycle d'achat"""
+b'DocType: Opportunity Item',b'Opportunity Item',"b""Article de l'Opportunit\xc3\xa9"""
+,b'Student and Guardian Contact Details',b'D\xc3\xa9tails des Contacts \xc3\x89tudiant et Tuteur'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +53',b'Row {0}: For supplier {0} Email Address is required to send email',b'Ligne {0} : Pour le fournisseur {0} une Adresse Email est n\xc3\xa9cessaire pour envoyer des email'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +72',b'Temporary Opening',b'Ouverture Temporaire'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +10',b'View Hub',b'Afficher le Hub'
+,b'Employee Leave Balance',"b""Solde des Cong\xc3\xa9s de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +147',b'Balance for Account {0} must always be {1}',b'Solde pour le compte {0} doit toujours \xc3\xaatre {1}'
+b'DocType: Patient Appointment',b'More Info',b'Plus d&#39;infos'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +180',b'Valuation Rate required for Item in row {0}',b'Taux de Valorisation requis pour l\xe2\x80\x99Article de la ligne {0}'
+b'DocType: Supplier Scorecard',b'Scorecard Actions',"b""Actions de la Fiche d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +169',b'Example: Masters in Computer Science',b'Exemple: Master en Sciences Informatiques'
+b'DocType: Purchase Invoice',b'Rejected Warehouse',b'Entrep\xc3\xb4t Rejet\xc3\xa9'
+b'DocType: GL Entry',b'Against Voucher',b'Pour le Bon'
+b'DocType: Item',b'Default Buying Cost Center',"b""Centre de Co\xc3\xbbts d'Achat par D\xc3\xa9faut"""
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +6',"b'To get the best out of ERPNext, we recommend that you take some time and watch these help videos.'","b""Pour tirer le meilleur parti d\xe2\x80\x99ERPNext, nous vous recommandons de prendre un peu de temps et de regarder ces vid\xc3\xa9os d'aide."""
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +76',b' to ',b'\xc3\xa0'
+b'DocType: Supplier Quotation Item',b'Lead Time in days',b'D\xc3\xa9lai en Jours'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +70',b'Accounts Payable Summary',b'R\xc3\xa9sum\xc3\xa9 des Comptes Cr\xc3\xa9diteurs'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +326',b'Payment of salary from {0} to {1}',b'Paiement du salaire de {0} \xc3\xa0 {1}'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +213',b'Not authorized to edit frozen Account {0}',"b""Vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 modifier le compte gel\xc3\xa9 {0}"""
+b'DocType: Journal Entry',b'Get Outstanding Invoices',b'Obtenir les Factures Impay\xc3\xa9es'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +84',b'Sales Order {0} is not valid',b'Commande Client {0} invalide'
+b'DocType: Supplier Scorecard',b'Warn for new Request for Quotations',"b""Avertir lors d'une nouvelle Demande de Devis"""
+b'apps/erpnext/erpnext/utilities/activation.py +91',b'Purchase orders help you plan and follow up on your purchases',b'Les Bons de Commande vous aider \xc3\xa0 planifier et \xc3\xa0 assurer le suivi de vos achats'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +151',b'Lab Test Prescriptions',b'Prescriptions de test de laboratoire'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +166',b'The total Issue / Transfer quantity {0} in Material Request {1}  \\\n\t\t\t\t\t\t\tcannot be greater than requested quantity {2} for Item {3}',b'La quantit\xc3\xa9 totale d\xe2\x80\x99\xc3\x89mission / Transfert {0} dans la Demande de Mat\xc3\xa9riel {1} \\ ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 la quantit\xc3\xa9 demand\xc3\xa9e {2} pour l\xe2\x80\x99Article {3}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +197',b'Small',b'Petit'
+b'DocType: Opening Invoice Creation Tool Item',b'Opening Invoice Creation Tool Item',b'Ouverture d&#39;un outil de cr\xc3\xa9ation de facture'
+b'DocType: Education Settings',b'Employee Number',"b""Num\xc3\xa9ro d'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +67',b'Case No(s) already in use. Try from Case No {0}',b'N\xc2\xb0 de dossier d\xc3\xa9j\xc3\xa0 utilis\xc3\xa9. Essayez depuis N\xc2\xb0 de dossier {0}'
+b'DocType: Project',b'% Completed',b'% Compl\xc3\xa9t\xc3\xa9'
+,b'Invoiced Amount (Exculsive Tax)',b'Montant Factur\xc3\xa9 (Hors Taxes)'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +14',b'Item 2',b'Article 2'
+b'DocType: Supplier',b'SUPP-',b'SUPP-'
+b'DocType: Training Event',b'Training Event',b'\xc3\x89v\xc3\xa8nement de Formation'
+b'DocType: Item',b'Auto re-order',b'Re-commande auto'
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +59',b'Total Achieved',b'Total Obtenu'
+b'DocType: Employee',b'Place of Issue',"b""Lieu d'\xc3\x89mission"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +101',b'Contract',b'Contrat'
+b'DocType: Plant Analysis',b'Laboratory Testing Datetime',b'Test de laboratoire Datetime'
+b'DocType: Email Digest',b'Add Quote',b'Ajouter une Citation'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +987',b'UOM coversion factor required for UOM: {0} in Item: {1}',"b""Facteur de coversion UDM requis pour l'UDM : {0} dans l'Article : {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +92',b'Indirect Expenses',b'Charges Indirectes'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +98',b'Row {0}: Qty is mandatory',b'Ligne {0} : Qt\xc3\xa9 obligatoire'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture',b'Agriculture'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +794',b'Sync Master Data',b'Sync Donn\xc3\xa9es de Base'
+b'DocType: Asset Repair',b'Repair Cost',b'Co\xc3\xbbt de r\xc3\xa9paration'
+b'apps/erpnext/erpnext/utilities/user_progress.py +138',b'Your Products or Services',b'Vos Produits ou Services'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +15',b'Failed to login',b'\xc3\x89chec de la connexion'
+b'DocType: Special Test Items',b'Special Test Items',b'Articles de Test Sp\xc3\xa9cial'
+b'DocType: Mode of Payment',b'Mode of Payment',b'Mode de Paiement'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +202',b'Website Image should be a public file or website URL',"b""L'Image du Site Web doit \xc3\xaatre un fichier public ou l'URL d'un site web"""
+b'DocType: Student Applicant',b'AP',b'AP'
+b'DocType: Purchase Invoice Item',b'BOM',b'LDM (Liste de Mat\xc3\xa9riaux)'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +37',b'This is a root item group and cannot be edited.',"b""Il s\xe2\x80\x99agit d\xe2\x80\x99un groupe d'\xc3\xa9l\xc3\xa9ment racine qui ne peut \xc3\xaatre modifi\xc3\xa9."""
+b'DocType: Journal Entry Account',b'Purchase Order',b'Bon de Commande'
+b'DocType: Vehicle',b'Fuel UOM',b'UDM Carburant'
+b'DocType: Warehouse',b'Warehouse Contact Info',"b""Info de Contact de l'Entrep\xc3\xb4t"""
+b'DocType: Payment Entry',b'Write Off Difference Amount',b'Montant de la Diff\xc3\xa9rence de la Reprise'
+b'DocType: Volunteer',b'Volunteer Name',b'Nom du b\xc3\xa9n\xc3\xa9vole'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +434',"b'{0}: Employee email not found, hence email not sent'","b""{0} : Adresse email de l'employ\xc3\xa9 introuvable : l\xe2\x80\x99email n'a pas \xc3\xa9t\xc3\xa9 envoy\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +85',b'Shipping rule not applicable for country {0}',b'R\xc3\xa8gle d&#39;exp\xc3\xa9dition non applicable pour le pays {0}'
+b'DocType: Item',b'Foreign Trade Details',b'D\xc3\xa9tails du Commerce Ext\xc3\xa9rieur'
+,b'Assessment Plan Status',"b""Statut du Plan d'\xc3\x89valuation"""
+b'DocType: Email Digest',b'Annual Income',b'Revenu Annuel'
+b'DocType: Serial No',b'Serial No Details',b'D\xc3\xa9tails du N\xc2\xb0 de S\xc3\xa9rie'
+b'DocType: Purchase Invoice Item',b'Item Tax Rate',"b""Taux de la Taxe sur l'Article"""
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +89',b'Please select Physician and Date',b'Veuillez s\xc3\xa9lectionner M\xc3\xa9decin et Date'
+b'DocType: Student Group Student',b'Group Roll Number',b'Num\xc3\xa9ro de Groupe'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +145',"b'For {0}, only credit accounts can be linked against another debit entry'","b'Pour {0}, seuls les comptes de cr\xc3\xa9dit peuvent \xc3\xaatre li\xc3\xa9s avec une autre \xc3\xa9criture de d\xc3\xa9bit'"
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +84',b'Total of all task weights should be 1. Please adjust weights of all Project tasks accordingly',b'Le total des poids des t\xc3\xa2ches doit \xc3\xaatre \xc3\xa9gal \xc3\xa0 1. Veuillez ajuster les poids de toutes les t\xc3\xa2ches du Projet en cons\xc3\xa9quence'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588',b'Delivery Note {0} is not submitted',"b""Bon de Livraison {0} n'est pas soumis"""
+b'apps/erpnext/erpnext/stock/get_item_details.py +148',b'Item {0} must be a Sub-contracted Item',"b""L'article {0} doit \xc3\xaatre un Article Sous-trait\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +43',b'Capital Equipments',b'Capitaux Immobilis\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +33',"b""Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.""","b""La R\xc3\xa8gle de Tarification est d'abord s\xc3\xa9lectionn\xc3\xa9e sur la base du champ \xe2\x80\x98Appliquer Sur\xe2\x80\x99, qui peut \xc3\xaatre un Article, un Groupe d'Articles ou une Marque."""
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +246',b'Please set the Item Code first',"b""Veuillez d\xc3\xa9finir le Code d'Article en premier"""
+b'DocType: Item',b'ITEM-',b'ARTICLE-'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +123',b'Total allocated percentage for sales team should be 100',"b""Pourcentage total attribu\xc3\xa9 \xc3\xa0 l'\xc3\xa9quipe commerciale devrait \xc3\xaatre de 100"""
+b'DocType: Sales Invoice Item',b'Edit Description',b'Modifier la description'
+b'DocType: Antibiotic',b'Antibiotic',b'Antibiotique'
+,b'Team Updates',b'Mises \xc3\xa0 Jour de l\xe2\x80\x99\xc3\x89quipe'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +912',b'For Supplier',b'Pour Fournisseur'
+b'DocType: Account',b'Setting Account Type helps in selecting this Account in transactions.',b'D\xc3\xa9finir le Type de Compte aide \xc3\xa0 s\xc3\xa9lectionner ce Compte dans les transactions.'
+b'DocType: Purchase Invoice',b'Grand Total (Company Currency)',b'Total TTC (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Create Print Format',"b""Cr\xc3\xa9er Format d'Impression"""
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +5',b'Fee Created',b'Honoraires Cr\xc3\xa9\xc3\xa9s'
+b'apps/erpnext/erpnext/utilities/bot.py +39',b'Did not find any item called {0}',"b""N'a pas trouv\xc3\xa9 d'\xc3\xa9l\xc3\xa9ment appel\xc3\xa9 {0}"""
+b'DocType: Supplier Scorecard Criteria',b'Criteria Formula',b'Formule du Crit\xc3\xa8re'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Total Outgoing',b'Total Sortant'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +39',"b'There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""'","b'Il ne peut y avoir qu\xe2\x80\x99une Condition de R\xc3\xa8gle de Livraison avec 0 ou une valeur vide pour \xc2\xab\xc2\xa0A la Valeur""'"
+b'DocType: Authorization Rule',b'Transaction',b'Transaction'
+b'DocType: Patient Appointment',b'Duration',b'Dur\xc3\xa9e'
+b'apps/erpnext/erpnext/controllers/status_updater.py +160',"b'For an item {0}, quantity must be positive number'","b'Pour un article {0}, la quantit\xc3\xa9 doit \xc3\xaatre un nombre positif'"
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +27',b'Note: This Cost Center is a Group. Cannot make accounting entries against groups.',b'Remarque : Ce Centre de Co\xc3\xbbts est un Groupe. Vous ne pouvez pas faire des \xc3\xa9critures comptables sur des groupes.'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +53',b'Child warehouse exists for this warehouse. You can not delete this warehouse.',b'Un entrep\xc3\xb4t enfant existe pour cet entrep\xc3\xb4t. Vous ne pouvez pas supprimer cet entrep\xc3\xb4t.'
+b'DocType: Item',b'Website Item Groups',"b""Groupes d'Articles du Site Web"""
+b'DocType: Purchase Invoice',b'Total (Company Currency)',b'Total (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Daily Work Summary Group',b'Reminder',b'Rappel'
+b'apps/erpnext/erpnext/stock/utils.py +207',b'Serial number {0} entered more than once',"b""Num\xc3\xa9ro de s\xc3\xa9rie {0} est entr\xc3\xa9 plus d'une fois"""
+b'DocType: Journal Entry',b'Journal Entry',b'\xc3\x89criture de Journal'
+b'DocType: Expense Claim Advance',b'Unclaimed amount',b'Montant non r\xc3\xa9clam\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +148',b'{0} items in progress',b'{0} articles en cours'
+b'DocType: Workstation',b'Workstation Name',b'Nom du Bureau'
+b'DocType: Grading Scale Interval',b'Grade Code',b'Code de la Note'
+b'DocType: POS Item Group',b'POS Item Group',"b""Groupe d'Articles PDV"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +17',b'Email Digest:',b'Compte Rendu par Email :'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +613',b'BOM {0} does not belong to Item {1}',"b""LDM {0} n\xe2\x80\x99appartient pas \xc3\xa0 l'article {1}"""
+b'DocType: Sales Partner',b'Target Distribution',b'Distribution Cible'
+b'DocType: Purchase Invoice',b'06-Finalization of Provisional assessment',b'06-Finalisation de l&#39;\xc3\xa9valuation provisoire'
+b'DocType: Salary Slip',b'Bank Account No.',b'N\xc2\xb0 de Compte Bancaire'
+b'DocType: Naming Series',b'This is the number of the last created transaction with this prefix',b'Num\xc3\xa9ro de la derni\xc3\xa8re transaction cr\xc3\xa9\xc3\xa9e avec ce pr\xc3\xa9fixe'
+b'DocType: Supplier Scorecard',"b'Scorecard variables can be used, as well as:\n{total_score} (the total score from that period),\n{period_number} (the number of periods to present day)\n'","b""Les variables de la fiche d'\xc3\xa9valuation peuvent \xc3\xaatre utilis\xc3\xa9es, ainsi que: {total_score} (the total score from that period), {period_number} (the number of periods to present day)"""
+b'DocType: Quality Inspection Reading',b'Reading 8',b'Lecture 8'
+b'DocType: Sales Partner',b'Agent',b'Agent'
+b'DocType: Purchase Invoice',b'Taxes and Charges Calculation',b'Calcul des Frais et Taxes'
+b'DocType: Accounts Settings',b'Book Asset Depreciation Entry Automatically',"b""Comptabiliser les Entr\xc3\xa9es de D\xc3\xa9pr\xc3\xa9ciation d'Actifs Automatiquement"""
+b'DocType: BOM Operation',b'Workstation',b'Bureau'
+b'DocType: Request for Quotation Supplier',b'Request for Quotation Supplier',"b""Fournisseur de l'Appel d'Offre"""
+b'DocType: Healthcare Settings',b'Registration Message',"b""Message d'Inscription"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +154',b'Hardware',b'Mat\xc3\xa9riel'
+b'DocType: Prescription Dosage',b'Prescription Dosage',b'Dosage de la prescription'
+b'DocType: Attendance',b'HR Manager',b'Responsable RH'
+b'apps/erpnext/erpnext/accounts/party.py +175',b'Please select a Company',b'Veuillez s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +92',b'Privilege Leave',b'Cong\xc3\xa9 de Privil\xc3\xa8ge'
+b'DocType: Purchase Invoice',b'Supplier Invoice Date',b'Date de la Facture du Fournisseur'
+b'DocType: Asset Settings',b'This value is used for pro-rata temporis calculation',b'Cette valeur est utilis\xc3\xa9e pour le calcul pro-rata temporis'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +90',b'You need to enable Shopping Cart',b'Vous devez activer le Panier'
+b'DocType: Payment Entry',b'Writeoff',b'\xc3\x89crire'
+b'DocType: Stock Settings',b'Naming Series Prefix',b'Attribution d&#39;un nom au pr\xc3\xa9fixe de s\xc3\xa9rie'
+b'DocType: Appraisal Template Goal',b'Appraisal Template Goal',"b""But du Mod\xc3\xa8le d'\xc3\x89valuation"""
+b'DocType: Salary Component',b'Earning',b'Revenus'
+b'DocType: Supplier Scorecard',b'Scoring Criteria',b'Crit\xc3\xa8res de Notation'
+b'DocType: Purchase Invoice',b'Party Account Currency',b'Devise du Compte de Tiers'
+,b'BOM Browser',b'Explorateur LDM'
+b'apps/erpnext/erpnext/templates/emails/training_event.html +13',b'Please update your status for this training event',b'Veuillez mettre \xc3\xa0 jour votre statut pour cet \xc3\xa9v\xc3\xa9nement de formation'
+b'DocType: Item Barcode',b'EAN',b'EAN'
+b'DocType: Purchase Taxes and Charges',b'Add or Deduct',b'Ajouter ou D\xc3\xa9duire'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +148',b'Overlapping conditions found between:',b'Conditions qui coincident touv\xc3\xa9es entre :'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +187',b'Against Journal Entry {0} is already adjusted against some other voucher',"b""L'\xc3\x89criture de Journal {0} est d\xc3\xa9j\xc3\xa0 ajust\xc3\xa9e par un autre bon"""
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +68',b'Total Order Value',b'Total de la Valeur de la Commande'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +328',b'Food',b'Alimentation'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +57',b'Ageing Range 3',b'Balance Ag\xc3\xa9e 3'
+b'DocType: Maintenance Schedule Item',b'No of Visits',b'Nb de Visites'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +165',b'Maintenance Schedule {0} exists against {1}',b'Un Calendrier de Maintenance {0} existe pour {1}'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +36',b'Enrolling student',b'Inscrire un \xc3\xa9tudiant'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +33',b'Currency of the Closing Account must be {0}',b'La devise du Compte Clotur\xc3\xa9 doit \xc3\xaatre {0}'
+b'apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21',b'Sum of points for all goals should be 100. It is {0}',b'Somme des points pour tous les objectifs devraient \xc3\xaatre 100. Il est {0}'
+b'DocType: Project',b'Start and End Dates',b'Dates de D\xc3\xa9but et de Fin'
+,b'Delivered Items To Be Billed',b'Articles Livr\xc3\xa9s \xc3\xa0 Facturer'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +16',b'Open BOM {0}',b'Ouvrir LDM {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +60',b'Warehouse cannot be changed for Serial No.',"b""L'entrep\xc3\xb4t ne peut \xc3\xaatre modifi\xc3\xa9 pour le N\xc2\xb0 de S\xc3\xa9rie"""
+b'DocType: Authorization Rule',b'Average Discount',b'Remise Moyenne'
+b'DocType: Project Update',b'Great/Quickly',b'Super / rapidement'
+b'DocType: Purchase Invoice Item',b'UOM',b'UDM'
+b'DocType: Rename Tool',b'Utilities',b'Utilitaires'
+b'DocType: POS Profile',b'Accounting',b'Comptabilit\xc3\xa9'
+b'DocType: Employee',b'EMP/',b'EMP/'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +133',b'Please select batches for batched item ',b'Veuillez s\xc3\xa9lectionner les lots pour les articles en lots'
+b'DocType: Asset',b'Depreciation Schedules',"b""Calendriers d'Amortissement"""
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +192',b'Following accounts might be selected in GST Settings:',b'Les comptes suivants peuvent \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9s dans les param\xc3\xa8tres de TPS:'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +70',b'Application period cannot be outside leave allocation period',"b""La p\xc3\xa9riode de la demande ne peut pas \xc3\xaatre hors de la p\xc3\xa9riode d'allocation de cong\xc3\xa9"""
+b'DocType: Activity Cost',b'Projects',b'Projets'
+b'DocType: Payment Request',b'Transaction Currency',b'Devise de la Transaction'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +30',b'From {0} | {1} {2}',b'Du {0} | {1} {2}'
+b'DocType: Work Order Operation',b'Operation Description',"b""Description de l'Op\xc3\xa9ration"""
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34',b'Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.',"b""Impossible de modifier les dates de d\xc3\xa9but et de fin d'exercice une fois que l'exercice est enregistr\xc3\xa9."""
+b'DocType: Quotation',b'Shopping Cart',b'Panier'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41',b'Avg Daily Outgoing',b'Moy Quotidienne Sortante'
+b'DocType: POS Profile',b'Campaign',b'Campagne'
+b'DocType: Supplier',b'Name and Type',b'Nom et Type'
+b'DocType: Physician',b'Contacts and Address',b'Contacts et Adresse'
+b'DocType: Purchase Invoice',b'Contact Person',b'Personne \xc3\xa0 Contacter'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +38',"b""'Expected Start Date' can not be greater than 'Expected End Date'""","b""'Date de D\xc3\xa9but Pr\xc3\xa9vue' ne peut pas \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 'Date de Fin Pr\xc3\xa9vue'"""
+b'DocType: Course Scheduling Tool',b'Course End Date',b'Date de Fin du Cours'
+b'DocType: Holiday List',b'Holidays',b'Jours F\xc3\xa9ri\xc3\xa9s'
+b'DocType: Sales Order Item',b'Planned Quantity',b'Quantit\xc3\xa9 Planifi\xc3\xa9e'
+b'DocType: Purchase Invoice Item',b'Item Tax Amount',"b""Montant de la Taxe sur l'Article"""
+b'DocType: Water Analysis',b'Water Analysis Criteria',b'Crit\xc3\xa8res d&#39;analyse de l&#39;eau'
+b'DocType: Item',b'Maintain Stock',b'Maintenir Stock'
+b'DocType: Employee',b'Prefered Email',b'Email Pr\xc3\xa9f\xc3\xa9r\xc3\xa9'
+b'DocType: Student Admission',b'Eligibility and Details',b'Admissibilit\xc3\xa9 et D\xc3\xa9tails'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +38',b'Net Change in Fixed Asset',b'Variation Nette des Actifs Immobilis\xc3\xa9s'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all designations',b'Laisser vide pour toutes les d\xc3\xa9signations'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +806',"b""Charge of type 'Actual' in row {0} cannot be included in Item Rate""","b""Charge de type ' r\xc3\xa9el ' \xc3\xa0 la ligne {0} ne peut pas \xc3\xaatre inclus dans le prix de l'article"""
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +382',b'Max: {0}',b'Max : {0}'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'From Datetime',b'A partir du (Date et Heure)'
+b'DocType: Email Digest',b'For Company',b'Pour la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/config/support.py +17',b'Communication log.',b'Journal des communications.'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +195',"b'Request for Quotation is disabled to access from portal, for more check portal settings.'","b'L\xe2\x80\x99acc\xc3\xa8s au portail est d\xc3\xa9sactiv\xc3\xa9 pour les Appels d\xe2\x80\x99Offres. Pour plus d\xe2\x80\x99informations, v\xc3\xa9rifiez les r\xc3\xa9glages du portail.'"
+b'DocType: Supplier Scorecard Scoring Variable',b'Supplier Scorecard Scoring Variable',"b""Variable de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +72',b'Buying Amount',"b""Montant d'Achat"""
+b'DocType: Sales Invoice',b'Shipping Address Name',"b""Nom de l'Adresse de Livraison"""
+b'DocType: Material Request',b'Terms and Conditions Content',b'Contenu des Termes et Conditions'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +18',b'There were errors creating Course Schedule',b'Des erreurs se sont produites lors de la cr\xc3\xa9ation du programme'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +581',b'cannot be greater than 100',b'ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 100'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +752',b'Item {0} is not a stock Item',"b""Article {0} n'est pas un article stock\xc3\xa9"""
+b'DocType: Maintenance Visit',b'Unscheduled',b'Non programm\xc3\xa9'
+b'DocType: Employee',b'Owned',b'D\xc3\xa9tenu'
+b'DocType: Salary Detail',b'Depends on Leave Without Pay',b'D\xc3\xa9pend de Cong\xc3\xa9 Non Pay\xc3\xa9'
+b'DocType: Pricing Rule',"b'Higher the number, higher the priority'","b'Plus le nombre est grand, plus la priorit\xc3\xa9 est haute'"
+,b'Purchase Invoice Trends',"b""Tendances des Factures d'Achat"""
+b'DocType: Employee',b'Better Prospects',b'Meilleures Perspectives'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +217',"b'Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches'","b""Ligne # {0}: Le lot {1} n'a que {2} qt\xc3\xa9(s). Veuillez s\xc3\xa9lectionner un autre lot contenant {3} qt\xc3\xa9s disponible ou diviser la rang\xc3\xa9e en plusieurs lignes, pour livrer / \xc3\xa9mettre \xc3\xa0 partir de plusieurs lots"""
+b'DocType: Vehicle',b'License Plate',"b""Plaque d'Immatriculation"""
+b'DocType: Appraisal',b'Goals',b'Objectifs'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +353',b'Select POS Profile',b'S\xc3\xa9lectionnez le profil POS'
+b'DocType: Warranty Claim',b'Warranty / AMC Status',b'Garantie / Statut AMC'
+,b'Accounts Browser',b'Navigateur des Comptes'
+b'DocType: Payment Entry Reference',b'Payment Entry Reference',b'R\xc3\xa9f\xc3\xa9rence d\xe2\x80\x99\xc3\x89criture de Paiement'
+b'DocType: GL Entry',b'GL Entry',b'\xc3\x89criture GL'
+b'DocType: HR Settings',b'Employee Settings',b'Param\xc3\xa8tres des Employ\xc3\xa9s'
+,b'Batch-Wise Balance History',b'Historique de Balance des Lots'
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +73',b'Print settings updated in respective print format',"b""R\xc3\xa9glages d'impression mis \xc3\xa0 jour au format d'impression respectif"""
+b'DocType: Package Code',b'Package Code',b'Code du Paquet'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +105',b'Apprentice',b'Apprenti'
+b'DocType: Purchase Invoice',b'Company GSTIN',b'GSTIN de la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +105',b'Negative Quantity is not allowed',"b""Quantit\xc3\xa9 N\xc3\xa9gative n'est pas autoris\xc3\xa9e"""
+b'DocType: Purchase Invoice Item',b'Tax detail table fetched from item master as a string and stored in this field.\nUsed for Taxes and Charges',"b""La table de d\xc3\xa9tails de taxe est r\xc3\xa9cup\xc3\xa9r\xc3\xa9e depuis les donn\xc3\xa9es de base de l'article comme une cha\xc3\xaene de caract\xc3\xa8res et stock\xc3\xa9e dans ce champ. Elle est utilis\xc3\xa9e pour les Taxes et Frais."""
+b'DocType: Supplier Scorecard Period',b'SSC-',b'SSC-'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +159',b'Employee cannot report to himself.',"b""L'employ\xc3\xa9 ne peut pas rendre de compte \xc3\xa0 lui-m\xc3\xaame."""
+b'DocType: Account',"b'If the account is frozen, entries are allowed to restricted users.'","b""Si le compte est gel\xc3\xa9, les \xc3\xa9critures ne sont autoris\xc3\xa9s que pour un nombre restreint d'utilisateurs."""
+b'DocType: Email Digest',b'Bank Balance',b'Solde Bancaire'
+b'apps/erpnext/erpnext/accounts/party.py +240',b'Accounting Entry for {0}: {1} can only be made in currency: {2}',"b""\xc3\x89criture Comptable pour {0}: {1} ne peut \xc3\xaatre effectu\xc3\xa9e qu'en devise: {2}"""
+b'DocType: Job Opening',"b'Job profile, qualifications required etc.'",b'Profil de l\xe2\x80\x99Emploi. qualifications requises ect...'
+b'DocType: Journal Entry Account',b'Account Balance',b'Solde du Compte'
+b'apps/erpnext/erpnext/config/accounts.py +183',b'Tax Rule for transactions.',b'R\xc3\xa8gle de Taxation pour les transactions.'
+b'DocType: Rename Tool',b'Type of document to rename.',b'Type de document \xc3\xa0 renommer.'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +53',b'{0} {1}: Customer is required against Receivable account {2}',b'{0} {1} : Un Client est requis pour le Compte D\xc3\xa9biteur {2}'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges (Company Currency)',b'Total des Taxes et Frais (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Weather',b'Weather Parameter',b'Param\xc3\xa8tre m\xc3\xa9t\xc3\xa9o'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +60',"b""Show unclosed fiscal year's P&L balances""",b'Afficher le solde du compte de r\xc3\xa9sulat des exercices non clotur\xc3\xa9s'
+b'DocType: Lab Test Template',b'Collection Details',b'D\xc3\xa9tails de la Collection'
+b'DocType: POS Profile',b'Allow Print Before Pay',b'Autoriser l&#39;impression avant la paie'
+b'DocType: Land Unit',b'Linked Soil Texture',b'Texture de sol li\xc3\xa9e'
+b'DocType: Shipping Rule',b'Shipping Account',b'Compte de Livraison'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +92',b'{0} {1}: Account {2} is inactive',b'{0} {1} : Compte {2} inactif'
+b'apps/erpnext/erpnext/utilities/activation.py +82',b'Make Sales Orders to help you plan your work and deliver on-time',b'Cr\xc3\xa9er des Commandes Clients pour vous aider \xc3\xa0 planifier votre travail et livrer \xc3\xa0 temps'
+b'DocType: Quality Inspection',b'Readings',b'Lectures'
+b'DocType: Stock Entry',b'Total Additional Costs',b'Total des Co\xc3\xbbts Additionnels'
+b'DocType: Course Schedule',b'SH',b'SH'
+b'DocType: BOM',b'Scrap Material Cost(Company Currency)',b'Co\xc3\xbbt de Mise au Rebut des Mat\xc3\xa9riaux (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +66',b'Sub Assemblies',b'Sous-Ensembles'
+b'DocType: Asset',b'Asset Name',"b""Nom de l'Actif"""
+b'DocType: Project',b'Task Weight',b'Poids de la T\xc3\xa2che'
+b'DocType: Shipping Rule Condition',b'To Value',b'Valeur Finale'
+b'DocType: Asset Movement',b'Stock Manager',b'Responsable des Stocks'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +171',b'Source warehouse is mandatory for row {0}',b'Entrep\xc3\xb4t source est obligatoire \xc3\xa0 la ligne {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +38',b'The Payment Term at row {0} is possibly a duplicate.',b'Le d\xc3\xa9lai de paiement \xc3\xa0 la ligne {0} est probablement un doublon.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +30',b'Agriculture (beta)',b'Agriculture (beta)'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +863',b'Packing Slip',b'Bordereau de Colis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +110',b'Office Rent',b'Loyer du Bureau'
+b'apps/erpnext/erpnext/config/setup.py +111',b'Setup SMS gateway settings',b'Configuration de la passerelle SMS'
+b'DocType: Disease',b'Common Name',b'Nom commun'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +61',b'Import Failed!',"b""\xc3\x89chec de l'Importation !"""
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +20',b'No address added yet.',b'Aucune adresse ajout\xc3\xa9e.'
+b'DocType: Workstation Working Hour',b'Workstation Working Hour',b'Heures de Travail au Bureau'
+b'DocType: Vital Signs',b'Blood Pressure',b'Pression Art\xc3\xa9rielle'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +125',b'Analyst',b'Analyste'
+b'DocType: Item',b'Inventory',b'Inventaire'
+b'DocType: Item',b'Sales Details',b'D\xc3\xa9tails Ventes'
+b'DocType: Quality Inspection',b'QI-',b'QI-'
+b'DocType: Opportunity',b'With Items',b'Avec Articles'
+b'DocType: Asset Maintenance',b'Maintenance Team',b'\xc3\x89quipe de maintenance'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'In Qty',b'En Qt\xc3\xa9'
+b'DocType: Education Settings',b'Validate Enrolled Course for Students in Student Group',b'Valider le Cours Inscrit pour les \xc3\x89tudiants en Groupe \xc3\x89tudiant'
+b'DocType: Notification Control',b'Expense Claim Rejected',b'Note de Frais Rejet\xc3\xa9e'
+b'DocType: Item',b'Item Attribute',"b""Attribut de l'Article"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +147',b'Government',b'Gouvernement'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +40',b'Expense Claim {0} already exists for the Vehicle Log',"b""Note de Frais {0} existe d\xc3\xa9j\xc3\xa0 pour l'Ind\xc3\xa9mnit\xc3\xa9 Kilom\xc3\xa9trique"""
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +64',b'Institute Name',b'Nom de l&#39;Institut'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +117',b'Please enter repayment Amount',b'Veuillez entrer le Montant de remboursement'
+b'apps/erpnext/erpnext/config/stock.py +309',b'Item Variants',"b""Variantes de l'Article"""
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +29',b'Services',b'Services'
+b'DocType: HR Settings',b'Email Salary Slip to Employee',"b""Envoyer la Fiche de Paie \xc3\xa0 l'Employ\xc3\xa9 par Mail"""
+b'DocType: Cost Center',b'Parent Cost Center',b'Centre de Co\xc3\xbbts Parent'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1041',b'Select Possible Supplier',b'S\xc3\xa9lectionner le Fournisseur Possible'
+b'DocType: Sales Invoice',b'Source',b'Source'
+b'DocType: Customer',"b'Select, to make the customer searchable with these fields'","b'S\xc3\xa9lectionnez, pour rendre le client consultable avec ces champs'"
+b'apps/erpnext/erpnext/templates/pages/projects.html +31',b'Show closed',b'Afficher ferm\xc3\xa9'
+b'DocType: Leave Type',b'Is Leave Without Pay',b'Est un Cong\xc3\xa9 Sans Solde'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +261',b'Asset Category is mandatory for Fixed Asset item',"b""Cat\xc3\xa9gorie d'Actif est obligatoire pour l'article Immobilis\xc3\xa9"""
+b'DocType: Fee Validity',b'Fee Validity',b'Validit\xc3\xa9 des Honoraires'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +146',b'No records found in the Payment table',b'Aucun enregistrement trouv\xc3\xa9 dans la table Paiement'
+b'apps/erpnext/erpnext/education/utils.py +19',b'This {0} conflicts with {1} for {2} {3}',b'Ce {0} est en conflit avec {1} pour {2} {3}'
+b'DocType: Student Attendance Tool',b'Students HTML',b'HTML \xc3\x89tudiants'
+b'DocType: POS Profile',b'Apply Discount',b'Appliquer R\xc3\xa9duction'
+b'DocType: GST HSN Code',b'GST HSN Code',b'Code GST HSN'
+b'DocType: Employee External Work History',b'Total Experience',b'Exp\xc3\xa9rience Totale'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +70',b'Open Projects',b'Ouvrir les Projets'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +295',b'Packing Slip(s) cancelled',b'Bordereau(x) de Colis annul\xc3\xa9(s)'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +36',b'Cash Flow from Investing',b'Flux de Tr\xc3\xa9sorerie des Investissements'
+b'DocType: Program Course',b'Program Course',b'Cours du Programme'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99',b'Freight and Forwarding Charges',"b""Frais de Fret et d'Exp\xc3\xa9dition"""
+b'DocType: Homepage',b'Company Tagline for website homepage',"b""Slogan de la Soci\xc3\xa9t\xc3\xa9 pour la page d'accueil du site web"""
+b'DocType: Item Group',b'Item Group Name',"b""Nom du Groupe d'Article"""
+b'apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +27',b'Taken',b'Pris'
+b'DocType: Student',b'Date of Leaving',b'Date de D\xc3\xa9part'
+b'DocType: Pricing Rule',b'For Price List',b'Pour la Liste de Prix'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +27',b'Executive Search',b'Recrutement de Cadres'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +55',b'Setting defaults',b'D\xc3\xa9finition des valeurs par d\xc3\xa9faut'
+b'apps/erpnext/erpnext/utilities/activation.py +63',b'Create Leads',b'Cr\xc3\xa9er des Prospects'
+b'DocType: Maintenance Schedule',b'Schedules',b'Horaires'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +468',b'POS Profile is required to use Point-of-Sale',b'Un profil PDV est requis pour utiliser le point de vente'
+b'DocType: Purchase Invoice Item',b'Net Amount',b'Montant Net'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +141',b'{0} {1} has not been submitted so the action cannot be completed',"b""{0} {1} n'a pas \xc3\xa9t\xc3\xa9 soumis, donc l'action ne peut pas \xc3\xaatre compl\xc3\xa9t\xc3\xa9e"""
+b'DocType: Purchase Order Item Supplied',b'BOM Detail No',b'N\xc2\xb0 de D\xc3\xa9tail LDM'
+b'DocType: Landed Cost Voucher',b'Additional Charges',b'Frais Suppl\xc3\xa9mentaires'
+b'DocType: Purchase Invoice',b'Additional Discount Amount (Company Currency)',b'Montant de la Remise Suppl\xc3\xa9mentaire (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Supplier Scorecard',b'Supplier Scorecard',"b""Fiche d'\xc3\x89valuation des Fournisseurs"""
+b'DocType: Plant Analysis',b'Result Datetime',b'R\xc3\xa9sultat Datetime'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +21',b'Please create new account from Chart of Accounts.',b'Veuillez cr\xc3\xa9er un nouveau compte au sein du Plan Comptable.'
+,b'Support Hour Distribution',b'R\xc3\xa9partition des Heures de Support'
+b'DocType: Maintenance Visit',b'Maintenance Visit',"b""Visite d'Entretien"""
+b'DocType: Student',b'Leaving Certificate Number',b'Num\xc3\xa9ro de Certificat'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +58',"b'Appointment cancelled, Please review and cancel the invoice {0}'","b'Rendez-vous annul\xc3\xa9, veuillez v\xc3\xa9rifier et annuler la facture {0}'"
+b'DocType: Sales Invoice Item',b'Available Batch Qty at Warehouse',"b""Qt\xc3\xa9 de lot disponible \xc3\xa0 l'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js +9',b'Update Print Format',"b""Mettre \xc3\xa0 Jour le Format d'Impression"""
+b'DocType: Landed Cost Voucher',b'Landed Cost Help',b'Aide Co\xc3\xbbts Logistiques'
+b'DocType: Purchase Invoice',b'Select Shipping Address',"b""S\xc3\xa9lectionner l'Adresse de Livraison"""
+b'apps/erpnext/erpnext/config/non_profit.py +28',b'Memebership Details',b'D\xc3\xa9tails de Memebership'
+b'DocType: Leave Block List',b'Block Holidays on important days.',b'Bloquer les Vacances sur les jours importants.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +220',b'Please input all required Result Value(s)',b'Veuillez entrer toutes les valeurs de r\xc3\xa9sultat requises'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +106',b'Accounts Receivable Summary',b'R\xc3\xa9sum\xc3\xa9 des Comptes D\xc3\xa9biteurs'
+b'DocType: Employee Loan',b'Monthly Repayment Amount',b'Montant du Remboursement Mensuel'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +9',b'Opening Invoices',b'Ouverture des factures'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +195',b'Please set User ID field in an Employee record to set Employee Role',"b""Veuillez d\xc3\xa9finir le champ ID de l'Utilisateur dans un dossier Employ\xc3\xa9 pour d\xc3\xa9finir le R\xc3\xb4le de l\xe2\x80\x99Employ\xc3\xa9s"""
+b'DocType: UOM',b'UOM Name',b'Nom UDM'
+b'DocType: GST HSN Code',b'HSN Code',b'Code HSN'
+b'apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +39',b'Contribution Amount',b'Montant de la Contribution'
+b'DocType: Purchase Invoice',b'Shipping Address',b'Adresse de Livraison'
+b'DocType: Stock Reconciliation',b'This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.',"b""Cet outil vous permet de mettre \xc3\xa0 jour ou de corriger la quantit\xc3\xa9 et l'\xc3\xa9valuation de stock dans le syst\xc3\xa8me. Il est g\xc3\xa9n\xc3\xa9ralement utilis\xc3\xa9 pour synchroniser les valeurs du syst\xc3\xa8me et ce qui existe r\xc3\xa9ellement dans vos entrep\xc3\xb4ts."""
+b'DocType: Delivery Note',b'In Words will be visible once you save the Delivery Note.',b'En Toutes Lettres. Sera visible une fois que vous enregistrez le Bon de Livraison.'
+b'DocType: Expense Claim',b'EXP',b'EXP'
+b'DocType: Water Analysis',b'Container',b'R\xc3\xa9cipient'
+b'apps/erpnext/erpnext/education/utils.py +50',b'Student {0} - {1} appears Multiple times in row {2} & {3}',b'\xc3\x89tudiant {0} - {1} appara\xc3\xaet Plusieurs fois dans la ligne {2} & {3}'
+b'DocType: Project',b'Day to Send',b'Jour pour envoyer'
+b'DocType: Healthcare Settings',b'Manage Sample Collection',"b""Gestion des collections d'\xc3\xa9chantillons"""
+b'DocType: Production Plan',b'Ignore Existing Ordered Quantity',b'Ignorer la quantit\xc3\xa9 command\xc3\xa9e existante'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +66',b'Please set the series to be used.',b'Veuillez d\xc3\xa9finir la s\xc3\xa9rie \xc3\xa0 utiliser.'
+b'DocType: Patient',b'Tobacco Past Use',b'Consommation pass\xc3\xa9e de tabac'
+b'DocType: Sales Invoice Item',b'Brand Name',b'Nom de la Marque'
+b'DocType: Purchase Receipt',b'Transporter Details',b'D\xc3\xa9tails du Transporteur'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +55',b'User {0} is already assigned to Physician {1}',"b""L'Utilisateur {0} est d\xc3\xa9j\xc3\xa0 affect\xc3\xa9 au M\xc3\xa9decin {1}"""
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2700',b'Default warehouse is required for selected item',b'Un Entrep\xc3\xb4t par d\xc3\xa9faut est n\xc3\xa9cessaire pour l\xe2\x80\x99Article s\xc3\xa9lectionn\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Box',b'Bo\xc3\xaete'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1038',b'Possible Supplier',b'Fournisseur Potentiel'
+b'DocType: Budget',b'Monthly Distribution',b'R\xc3\xa9partition Mensuelle'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +68',b'Receiver List is empty. Please create Receiver List',b'La Liste de Destinataires est vide. Veuillez cr\xc3\xa9er une Liste de Destinataires'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +31',b'Healthcare (beta)',b'Sant\xc3\xa9 (b\xc3\xaata)'
+b'DocType: Production Plan Sales Order',b'Production Plan Sales Order',b'Commande Client du Plan de Production'
+b'DocType: Sales Partner',b'Sales Partner Target',b'Objectif du Partenaire Commercial'
+b'DocType: Loan Type',b'Maximum Loan Amount',b'Montant Max du Pr\xc3\xaat'
+b'DocType: Pricing Rule',b'Pricing Rule',b'R\xc3\xa8gle de Tarification'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +58',b'Duplicate roll number for student {0}',"b""Num\xc3\xa9ro de liste en double pour l'\xc3\xa9l\xc3\xa8ve {0}"""
+b'DocType: Budget',b'Action if Annual Budget Exceeded',b'Action si le Budget Annuel est D\xc3\xa9pass\xc3\xa9'
+b'apps/erpnext/erpnext/config/learn.py +197',b'Material Request to Purchase Order',b'Demande de Mat\xc3\xa9riel au Bon de Commande'
+b'DocType: Shopping Cart Settings',b'Payment Success URL',b'URL pour Paiement Effectu\xc3\xa9 avec Succ\xc3\xa8s'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +81',b'Row # {0}: Returned Item {1} does not exists in {2} {3}',b'Ligne # {0} : article retourn\xc3\xa9 {1} n\xe2\x80\x99existe pas dans {2} {3}'
+b'DocType: Purchase Receipt',b'PREC-',b'PREC-'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16',b'Bank Accounts',b'Comptes Bancaires'
+,b'Bank Reconciliation Statement',b'Relev\xc3\xa9 de R\xc3\xa9conciliation Bancaire'
+b'DocType: Consultation',b'Medical Coding',b'Codification m\xc3\xa9dicale'
+b'DocType: Healthcare Settings',b'Reminder Message',b'Message de Rappel'
+,b'Lead Name',b'Nom du Prospect'
+,b'POS',b'PDV'
+b'DocType: C-Form',b'III',b'III'
+b'apps/erpnext/erpnext/config/stock.py +314',b'Opening Stock Balance',"b""Solde d'Ouverture des Stocks"""
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +58',b'{0} must appear only once',"b""{0} ne doit appara\xc3\xaetre qu'une seule fois"""
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +59',b'Leaves Allocated Successfully for {0}',b'Cong\xc3\xa9s Attribu\xc3\xa9s avec Succ\xc3\xa8s pour {0}'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +42',b'No Items to pack',b'Pas d\xe2\x80\x99Articles \xc3\xa0 emballer'
+b'DocType: Shipping Rule Condition',b'From Value',b'De la Valeur'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +606',b'Manufacturing Quantity is mandatory',b'Quantit\xc3\xa9 de Fabrication est obligatoire'
+b'DocType: Employee Loan',b'Repayment Method',b'M\xc3\xa9thode de Remboursement'
+b'DocType: Products Settings',"b'If checked, the Home page will be the default Item Group for the website'","b""Si coch\xc3\xa9e, la page d'Accueil pour le site sera le Groupe d'Article par d\xc3\xa9faut"""
+b'DocType: Quality Inspection Reading',b'Reading 4',b'Reading 4'
+b'apps/erpnext/erpnext/config/hr.py +132',b'Claims for company expense.',b'Notes de frais de la soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/activation.py +118',"b'Students are at the heart of the system, add all your students'","b'Les \xc3\xa9tudiants sont au c\xc5\x93ur du syst\xc3\xa8me, ajouter tous vos \xc3\xa9tudiants'"
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +97',b'Row #{0}: Clearance date {1} cannot be before Cheque Date {2}',b'Ligne #{0} : Date de compensation {1} ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date du Ch\xc3\xa8que {2}'
+b'DocType: Asset Maintenance Task',b'Certificate Required',b'Certificat requis'
+b'DocType: Company',b'Default Holiday List',b'Liste de Vacances par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +196',b'Row {0}: From Time and To Time of {1} is overlapping with {2}',b'Ligne {0} : Heure de D\xc3\xa9but et Heure de Fin de {1} sont en conflit avec {2}'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +145',b'Stock Liabilities',b'Passif du Stock'
+b'DocType: Purchase Invoice',b'Supplier Warehouse',b'Entrep\xc3\xb4t Fournisseur'
+b'DocType: Opportunity',b'Contact Mobile No',b'N\xc2\xb0 de Portable du Contact'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +399',b'Select Company',b'S\xc3\xa9lectionnez une entreprise'
+,b'Material Requests for which Supplier Quotations are not created',b'Demandes de Mat\xc3\xa9riel dont les Devis Fournisseur ne sont pas cr\xc3\xa9\xc3\xa9s'
+b'DocType: Student Report Generation Tool',b'Print Section',b'Section impression'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +34',"b""User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.""",b'L&#39;utilisateur {0} n&#39;a aucun profil POS par d\xc3\xa9faut. V\xc3\xa9rifiez par d\xc3\xa9faut \xc3\xa0 la ligne {1} pour cet utilisateur.'
+b'DocType: Student Group',b'Set 0 for no limit',b'D\xc3\xa9finir \xc3\xa0 0 pour aucune limite'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +122',b'The day(s) on which you are applying for leave are holidays. You need not apply for leave.',b'Le(s) jour(s) pour le(s)quel(s) vous demandez un cong\xc3\xa9 sont des jour(s) f\xc3\xa9ri\xc3\xa9(s). Vous n\xe2\x80\x99avez pas besoin d\xe2\x80\x99effectuer de demande.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +64',b'Row {idx}: {field} is required to create the Opening {invoice_type} Invoices',b'Row {idx}: {field} est requis pour cr\xc3\xa9er les factures {invoice_type} d&#39;ouverture'
+b'DocType: Customer',b'Primary Address and Contact Detail',b'Adresse principale et coordonn\xc3\xa9es'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +20',b'Resend Payment Email',b'Renvoyer Email de Paiement'
+b'apps/erpnext/erpnext/templates/pages/projects.html +27',b'New task',b'Nouvelle t\xc3\xa2che'
+b'DocType: Consultation',b'Appointment',b'Rendez-Vous'
+b'apps/erpnext/erpnext/utilities/activation.py +74',b'Make Quotation',b'Faire un Devis'
+b'apps/erpnext/erpnext/config/education.py +230',b'Other Reports',b'Autres Rapports'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +39',b'Please select at least one domain.',b'Veuillez s\xc3\xa9lectionner au moins un domaine.'
+b'DocType: Dependent Task',b'Dependent Task',b'T\xc3\xa2che D\xc3\xa9pendante'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +444',b'Conversion factor for default Unit of Measure must be 1 in row {0}',"b""Facteur de conversion de l'Unit\xc3\xa9 de Mesure par d\xc3\xa9faut doit \xc3\xaatre 1 dans la ligne {0}"""
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +188',b'Leave of type {0} cannot be longer than {1}',b'Les Cong\xc3\xa9s de type {0} ne peuvent pas \xc3\xaatre plus long que {1}'
+b'DocType: Manufacturing Settings',b'Try planning operations for X days in advance.',"b""Essayez de planifer des op\xc3\xa9rations X jours \xc3\xa0 l'avance."""
+b'DocType: HR Settings',b'Stop Birthday Reminders',"b""Arr\xc3\xaater les Rappels d'Anniversaire"""
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +235',b'Please set Default Payroll Payable Account in Company {0}',b'Veuillez d\xc3\xa9finir le Compte Cr\xc3\xa9diteur de Paie par D\xc3\xa9faut pour la Soci\xc3\xa9t\xc3\xa9 {0}'
+b'DocType: SMS Center',b'Receiver List',b'Liste de Destinataires'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1094',b'Search Item',b'Rechercher Article'
+b'DocType: Payment Schedule',b'Payment Amount',b'Montant du paiement'
+b'DocType: Patient Appointment',b'Referring Physician',b'M\xc3\xa9decin R\xc3\xa9f\xc3\xa9rent'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46',b'Consumed Amount',b'Montant Consomm\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +100',b'Net Change in Cash',b'Variation Nette de Tr\xc3\xa9sorerie'
+b'DocType: Assessment Plan',b'Grading Scale',b'\xc3\x89chelle de Notation'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +438',b'Unit of Measure {0} has been entered more than once in Conversion Factor Table',"b""Unit\xc3\xa9 de Mesure {0} a \xc3\xa9t\xc3\xa9 saisie plus d'une fois dans la Table de Facteur de Conversion"""
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +639',b'Already completed',b'D\xc3\xa9j\xc3\xa0 termin\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +33',b'Stock In Hand',b'Stock Existant'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +64',b'Import Successful!',b'Importation R\xc3\xa9ussie !'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +29',b'Payment Request already exists {0}',b'Demande de Paiement existe d\xc3\xa9j\xc3\xa0 {0}'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27',b'Cost of Issued Items',b'Co\xc3\xbbt des Marchandises Vendues'
+b'DocType: Physician',b'Hospital',b'H\xc3\xb4pital'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +385',b'Quantity must not be more than {0}',b'Quantit\xc3\xa9 ne doit pas \xc3\xaatre plus de {0}'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +117',b'Previous Financial Year is not closed',b'L\xe2\x80\x99Exercice Financier Pr\xc3\xa9c\xc3\xa9dent n\xe2\x80\x99est pas ferm\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +46',b'Age (Days)',b'\xc3\x82ge (Jours)'
+b'DocType: Quotation Item',b'Quotation Item',b'Article du Devis'
+b'DocType: Customer',b'Customer POS Id',b'ID PDV du Client'
+b'DocType: Account',b'Account Name',b'Nom du Compte'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +40',b'From Date cannot be greater than To Date',b'La Date Initiale ne peut pas \xc3\xaatre post\xc3\xa9rieure \xc3\xa0 la Date Finale'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +198',b'Serial No {0} quantity {1} cannot be a fraction',b'N\xc2\xb0 de s\xc3\xa9rie {0} quantit\xc3\xa9 {1} ne peut pas \xc3\xaatre une fraction'
+b'apps/erpnext/erpnext/config/buying.py +43',b'Supplier Type master.',b'Type de Fournisseur principal'
+b'DocType: Purchase Order Item',b'Supplier Part Number',b'Num\xc3\xa9ro de Pi\xc3\xa8ce du Fournisseur'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +108',b'Conversion rate cannot be 0 or 1',b'Le taux de conversion ne peut pas \xc3\xaatre \xc3\xa9gal \xc3\xa0 0 ou 1'
+b'DocType: Share Balance',b'To No',b'Pour Non'
+b'DocType: Subscription',b'Reference Document',b'Document de R\xc3\xa9f\xc3\xa9rence'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +229',b'{0} {1} is cancelled or stopped',b'{0} {1} est annul\xc3\xa9 ou arr\xc3\xaat\xc3\xa9'
+b'DocType: Accounts Settings',b'Credit Controller',b'Controlleur du Cr\xc3\xa9dit'
+b'DocType: Grant Application',b'Applicant Type',b'Type de demandeur'
+b'DocType: Purchase Invoice',b'03-Deficiency in services',b'03-D\xc3\xa9ficience dans les services'
+b'DocType: Delivery Note',b'Vehicle Dispatch Date',"b""Date d'Envoi du V\xc3\xa9hicule"""
+b'DocType: Healthcare Settings',b'Default Medical Code Standard',b'Code M\xc3\xa9dical Standard par D\xc3\xa9faut'
+b'DocType: Purchase Invoice Item',b'HSN/SAC',b'HSN / SAC'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +237',b'Purchase Receipt {0} is not submitted',"b""Le Re\xc3\xa7u d\xe2\x80\x99Achat {0} n'est pas soumis"""
+b'DocType: Company',b'Default Payable Account',b'Compte Cr\xc3\xa9diteur par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/config/website.py +17',"b'Settings for online shopping cart such as shipping rules, price list etc.'","b'R\xc3\xa9glages pour panier telles que les r\xc3\xa8gles de livraison, liste de prix, etc.'"
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +113',b'{0}% Billed',b'{0}% Factur\xc3\xa9'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +18',b'Reserved Qty',b'Qt\xc3\xa9 R\xc3\xa9serv\xc3\xa9es'
+b'DocType: Party Account',b'Party Account',b'Compte de Tiers'
+b'apps/erpnext/erpnext/config/setup.py +122',b'Human Resources',b'Ressources Humaines'
+b'DocType: Lead',b'Upper Income',b'Revenu \xc3\x89lev\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +17',b'Reject',b'Rejeter'
+b'DocType: Journal Entry Account',b'Debit in Company Currency',b'D\xc3\xa9bit en Devise Soci\xc3\xa9t\xc3\xa9'
+b'DocType: BOM Item',b'BOM Item',b'Article LDM'
+b'DocType: Appraisal',b'For Employee',b'Employ\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.js +49',b'Make Disbursement Entry',b'Faire une \xc3\x89criture de D\xc3\xa9caissement'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +138',b'Row {0}: Advance against Supplier must be debit',b'Ligne {0} : L\xe2\x80\x99Avance du Fournisseur doit \xc3\xaatre un d\xc3\xa9bit'
+b'DocType: Company',b'Default Values',b'Valeurs Par D\xc3\xa9faut'
+b'DocType: Membership',b'INR',b'INR'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +60',b'{frequency} Digest',b'Rapport {Frequency}'
+b'DocType: Expense Claim',b'Total Amount Reimbursed',b'Montant Total Rembours\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py +5',b'This is based on logs against this Vehicle. See timeline below for details',b'Bas\xc3\xa9 sur les journaux de ce V\xc3\xa9hicule. Voir la chronologie ci-dessous pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +90',b'Against Supplier Invoice {0} dated {1}',b'Pour la Facture Fournisseur {0} dat\xc3\xa9e {1}'
+b'DocType: Customer',b'Default Price List',b'Liste des Prix par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +322',b'Asset Movement record {0} created',"b""Registre de Mouvement de l'Actif {0} cr\xc3\xa9\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +51',b'You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings',"b""Vous ne pouvez pas supprimer l'Exercice {0}. L'exercice {0} est d\xc3\xa9fini par d\xc3\xa9faut dans les R\xc3\xa9glages Globaux"""
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20',b'A customer with the same name already exists',b'Un client avec un nom identique existe d\xc3\xa9j\xc3\xa0'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +185',b'This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?',b'Cela permettra de soumettre des bulletins de salaire et de cr\xc3\xa9er une \xc3\xa9criture de journal d&#39;accumulation. Voulez-vous poursuivre?'
+b'DocType: Purchase Invoice',b'Total Net Weight',b'Poids net total'
+b'DocType: Purchase Invoice',b'Eligibility For ITC',b'Admissibilit\xc3\xa9 pour ITC'
+b'DocType: Journal Entry',b'Entry Type',"b""Type d'\xc3\x89criture"""
+,b'Customer Credit Balance',b'Solde de Cr\xc3\xa9dit des Clients'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +28',b'Net Change in Accounts Payable',b'Variation Nette des Comptes Cr\xc3\xa9diteurs'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'EcritureLet',b'EcritureLet'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +209',b'Credit limit has been crossed for customer {0} ({1}/{2})',b'La limite de cr\xc3\xa9dit a \xc3\xa9t\xc3\xa9 d\xc3\xa9pass\xc3\xa9e pour le client {0} ({1} / {2})'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42',"b""Customer required for 'Customerwise Discount'""","b""Client requis pour appliquer une 'Remise en fonction du Client'"""
+b'apps/erpnext/erpnext/config/accounts.py +140',b'Update bank payment dates with journals.',b'Mettre \xc3\xa0 jour les dates de paiement bancaires avec les journaux.'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +21',b'Pricing',b'Tarification'
+b'DocType: Quotation',b'Term Details',b'D\xc3\xa9tails du Terme'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +30',b'Cannot enroll more than {0} students for this student group.',"b""Inscription de plus de {0} \xc3\xa9tudiants impossible pour ce groupe d'\xc3\xa9tudiants."""
+b'apps/erpnext/erpnext/templates/print_formats/includes/total.html +4',b'Total (Without Tax)',b'Total (hors taxes)'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +17',b'Lead Count',b'Nombre de Prospects'
+b'apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py +15',b'{0} must be greater than 0',b'{0} doit \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 0'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +30',b'Stock Available',b'Stock disponible'
+b'DocType: Manufacturing Settings',b'Capacity Planning For (Days)',b'Planification de Capacit\xc3\xa9 Pendant (Jours)'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py +10',b'Procurement',b'Approvisionnement'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +66',b'None of the items have any change in quantity or value.',b'Aucun des Articles n\xe2\x80\x99a de changement en quantit\xc3\xa9 ou en valeur.'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +17',b'Mandatory field - Program',b'Champ Obligatoire - Programme'
+b'DocType: Special Test Template',b'Result Component',b'Composante de R\xc3\xa9sultat'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js +46',b'Warranty Claim',b'R\xc3\xa9clamation de Garantie'
+,b'Lead Details',b'D\xc3\xa9tails du Prospect'
+b'DocType: Volunteer',b'Availability and Skills',b'Disponibilit\xc3\xa9 et comp\xc3\xa9tences'
+b'DocType: Salary Slip',b'Loan repayment',b'Remboursement de Pr\xc3\xaat'
+b'DocType: Purchase Invoice',"b""End date of current invoice's period""",b'Date de fin de la p\xc3\xa9riode de facturation en cours'
+b'DocType: Pricing Rule',b'Applicable For',b'Applicable Pour'
+b'DocType: Lab Test',b'Technician Name',b'Nom du Technicien'
+b'DocType: Accounts Settings',b'Unlink Payment on Cancellation of Invoice',"b""D\xc3\xa9lier Paiement \xc3\xa0 l'Annulation de la Facture"""
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +16',b'Current Odometer reading entered should be greater than initial Vehicle Odometer {0}',b'Le Compteur(kms) Actuel entr\xc3\xa9 devrait \xc3\xaatre plus grand que le Compteur(kms) initial du V\xc3\xa9hicule {0}'
+b'DocType: Restaurant Reservation',b'No Show',b'Non Pr\xc3\xa9sent\xc3\xa9'
+b'DocType: Shipping Rule Country',b'Shipping Rule Country',b'Pays de la R\xc3\xa8gle de Livraison'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +10',b'Leave and Attendance',b'Cong\xc3\xa9s et Pr\xc3\xa9sences'
+b'DocType: Maintenance Visit',b'Partially Completed',b'Partiellement Compl\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/healthcare/setup.py +257',b'Moderate Sensitivity',b'Sensibilit\xc3\xa9 Mod\xc3\xa9r\xc3\xa9e'
+b'DocType: Leave Type',b'Include holidays within leaves as leaves',b'Inclure les vacances dans les cong\xc3\xa9s en tant que cong\xc3\xa9s'
+b'DocType: Sales Invoice',b'Packed Items',b'Articles Emball\xc3\xa9s'
+b'apps/erpnext/erpnext/config/support.py +27',b'Warranty Claim against Serial No.',b'R\xc3\xa9clamation de Garantie pour le N\xc2\xb0 de S\xc3\xa9rie.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +197',"b""'Total'""","b""'Total'"""
+b'DocType: Shopping Cart Settings',b'Enable Shopping Cart',b'Activer Panier'
+b'DocType: Employee',b'Permanent Address',b'Adresse Permanente'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +260',b'Advance paid against {0} {1} cannot be greater \\\n\t\t\t\t\t\tthan Grand Total {2}',"b""L'avance vers\xc3\xa9e pour {0} {1} ne peut \xc3\xaatre sup\xc3\xa9rieure \\ au Total G\xc3\xa9n\xc3\xa9ral {2}"""
+b'DocType: Consultation',b'Medication',b'M\xc3\xa9dicaments'
+b'DocType: Production Plan',b'Include Non Stock Items',b'Inclure les articles non stock\xc3\xa9s'
+b'DocType: Project Update',b'Challenging/Slow',b'Difficile / lent'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +147',b'Please select item code',"b""Veuillez s\xc3\xa9lectionner un code d'article"""
+b'DocType: Student Sibling',b'Studying in Same Institute',b'\xc3\x89tudier au m\xc3\xaame Institut'
+b'DocType: Territory',b'Territory Manager',b'Responsable R\xc3\xa9gional'
+b'DocType: Packed Item',b'To Warehouse (Optional)',"b""\xc3\x80 l'Entrep\xc3\xb4t (Facultatif)"""
+b'DocType: GST Settings',b'GST Accounts',b'Comptes de la TPS'
+b'DocType: Payment Entry',b'Paid Amount (Company Currency)',b'Montant Pay\xc3\xa9 (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Purchase Invoice',b'Additional Discount',b'Remise Suppl\xc3\xa9mentaire'
+b'DocType: Selling Settings',b'Selling Settings',b'R\xc3\xa9glages de Vente'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +83',b'Confirm Action',"b""Confirmer l'Action"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +39',b'Online Auctions',b'Ench\xc3\xa8res en Ligne'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +100',b'Please specify either Quantity or Valuation Rate or both',"b'Veuillez sp\xc3\xa9cifier la Quantit\xc3\xa9, le Taux de Valorisation ou les deux'"
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py +18',b'Fulfillment',b'Accomplissement'
+b'apps/erpnext/erpnext/templates/generators/item.html +82',b'View in Cart',b'Voir Panier'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +103',b'Marketing Expenses',b'Frais de Marketing'
+,b'Item Shortage Report',"b""Rapport de Rupture de Stock d'Article"""
+b'apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py +15',"b""Can't create standard criteria. Please rename the criteria""",b'Impossible de cr\xc3\xa9er des crit\xc3\xa8res standard. Veuillez renommer les crit\xc3\xa8res'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +311',"b'Weight is mentioned,\\nPlease mention ""Weight UOM"" too'","b'Poids est mentionn\xc3\xa9,\\nVeuillez aussi mentionner ""UDM de Poids""'"
+b'DocType: Stock Entry Detail',b'Material Request used to make this Stock Entry',b'Demande de Mat\xc3\xa9riel utilis\xc3\xa9e pour r\xc3\xa9aliser cette \xc3\x89criture de Stock'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +68',b'Next Depreciation Date is mandatory for new asset',b'Date de l\xe2\x80\x99Amortissement Suivant est obligatoire pour un nouvel actif'
+b'DocType: Student Group Creation Tool',b'Separate course based Group for every Batch',b'Groupes bas\xc3\xa9s sur les cours diff\xc3\xa9rents pour chaque Lot'
+b'apps/erpnext/erpnext/config/support.py +32',b'Single unit of an Item.',"b""Seule unit\xc3\xa9 d'un Article."""
+b'DocType: Fee Category',b'Fee Category',"b""Cat\xc3\xa9gorie d'Honoraires"""
+b'DocType: Agriculture Task',b'Next Business Day',b'Le jour ouvrable suivant'
+b'DocType: Drug Prescription',b'Dosage by time interval',b'Dosage par intervalle de temps'
+b'DocType: Cash Flow Mapper',b'Section Header',b'En-t\xc3\xaate de section'
+,b'Student Fee Collection',b'Frais de Scolarit\xc3\xa9'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +24',b'Appointment Duration (mins)',b'Dur\xc3\xa9e du Rendez-Vous (min.)'
+b'DocType: Accounts Settings',b'Make Accounting Entry For Every Stock Movement',b'Faites une \xc3\x89criture Comptable Pour Chaque Mouvement du Stock'
+b'DocType: Leave Allocation',b'Total Leaves Allocated',b'Total des Cong\xc3\xa9s Attribu\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163',b'Warehouse required at Row No {0}',b'Entrep\xc3\xb4t requis \xc3\xa0 la Ligne N\xc2\xb0 {0}'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +145',b'Please enter valid Financial Year Start and End Dates',b'Veuillez entrer des Dates de D\xc3\xa9but et de Fin d\xe2\x80\x99Exercice Comptable valides'
+b'DocType: Employee',b'Date Of Retirement',b'Date de D\xc3\xa9part \xc3\xa0 la Retraite'
+b'DocType: Upload Attendance',b'Get Template',b'Obtenir Mod\xc3\xa8le'
+b'DocType: Material Request',b'Transferred',b'Transf\xc3\xa9r\xc3\xa9'
+b'DocType: Vehicle',b'Doors',b'Portes'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/defaults_setup.py +117',b'ERPNext Setup Complete!',"b""Installation d'ERPNext Termin\xc3\xa9e!"""
+b'DocType: Healthcare Settings',b'Collect Fee for Patient Registration',"b""Collecter les honoraires pour l'inscription des patients"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +678',b'Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item',"b""Impossible de modifier les attributs suite \xc3\xa0 des mouvements d'inventaire. Faites un nouvel article et transf\xc3\xa9rez la quantit\xc3\xa9 en main au nouvel article"""
+b'DocType: Course Assessment Criteria',b'Weightage',b'Poids'
+b'DocType: Purchase Invoice',b'Tax Breakup',b'R\xc3\xa9partition des Taxes'
+b'DocType: Packing Slip',b'PS-',b'PS-'
+b'DocType: Member',b'Non Profit Member',b'Membre \xc3\xa0 but non lucratif'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +67',"b""{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.""","b'{0} {1} : Un Centre de Co\xc3\xbbts est requis pour le compte ""Pertes et Profits"" {2}.Veuillez mettre en place un centre de co\xc3\xbbts par d\xc3\xa9faut pour la Soci\xc3\xa9t\xc3\xa9.'"
+b'DocType: Payment Schedule',b'Payment Term',b'Terme de paiement'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +160',b'A Customer Group exists with same name please change the Customer name or rename the Customer Group',"b'Un Groupe de Clients existe avec le m\xc3\xaame nom, veuillez changer le nom du Client ou renommer le Groupe de Clients'"
+b'DocType: Land Unit',b'Area',b'R\xc3\xa9gion'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +37',b'New Contact',b'Nouveau Contact'
+b'DocType: Territory',b'Parent Territory',b'Territoire Parent'
+b'DocType: Purchase Invoice',b'Place of Supply',"b""Lieu d'Approvisionnement"""
+b'DocType: Quality Inspection Reading',b'Reading 2',b'Lecture 2'
+b'DocType: Stock Entry',b'Material Receipt',b'R\xc3\xa9ception Mat\xc3\xa9riel'
+b'DocType: Homepage',b'Products',b'Produits'
+b'DocType: Announcement',b'Instructor',b'Instructeur'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +61',b'Select Item (optional)',"b""S\xc3\xa9lectionnez l'Article (facultatif)"""
+b'DocType: Fee Schedule Student Group',b'Fee Schedule Student Group',b'Groupe \xc3\x89tudiant Calendrier des Honoraires'
+b'DocType: Student',b'AB+',b'AB+'
+b'DocType: Item',"b'If this item has variants, then it cannot be selected in sales orders etc.'","b'Si cet article a des variantes, alors il ne peut pas \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9 dans les commandes clients, etc.'"
+b'DocType: Lead',b'Next Contact By',b'Contact Suivant Par'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +325',b'Quantity required for Item {0} in row {1}',"b""Quantit\xc3\xa9 requise pour l'Article {0} \xc3\xa0 la ligne {1}"""
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +45',b'Warehouse {0} can not be deleted as quantity exists for Item {1}',"b""L'entrep\xc3\xb4t {0} ne peut pas \xc3\xaatre supprim\xc3\xa9 car il existe une quantit\xc3\xa9 pour l'Article {1}"""
+b'DocType: Quotation',b'Order Type',b'Type de Commande'
+,b'Item-wise Sales Register',b'Registre des Ventes par Article'
+b'DocType: Asset',b'Gross Purchase Amount',"b""Montant d'Achat Brut"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +39',b'Opening Balances',"b""Balances d'Ouverture"""
+b'DocType: Asset',b'Depreciation Method',"b""M\xc3\xa9thode d'Amortissement"""
+b'DocType: Purchase Taxes and Charges',b'Is this Tax included in Basic Rate?',b'Cette Taxe est-elle incluse dans le Taux de Base ?'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Target',b'Cible Totale'
+b'DocType: Soil Texture',b'Sand Composition (%)',b'Composition de sable (%)'
+b'DocType: Job Applicant',b'Applicant for a Job',b'Candidat \xc3\xa0 un Emploi'
+b'DocType: Production Plan Material Request',b'Production Plan Material Request',b'Demande de Mat\xc3\xa9riel du Plan de Production'
+b'DocType: Stock Reconciliation',b'Reconciliation JSON',b'R\xc3\xa9conciliation JSON'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.html +3',b'Too many columns. Export the report and print it using a spreadsheet application.',"b""Trop de colonnes. Exportez le rapport et imprimez-le \xc3\xa0 l'aide d'un tableur."""
+b'DocType: Purchase Invoice Item',b'Batch No',b'N\xc2\xb0 du Lot'
+b'DocType: Selling Settings',"b""Allow multiple Sales Orders against a Customer's Purchase Order""","b""Autoriser plusieurs Commandes Clients pour un Bon de Commande d'un Client"""
+b'DocType: Student Group Instructor',b'Student Group Instructor',"b""Instructeur de Groupe d'\xc3\x89tudiant"""
+b'DocType: Grant Application',b'Assessment  Mark (Out of 10)',b'Note d&#39;\xc3\xa9valuation (sur 10)'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +61',b'Guardian2 Mobile No',b'N\xc2\xb0 du Mobile du Tuteur 1'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +218',b'Main',b'Principal'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +72',b'Variant',b'Variante'
+b'DocType: Naming Series',b'Set prefix for numbering series on your transactions',b'D\xc3\xa9finir le pr\xc3\xa9fixe des s\xc3\xa9ries num\xc3\xa9rot\xc3\xa9es pour vos transactions'
+b'DocType: Employee Attendance Tool',b'Employees HTML',b'Employ\xc3\xa9s HTML'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +458',b'Default BOM ({0}) must be active for this item or its template',b'LDM par d\xc3\xa9faut ({0}) doit \xc3\xaatre actif pour ce produit ou son mod\xc3\xa8le'
+b'DocType: Employee',b'Leave Encashed?',b'Laisser Encaiss\xc3\xa9 ?'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +32',b'Opportunity From field is mandatory',b'Le champ Opportunit\xc3\xa9 De est obligatoire'
+b'DocType: Email Digest',b'Annual Expenses',b'Charges Annuelles'
+b'DocType: Item',b'Variants',b'Variantes'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1148',b'Make Purchase Order',b'Faire un Bon de Commande'
+b'DocType: SMS Center',b'Send To',b'Envoyer \xc3\x80'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +133',b'There is not enough leave balance for Leave Type {0}',"b""Il n'y a pas assez de solde de cong\xc3\xa9s pour les Cong\xc3\xa9s de Type {0}"""
+b'DocType: Payment Reconciliation Payment',b'Allocated amount',b'Montant allou\xc3\xa9'
+b'DocType: Sales Team',b'Contribution to Net Total',b'Contribution au Total Net'
+b'DocType: Sales Invoice Item',"b""Customer's Item Code""","b""Code de l'Article du Client"""
+b'DocType: Stock Reconciliation',b'Stock Reconciliation',b'R\xc3\xa9conciliation du Stock'
+b'DocType: Territory',b'Territory Name',b'Nom de la R\xc3\xa9gion'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +204',b'Work-in-Progress Warehouse is required before Submit',"b""L'entrep\xc3\xb4t des Travaux en Cours est n\xc3\xa9cessaire avant de Soumettre"""
+b'apps/erpnext/erpnext/config/hr.py +40',b'Applicant for a Job.',b'Candidat \xc3\xa0 un Emploi.'
+b'DocType: Purchase Order Item',b'Warehouse and Reference',b'Entrep\xc3\xb4t et R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Supplier',b'Statutory info and other general information about your Supplier',b'Informations l\xc3\xa9gales et autres informations g\xc3\xa9n\xc3\xa9rales au sujet de votre Fournisseur'
+b'DocType: Item',b'Serial Nos and Batches',b'N\xc2\xb0 de S\xc3\xa9rie et Lots'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +42',b'Student Group Strength',"b""Force du Groupe d'\xc3\x89tudiant"""
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +261',b'Against Journal Entry {0} does not have any unmatched {1} entry',"b""L'\xc3\x89criture de Journal {0} n'a pas d'entr\xc3\xa9e non associ\xc3\xa9e {1}"""
+b'apps/erpnext/erpnext/config/hr.py +142',b'Appraisals',b'\xc3\x89valuation'
+b'apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py +8',b'Training Events',b'\xc3\x89v\xc3\xa9nements de formation'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +205',b'Duplicate Serial No entered for Item {0}',"b""Dupliquer N\xc2\xb0 de S\xc3\xa9rie pour l'Article {0}"""
+b'apps/erpnext/erpnext/config/selling.py +179',b'Track Leads by Lead Source.',b'Suivre les pistes par source de plomb.'
+b'DocType: Shipping Rule Condition',b'A condition for a Shipping Rule',b'Une condition pour une R\xc3\xa8gle de Livraison'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +167',b'Please enter ',b'Veuillez entrer'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js +43',b'Maintenance Log',b'Journal de maintenance'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +236',b'Please set filter based on Item or Warehouse',"b""Veuillez d\xc3\xa9finir un filtre bas\xc3\xa9 sur l'Article ou l'Entrep\xc3\xb4t"""
+b'DocType: Packing Slip',b'The net weight of this package. (calculated automatically as sum of net weight of items)',b'Le poids net de ce paquet. (Calcul\xc3\xa9 automatiquement comme la somme du poids net des articles)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +802',b'Discount amount cannot be greater than 100%',b'Le montant de l&#39;escompte ne peut pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 100%'
+b'DocType: Sales Order',b'To Deliver and Bill',b'\xc3\x80 Livrer et Facturer'
+b'DocType: Student Group',b'Instructors',b'Instructeurs'
+b'DocType: GL Entry',b'Credit Amount in Account Currency',b'Montant du Cr\xc3\xa9dit dans la Devise du Compte'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +603',b'BOM {0} must be submitted',b'LDM {0} doit \xc3\xaatre soumise'
+b'apps/erpnext/erpnext/config/accounts.py +460',b'Share Management',b'Gestion des partages'
+b'DocType: Authorization Control',b'Authorization Control',"b""Contr\xc3\xb4le d'Autorisation"""
+b'apps/erpnext/erpnext/controllers/buying_controller.py +317',b'Row #{0}: Rejected Warehouse is mandatory against rejected Item {1}',b'Ligne #{0} : Entrep\xc3\xb4t de Rejet est obligatoire pour l\xe2\x80\x99Article rejet\xc3\xa9 {1}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +810',b'Payment',b'Paiement'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +92',"b'Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.'","b""L'Entrep\xc3\xb4t {0} n'est li\xc3\xa9 \xc3\xa0 aucun compte, veuillez mentionner ce compte dans la fiche de l'Entrep\xc3\xb4t ou d\xc3\xa9finir un compte d'Entrep\xc3\xb4t par d\xc3\xa9faut dans la Soci\xc3\xa9t\xc3\xa9 {1}."""
+b'apps/erpnext/erpnext/utilities/activation.py +81',b'Manage your orders',b'G\xc3\xa9rer vos commandes'
+b'DocType: Work Order Operation',b'Actual Time and Cost',b'Temps et Co\xc3\xbbt R\xc3\xa9els'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +56',b'Material Request of maximum {0} can be made for Item {1} against Sales Order {2}',"b""Demande de Mat\xc3\xa9riel d'un maximum de {0} peut \xc3\xaatre faite pour l'article {1} pour la Commande Client {2}"""
+b'DocType: Crop',b'Crop Spacing',b'Espacement des cultures'
+b'DocType: Course',b'Course Abbreviation',b'Abr\xc3\xa9viation du Cours'
+b'DocType: Student Leave Application',b'Student Leave Application',"b""Demande de Cong\xc3\xa9 d'\xc3\x89tudiant"""
+b'DocType: Item',b'Will also apply for variants',"b""S'appliquera \xc3\xa9galement pour les variantes"""
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +217',"b'Asset cannot be cancelled, as it is already {0}'","b""L'actif ne peut \xc3\xaatre annul\xc3\xa9, car il est d\xc3\xa9j\xc3\xa0 {0}"""
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29',b'Employee {0} on Half day on {1}',b'Employ\xc3\xa9 {0} sur une demi-journ\xc3\xa9e sur {1}'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +42',b'Total working hours should not be greater than max working hours {0}',"b""Le nombre total d'heures travaill\xc3\xa9es ne doit pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 la dur\xc3\xa9e maximale du travail {0}"""
+b'apps/erpnext/erpnext/templates/pages/task_info.html +90',b'On',b'Sur'
+b'apps/erpnext/erpnext/config/selling.py +62',b'Bundle items at time of sale.',b'Grouper les articles au moment de la vente.'
+b'DocType: Material Request Plan Item',b'Actual Qty',b'Quantit\xc3\xa9 R\xc3\xa9elle'
+b'DocType: Sales Invoice Item',b'References',b'R\xc3\xa9f\xc3\xa9rences'
+b'DocType: Quality Inspection Reading',b'Reading 10',b'Lecture 10'
+b'DocType: Item',b'Barcodes',b'Codes-barres'
+b'DocType: Hub Category',b'Hub Node',b'Noeud du Hub'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78',b'You have entered duplicate items. Please rectify and try again.',b'Vous avez entr\xc3\xa9 un doublon. Veuillez rectifier et essayer \xc3\xa0 nouveau.'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +129',b'Associate',b'Associ\xc3\xa9'
+b'DocType: Asset Movement',b'Asset Movement',"b""Mouvement d'Actif"""
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +508',b'Work Order {0} must be submitted',b'Le bon de travail {0} doit \xc3\xaatre soumis'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2214',b'New Cart',b'Nouveau Panier'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44',b'Item {0} is not a serialized Item',"b""L'article {0} n'est pas un Article avec un num\xc3\xa9ro de serie"""
+b'DocType: SMS Center',b'Create Receiver List',b'Cr\xc3\xa9er une Liste de R\xc3\xa9ception'
+b'DocType: Vehicle',b'Wheels',b'Roues'
+b'DocType: Packing Slip',b'To Package No.',b'Au N\xc2\xb0 de Paquet'
+b'DocType: Patient Relation',b'Family',b'Famille'
+b'DocType: Production Plan',b'Material Requests',b'Les Demandes de Mat\xc3\xa9riel'
+b'DocType: Warranty Claim',b'Issue Date',"b""Date d'\xc3\x89mission"""
+b'DocType: Activity Cost',b'Activity Cost',"b""Co\xc3\xbbt de l'Activit\xc3\xa9"""
+b'DocType: Sales Invoice Timesheet',b'Timesheet Detail',b'D\xc3\xa9tails de la Feuille de Temps'
+b'DocType: Purchase Receipt Item Supplied',b'Consumed Qty',b'Qt\xc3\xa9 Consomm\xc3\xa9e'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +52',b'Telecommunications',b'T\xc3\xa9l\xc3\xa9communications'
+b'apps/erpnext/erpnext/accounts/party.py +263',"b""Billing currency must be equal to either default company's currency or party account currency""",b'La devise de facturation doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 la devise de la soci\xc3\xa9t\xc3\xa9 par d\xc3\xa9faut ou \xc3\xa0 la devise du compte du partenaire'
+b'DocType: Packing Slip',b'Indicates that the package is a part of this delivery (Only Draft)',b'Indique que le paquet est une partie de cette livraison (Brouillons Seulement)'
+b'DocType: Soil Texture',b'Loam',b'Terreau'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +705',b'Row {0}: Due Date cannot be before posting date',b'Ligne {0}: la date d&#39;\xc3\xa9ch\xc3\xa9ance ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date d&#39;envoi'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +36',b'Make Payment Entry',b'Faire une \xc3\x89criture de Paiement'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +129',b'Quantity for Item {0} must be less than {1}',"b""Quantit\xc3\xa9 de l'article {0} doit \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 {1}"""
+,b'Sales Invoice Trends',b'Tendances des Factures de Vente'
+b'DocType: Leave Application',b'Apply / Approve Leaves',b'Appliquer / Approuver les Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'For',b'Pour'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +167',"b""Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total'""","b""Peut se r\xc3\xa9f\xc3\xa9rer \xc3\xa0 ligne seulement si le type de charge est 'Montant de la ligne pr\xc3\xa9cedente' ou 'Total des lignes pr\xc3\xa9cedente'"""
+b'DocType: Sales Order Item',b'Delivery Warehouse',b'Entrep\xc3\xb4t de Livraison'
+b'apps/erpnext/erpnext/config/accounts.py +241',b'Tree of financial Cost Centers.',b'Arbre des Centres de Co\xc3\xbbts financiers.'
+b'DocType: Serial No',b'Delivery Document No',b'Num\xc3\xa9ro de Document de Livraison'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +191',"b""Please set 'Gain/Loss Account on Asset Disposal' in Company {0}""",b'Veuillez d\xc3\xa9finir \xe2\x80\x98Compte de Gain/Perte sur les Cessions d\xe2\x80\x99Immobilisations\xe2\x80\x99 de la Soci\xc3\xa9t\xc3\xa9 {0}'
+b'DocType: Landed Cost Voucher',b'Get Items From Purchase Receipts',"b""Obtenir des Articles \xc3\xa0 partir des Re\xc3\xa7us d'Achat"""
+b'DocType: Serial No',b'Creation Date',b'Date de Cr\xc3\xa9ation'
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +33',b'Item {0} appears multiple times in Price List {1}',"b""L'article {0} appara\xc3\xaet plusieurs fois dans la Liste de Prix {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41',"b'Selling must be checked, if Applicable For is selected as {0}'","b'Vente doit \xc3\xaatre v\xc3\xa9rifi\xc3\xa9e, si ""Applicable pour"" est s\xc3\xa9lectionn\xc3\xa9 comme {0}'"
+b'DocType: Production Plan Material Request',b'Material Request Date',b'Date de la Demande de Mat\xc3\xa9riel'
+b'DocType: Purchase Order Item',b'Supplier Quotation Item',b'Article Devis Fournisseur'
+b'DocType: Student',b'Student Mobile Number',"b""Num\xc3\xa9ro de Mobile de l'\xc3\x89tudiant"""
+b'DocType: Item',b'Has Variants',b'A Variantes'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +488',"b'Cannot overbill for Item {0} in row {1} more than {2}. To allow over-billing, please set in Stock Settings'","b'Impossible de surfacturer pour l&#39;article {0} de la ligne {1} plus de {2}. Pour autoriser la surfacturation, veuillez d\xc3\xa9finir les param\xc3\xa8tres de stock.'"
+b'apps/erpnext/erpnext/templates/emails/training_event.html +11',b'Update Response',b'Mettre \xc3\xa0 jour la R\xc3\xa9ponse'
+b'apps/erpnext/erpnext/public/js/utils.js +232',b'You have already selected items from {0} {1}',b'Vous avez d\xc3\xa9j\xc3\xa0 choisi des articles de {0} {1}'
+b'DocType: Monthly Distribution',b'Name of the Monthly Distribution',b'Nom de la R\xc3\xa9partition Mensuelle'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +95',b'Batch ID is mandatory',b'Le N\xc2\xb0 du lot est obligatoire'
+b'DocType: Sales Person',b'Parent Sales Person',b'Commercial Parent'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +100',b'The seller and the buyer cannot be the same',b'Le vendeur et l&#39;acheteur ne peuvent pas \xc3\xaatre les m\xc3\xaames'
+b'DocType: Project',b'Collect Progress',b'Collecter les progr\xc3\xa8s'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +24',b'Select the program first',b'S\xc3\xa9lectionnez d&#39;abord le programme'
+b'DocType: Patient Appointment',b'Patient Age',b'\xc3\x82ge du patient'
+b'apps/erpnext/erpnext/config/learn.py +253',b'Managing Projects',b'Gestion de Projets'
+b'DocType: Supplier',b'Supplier of Goods or Services.',b'Fournisseur de Biens ou Services.'
+b'DocType: Budget',b'Fiscal Year',b'Exercice Fiscal'
+b'DocType: Asset Maintenance Log',b'Planned',b'Pr\xc3\xa9vu'
+b'DocType: Healthcare Settings',b'Default receivable accounts to be used if not set in Patient to book Consultation charges.',b'Comptes d\xc3\xa9biteurs par d\xc3\xa9faut \xc3\xa0 utiliser si non d\xc3\xa9finis dans la fiche Patient pour enregistrer les honoraires de consultation.'
+b'DocType: Vehicle Log',b'Fuel Price',b'Prix du Carburant'
+b'DocType: Budget',b'Budget',b'Budget'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +65',b'Set Open',b'D\xc3\xa9finir comme ouvert'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +258',b'Fixed Asset Item must be a non-stock item.',b'Un Article Immobilis\xc3\xa9 doit \xc3\xaatre un \xc3\xa9l\xc3\xa9ment non stock\xc3\xa9.'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +50',"b""Budget cannot be assigned against {0}, as it's not an Income or Expense account""","b'Budget ne peut pas \xc3\xaatre affect\xc3\xa9 pour {0}, car ce n\xe2\x80\x99est pas un compte de produits ou de charges'"
+b'apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.py +51',b'Achieved',b'Atteint'
+b'DocType: Student Admission',b'Application Form Route',b'Chemin du Formulaire de Candidature'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +66',b'Territory / Customer',b'R\xc3\xa9gion / Client'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +44',b'Leave Type {0} cannot be allocated since it is leave without pay',"b'Le Type de Cong\xc3\xa9 {0} ne peut pas \xc3\xaatre allou\xc3\xa9, car c\xe2\x80\x99est un cong\xc3\xa9 sans solde'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +167',b'Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2}',b'Ligne {0} : Le montant allou\xc3\xa9 {1} doit \xc3\xaatre inf\xc3\xa9rieur ou \xc3\xa9gal au montant restant sur la Facture {2}'
+b'DocType: Sales Invoice',b'In Words will be visible once you save the Sales Invoice.',b'En Toutes Lettres. Sera visible une fois que vous enregistrerez la Facture.'
+b'DocType: Lead',b'Follow Up',b'Suivre'
+b'DocType: Item',b'Is Sales Item',b'Est un Article \xc3\xa0 Vendre'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21',b'Item Group Tree',"b""Arborescence de Groupe d'Article"""
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +69',b'Item {0} is not setup for Serial Nos. Check Item master',"b""L'article {0} n'est pas configur\xc3\xa9 pour les Num\xc3\xa9ros de S\xc3\xa9rie. V\xc3\xa9rifiez la fiche de l'Article"""
+b'DocType: Maintenance Visit',b'Maintenance Time',"b""Temps d'Entretien"""
+,b'Amount to Deliver',b'Nombre \xc3\xa0 Livrer'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +335',b'Same item has been entered multiple times. {0}',b'Le m\xc3\xaame objet a \xc3\xa9t\xc3\xa9 saisi \xc3\xa0 plusieurs reprises. {0}'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +30',b'The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.',"b""La Date de D\xc3\xa9but de Terme ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de D\xc3\xa9but de l'Ann\xc3\xa9e Acad\xc3\xa9mique \xc3\xa0 laquelle le terme est li\xc3\xa9 (Ann\xc3\xa9e Acad\xc3\xa9mique {}). Veuillez corriger les dates et essayer \xc3\xa0 nouveau."""
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +190',b'There were errors.',b'Il y a eu des erreurs.'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +166',b'Employee {0} has already applied for {1} between {2} and {3} : ',b'L&#39;employ\xc3\xa9 {0} a d\xc3\xa9j\xc3\xa0 postul\xc3\xa9 pour {1} entre {2} et {3}:'
+b'DocType: Guardian',b'Guardian Interests',b'Part du Tuteur'
+b'DocType: Naming Series',b'Current Value',b'Valeur actuelle'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +273',b'Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year',"b""Plusieurs Exercices existent pour la date {0}. Veuillez d\xc3\xa9finir la soci\xc3\xa9t\xc3\xa9 dans l'Exercice"""
+b'DocType: Education Settings',b'Instructor Records to be created by',"b""Les Enregistrements de l'Instructeur seront cr\xc3\xa9\xc3\xa9s par"""
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +229',b'{0} created',b'{0} cr\xc3\xa9\xc3\xa9'
+b'DocType: GST Account',b'GST Account',b'Compte de TPS'
+b'DocType: Delivery Note Item',b'Against Sales Order',b'Pour la Commande Client'
+,b'Serial No Status',b'Statut du N\xc2\xb0 de S\xc3\xa9rie'
+b'DocType: Payment Entry Reference',b'Outstanding',b'Solde'
+b'DocType: Supplier',b'Warn POs',b'Avertir lors de Bons de Commande'
+,b'Daily Timesheet Summary',b'R\xc3\xa9capitulatif Quotidien des Feuilles de Pr\xc3\xa9sence'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +137',"b'Row {0}: To set {1} periodicity, difference between from and to date \\\n\t\t\t\t\t\tmust be greater than or equal to {2}'","b'""Ligne {0} : Pour r\xc3\xa9gler la p\xc3\xa9riodicit\xc3\xa9 de {1}, la diff\xc3\xa9rence entre la date de d\xc3\xa9but et la date de fin \\\ndoit \xc3\xaatre sup\xc3\xa9rieure ou \xc3\xa9gale \xc3\xa0 {2}""'"
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +6',b'This is based on stock movement. See {0} for details',b'Bas\xc3\xa9 sur les mouvements de stock. Voir {0} pour plus de d\xc3\xa9tails'
+b'DocType: Pricing Rule',b'Selling',b'Vente'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +392',b'Amount {0} {1} deducted against {2}',b'Montant {0} {1} d\xc3\xa9duit de {2}'
+b'DocType: Employee',b'Salary Information',b'Information sur le Salaire'
+b'DocType: Sales Person',b'Name and Employee ID',b'Nom et ID de l\xe2\x80\x99Employ\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/party.py +308',b'Due Date cannot be before Posting Date',"b""La Date d'\xc3\x89ch\xc3\xa9ance ne peut \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de Comptabilisation"""
+b'DocType: Website Item Group',b'Website Item Group',"b""Groupe d'Articles du Site Web"""
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +463',b'No salary slip found to submit for the above selected criteria OR salary slip already submitted',b'Aucun bulletin de salaire ne peut \xc3\xaatre soumis pour les crit\xc3\xa8res s\xc3\xa9lectionn\xc3\xa9s ci-dessus OU le bulletin de salaire d\xc3\xa9j\xc3\xa0 soumis'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +150',b'Duties and Taxes',b'Droits de Douane et Taxes'
+b'DocType: Projects Settings',b'Projects Settings',b'Param\xc3\xa8tres de projets'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356',b'Please enter Reference date',b'Veuillez entrer la date de R\xc3\xa9f\xc3\xa9rence'
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +44',b'{0} payment entries can not be filtered by {1}',b'{0} \xc3\xa9critures de paiement ne peuvent pas \xc3\xaatre filtr\xc3\xa9es par {1}'
+b'DocType: Item Website Specification',b'Table for Item that will be shown in Web Site',"b""Table pour l'Article qui sera affich\xc3\xa9 sur le site Web"""
+b'DocType: Purchase Order Item Supplied',b'Supplied Qty',b'Qt\xc3\xa9 Fournie'
+b'DocType: Purchase Order Item',b'Material Request Item',b'Article de Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/config/selling.py +75',b'Tree of Item Groups.',b'Arbre de Groupes d\xe2\x80\x99Articles .'
+b'DocType: Production Plan',b'Total Produced Qty',b'Quantit\xc3\xa9 totale produite'
+b'DocType: Payroll Entry',b'Get Employee Details',b'Obtenir les d\xc3\xa9tails de l&#39;employ\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +177',b'Cannot refer row number greater than or equal to current row number for this Charge type',b'Impossible de se r\xc3\xa9f\xc3\xa9rer au num\xc3\xa9ro de la ligne sup\xc3\xa9rieure ou \xc3\xa9gale au num\xc3\xa9ro de la ligne courante pour ce type de Charge'
+b'DocType: Asset',b'Sold',b'Vendu'
+,b'Item-wise Purchase History',"b""Historique d'Achats par Article"""
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +230',"b""Please click on 'Generate Schedule' to fetch Serial No added for Item {0}""","b""Veuillez cliquer sur \xe2\x80\x98G\xc3\xa9n\xc3\xa9rer Calendrier\xe2\x80\x99 pour r\xc3\xa9cup\xc3\xa9rer le N\xc2\xb0 S\xc3\xa9rie ajout\xc3\xa9 \xc3\xa0 l'article {0}"""
+b'DocType: Account',b'Frozen',b'Gel\xc3\xa9'
+b'DocType: Sales Invoice Payment',b'Base Amount (Company Currency)',b'Montant de Base (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +928',b'Raw Materials',b'Mati\xc3\xa8res premi\xc3\xa8res'
+b'DocType: Payment Reconciliation Payment',b'Reference Row',b'Ligne de R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Installation Note',b'Installation Time',"b""Temps d'Installation"""
+b'DocType: Sales Invoice',b'Accounting Details',b'D\xc3\xa9tails Comptabilit\xc3\xa9'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +113',b'Delete all the Transactions for this Company',b'Supprimer toutes les Transactions pour cette Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Patient',b'O Positive',b'O Positif'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68',b'Investments',b'Investissements'
+b'DocType: Issue',b'Resolution Details',b'D\xc3\xa9tails de la R\xc3\xa9solution'
+b'apps/erpnext/erpnext/hr/doctype/leave_type/leave_type.js +3',b'Allocations',b'Allocations'
+b'DocType: Item Quality Inspection Parameter',b'Acceptance Criteria',"b""Crit\xc3\xa8res d'Acceptation"""
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +159',b'Please enter Material Requests in the above table',b'Veuillez entrer les Demandes de Mat\xc3\xa9riel dans le tableau ci-dessus'
+b'DocType: Item Attribute',b'Attribute Name',"b""Nom de l'Attribut"""
+b'DocType: BOM',b'Show In Website',b'Afficher dans le Site Web'
+b'DocType: Shopping Cart Settings',b'Show Quantity in Website',b'Afficher la Quantit\xc3\xa9 sur le Site'
+b'DocType: Employee Loan Application',b'Total Payable Amount',b'Montant Total Cr\xc3\xa9diteur'
+b'DocType: Task',b'Expected Time (in hours)',b'Dur\xc3\xa9e Pr\xc3\xa9vue (en heures)'
+b'DocType: Item Reorder',b'Check in (group)',b'Enregistrement (groupe)'
+b'DocType: Soil Texture',b'Silt',b'Limon'
+,b'Qty to Order',b'Quantit\xc3\xa9 \xc3\xa0 Commander'
+b'DocType: Period Closing Voucher',"b'The account head under Liability or Equity, in which Profit/Loss will be booked'","b'Le titre du compte de Passif ou de Capitaux Propres, dans lequel les B\xc3\xa9n\xc3\xa9fices/Pertes seront comptabilis\xc3\xa9s'"
+b'apps/erpnext/erpnext/config/projects.py +36',b'Gantt chart of all tasks.',b'Diagramme de Gantt de toutes les t\xc3\xa2ches.'
+b'DocType: Opportunity',b'Mins to First Response',b'Minutes avant la Premi\xc3\xa8re R\xc3\xa9ponse'
+b'DocType: Pricing Rule',b'Margin Type',b'Type de Marge'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +15',b'{0} hours',b'{0} heures'
+b'DocType: Course',b'Default Grading Scale',b'\xc3\x89chelle de Notation par D\xc3\xa9fault'
+b'DocType: Appraisal',b'For Employee Name',"b""Nom de l'Employ\xc3\xa9"""
+b'DocType: Holiday List',b'Clear Table',b'Effacer le tableau'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +119',b'Available slots',b'Cr\xc3\xa9neaux Disponibles'
+b'DocType: C-Form Invoice Detail',b'Invoice No',b'No de Facture'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +363',b'Make Payment',b'Faire un Paiement'
+b'DocType: Room',b'Room Name',b'Nom de la Chambre'
+b'DocType: Prescription Duration',b'Prescription Duration',b'Dur\xc3\xa9e de la prescription'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +81',"b'Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b""Cong\xc3\xa9 ne peut \xc3\xaatre demand\xc3\xa9 / annul\xc3\xa9 avant le {0}, car le solde de cong\xc3\xa9s a d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 report\xc3\xa9 dans la feuille d'allocation de cong\xc3\xa9s futurs {1}"""
+b'DocType: Activity Cost',b'Costing Rate',b'Taux des Co\xc3\xbbts'
+b'apps/erpnext/erpnext/config/selling.py +234',b'Customer Addresses And Contacts',b'Adresses et Contacts des Clients'
+,b'Campaign Efficiency',b'Efficacit\xc3\xa9 des Campagnes'
+b'DocType: Discussion',b'Discussion',b'Discussion'
+b'DocType: Payment Entry',b'Transaction ID',b'Identifiant de Transaction'
+b'DocType: Volunteer',b'Anytime',b'\xc3\x80 tout moment'
+b'DocType: Patient',b'Surgical History',b'Ant\xc3\xa9c\xc3\xa9dents Chirurgicaux'
+b'DocType: Employee',b'Resignation Letter Date',b'Date de la Lettre de D\xc3\xa9mission'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +39',b'Pricing Rules are further filtered based on quantity.',"b""Les R\xc3\xa8gles de Tarification sont d'avantage filtr\xc3\xa9s en fonction de la quantit\xc3\xa9."""
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +127',b'Not Set',b'Non D\xc3\xa9fini'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +335',b'Please set the Date Of Joining for employee {0}',"b""Veuillez d\xc3\xa9finir la Date d'Embauche pour l'employ\xc3\xa9 {0}"""
+b'DocType: Task',b'Total Billing Amount (via Time Sheet)',b'Montant Total de Facturation (via Feuille de Temps)'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61',b'Repeat Customer Revenue',b'Revenus de Clients R\xc3\xa9currents'
+b'DocType: Soil Texture',b'Silty Clay Loam',b'Silo Clay Loam'
+b'DocType: Chapter',b'Chapter',b'Chapitre'
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Pair',b'Paire'
+b'DocType: Mode of Payment Account',b'Default account will be automatically updated in POS Invoice when this mode is selected.',b'Le compte par d\xc3\xa9faut sera automatiquement mis \xc3\xa0 jour dans la facture de point de vente lorsque ce mode est s\xc3\xa9lectionn\xc3\xa9.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +970',b'Select BOM and Qty for Production',b'S\xc3\xa9lectionner la LDM et la Qt\xc3\xa9 pour la Production'
+b'DocType: Asset',b'Depreciation Schedule',"b""Calendrier d'Amortissement"""
+b'apps/erpnext/erpnext/config/selling.py +124',b'Sales Partner Addresses And Contacts',b'Adresses et Contacts des Partenaires de Vente'
+b'DocType: Bank Reconciliation Detail',b'Against Account',b'Pour le Compte'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52',b'Half Day Date should be between From Date and To Date',b'La Date de Demi-Journ\xc3\xa9e doit \xc3\xaatre entre la Date de D\xc3\xa9but et la Date de Fin'
+b'DocType: Maintenance Schedule Detail',b'Actual Date',b'Date R\xc3\xa9elle'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +139',b'Please set the Default Cost Center in {0} company.',b'Veuillez d\xc3\xa9finir le Centre de co\xc3\xbbts par d\xc3\xa9faut dans la soci\xc3\xa9t\xc3\xa9 {0}.'
+b'DocType: Item',b'Has Batch No',b'A un Num\xc3\xa9ro de Lot'
+b'apps/erpnext/erpnext/public/js/utils.js +106',b'Annual Billing: {0}',b'Facturation Annuelle : {0}'
+b'apps/erpnext/erpnext/config/accounts.py +200',b'Goods and Services Tax (GST India)',b'Taxe sur les Biens et Services (GST India)'
+b'DocType: Delivery Note',b'Excise Page Number',"b""Num\xc3\xa9ro de Page d'Accise"""
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +227',"b'Company, From Date and To Date is mandatory'","b'Soci\xc3\xa9t\xc3\xa9, Date D\xc3\xa9but et Date Fin sont obligatoires'"
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +33',b'Get from Consultation',b'Obtenir depuis la Consultation'
+b'DocType: Asset',b'Purchase Date',"b""Date d'Achat"""
+b'DocType: Volunteer',b'Volunteer Type',b'Type de b\xc3\xa9n\xc3\xa9vole'
+b'DocType: Student',b'Personal Details',b'Donn\xc3\xa9es Personnelles'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +193',"b""Please set 'Asset Depreciation Cost Center' in Company {0}""","b""Veuillez d\xc3\xa9finir 'Centre de Co\xc3\xbbts des Amortissements d\xe2\x80\x99Actifs\xe2\x80\x99 de la Soci\xc3\xa9t\xc3\xa9 {0}"""
+,b'Maintenance Schedules',"b""\xc3\x89ch\xc3\xa9anciers d'Entretien"""
+b'DocType: Task',b'Actual End Date (via Time Sheet)',b'Date de Fin R\xc3\xa9elle (via la Feuille de Temps)'
+b'DocType: Soil Texture',b'Soil Type',b'Le type de sol'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +387',b'Amount {0} {1} against {2} {3}',b'Montant {0} {1} pour {2} {3}'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +277',b'New Message',b'Nouveau Message'
+,b'Quotation Trends',b'Tendances des Devis'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +160',b'Item Group not mentioned in item master for item {0}',"b""Le Groupe d'Articles n'est pas mentionn\xc3\xa9 dans la fiche de l'article pour l'article {0}"""
+b'DocType: GoCardless Mandate',b'GoCardless Mandate',b'Mandat GoCardless'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +368',b'Debit To account must be a Receivable account',b'Le compte de d\xc3\xa9bit doit \xc3\xaatre un compte D\xc3\xa9biteur'
+b'DocType: Shipping Rule',b'Shipping Amount',b'Montant de la Livraison'
+b'DocType: Supplier Scorecard Period',b'Period Score',b'Score de la P\xc3\xa9riode'
+b'apps/erpnext/erpnext/utilities/user_progress.py +66',b'Add Customers',b'Ajouter des Clients'
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Pending Amount',b'Montant en Attente'
+b'DocType: Lab Test Template',b'Special',b'Sp\xc3\xa9cial'
+b'DocType: Purchase Order Item Supplied',b'Conversion Factor',b'Facteur de Conversion'
+b'DocType: Purchase Order',b'Delivered',b'Livr\xc3\xa9'
+,b'Vehicle Expenses',b'Frais de V\xc3\xa9hicule'
+b'DocType: Serial No',b'Invoice Details',b'D\xc3\xa9tails de la Facture'
+b'DocType: Grant Application',b'Show on Website',b'Afficher sur le site Web'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +212',b'Expected value after useful life must be greater than or equal to {0}',b'Valeur attendue apr\xc3\xa8s utilisation compl\xc3\xa8te doit \xc3\xaatre sup\xc3\xa9rieure ou \xc3\xa9gale \xc3\xa0 {0}'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +29',b'Start on',b'D\xc3\xa9marrer'
+b'DocType: Hub Category',b'Hub Category',b'Cat\xc3\xa9gorie du Hub'
+b'DocType: Purchase Invoice',b'SEZ',b'SEZ'
+b'DocType: Purchase Receipt',b'Vehicle Number',b'Num\xc3\xa9ro de V\xc3\xa9hicule'
+b'DocType: Employee Loan',b'Loan Amount',b'Montant du Pr\xc3\xaat'
+b'DocType: Student Report Generation Tool',b'Add Letterhead',b'Ajouter un en-t\xc3\xaate'
+b'DocType: Program Enrollment',b'Self-Driving Vehicle',b'V\xc3\xa9hicule Autonome'
+b'DocType: Supplier Scorecard Standing',b'Supplier Scorecard Standing',"b""Classement de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +443',b'Row {0}: Bill of Materials not found for the Item {1}',b'Ligne {0} : Liste de Mat\xc3\xa9riaux non trouv\xc3\xa9e pour l\xe2\x80\x99Article {1}'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +98',b'Total allocated leaves {0} cannot be less than already approved leaves {1} for the period',b'Le Total des feuilles attribu\xc3\xa9es {0} ne peut pas \xc3\xaatre inf\xc3\xa9rieur aux feuilles d\xc3\xa9j\xc3\xa0 approuv\xc3\xa9es {1} pour la p\xc3\xa9riode'
+b'DocType: Journal Entry',b'Accounts Receivable',b'Comptes D\xc3\xa9biteurs'
+,b'Supplier-Wise Sales Analytics',b'Analyse des Ventes par Fournisseur'
+b'DocType: Purchase Invoice',b'Availed ITC Central Tax',b'Taxe centrale ITC supprim\xc3\xa9e'
+b'DocType: Salary Structure',b'Select employees for current Salary Structure',b'S\xc3\xa9lectionner les Employ\xc3\xa9s pour la Grille de Salaire actuelle'
+b'DocType: Sales Invoice',b'Company Address Name',"b""Nom de l'Adresse de la Soci\xc3\xa9t\xc3\xa9"""
+b'DocType: Work Order',b'Use Multi-Level BOM',b'Utiliser LDM \xc3\xa0 Plusieurs Niveaux'
+b'DocType: Bank Reconciliation',b'Include Reconciled Entries',b'Inclure les \xc3\x89critures R\xc3\xa9concili\xc3\xa9es'
+b'DocType: Course',"b""Parent Course (Leave blank, if this isn't part of Parent Course)""","b'Cours Parent (Laisser vide, si cela ne fait pas partie du Cours Parent)'"
+b'DocType: Leave Control Panel',b'Leave blank if considered for all employee types',"b""Laisser vide pour tous les types d'employ\xc3\xa9s"""
+b'DocType: Landed Cost Voucher',b'Distribute Charges Based On',b'Distribuer les Charges sur la Base de'
+b'DocType: Projects Settings',b'Timesheets',b'Feuilles de Temps'
+b'DocType: HR Settings',b'HR Settings',b'Param\xc3\xa8tres RH'
+b'DocType: Salary Slip',b'net pay info',b'Info de salaire net'
+b'DocType: Lab Test Template',b'This value is updated in the Default Sales Price List.',b'Cette valeur est mise \xc3\xa0 jour dans la liste de prix de vente par d\xc3\xa9faut.'
+b'DocType: Email Digest',b'New Expenses',b'Nouvelles Charges'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +79',b'PDC/LC Amount',b'PDC / LC Montant'
+b'DocType: Shareholder',b'Shareholder',b'Actionnaire'
+b'DocType: Purchase Invoice',b'Additional Discount Amount',b'Montant de la Remise Suppl\xc3\xa9mentaire'
+b'DocType: Cash Flow Mapper',b'Position',b'Position'
+b'DocType: Patient',b'Patient Details',b'D\xc3\xa9tails du patient'
+b'DocType: Patient',b'B Positive',b'B Positif'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +596',"b'Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.'","b'Ligne #{0} : Qt\xc3\xa9 doit \xc3\xa9gale \xc3\xa0 1, car l\xe2\x80\x99Article est un actif immobilis\xc3\xa9. Veuillez utiliser une ligne distincte pour une qt\xc3\xa9 multiple.'"
+b'DocType: Leave Block List Allow',b'Leave Block List Allow',b'Autoriser la Liste de Blocage des Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +317',b'Abbr can not be blank or space',b'Abr\xc3\xa9. ne peut \xc3\xaatre vide ou contenir un espace'
+b'DocType: Patient Medical Record',b'Patient Medical Record',b'Registre m\xc3\xa9dical du patient'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +68',b'Group to Non-Group',b'Groupe vers Non-Groupe'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +50',b'Sports',b'Sportif'
+b'DocType: Loan Type',b'Loan Name',b'Nom du Pr\xc3\xaat'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +56',b'Total Actual',b'Total R\xc3\xa9el'
+b'DocType: Lab Test UOM',b'Test UOM',b'UDM de Test'
+b'DocType: Student Siblings',b'Student Siblings',"b""Fr\xc3\xa8res et S\xc5\x93urs de l'\xc3\x89tudiants"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +146',b'Unit',b'Unit\xc3\xa9'
+b'apps/erpnext/erpnext/stock/get_item_details.py +138',b'Please specify Company',b'Veuillez sp\xc3\xa9cifier la Soci\xc3\xa9t\xc3\xa9'
+,b'Customer Acquisition and Loyalty',b'Acquisition et Fid\xc3\xa9lisation des Clients'
+b'DocType: Asset Maintenance Task',b'Maintenance Task',b'T\xc3\xa2che de maintenance'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +118',b'Please set B2C Limit in GST Settings.',b'Veuillez d\xc3\xa9finir la limite B2C dans les param\xc3\xa8tres GST.'
+b'DocType: Purchase Invoice',b'Warehouse where you are maintaining stock of rejected items',"b""L'entrep\xc3\xb4t o\xc3\xb9 vous conservez le stock d'objets refus\xc3\xa9s"""
+b'DocType: Work Order',b'Skip Material Transfer',b'Sauter le Transfert de Materiel'
+b'apps/erpnext/erpnext/setup/utils.py +109',b'Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually',b'Impossible de trouver le taux de change pour {0} \xc3\xa0 {1} pour la date cl\xc3\xa9 {2}. Veuillez cr\xc3\xa9er une entr\xc3\xa9e de taux de change manuellement'
+b'DocType: POS Profile',b'Price List',b'Liste de Prix'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +22',b'{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.',b'{0} est d\xc3\xa9sormais l\xe2\x80\x99Exercice par d\xc3\xa9faut. Veuillez actualiser la page pour que les modifications soient prises en compte.'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +45',b'Expense Claims',b'Notes de Frais'
+b'DocType: Issue',b'Support',b'Support'
+,b'BOM Search',b'Recherche LDM'
+b'DocType: Project',b'Total Consumed Material Cost  (via Stock Entry)',b'Co\xc3\xbbt total du mat\xc3\xa9riel consomm\xc3\xa9 (via la saisie des stocks)'
+b'DocType: Item',"b'Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.'","b'Publier ""En Stock"" ou ""Pas en Stock"" sur le Hub sur la base du stock disponible dans cet entrep\xc3\xb4t.'"
+b'DocType: Vehicle',b'Fuel Type',b'Type de Carburant'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +27',b'Please specify currency in Company',b'Veuillez sp\xc3\xa9cifier la devise de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Workstation',b'Wages per hour',b'Salaires par heure'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +47',b'Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}',"b""Solde du stock dans le Lot {0} deviendra n\xc3\xa9gatif {1} pour l'Article {2} \xc3\xa0 l'Entrep\xc3\xb4t {3}"""
+b'apps/erpnext/erpnext/templates/emails/reorder_item.html +1',"b""Following Material Requests have been raised automatically based on Item's re-order level""",b'Les Demandes de Mat\xc3\xa9riel suivantes ont \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9es automatiquement sur la base du niveau de r\xc3\xa9approvisionnement de l\xe2\x80\x99Article'
+b'DocType: Email Digest',b'Pending Sales Orders',b'Commandes Client en Attente'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +312',b'Account {0} is invalid. Account Currency must be {1}',b'Le compte {0} est invalide. La Devise du Compte doit \xc3\xaatre {1}'
+b'DocType: Healthcare Settings',b'Remind Before',b'Rappeler Avant'
+b'apps/erpnext/erpnext/buying/utils.py +34',b'UOM Conversion factor is required in row {0}',"b""Facteur de conversion de l'UDM est obligatoire dans la ligne {0}"""
+b'DocType: Production Plan Item',b'material_request_item',b'article_demande_de_materiel'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1087',"b'Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry'","b'Ligne #{0} : Le Type de Document de R\xc3\xa9f\xc3\xa9rence doit \xc3\xaatre une Commande Client, une Facture de Vente ou une \xc3\x89criture de Journal'"
+b'DocType: Salary Component',b'Deduction',b'D\xc3\xa9duction'
+b'DocType: Item',b'Retain Sample',b'Conserver l&#39;\xc3\xa9chantillon'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +115',b'Row {0}: From Time and To Time is mandatory.',b'Ligne {0} : Heure de D\xc3\xa9but et Heure de Fin obligatoires.'
+b'DocType: Stock Reconciliation Item',b'Amount Difference',b'Diff\xc3\xa9rence de Montant'
+b'apps/erpnext/erpnext/stock/get_item_details.py +356',b'Item Price added for {0} in Price List {1}',"b""Prix de l'Article ajout\xc3\xa9 pour {0} dans la Liste de Prix {1}"""
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +8',b'Please enter Employee Id of this sales person',b'Veuillez entrer l\xe2\x80\x99ID Employ\xc3\xa9 de ce commercial'
+b'DocType: Territory',b'Classification of Customers by region',b'Classification des Clients par r\xc3\xa9gion'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +71',b'In Production',b'En production'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +65',b'Difference Amount must be zero',b'L\xe2\x80\x99\xc3\x89cart de Montant doit \xc3\xaatre \xc3\xa9gal \xc3\xa0 z\xc3\xa9ro'
+b'DocType: Project',b'Gross Margin',b'Marge Brute'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +61',b'Please enter Production Item first',"b""Veuillez d\xe2\x80\x99abord entrer l'Article en Production"""
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +45',b'Calculated Bank Statement balance',b'Solde Calcul\xc3\xa9 du Relev\xc3\xa9 Bancaire'
+b'DocType: Normal Test Template',b'Normal Test Template',b'Mod\xc3\xa8le de Test Normal'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +64',b'disabled user',b'Utilisateur D\xc3\xa9sactiv\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +919',b'Quotation',b'Devis'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +984',b'Cannot set a received RFQ to No Quote',"b""Impossible de lier une R\xc3\xa9ponse \xc3\xa0 Appel d'Offres re\xc3\xa7ue \xc3\xa0 Aucun Devis"""
+b'DocType: Quotation',b'QTN-',b'QTN-'
+b'DocType: Salary Slip',b'Total Deduction',b'D\xc3\xa9duction Totale'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +18',b'Select an account to print in account currency',b'S\xc3\xa9lectionnez un compte \xc3\xa0 imprimer dans la devise du compte'
+,b'Production Analytics',b'Analyse de la Production'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +6',b'This is based on transactions against this Patient. See timeline below for details',b'Ceci est bas\xc3\xa9 sur les transactions de ce patient. Voir la chronologie ci-dessous pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +204',b'Cost Updated',b'Co\xc3\xbbt Mise \xc3\xa0 Jour'
+b'DocType: Patient',b'Date of Birth',b'Date de Naissance'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +133',b'Item {0} has already been returned',"b""L'article {0} a d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 retourn\xc3\xa9"""
+b'DocType: Fiscal Year',b'**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.',b'**Exercice** repr\xc3\xa9sente un Exercice Financier. Toutes les \xc3\xa9critures comptables et autres transactions majeures sont suivis en **Exercice**.'
+b'DocType: Opportunity',b'Customer / Lead Address',b'Adresse du Client / Prospect'
+b'DocType: Supplier Scorecard Period',b'Supplier Scorecard Setup',"b""Configuration de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +133',b'Assessment Plan Name',"b""Nom du Plan d'\xc3\x89valuation"""
+b'DocType: Work Order Operation',b'Work Order Operation',b'Op\xc3\xa9ration de commande de travail'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +233',b'Warning: Invalid SSL certificate on attachment {0}',b'Attention : certificat SSL non valide sur la pi\xc3\xa8ce jointe {0}'
+b'apps/erpnext/erpnext/utilities/activation.py +64',"b'Leads help you get business, add all your contacts and more as your leads'","b'Les prospects vous aident \xc3\xa0 obtenir des contrats, ajoutez tous vos contacts et plus dans votre liste de prospects'"
+b'DocType: Work Order Operation',b'Actual Operation Time',"b""Temps d'Exploitation R\xc3\xa9el"""
+b'DocType: Authorization Rule',b'Applicable To (User)',b'Applicable \xc3\x80 (Utilisateur)'
+b'DocType: Purchase Taxes and Charges',b'Deduct',b'D\xc3\xa9duire'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +238',b'Job Description',"b""Description de l'Emploi"""
+b'DocType: Student Applicant',b'Applied',b'Appliqu\xc3\xa9'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +874',b'Re-open',b'R\xc3\xa9-ouvrir'
+b'DocType: Sales Invoice Item',b'Qty as per Stock UOM',b'Qt\xc3\xa9 par UDM du Stock'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +59',b'Guardian2 Name',b'Nom du Tuteur 2'
+b'DocType: Purchase Invoice',b'02-Post Sale Discount',b'Remise de vente 02-Post'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +132',"b'Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series'","b'Les caract\xc3\xa8res sp\xc3\xa9ciaux sauf ""-"", ""#"", ""."" et ""/"" ne sont pas autoris\xc3\xa9s dans le nommage des s\xc3\xa9ries'"
+b'DocType: Campaign',"b'Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.'","b'Garder une Trace des Campagnes de Vente. Garder une trace des Prospects, Devis, Commandes Client etc. depuis les Campagnes pour mesurer le Retour sur Investissement.'"
+,b'SO Qty',b'SO Qt\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +91',b'The field To Shareholder cannot be blank',b'Le champ Destinataire ne peut pas \xc3\xaatre vide'
+b'DocType: Guardian',b'Work Address',b'Adresse du Bureau'
+b'DocType: Appraisal',b'Calculate Total Score',b'Calculer le R\xc3\xa9sultat Total'
+b'DocType: Health Insurance',b'Health Insurance',b'Assurance sant\xc3\xa9'
+b'DocType: Asset Repair',b'Manufacturing Manager',b'Responsable Fabrication'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +191',b'Serial No {0} is under warranty upto {1}',"b""N\xc2\xb0 de S\xc3\xa9rie {0} est sous garantie jusqu'au {1}"""
+b'DocType: Plant Analysis Criteria',b'Minimum Permissible Value',b'Valeur minimale autoris\xc3\xa9e'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +41',b'User {0} already exists',b'L&#39;utilisateur {0} existe d\xc3\xa9j\xc3\xa0'
+b'apps/erpnext/erpnext/hooks.py +109',b'Shipments',b'Livraisons'
+b'DocType: Payment Entry',b'Total Allocated Amount (Company Currency)',b'Montant Total Allou\xc3\xa9 (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Purchase Order Item',b'To be delivered to customer',b'\xc3\x80 livrer \xc3\xa0 la client\xc3\xa8le'
+b'DocType: BOM',b'Scrap Material Cost',b'Co\xc3\xbbt de Mise au Rebut des Mat\xc3\xa9riaux'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227',b'Serial No {0} does not belong to any Warehouse',b'N\xc2\xb0 de S\xc3\xa9rie {0} ne fait partie de aucun Entrep\xc3\xb4t'
+b'DocType: Grant Application',b'Email Notification Sent',b'Notification par e-mail envoy\xc3\xa9e'
+b'DocType: Purchase Invoice',b'In Words (Company Currency)',b'En Toutes Lettres (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1018',"b'Item Code, warehouse, quantity are required on row'","b'Le code d&#39;article, l&#39;entrep\xc3\xb4t, la quantit\xc3\xa9 sont requis sur la rang\xc3\xa9e'"
+b'DocType: Pricing Rule',b'Supplier',b'Fournisseur'
+b'apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js +41',b'Show Payment Details',b'Afficher les d\xc3\xa9tails du paiement'
+b'DocType: Consultation',b'Consultation Time',b'Dur\xc3\xa9e de Consultation'
+b'DocType: C-Form',b'Quarter',b'Trimestre'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +106',b'Miscellaneous Expenses',b'Charges Diverses'
+b'DocType: Global Defaults',b'Default Company',b'Soci\xc3\xa9t\xc3\xa9 par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +227',b'Expense or Difference account is mandatory for Item {0} as it impacts overall stock value',"b""Compte de Charge et d'\xc3\x89carts est obligatoire pour objet {0} car il impacte la valeur globale des actions"""
+b'DocType: Payment Request',b'PR',b'PR'
+b'DocType: Cheque Print Template',b'Bank Name',b'Nom de la Banque'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py +30',b'-Above',b'-Au-dessus'
+b'DocType: Employee Loan',b'Employee Loan Account',"b""Compte de Pr\xc3\xaat d'un Employ\xc3\xa9"""
+b'DocType: Leave Application',b'Total Leave Days',b'Total des Jours de Cong\xc3\xa9'
+b'DocType: Email Digest',b'Note: Email will not be sent to disabled users',b'Remarque : Email ne sera pas envoy\xc3\xa9 aux utilisateurs d\xc3\xa9sactiv\xc3\xa9s'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js +14',b'Number of Interaction',"b""Nombre d'Interactions"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +105',b'Item Variant Settings',"b""Param\xc3\xa8tres de Variante d'Article"""
+b'apps/erpnext/erpnext/manufacturing/page/production_analytics/production_analytics.js +37',b'Select Company...',b'S\xc3\xa9lectionner la Soci\xc3\xa9t\xc3\xa9 ...'
+b'DocType: Leave Control Panel',b'Leave blank if considered for all departments',b'Laisser vide pour tous les d\xc3\xa9partements'
+b'apps/erpnext/erpnext/config/hr.py +228',"b'Types of employment (permanent, contract, intern etc.).'","b'Type d\xe2\x80\x99emploi (CDI, CDD, Stagiaire, etc.)'"
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +434',b'{0} is mandatory for Item {1}',b'{0} est obligatoire pour l\xe2\x80\x99Article {1}'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js +136',"b'Item {0}: {1} qty produced, '","b'Article {0}: {1} quantit\xc3\xa9 produite,'"
+b'DocType: Payroll Entry',b'Fortnightly',b'Bimensuel'
+b'DocType: Currency Exchange',b'From Currency',b'De la Devise'
+b'DocType: Vital Signs',b'Weight (In Kilogram)',b'Poids (En Kilogramme)'
+b'DocType: Chapter',b'chapters/chapter_name\nleave blank automatically set after saving chapter.',"b""chapitres / nom_chapitre laisser vide automatiquement d\xc3\xa9fini apr\xc3\xa8s l'enregistrement du chapitre."""
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py +202',b'Please set GST Accounts in GST Settings',b'Veuillez d\xc3\xa9finir les comptes de TPS dans les param\xc3\xa8tres de la TPS'
+b'apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js +31',b'Type of Business',b'Type de commerce'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +171',"b'Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row'","b'Veuillez s\xc3\xa9lectionner le Montant Allou\xc3\xa9, le Type de Facture et le Num\xc3\xa9ro de Facture dans au moins une ligne'"
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +128',b'Cost of New Purchase',b'Co\xc3\xbbt du Nouvel Achat'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py +35',b'All tasks for the detected diseases were imported',b'Toutes les t\xc3\xa2ches pour les maladies d\xc3\xa9tect\xc3\xa9es ont \xc3\xa9t\xc3\xa9 import\xc3\xa9es'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +97',b'Sales Order required for Item {0}',"b""Commande Client requise pour l'Article {0}"""
+b'DocType: Grant Application',b'Grant Description',b'Description de la subvention'
+b'DocType: Purchase Invoice Item',b'Rate (Company Currency)',b'Prix (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Student Guardian',b'Others',b'Autres'
+b'DocType: Payment Entry',b'Unallocated Amount',b'Montant Non Allou\xc3\xa9'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +91',b'Cannot find a matching Item. Please select some other value for {0}.',b'Impossible de trouver un article similaire. Veuillez s\xc3\xa9lectionner une autre valeur pour {0}.'
+b'DocType: POS Profile',b'Taxes and Charges',b'Taxes et Frais'
+b'DocType: Item',"b'A Product or a Service that is bought, sold or kept in stock.'","b'Un Produit ou un Service qui est achet\xc3\xa9, vendu ou conserv\xc3\xa9 en stock.'"
+b'apps/erpnext/erpnext/hr/page/team_updates/team_updates.js +44',b'No more updates',b'Pas de mise \xc3\xa0 jour suppl\xc3\xa9mentaire'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +171',"b""Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row""",b'Impossible de s\xc3\xa9lectionner le type de charge comme \xc3\xa9tant \xc2\xabLe Montant de la Ligne Pr\xc3\xa9c\xc3\xa9dente\xc2\xbb ou \xc2\xabMontant Total de la Ligne Pr\xc3\xa9c\xc3\xa9dente\xc2\xbb pour la premi\xc3\xa8re ligne'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +6',b'This covers all scorecards tied to this Setup',"b""Cela couvre toutes les fiches d'\xc3\x89valuation li\xc3\xa9es \xc3\xa0 cette Configuration"""
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +29',b'Child Item should not be a Product Bundle. Please remove item `{0}` and save',"b""Le sous-article ne doit pas \xc3\xaatre un ensemble de produit. S'il vous pla\xc3\xaet retirer l'article `{0}` et sauver"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +12',b'Banking',b'Banque'
+b'apps/erpnext/erpnext/utilities/activation.py +108',b'Add Timesheets',b'Ajouter des Feuilles de Temps'
+b'DocType: Vehicle Service',b'Service Item',b'Poste de Service'
+b'DocType: Bank Guarantee',b'Bank Guarantee',b'Garantie Bancaire'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +39',"b""Please click on 'Generate Schedule' to get schedule""",b'Veuillez cliquer sur \xe2\x80\x98G\xc3\xa9n\xc3\xa9rer Calendrier\xe2\x80\x99 pour obtenir le calendrier'
+b'DocType: Bin',b'Ordered Quantity',b'Quantit\xc3\xa9 Command\xc3\xa9e'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +118',"b'e.g. ""Build tools for builders""'","b'e.g. ""Construire des outils pour les constructeurs""'"
+b'DocType: Grading Scale',b'Grading Scale Intervals',"b""Intervalles de l'\xc3\x89chelle de Notation"""
+b'apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +39',b'Profit for the year',b'B\xc3\xa9n\xc3\xa9fice pour l&#39;ann\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +125',b'{0} {1}: Accounting Entry for {2} can only be made in currency: {3}',b'{0} {1} : L\xe2\x80\x99\xc3\x89criture Comptable pour {2} peut seulement \xc3\xaatre faite en devise: {3}'
+b'DocType: Fee Schedule',b'In Process',b'En Cours'
+b'DocType: Authorization Rule',b'Itemwise Discount',b'Remise par Article'
+b'apps/erpnext/erpnext/config/accounts.py +75',b'Tree of financial accounts.',b'Arbre des comptes financiers.'
+b'DocType: Cash Flow Mapping',b'Cash Flow Mapping',b'Cartographie des flux de tr\xc3\xa9sorerie'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +364',b'{0} against Sales Order {1}',b'{0} pour la Commande Client {1}'
+b'DocType: Account',b'Fixed Asset',b'Actif Immobilis\xc3\xa9'
+b'apps/erpnext/erpnext/config/stock.py +324',b'Serialized Inventory',b'Inventaire S\xc3\xa9rialis\xc3\xa9'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +74',b'Email not found in default contact',b'Email non trouv\xc3\xa9 dans le contact par d\xc3\xa9faut'
+b'DocType: Employee Loan',b'Account Info',b'Information du Compte'
+b'DocType: Activity Type',b'Default Billing Rate',b'Prix de Facturation par D\xc3\xa9faut'
+b'DocType: Fees',b'Include Payment',b'Inclure le Paiement'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +77',b'{0} Student Groups created.',"b""{0} Groupes d'\xc3\x89tudiants cr\xc3\xa9\xc3\xa9s."""
+b'DocType: Sales Invoice',b'Total Billing Amount',b'Montant Total de Facturation'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py +50',b'Program in the Fee Structure and Student Group {0} are different.',b'Le programme dans la structure des frais et le groupe d&#39;\xc3\xa9tudiants {0} sont diff\xc3\xa9rents.'
+b'DocType: Fee Schedule',b'Receivable Account',b'Compte D\xc3\xa9biteur'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +618',b'Row #{0}: Asset {1} is already {2}',b'Ligne #{0} : L\xe2\x80\x99Actif {1} est d\xc3\xa9j\xc3\xa0 {2}'
+b'DocType: Quotation Item',b'Stock Balance',b'Solde du Stock'
+b'apps/erpnext/erpnext/config/selling.py +321',b'Sales Order to Payment',b'De la Commande Client au Paiement'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +123',b'CEO',b'PDG'
+b'DocType: Purchase Invoice',b'With Payment of Tax',b'Avec Paiement de Taxe'
+b'DocType: Expense Claim Detail',b'Expense Claim Detail',b'D\xc3\xa9tail de la Note de Frais'
+b'DocType: Purchase Invoice',b'TRIPLICATE FOR SUPPLIER',b'TRIPLICAT POUR LE FOURNISSEUR'
+b'DocType: Land Unit',b'Is Container',b'Est le conteneur'
+b'DocType: Crop Cycle',b'This will be day 1 of the crop cycle',b'Ce sera le jour 1 du cycle de la culture'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +871',b'Please select correct account',b'Veuillez s\xc3\xa9lectionner un compte correct'
+b'DocType: Purchase Invoice Item',b'Weight UOM',b'UDM de Poids'
+b'apps/erpnext/erpnext/config/accounts.py +466',b'List of available Shareholders with folio numbers',b'Liste des actionnaires disponibles avec num\xc3\xa9ros de folio'
+b'DocType: Salary Structure Employee',b'Salary Structure Employee',b'Grille des Salaires des Employ\xc3\xa9s'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js +45',b'Show Variant Attributes',b'Afficher les attributs de variante'
+b'DocType: Student',b'Blood Group',b'Groupe Sanguin'
+b'DocType: Course',b'Course Name',b'Nom du Cours'
+b'DocType: Employee Leave Approver',"b""Users who can approve a specific employee's leave applications""","b""Les utilisateurs qui peuvent approuver les demandes de cong\xc3\xa9 d'un employ\xc3\xa9 en particulier"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +52',b'Office Equipments',b'\xc3\x89quipements de Bureau'
+b'DocType: Purchase Invoice Item',b'Qty',b'Qt\xc3\xa9'
+b'DocType: Fiscal Year',b'Companies',b'Soci\xc3\xa9t\xc3\xa9s'
+b'DocType: Supplier Scorecard',b'Scoring Setup',b'Param\xc3\xa9trage de la Notation'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +24',b'Electronics',b'\xc3\x89lectronique'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +326',b'Debit ({0})',b'D\xc3\xa9bit ({0})'
+b'DocType: Stock Settings',b'Raise Material Request when stock reaches re-order level',b'Cr\xc3\xa9er une demande de mat\xc3\xa9riel lorsque le stock atteint le niveau de r\xc3\xa9approvisionnement'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +98',b'Full-time',b'Temps Plein'
+b'DocType: Payroll Entry',b'Employees',b'Employ\xc3\xa9s'
+b'DocType: Employee',b'Contact Details',b'Coordonn\xc3\xa9es'
+b'DocType: C-Form',b'Received Date',b'Date de R\xc3\xa9ception'
+b'DocType: Delivery Note',"b'If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.'","b'Si vous avez cr\xc3\xa9\xc3\xa9 un mod\xc3\xa8le standard dans Mod\xc3\xa8le de Taxes et Frais de Vente, s\xc3\xa9lectionnez-en un et cliquez sur le bouton ci-dessous.'"
+b'DocType: BOM Scrap Item',b'Basic Amount (Company Currency)',b'Montant de Base (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Student',b'Guardians',b'Tuteurs'
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html +13',b'Payment Confirmation',b'Confirmation de paiement'
+b'DocType: Shopping Cart Settings',b'Prices will not be shown if Price List is not set',"b""Les Prix ne seront pas affich\xc3\xa9s si la Liste de Prix n'est pas d\xc3\xa9finie"""
+b'DocType: Stock Entry',b'Total Incoming Value',b'Valeur Entrante Totale'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +362',b'Debit To is required',b'Compte de D\xc3\xa9bit Requis'
+b'apps/erpnext/erpnext/utilities/activation.py +109',"b'Timesheets help keep track of time, cost and billing for activites done by your team'","b'Les Feuilles de Temps aident au suivi du temps, co\xc3\xbbt et facturation des activit\xc3\xa9s effectu\xc3\xa9es par votre \xc3\xa9quipe'"
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'Purchase Price List',"b""Liste des Prix d'Achat"""
+b'apps/erpnext/erpnext/config/buying.py +155',b'Templates of supplier scorecard variables.',"b""Mod\xc3\xa8les des Variables de  Fiche d'\xc3\x89valuation Fournisseur."""
+b'DocType: Job Offer Term',b'Offer Term',b'Terme de la Proposition'
+b'DocType: Asset',b'Quality Manager',b'Responsable Qualit\xc3\xa9'
+b'DocType: Job Applicant',b'Job Opening',b'Offre d\xe2\x80\x99Emploi'
+b'DocType: Payment Reconciliation',b'Payment Reconciliation',b'R\xc3\xa9conciliation des Paiements'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +153',"b""Please select Incharge Person's name""",b'Veuillez s\xc3\xa9lectionner le nom du/de la Responsable'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +51',b'Technology',b'Technologie'
+b'DocType: Hub Settings',b'Unregister from Hub',b'Annuler l&#39;inscription de Hub'
+b'apps/erpnext/erpnext/public/js/utils.js +108',b'Total Unpaid: {0}',b'Total des Impay\xc3\xa9s : {0}'
+b'DocType: BOM Website Operation',b'BOM Website Operation',b'Op\xc3\xa9ration de LDM du Site Internet'
+b'DocType: Supplier Scorecard',b'Supplier Score',b'Note du Fournisseur'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +213',b'Total Invoiced Amt',b'Mnt Total Factur\xc3\xa9'
+b'DocType: Supplier',b'Warn RFQs',"b""Avertir lors des Appels d'Offres"""
+b'DocType: BOM',b'Conversion Rate',b'Taux de Conversion'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +3',b'Product Search',b'Recherche de Produit'
+b'DocType: Assessment Plan',b'To Time',b'Horaire de Fin'
+b'DocType: Authorization Rule',b'Approving Role (above authorized value)',b'R\xc3\xb4le Approbateur (valeurs autoris\xc3\xa9es ci-dessus)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +118',b'Credit To account must be a Payable account',b'Le compte \xc3\x80 Cr\xc3\xa9diter doit \xc3\xaatre un compte Cr\xc3\xa9diteur'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +43',b'Please select Student Admission which is mandatory for the paid student applicant',"b""Veuillez s\xc3\xa9lectionner obligatoirement une Admission d'\xc3\x89tudiant pour la candidature \xc3\xa9tudiante pay\xc3\xa9e"""
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +355',b'BOM recursion: {0} cannot be parent or child of {2}',b'R\xc3\xa9p\xc3\xa9tition\xc2\xa0LDM : {0} ne peut pas \xc3\xaatre parent ou enfant de {2}'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +21',b'Please select a Price List to publish pricing',b'Veuillez s\xc3\xa9lectionner une liste de prix pour publier les prix'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +38',b'Budget List',b'Liste budg\xc3\xa9taire'
+b'DocType: Work Order Operation',b'Completed Qty',b'Quantit\xc3\xa9 Termin\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +148',"b'For {0}, only debit accounts can be linked against another credit entry'","b'Pour {0}, seuls les comptes de d\xc3\xa9bit peuvent \xc3\xaatre li\xc3\xa9s avec une autre \xc3\xa9criture de cr\xc3\xa9dit'"
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +27',b'Price List {0} is disabled',b'La Liste de Prix {0} est d\xc3\xa9sactiv\xc3\xa9e'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +127',b'Row {0}: Completed Qty cannot be more than {1} for operation {2}',b'Ligne {0} : Qt\xc3\xa9 Compl\xc3\xa9t\xc3\xa9e ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 {1} pour l\xe2\x80\x99op\xc3\xa9ration {2}'
+b'DocType: Manufacturing Settings',b'Allow Overtime',b'Autoriser les Heures Suppl\xc3\xa9mentaires'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +148',"b'Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry'","b""L'Article S\xc3\xa9rialis\xc3\xa9 {0} ne peut pas \xc3\xaatre mis \xc3\xa0 jour en utilisant la r\xc3\xa9conciliation des stocks, veuillez utiliser l'entr\xc3\xa9e de stock"""
+b'DocType: Training Event Employee',b'Training Event Employee',b'\xc3\x89v\xc3\xa8nement de Formation \xe2\x80\x93 Employ\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1031',b'Maximum Samples - {0} can be retained for Batch {1} and Item {2}.',b'Maximum d&#39;\xc3\xa9chantillons - {0} peut \xc3\xaatre conserv\xc3\xa9 pour le lot {1} et l&#39;article {2}.'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +7',b'Add Time Slots',b'Ajouter des Cr\xc3\xa9neaux'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +201',b'{0} Serial Numbers required for Item {1}. You have provided {2}.',b'{0} Num\xc3\xa9ros de S\xc3\xa9rie requis pour objet {1}. Vous en avez fourni {2}.'
+b'DocType: Stock Reconciliation Item',b'Current Valuation Rate',b'Taux de Valorisation Actuel'
+b'DocType: Training Event',b'Advance',b'Avance'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'for making recurring again.',b'pour que le document soit \xc3\xa0 nouveau un document r\xc3\xa9current.'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +13',b'GoCardless payment gateway settings',b'Param\xc3\xa8tres de la passerelle de paiement GoCardless'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +122',b'Exchange Gain/Loss',b'Profits / Pertes sur Change'
+b'DocType: Opportunity',b'Lost Reason',b'Raison de la Perte'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +265',b'Row #{0}: Account {1} does not belong to company {2}',b'Ligne # {0}: le compte {1} n&#39;appartient pas \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 {2}'
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +30',b'Unable to find DocType {0}',b'Impossible de trouver DocType {0}'
+b'apps/erpnext/erpnext/public/js/templates/address_list.html +22',b'New Address',b'Nouvelle Adresse'
+b'DocType: Quality Inspection',b'Sample Size',"b""Taille de l'\xc3\x89chantillon"""
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +47',b'Please enter Receipt Document',b'Veuillez entrer le Document de R\xc3\xa9ception'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +369',b'All items have already been invoiced',b'Tous les articles ont d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 factur\xc3\xa9s'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +49',"b""Please specify a valid 'From Case No.'""",b'Veuillez sp\xc3\xa9cifier un \xe2\x80\x98Depuis le Cas N\xc2\xb0.\xe2\x80\x99 valide'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +24',b'Further cost centers can be made under Groups but entries can be made against non-Groups',"b""D'autres centres de co\xc3\xbbts peuvent \xc3\xaatre cr\xc3\xa9\xc3\xa9s dans des Groupes, mais des \xc3\xa9critures ne peuvent \xc3\xaatre faites que sur des centres de co\xc3\xbbts individuels."""
+b'apps/erpnext/erpnext/config/setup.py +66',b'Users and Permissions',b'Utilisateurs et Autorisations'
+b'DocType: Vehicle Log',b'VLOG.',b'VLOG.'
+b'DocType: Branch',b'Branch',b'Branche'
+b'DocType: Soil Analysis',b'Ca/(K+Ca+Mg)',b'Ca / (K + Ca + Mg)'
+b'DocType: Delivery Trip',b'Fulfillment User',b'Utilisateur Fulfillment'
+b'apps/erpnext/erpnext/config/setup.py +61',b'Printing and Branding',b'Impression et Marque'
+b'DocType: Company',b'Total Monthly Sales',b'Total des Ventes Mensuelles'
+b'DocType: Agriculture Analysis Criteria',b'Weather',b'M\xc3\xa9t\xc3\xa9o'
+b'DocType: Bin',b'Actual Quantity',b'Quantit\xc3\xa9 R\xc3\xa9elle'
+b'DocType: Shipping Rule',b'example: Next Day Shipping',b'Exemple : Livraison le Jour Suivant'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +187',b'Serial No {0} not found',b'N\xc2\xb0 de S\xc3\xa9rie {0} introuvable'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +291',b'Subscription has been {0}',b'L&#39;abonnement a \xc3\xa9t\xc3\xa9 {0}'
+b'DocType: Fee Schedule Program',b'Fee Schedule Program',b'Programme de planification des honoraires'
+b'DocType: Fee Schedule Program',b'Student Batch',"b""Lot d'\xc3\x89tudiants"""
+b'apps/erpnext/erpnext/utilities/activation.py +119',b'Make Student',b'Cr\xc3\xa9er un \xc3\x89tudiant'
+b'DocType: Supplier Scorecard Scoring Standing',b'Min Grade',b'Note Minimale'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +218',b'You have been invited to collaborate on the project: {0}',b'Vous avez \xc3\xa9t\xc3\xa9 invit\xc3\xa9 \xc3\xa0 collaborer sur le projet : {0}'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +157',b'Physician not available on {0}',"b""Le m\xc3\xa9decin n'est pas disponible le {0}"""
+b'DocType: Leave Block List Date',b'Block Date',b'Bloquer la Date'
+b'DocType: Crop',b'Crop',b'Culture'
+b'DocType: Purchase Receipt',b'Supplier Delivery Note',b'Bon de Livraison du Fournisseur'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +70',b'Apply Now',b'Choisir'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html +25',b'Actual Qty {0} / Waiting Qty {1}',b'Qt\xc3\xa9 R\xc3\xa9elle {0} / Quantit\xc3\xa9 en Attente {1}'
+b'DocType: Purchase Invoice',b'E-commerce GSTIN',b'GSTIN E-commerce'
+b'DocType: Sales Order',b'Not Delivered',b'Non Livr\xc3\xa9'
+,b'Bank Clearance Summary',b'Bilan des Compensations Bancaires'
+b'apps/erpnext/erpnext/config/setup.py +106',"b'Create and manage daily, weekly and monthly email digests.'","b""Cr\xc3\xa9er et g\xc3\xa9rer des r\xc3\xa9sum\xc3\xa9s  d'E-mail quotidiens, hebdomadaires et mensuels ."""
+b'DocType: Appraisal Goal',b'Appraisal Goal',"b""Objectif d'Estimation"""
+b'DocType: Stock Reconciliation Item',b'Current Amount',b'Montant Actuel'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +58',b'Buildings',b'B\xc3\xa2timents'
+b'DocType: Fee Schedule',b'Fee Structure',"b""Structure d'Honoraires"""
+b'DocType: Timesheet Detail',b'Costing Amount',b'Montant des Co\xc3\xbbts'
+b'DocType: Student Admission Program',b'Application Fee',b'Frais de Dossier'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +52',b'Submit Salary Slip',b'Soumettre la Fiche de Paie'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +137',b'Maxiumm discount for Item {0} is {1}%',"b""Remise maximum pour l'article {0} est de {1} %"""
+b'apps/erpnext/erpnext/stock/doctype/item_price/item_price.js +16',b'Import in Bulk',b'Importer en Masse'
+b'DocType: Sales Partner',b'Address & Contacts',b'Adresse &amp; Contacts'
+b'DocType: SMS Log',b'Sender Name',"b""Nom de l'Exp\xc3\xa9diteur"""
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Analysis Criteria',b'Crit\xc3\xa8res d&#39;analyse de l&#39;agriculture'
+b'DocType: POS Profile',b'[Select]',b'[Choisir]'
+b'DocType: Vital Signs',b'Blood Pressure (diastolic)',b'Pression Art\xc3\xa9rielle (Diastolique)'
+b'DocType: SMS Log',b'Sent To',b'Envoy\xc3\xa9 \xc3\x80'
+b'DocType: Agriculture Task',b'Holiday Management',b'Gestion des vacances'
+b'DocType: Payment Request',b'Make Sales Invoice',b'Faire des Factures de Vente'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61',b'Softwares',b'Softwares'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +53',b'Next Contact Date cannot be in the past',b'La Date de Prochain Contact ne peut pas \xc3\xaatre dans le pass\xc3\xa9'
+b'DocType: Company',b'For Reference Only.',b'Pour R\xc3\xa9f\xc3\xa9rence Seulement.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +112',b'Physician {0} not available on {1}',"b""Le m\xc3\xa9decin {0} n'est pas disponible le {1}"""
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2581',b'Select Batch No',b'S\xc3\xa9lectionnez le N\xc2\xb0 de Lot'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +61',b'Invalid {0}: {1}',b'Invalide {0} : {1}'
+,b'GSTR-1',b'GSTR-1'
+b'DocType: Purchase Invoice',b'PINV-RET-',b'PINV-RET-'
+b'DocType: Fee Validity',b'Reference Inv',b'Facture de R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Sales Invoice Advance',b'Advance Amount',"b""Montant de l'Avance"""
+b'DocType: Manufacturing Settings',b'Capacity Planning',b'Planification de Capacit\xc3\xa9'
+b'DocType: Supplier Quotation',b'Rounding Adjustment (Company Currency',b'Arrondi (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +43',"b""'From Date' is required""","b""'Date d\xc3\xa9but' est requise"""
+b'DocType: Journal Entry',b'Reference Number',b'Num\xc3\xa9ro de R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Employee',b'Employment Details',"b""D\xc3\xa9tails de l'Emploi"""
+b'DocType: Employee',b'New Workplace',b'Nouveau Lieu de Travail'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17',b'Set as Closed',b'D\xc3\xa9finir comme Ferm\xc3\xa9'
+b'apps/erpnext/erpnext/stock/get_item_details.py +127',b'No Item with Barcode {0}',b'Aucun Article avec le Code Barre {0}'
+b'DocType: Normal Test Items',b'Require Result Value',b'N\xc3\xa9cessite la Valeur du R\xc3\xa9sultat'
+b'DocType: Item',b'Show a slideshow at the top of the page',b'Afficher un diaporama en haut de la page'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +532',b'Boms',b'Listes de Mat\xc3\xa9riaux'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +162',b'Stores',b'Magasins'
+b'DocType: Project Type',b'Projects Manager',b'Chef de Projet'
+b'DocType: Serial No',b'Delivery Time',b'Heure de la Livraison'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +33',b'Ageing Based On',b'Bas\xc3\xa9 Sur le Vieillissement'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +61',b'Appointment cancelled',b'Rendez-Vous Annul\xc3\xa9'
+b'DocType: Item',b'End of Life',b'Fin de Vie'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +331',b'Travel',b'D\xc3\xa9placement'
+b'DocType: Student Report Generation Tool',b'Include All Assessment Group',b'Inclure tout le groupe d&#39;\xc3\xa9valuation'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +183',b'No active or default Salary Structure found for employee {0} for the given dates',b'Aucune Structure de Salaire active ou par d\xc3\xa9faut trouv\xc3\xa9e pour employ\xc3\xa9 {0} pour les dates donn\xc3\xa9es'
+b'DocType: Leave Block List',b'Allow Users',b'Autoriser les Utilisateurs'
+b'DocType: Purchase Order',b'Customer Mobile No',b'N\xc2\xb0 de Portable du Client'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +1',b'Recurring',b'R\xc3\xa9current'
+b'DocType: Cash Flow Mapping Template Details',b'Cash Flow Mapping Template Details',b'D\xc3\xa9tails du mod\xc3\xa8le de mappage de flux de tr\xc3\xa9sorerie'
+b'DocType: Cost Center',b'Track separate Income and Expense for product verticals or divisions.',b'Suivre s\xc3\xa9par\xc3\xa9ment les Produits et Charges pour les gammes de produits.'
+b'DocType: Rename Tool',b'Rename Tool',b'Outil de Renommage'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +72',b'Update Cost',b'Mettre \xc3\xa0 jour le Co\xc3\xbbt'
+b'DocType: Item Reorder',b'Item Reorder',b'R\xc3\xa9organiser les Articles'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +463',b'Show Salary Slip',b'Afficher la Fiche de Salaire'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +849',b'Transfer Material',b'Transfert de Mat\xc3\xa9riel'
+b'DocType: Fees',b'Send Payment Request',b'Envoyer une Demande de Paiement'
+b'DocType: BOM',"b'Specify the operations, operating cost and give a unique Operation no to your operations.'","b""Sp\xc3\xa9cifier les op\xc3\xa9rations, le co\xc3\xbbt d'exploitation et donner un N\xc2\xb0 d'Op\xc3\xa9ration unique \xc3\xa0 vos op\xc3\xa9rations."""
+b'DocType: Water Analysis',b'Origin',b'Origine'
+b'apps/erpnext/erpnext/controllers/status_updater.py +204',b'This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?',b'Ce document exc\xc3\xa8de la limite de {0} {1} pour l\xe2\x80\x99article {4}. Faites-vous un autre {3} contre le m\xc3\xaame {2} ?'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1154',b'Please set recurring after saving',b'Veuillez d\xc3\xa9finir la r\xc3\xa9currence apr\xc3\xa8s avoir sauvegard\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +769',b'Select change amount account',b'S\xc3\xa9lectionner le compte de change'
+b'DocType: Purchase Invoice',b'Price List Currency',b'Devise de la Liste de Prix'
+b'DocType: Naming Series',b'User must always select',"b""L'utilisateur doit toujours s\xc3\xa9lectionner"""
+b'DocType: Stock Settings',b'Allow Negative Stock',b'Autoriser un Stock N\xc3\xa9gatif'
+b'DocType: Installation Note',b'Installation Note',"b""Note d'Installation"""
+b'DocType: Soil Texture',b'Clay',b'Argile'
+b'DocType: Topic',b'Topic',b'Sujet'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +45',b'Cash Flow from Financing',b'Flux de Tr\xc3\xa9sorerie du Financement'
+b'DocType: Budget Account',b'Budget Account',b'Compte de Budget'
+b'DocType: Quality Inspection',b'Verified By',b'V\xc3\xa9rifi\xc3\xa9 Par'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +78',"b""Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.""","b""Impossible de changer la devise par d\xc3\xa9faut de la soci\xc3\xa9t\xc3\xa9, parce qu'il y a des op\xc3\xa9rations existantes. Les transactions doivent \xc3\xaatre annul\xc3\xa9es pour changer la devise par d\xc3\xa9faut."""
+b'DocType: Cash Flow Mapping',b'Is Income Tax Liability',b'La dette d&#39;imp\xc3\xb4t sur le revenu'
+b'DocType: Grading Scale Interval',b'Grade Description',b'Description de la Note'
+b'DocType: Stock Entry',b'Purchase Receipt No',"b""N\xc2\xb0 du Re\xc3\xa7u d'Achat"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30',b'Earnest Money',b'Arrhes'
+b'DocType: Sales Invoice',b' Shipping Bill Number',b'Num\xc3\xa9ro de facture d&#39;exp\xc3\xa9dition'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +34',b'Traceability',b'Tra\xc3\xa7abilit\xc3\xa9'
+b'DocType: Asset Maintenance Log',b'Actions performed',b'Actions r\xc3\xa9alis\xc3\xa9es'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +51',b'Customer &gt; Customer Group &gt; Territory',b'Client&gt; Groupe de clients&gt; Territoire'
+b'DocType: Cash Flow Mapper',b'Section Leader',b'Chef de section'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +137',b'Source of Funds (Liabilities)',b'Source des Fonds (Passif)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +431',b'Quantity in row {0} ({1}) must be same as manufactured quantity {2}',b'Quantit\xc3\xa9 \xc3\xa0 la ligne {0} ({1}) doit \xc3\xaatre \xc3\xa9gale a la quantit\xc3\xa9 fabriqu\xc3\xa9e {2}'
+b'DocType: Supplier Scorecard Scoring Standing',b'Employee',b'Employ\xc3\xa9'
+b'DocType: Asset Repair',b'Failure Date',b'Date d&#39;\xc3\xa9chec'
+b'DocType: Sample Collection',b'Collected Time',b'Heure de Collecte'
+b'DocType: Company',b'Sales Monthly History',b'Historique des Ventes Mensuel'
+b'DocType: Asset Maintenance Task',b'Next Due Date',b'prochaine date d&#39;\xc3\xa9ch\xc3\xa9ance'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +214',b'Select Batch',b'S\xc3\xa9lectionnez le Lot'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +244',b'{0} {1} is fully billed',b'{0} {1} est enti\xc3\xa8rement factur\xc3\xa9'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +31',b'Vital Signs',b'Signes Vitaux'
+b'DocType: Training Event',b'End Time',b'Heure de Fin'
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +63',b'Active Salary Structure {0} found for employee {1} for the given dates',"b""Grille de Salaire active {0} trouv\xc3\xa9e pour l'employ\xc3\xa9 {1} pour les dates donn\xc3\xa9es"""
+b'DocType: Payment Entry',b'Payment Deductions or Loss',b'D\xc3\xa9ductions sur le Paiement ou Perte'
+b'DocType: Soil Analysis',b'Soil Analysis Criterias',b'Crit\xc3\xa8res d&#39;analyse des sols'
+b'apps/erpnext/erpnext/config/setup.py +42',b'Standard contract terms for Sales or Purchase.',b'Termes contractuels standards pour Ventes ou Achats'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +112',b'Group by Voucher',b'Groupe par Bon'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +233',b'Are you sure you want to cancel this appointment?',b'\xc3\x8ates-vous s\xc3\xbbr de vouloir annuler ce rendez-vous?'
+b'DocType: Hotel Room Pricing Package',b'Hotel Room Pricing Package',b'Forfait de prix de chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/config/crm.py +6',b'Sales Pipeline',b'Pipeline de Ventes'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +201',b'Please set default account in Salary Component {0}',b'Veuillez d\xc3\xa9finir le compte par d\xc3\xa9faut dans la Composante Salariale {0}'
+b'apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7',b'Required On',b'Requis Pour'
+b'DocType: Rename Tool',b'File to Rename',b'Fichier \xc3\xa0 Renommer'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +200',b'Please select BOM for Item in Row {0}',b'Veuillez s\xc3\xa9lectionnez une LDM pour l\xe2\x80\x99Article \xc3\xa0 la Ligne {0}'
+b'apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py +28',b'Account {0} does not match with Company {1} in Mode of Account: {2}',b'Le Compte {0} ne correspond pas \xc3\xa0 la Soci\xc3\xa9t\xc3\xa9 {1} dans le Mode de Compte : {2}'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +464',b'Specified BOM {0} does not exist for Item {1}',"b""La LDM {0} sp\xc3\xa9cifi\xc3\xa9e n'existe pas pour l'Article {1}"""
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +301',b'Course: ',b'Cours:'
+b'DocType: Soil Texture',b'Sandy Loam',b'terreau arigileux'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +232',b'Maintenance Schedule {0} must be cancelled before cancelling this Sales Order',"b""L'\xc3\x89ch\xc3\xa9ancier d'Entretien {0} doit \xc3\xaatre annul\xc3\xa9 avant d'annuler cette Commande Client"""
+b'DocType: POS Profile',b'Applicable for Users',b'Applicable aux Utilisateurs'
+b'DocType: Notification Control',b'Expense Claim Approved',b'Note de Frais Approuv\xc3\xa9e'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +231',b'No Work Orders created',b'Aucun ordre de travail cr\xc3\xa9\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +321',b'Salary Slip of employee {0} already created for this period',"b""Fiche de Paie de l'employ\xc3\xa9 {0} d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9e pour cette p\xc3\xa9riode"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +155',b'Pharmaceutical',b'Pharmaceutique'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Cost of Purchased Items',b'Co\xc3\xbbt des Articles Achet\xc3\xa9s'
+b'DocType: Selling Settings',b'Sales Order Required',b'Commande Client Requise'
+b'DocType: Purchase Invoice',b'Credit To',b'\xc3\x80 Cr\xc3\xa9diter'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +46',b'PieceDate',b'PieceDate'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +31',b'Active Leads / Customers',b'Prospects / Clients Actifs'
+b'DocType: Employee Education',b'Post Graduate',b'Post-Dipl\xc3\xb4m\xc3\xa9'
+b'DocType: Maintenance Schedule Detail',b'Maintenance Schedule Detail',"b""D\xc3\xa9tails de l'\xc3\x89ch\xc3\xa9ancier d'Entretien"""
+b'DocType: Supplier Scorecard',b'Warn for new Purchase Orders',b'Avertir lors des nouveaux Bons de Commande'
+b'DocType: Quality Inspection Reading',b'Reading 9',b'Lecture 9'
+b'DocType: Supplier',b'Is Frozen',b'Est Gel\xc3\xa9'
+b'apps/erpnext/erpnext/stock/utils.py +224',b'Group node warehouse is not allowed to select for transactions',"b""Un noeud de groupe d'entrep\xc3\xb4t ne peut pas \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9 pour les transactions"""
+b'DocType: Buying Settings',b'Buying Settings',"b""R\xc3\xa9glages d'Achat"""
+b'DocType: Stock Entry Detail',b'BOM No. for a Finished Good Item',b'N\xc2\xb0 d\xe2\x80\x99Article Produit Fini LDM'
+b'DocType: Upload Attendance',b'Attendance To Date',"b""Pr\xc3\xa9sence Jusqu'\xc3\xa0"""
+b'DocType: Request for Quotation Supplier',b'No Quote',b'Aucun Devis'
+b'DocType: Warranty Claim',b'Raised By',b'Cr\xc3\xa9\xc3\xa9 par'
+b'DocType: Payment Gateway Account',b'Payment Account',b'Compte de Paiement'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +909',b'Please specify Company to proceed',b'Veuillez sp\xc3\xa9cifier la Soci\xc3\xa9t\xc3\xa9 pour continuer'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +27',b'Net Change in Accounts Receivable',b'Variation Nette des Comptes D\xc3\xa9biteurs'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +88',b'Compensatory Off',b'Cong\xc3\xa9 Compensatoire'
+b'DocType: Job Offer',b'Accepted',b'Accept\xc3\xa9'
+b'DocType: Grant Application',b'Organization',b'Organisation'
+b'DocType: BOM Update Tool',b'BOM Update Tool',b'Outil de mise \xc3\xa0 jour de LDM'
+b'DocType: SG Creation Tool Course',b'Student Group Name',"b""Nom du Groupe d'\xc3\x89tudiants"""
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js +17',b'Show exploded view',b'Afficher la vue \xc3\xa9clat\xc3\xa9e'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +7',b'Creating Fees',"b""Cr\xc3\xa9ation d'Honoraires"""
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +91',b'Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.',b'Veuillez vous assurer que vous voulez vraiment supprimer tous les transactions de cette soci\xc3\xa9t\xc3\xa9. Vos donn\xc3\xa9es de base resteront intactes. Cette action ne peut \xc3\xaatre annul\xc3\xa9e.'
+b'apps/erpnext/erpnext/templates/pages/product_search.html +21',b'Search Results',b'R\xc3\xa9sultats de la Recherche'
+b'DocType: Room',b'Room Number',b'Num\xc3\xa9ro de la Chambre'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +107',b'Invalid reference {0} {1}',b'R\xc3\xa9f\xc3\xa9rence invalide {0} {1}'
+b'DocType: Shipping Rule',b'Shipping Rule Label',b'\xc3\x89tiquette de la R\xc3\xa8gle de Livraison'
+b'DocType: Journal Entry Account',b'Payroll Entry',b'Entr\xc3\xa9e de la paie'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +75',b'View Fees Records',b'Voir les dossiers de frais'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +35',b'Make Tax Template',b'Cr\xc3\xa9er un mod\xc3\xa8le d&#39;imposition'
+b'apps/erpnext/erpnext/public/js/conf.js +28',b'User Forum',"b""Forum de l'Utilisateur"""
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +319',b'Raw Materials cannot be blank.',b'Mati\xc3\xa8res Premi\xc3\xa8res ne peuvent pas \xc3\xaatre vides.'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +498',"b'Could not update stock, invoice contains drop shipping item.'","b'Impossible de mettre \xc3\xa0 jour de stock, facture contient un \xc3\xa9l\xc3\xa9ment en livraison directe.'"
+b'DocType: Lab Test Sample',b'Lab Test Sample',b'\xc3\x89chantillon de test de laboratoire'
+b'DocType: Item Variant Settings',b'Allow Rename Attribute Value',b'Autoriser la modification de la valeur de l&#39;attribut'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +491',b'Quick Journal Entry',b'\xc3\x89criture Rapide dans le Journal'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +200',b'You can not change rate if BOM mentioned agianst any item',b'Vous ne pouvez pas modifier le taux si la LDM est mentionn\xc3\xa9e pour un article'
+b'DocType: Restaurant',b'Invoice Series Prefix',b'Pr\xc3\xa9fixe de la S\xc3\xa9rie de Factures'
+b'DocType: Employee',b'Previous Work Experience',b'Exp\xc3\xa9rience de Travail Ant\xc3\xa9rieure'
+b'DocType: Stock Entry',b'For Quantity',b'Pour la Quantit\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +205',b'Please enter Planned Qty for Item {0} at row {1}',"b""Veuillez entrer la Qt\xc3\xa9 Planifi\xc3\xa9e pour l'Article {0} \xc3\xa0 la ligne {1}"""
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +93',b'Google Maps integration is not enabled',b'L&#39;int\xc3\xa9gration de Google Maps n&#39;est pas activ\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +241',b'{0} {1} is not submitted',"b""{0} {1} n'a pas \xc3\xa9t\xc3\xa9 soumis"""
+b'DocType: Member',b'Membership Expiry Date',b'Date d&#39;expiration de l&#39;adh\xc3\xa9sion'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +131',b'{0} must be negative in return document',b'{0} doit \xc3\xaatre n\xc3\xa9gatif dans le document de retour'
+,b'Minutes to First Response for Issues',b'Minutes avant la Premi\xc3\xa8re R\xc3\xa9ponse aux Questions'
+b'DocType: Purchase Invoice',b'Terms and Conditions1',b'Termes et Conditions'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +109',b'The name of the institute for which you are setting up this system.',"b""Le nom de l'institut pour lequel vous configurez ce syst\xc3\xa8me."""
+b'DocType: Accounts Settings',"b'Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.'","b""Les \xc3\xa9critures comptables sont gel\xc3\xa9es jusqu'\xc3\xa0 cette date, personne ne peut ajouter / modifier les entr\xc3\xa9es sauf les r\xc3\xb4les sp\xc3\xa9cifi\xc3\xa9s ci-dessous."""
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +116',b'Please save the document before generating maintenance schedule',"b""Veuillez enregistrer le document avant de g\xc3\xa9n\xc3\xa9rer le calendrier d'entretien"""
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js +30',b'Latest price updated in all BOMs',b'Prix les plus r\xc3\xa9cents mis \xc3\xa0 jour dans toutes les LDMs'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28',b'Project Status',b'Statut du Projet'
+b'DocType: UOM',b'Check this to disallow fractions. (for Nos)',b'Cochez cette case pour interdire les fractions. (Pour les num\xc3\xa9ros)'
+b'DocType: Student Admission Program',b'Naming Series (for Student Applicant)',b'Nom de la S\xc3\xa9rie (pour le Candidat \xc3\x89tudiant)'
+b'DocType: Delivery Note',b'Transporter Name',b'Nom du Transporteur'
+b'DocType: Authorization Rule',b'Authorized Value',b'Valeur Autoris\xc3\xa9e'
+b'DocType: BOM',b'Show Operations',b'Afficher Op\xc3\xa9rations'
+,b'Minutes to First Response for Opportunity',b'Minutes avant la Premi\xc3\xa8re R\xc3\xa9ponse \xc3\xa0 une Opportunit\xc3\xa9'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Absent',b'Total des Absences'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +862',b'Item or Warehouse for row {0} does not match Material Request',"b""L'Article ou l'Entrep\xc3\xb4t pour la ligne {0} ne correspond pas avec la Requ\xc3\xaate de Mat\xc3\xa9riel"""
+b'apps/erpnext/erpnext/config/stock.py +191',b'Unit of Measure',b'Unit\xc3\xa9 de Mesure'
+b'DocType: Fiscal Year',b'Year End Date',"b""Date de Fin de l'Exercice"""
+b'DocType: Task Depends On',b'Task Depends On',b'T\xc3\xa2che D\xc3\xa9pend De'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +1026',b'Opportunity',b'Opportunit\xc3\xa9'
+b'DocType: Operation',b'Default Workstation',b'Station de Travail par D\xc3\xa9faut'
+b'DocType: Notification Control',b'Expense Claim Approved Message',"b""Message d'une Note de Frais Approuv\xc3\xa9e"""
+b'DocType: Payment Entry',b'Deductions or Loss',b'D\xc3\xa9ductions ou Perte'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +247',b'{0} {1} is closed',b'{0} {1} est ferm\xc3\xa9'
+b'DocType: Email Digest',b'How frequently?',b'A quelle fr\xc3\xa9quence ?'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +55',b'Total Collected: {0}',b'Total Collect\xc3\xa9: {0}'
+b'DocType: Purchase Receipt',b'Get Current Stock',b'Obtenir le Stock Actuel'
+b'DocType: Purchase Invoice',b'ineligible',b'in\xc3\xa9ligible'
+b'apps/erpnext/erpnext/config/manufacturing.py +46',b'Tree of Bill of Materials',b'Arbre des Listes de Mat\xc3\xa9riaux'
+b'DocType: Student',b'Joining Date',"b""Date d'Inscription"""
+,b'Employees working on a holiday',b'Employ\xc3\xa9s qui travaillent un jour f\xc3\xa9ri\xc3\xa9'
+b'DocType: Share Balance',b'Current State',b'\xc3\x89tat actuel'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +152',b'Mark Present',b'Marquer Pr\xc3\xa9sent'
+b'DocType: Share Transfer',b'From Shareholder',b'De l&#39;actionnaire'
+b'DocType: Project',b'% Complete Method',b'% M\xc3\xa9thode Compl\xc3\xa8te'
+b'apps/erpnext/erpnext/healthcare/setup.py +181',b'Drug',b'M\xc3\xa9dicament'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +200',b'Maintenance start date can not be before delivery date for Serial No {0}',"b""La date de d\xc3\xa9but d'entretien ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date de livraison pour le N\xc2\xb0 de S\xc3\xa9rie {0}"""
+b'DocType: Work Order',b'Actual End Date',b'Date de Fin R\xc3\xa9elle'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost Adjustment',b'L&#39;ajustement des co\xc3\xbbts financiers'
+b'DocType: BOM',b'Operating Cost (Company Currency)',"b""Co\xc3\xbbt d'Exploitation (Devise Soci\xc3\xa9t\xc3\xa9)"""
+b'DocType: Purchase Invoice',b'PINV-',b'PINV-'
+b'DocType: Authorization Rule',b'Applicable To (Role)',b'Applicable \xc3\x80 (R\xc3\xb4le)'
+b'DocType: BOM Update Tool',b'Replace BOM',b'Remplacer la LDM'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +110',b'Code {0} already exist',b'Le code {0} existe d\xc3\xa9j\xc3\xa0'
+b'DocType: Employee Advance',b'Purpose',b'Objet'
+b'DocType: Company',b'Fixed Asset Depreciation Settings',"b""Param\xc3\xa8tres d'Amortissement des Immobilisations"""
+b'DocType: Item',b'Will also apply for variants unless overrridden',"b""S'appliquera \xc3\xa9galement pour des variantes sauf si remplac\xc3\xa9"""
+b'DocType: Purchase Invoice',b'Advances',b'Avances'
+b'DocType: Work Order',b'Manufacture against Material Request',b'Fabrication pour une Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +14',b'Assessment Group: ',"b""Groupe d'\xc3\x89valuation:"""
+b'DocType: Item Reorder',b'Request for',b'Demander Pour'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32',b'Approving User cannot be same as user the rule is Applicable To',"b""L'Utilisateur Approbateur ne peut pas \xc3\xaatre identique \xc3\xa0 l'utilisateur dont la r\xc3\xa8gle est Applicable"""
+b'DocType: Stock Entry Detail',b'Basic Rate (as per Stock UOM)',b'Taux de base (comme l\xe2\x80\x99UDM du Stock)'
+b'DocType: SMS Log',b'No of Requested SMS',b'Nb de SMS Demand\xc3\xa9s'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +246',b'Leave Without Pay does not match with approved Leave Application records',b'Cong\xc3\xa9 sans solde ne correspond pas aux Feuilles de Demandes de Cong\xc3\xa9 Approuv\xc3\xa9es'
+b'DocType: Campaign',b'Campaign-.####',b'Campagne-.####'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +21',b'Next Steps',b'Prochaines \xc3\x89tapes'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +796',b'Please supply the specified items at the best possible rates',b'Veuillez fournir les articles sp\xc3\xa9cifi\xc3\xa9s aux meilleurs tarifs possibles'
+b'DocType: Membership',b'USD',b'USD'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +28',b'Make Invoice',b'Faire une Facture'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +80',b'Remaining Balance',b'Solde restant'
+b'DocType: Selling Settings',b'Auto close Opportunity after 15 days',b'Fermer automatiquement les Opportunit\xc3\xa9s apr\xc3\xa8s 15 jours'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +86',b'Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.',"b""Les Bons de Commande ne sont pas autoris\xc3\xa9s pour {0} en raison d'une note sur la fiche d'\xc3\xa9valuation de {1}."""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +498',b'Barcode {0} is not a valid {1} code',b'Le code \xc3\xa0 barres {0} n&#39;est pas un code {1} valide'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +83',b'End Year',b'Ann\xc3\xa9e de Fin'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +23',b'Quot/Lead %',b'Devis / Prospects %'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +124',b'Contract End Date must be greater than Date of Joining',"b""La Date de Fin de Contrat doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 la Date d'Embauche"""
+b'DocType: Driver',b'Driver',b'Chauffeur'
+b'DocType: Vital Signs',b'Nutrition Values',b'Valeurs Nutritionnelles'
+b'DocType: Lab Test Template',b'Is billable',b'Est facturable'
+b'DocType: Delivery Note',b'DN-',b'DN-'
+b'DocType: Sales Partner',b'A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.',"b""Un tiers distributeur / commer\xc3\xa7ant / commissionnaire / affili\xc3\xa9 / revendeur qui vend les produits de l'entreprise en \xc3\xa9change d'une commission."""
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +376',b'{0} against Purchase Order {1}',"b""{0} pour le Bon de Commande d'Achat {1}"""
+b'DocType: Patient',b'Patient Demographics',b'D\xc3\xa9mographie du Patient'
+b'DocType: Task',b'Actual Start Date (via Time Sheet)',b'Date de D\xc3\xa9but R\xc3\xa9elle (via la feuille de temps)'
+b'apps/erpnext/erpnext/portal/doctype/homepage/homepage.py +15',b'This is an example website auto-generated from ERPNext',b'Ceci est un exemple de site g\xc3\xa9n\xc3\xa9r\xc3\xa9 automatiquement \xc3\xa0 partir d\xe2\x80\x99ERPNext'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +43',b'Ageing Range 1',b'Balance Ag\xc3\xa9e 1'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +212',b'Total advance amount cannot be greater than total claimed amount',b'Le montant total de l&#39;avance ne peut \xc3\xaatre sup\xc3\xa9rieur au montant total r\xc3\xa9clam\xc3\xa9'
+b'DocType: Purchase Taxes and Charges Template',"b'Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.\n\n#### Note\n\nThe tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.\n\n#### Description of Columns\n\n1. Calculation Type: \n    - This can be on **Net Total** (that is the sum of basic amount).\n    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.\n    - **Actual** (as mentioned).\n2. Account Head: The Account ledger under which this tax will be booked\n3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.\n4. Description: Description of the tax (that will be printed in invoices / quotes).\n5. Rate: Tax rate.\n6. Amount: Tax amount.\n7. Total: Cumulative total to this point.\n8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).\n9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.\n10. Add or Deduct: Whether you want to add or deduct the tax.'","b'Mod\xc3\xa8le de la taxe standard qui peut \xc3\xaatre appliqu\xc3\xa9 \xc3\xa0 toutes les Op\xc3\xa9rations d\'Achat. Ce mod\xc3\xa8le peut contenir la liste des titres d\'imp\xc3\xb4ts ainsi que d\'autres titre de charges comme ""Livraison"", ""Assurance"", ""Gestion"", etc. \n\n#### Remarque \n\nLe taux d\'imposition que vous d\xc3\xa9finissez ici sera le taux d\'imposition standard pour tous les **Articles**. S\'il y a des **Articles** qui ont des taux diff\xc3\xa9rents, ils doivent \xc3\xaatre ajout\xc3\xa9s dans la table **Taxe de l\'Article** dans les donn\xc3\xa9es de base **Article**.\n\n#### Description des Colonnes\n\n1. Type de Calcul : \n    - Cela peut \xc3\xaatre le **Total Net** (qui est la somme des montants de base).\n    - **Total / Montant Sur la Ligne Pr\xc3\xa9c\xc3\xa9dente** (pour les taxes ou frais accumul\xc3\xa9s). Si vous s\xc3\xa9lectionnez cette option, la taxe sera appliqu\xc3\xa9e en pourcentage du montant ou du total de la ligne pr\xc3\xa9c\xc3\xa9dente (dans la table d\'imp\xc3\xb4ts).\n    - **R\xc3\xa9el** (comme mentionn\xc3\xa9).\n2. Titre du Compte : Le journal comptable dans lequel cette taxe sera comptabilis\xc3\xa9e\n3. Centre de Co\xc3\xbbt : Si la taxe / redevance est un revenu (comme la livraison) ou une charge, elle doit \xc3\xaatre comptabilis\xc3\xa9e dans un Centre de Co\xc3\xbbts.\n4. Description : Description de la taxe (qui sera imprim\xc3\xa9e sur les factures / devis).\n5. Taux : Le taux d\'imposition.\n6. Montant : Le montant de la taxe.\n7. Total : Total accumul\xc3\xa9 \xc3\xa0 ce point.\n8. Entrez la Ligne : Si elle est bas\xc3\xa9e sur ""Total de la Ligne Pr\xc3\xa9c\xc3\xa9dente"" vous pouvez s\xc3\xa9lectionner le num\xc3\xa9ro de la ligne qui sera pris comme base pour ce calcul (par d\xc3\xa9faut la ligne pr\xc3\xa9c\xc3\xa9dente).\n9. Consid\xc3\xa9rez Taxe ou Charge pour : Dans cette section, vous pouvez sp\xc3\xa9cifier si la taxe / redevance est seulement pour la valorisation (pas une partie du total) ou seulement pour le total (n\'ajoute pas de la valeur \xc3\xa0 l\'article) ou pour les deux.\n10. Ajouter ou D\xc3\xa9duire : Ce que vous voulez ajouter ou d\xc3\xa9duire de la taxe.'"
+b'DocType: Homepage',b'Homepage',"b""Page d'Accueil"""
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +68',b'Select Physician...',b'S\xc3\xa9lectionnez le M\xc3\xa9decin...'
+b'DocType: Grant Application',b'Grant Application Details ',b'D\xc3\xa9tails de la demande de subvention'
+b'DocType: Purchase Receipt Item',b'Recd Quantity',b'Quantit\xc3\xa9 Re\xc3\xa7ue'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +65',b'Fee Records Created - {0}',"b""Archive d'Honoraires Cr\xc3\xa9\xc3\xa9e - {0}"""
+b'DocType: Asset Category Account',b'Asset Category Account',"b""Compte de Cat\xc3\xa9gorie d'Actif"""
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +913',b'Row #{0} (Payment Table): Amount must be positive',b'Row # {0} (Table de paiement): Le montant doit \xc3\xaatre positif'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +44',b'CompteNum',b'CompteNum'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +137',b'Cannot produce more Item {0} than Sales Order quantity {1}',"b""Impossible de produire plus d'Article {0} que la quantit\xc3\xa9 {1} du Bon de Commande"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +391',b'Select Attribute Values',b'S\xc3\xa9lectionner les valeurs d&#39;attribut'
+b'DocType: Purchase Invoice',b'Reason For Issuing document',b'Raison de l&#39;\xc3\xa9mission du document'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +539',b'Stock Entry {0} is not submitted',"b""\xc3\x89criture de Stock {0} n'est pas soumise"""
+b'DocType: Payment Reconciliation',b'Bank / Cash Account',b'Compte Bancaire / de Caisse'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +47',b'Next Contact By cannot be same as the Lead Email Address',b'Prochain Contact Par ne peut \xc3\xaatre identique \xc3\xa0 l\xe2\x80\x99Adresse Email du Prospect'
+b'DocType: Tax Rule',b'Billing City',b'Ville de Facturation'
+b'DocType: Asset',b'Manual',b'Manuel'
+b'DocType: Salary Component Account',b'Salary Component Account',b'Compte Composante Salariale'
+b'DocType: Global Defaults',b'Hide Currency Symbol',b'Masquer le Symbole Mon\xc3\xa9taire'
+b'apps/erpnext/erpnext/config/non_profit.py +58',b'Donor information.',b'Informations sur le donneur'
+b'apps/erpnext/erpnext/config/accounts.py +330',"b'e.g. Bank, Cash, Credit Card'","b'e.g. Cash, Banque, Carte de cr\xc3\xa9dit'"
+b'DocType: Lead Source',b'Source Name',b'Nom de la Source'
+b'DocType: Vital Signs',"b'Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""'","b'La tension art\xc3\xa9rielle normale chez un adulte est d&#39;environ 120 mmHg systolique et 80 mmHg diastolique, abr\xc3\xa9g\xc3\xa9 &quot;120/80 mmHg&quot;'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +119',"b'Set items shelf life in days, to set expiry based on manufacturing_date plus self life'","b'D\xc3\xa9finissez la dur\xc3\xa9e de conservation des \xc3\xa9l\xc3\xa9ments en jours, pour d\xc3\xa9finir l&#39;expiration en fonction de la date de fabrication et de la vie autonome'"
+b'DocType: Journal Entry',b'Credit Note',b'Note de Cr\xc3\xa9dit'
+b'DocType: Projects Settings',b'Ignore Employee Time Overlap',b'Ignorer le chevauchement de temps des employ\xc3\xa9s'
+b'DocType: Warranty Claim',b'Service Address',b'Adresse du Service'
+b'DocType: Asset Maintenance Task',b'Calibration',b'\xc3\x89talonnage'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +97',b'{0} is a company holiday',b'{0} est un jour f\xc3\xa9ri\xc3\xa9 en entreprise'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +49',b'Furnitures and Fixtures',b'Meubles et Accessoires'
+b'DocType: Item',b'Manufacture',b'Fabrication'
+b'apps/erpnext/erpnext/utilities/user_progress.py +27',b'Setup Company',b'Configurer la Soci\xc3\xa9t\xc3\xa9'
+,b'Lab Test Report',b'Rapport de test de laboratoire'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13',b'Please Delivery Note first',b'Veuillez d\xe2\x80\x99abord cr\xc3\xa9er un Bon de Livraison'
+b'DocType: Student Applicant',b'Application Date',b'Date de la Candidature'
+b'DocType: Salary Detail',b'Amount based on formula',b'Montant bas\xc3\xa9 sur la formule'
+b'DocType: Purchase Invoice',b'Currency and Price List',b'Devise et liste de prix'
+b'DocType: Opportunity',b'Customer / Lead Name',b'Nom du Client / Prospect'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +115',b'Clearance Date not mentioned',b'Date de Compensation non indiqu\xc3\xa9e'
+b'apps/erpnext/erpnext/config/manufacturing.py +7',b'Production',b'Production'
+b'DocType: Guardian',b'Occupation',b'Occupation'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +74',b'Row {0}:Start Date must be before End Date',b'Ligne {0} : La Date de D\xc3\xa9but doit \xc3\xaatre avant la Date de Fin'
+b'DocType: Crop',b'Planting Area',b'Zone de plantation'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Qty)',b'Total (Qt\xc3\xa9)'
+b'DocType: Installation Note Item',b'Installed Qty',b'Qt\xc3\xa9 Install\xc3\xa9e'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +4',b'This could be because of some invalid Email Addresses in the',b'Cela pourrait \xc3\xaatre d\xc3\xbb \xc3\xa0 certaines adresses de messagerie invalides dans le'
+b'apps/erpnext/erpnext/utilities/user_progress.py +31',b'You added ',b'Vous avez ajout\xc3\xa9'
+b'DocType: Purchase Taxes and Charges',b'Parenttype',b'Type Parent'
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +10',b'Training Result',b'R\xc3\xa9sultat de la Formation'
+b'DocType: Purchase Invoice',b'Is Paid',b'Est Pay\xc3\xa9'
+b'DocType: Salary Structure',b'Total Earning',b'Total Revenus'
+b'DocType: Purchase Receipt',b'Time at which materials were received',b'Heure \xc3\xa0 laquelle les mat\xc3\xa9riaux ont \xc3\xa9t\xc3\xa9 re\xc3\xa7us'
+b'DocType: Products Settings',b'Products per Page',b'Produits par page'
+b'DocType: Stock Ledger Entry',b'Outgoing Rate',b'Taux Sortant'
+b'apps/erpnext/erpnext/config/hr.py +233',b'Organization branch master.',b'Organisation principale des branches.'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +313',b' or ',b'ou'
+b'DocType: Sales Order',b'Billing Status',b'Statut de la Facturation'
+b'apps/erpnext/erpnext/public/js/conf.js +32',b'Report an Issue',b'Signaler un Probl\xc3\xa8me'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120',b'Utility Expenses',"b""Frais de Services d'Utilit\xc3\xa9 Publique"""
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +64',b'90-Above',b'90-Dessus'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +252',b'Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher',"b""Ligne #{0} : L\xe2\x80\x99\xc3\x89criture de Journal {1} n'a pas le compte {2} ou est d\xc3\xa9j\xc3\xa0 r\xc3\xa9concili\xc3\xa9e avec une autre r\xc3\xa9f\xc3\xa9rence"""
+b'DocType: Supplier Scorecard Criteria',b'Criteria Weight',b'Pond\xc3\xa9ration du Crit\xc3\xa8re'
+b'DocType: Buying Settings',b'Default Buying Price List',"b""Liste des Prix d'Achat par D\xc3\xa9faut"""
+b'DocType: Payroll Entry',b'Salary Slip Based on Timesheet',b'Fiche de Paie bas\xc3\xa9e sur la Feuille de Temps'
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +43',b'Buying Rate',"b""Prix d'achat"""
+b'DocType: Notification Control',b'Sales Order Message',b'Message de la Commande Client'
+b'apps/erpnext/erpnext/config/setup.py +15',"b'Set Default Values like Company, Currency, Current Fiscal Year, etc.'","b'D\xc3\xa9finir les Valeurs par D\xc3\xa9faut comme : Societ\xc3\xa9, Devise, Exercice Actuel, etc...'"
+b'DocType: Payment Entry',b'Payment Type',b'Type de Paiement'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +240',b'Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement',"b""Veuillez s\xc3\xa9lectionner un Lot pour l'Article {0}. Impossible de trouver un seul lot satisfaisant \xc3\xa0 cette exigence"""
+b'DocType: Hub Category',b'Parent Category',b'Cat\xc3\xa9gorie Parente'
+b'DocType: Payroll Entry',b'Select Employees',b'S\xc3\xa9lectionner les Employ\xc3\xa9s'
+b'DocType: Opportunity',b'Potential Sales Deal',b'Ventes Potentielles'
+b'DocType: Complaint',b'Complaints',b'Plaintes'
+b'DocType: Payment Entry',b'Cheque/Reference Date',b'Ch\xc3\xa8que/Date de R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Purchase Invoice',b'Total Taxes and Charges',b'Total des Taxes et Frais'
+b'DocType: Employee',b'Emergency Contact',"b""Contact en cas d'Urgence"""
+b'DocType: Bank Reconciliation Detail',b'Payment Entry',b'\xc3\x89criture de Paiement'
+,b'sales-browser',b'navigateur-ventes'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +79',b'Ledger',b'Livre'
+b'DocType: Patient Medical Record',b'PMR-',b'PMR-'
+b'DocType: Drug Prescription',b'Drug Code',b'Code du M\xc3\xa9dicament'
+b'DocType: Target Detail',b'Target  Amount',b'Montant Cible'
+b'DocType: POS Profile',b'Print Format for Online',"b""Format d'Impression en Ligne"""
+b'DocType: Shopping Cart Settings',b'Shopping Cart Settings',b'Param\xc3\xa8tres du Panier'
+b'DocType: Journal Entry',b'Accounting Entries',b'\xc3\x89critures Comptables'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +17',"b""If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.""","b'Si la r\xc3\xa8gle de tarification s\xc3\xa9lectionn\xc3\xa9e est d\xc3\xa9finie pour \xc2\xabTaux\xc2\xbb, elle \xc3\xa9crase la liste de prix. Le taux de la r\xc3\xa8gle de tarification est le taux final, donc aucune autre r\xc3\xa9duction ne doit \xc3\xaatre appliqu\xc3\xa9e. Par cons\xc3\xa9quent, dans les transactions telles que la commande client, la commande d&#39;achat, etc., elle sera r\xc3\xa9cup\xc3\xa9r\xc3\xa9e dans le champ &quot;Taux&quot;, plut\xc3\xb4t que dans le champ &quot;Tarif liste de prix&quot;.'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24',b'Duplicate Entry. Please check Authorization Rule {0}',b'\xc3\x89criture en double. Merci de v\xc3\xa9rifier la R\xc3\xa8gle d\xe2\x80\x99Autorisation {0}'
+b'DocType: Journal Entry Account',b'Reference Due Date',b'Date d&#39;\xc3\xa9ch\xc3\xa9ance de r\xc3\xa9f\xc3\xa9rence'
+b'DocType: Purchase Order',b'Ref SQ',b'R\xc3\xa9f SQ'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55',b'Receipt document must be submitted',b'Le re\xc3\xa7u doit \xc3\xaatre soumis'
+b'DocType: Purchase Invoice Item',b'Received Qty',b'Qt\xc3\xa9 Re\xc3\xa7ue'
+b'DocType: Stock Entry Detail',b'Serial No / Batch',b'N\xc2\xb0 de S\xc3\xa9rie / Lot'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +340',b'Not Paid and Not Delivered',b'Non Pay\xc3\xa9 et Non Livr\xc3\xa9'
+b'DocType: Product Bundle',b'Parent Item',b'Article Parent'
+b'DocType: Account',b'Account Type',b'Type de Compte'
+b'DocType: Delivery Note',b'DN-RET-',b'DN-RET-'
+b'apps/erpnext/erpnext/templates/pages/projects.html +58',b'No time sheets',b'Aucunes feuilles de temps'
+b'DocType: GoCardless Mandate',b'GoCardless Customer',b'Client GoCardless'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +123',b'Leave Type {0} cannot be carry-forwarded',b'Le Type de Cong\xc3\xa9 {0} ne peut pas \xc3\xaatre report\xc3\xa9'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +215',"b""Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule'""","b""L'\xc3\x89ch\xc3\xa9ancier d'Entretien n'est pas cr\xc3\xa9\xc3\xa9 pour tous les articles. Veuillez clicker sur 'Cr\xc3\xa9er un \xc3\x89ch\xc3\xa9ancier'"""
+,b'To Produce',b'\xc3\x80 Produire'
+b'apps/erpnext/erpnext/config/hr.py +93',b'Payroll',b'Paie'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +196',"b'For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included'","b""Pour la ligne {0} dans {1}. Pour inclure {2} dans le prix de l'Article, les lignes {3} doivent \xc3\xa9galement \xc3\xaatre incluses"""
+b'DocType: Patient Service Unit',b'Parent Service Unit',b'Unit\xc3\xa9 de service parentale'
+b'apps/erpnext/erpnext/utilities/activation.py +101',b'Make User',b'Cr\xc3\xa9er un Utilisateur'
+b'DocType: Packing Slip',b'Identification of the package for the delivery (for print)',"b""Identification de l'emballage pour la livraison (pour l'impression)"""
+b'DocType: Bin',b'Reserved Quantity',b'Quantit\xc3\xa9 R\xc3\xa9serv\xc3\xa9e'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +34',b'Please enter valid email address',b'Entrez une adresse email valide'
+b'DocType: Volunteer Skill',b'Volunteer Skill',b'Comp\xc3\xa9tence b\xc3\xa9n\xc3\xa9vole'
+b'DocType: Bank Reconciliation',b'Include POS Transactions',b'Inclure les transactions POS'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +784',b'Please select an item in the cart',b'Veuillez s\xc3\xa9lectionner un article dans le panier'
+b'DocType: Landed Cost Voucher',b'Purchase Receipt Items',b'Articles du Re\xc3\xa7u d\xe2\x80\x99Achat'
+b'apps/erpnext/erpnext/config/learn.py +21',b'Customizing Forms',b'Personnalisation des Formulaires'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +74',b'Arrear',b'Arri\xc3\xa9r\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +158',b'Depreciation Amount during the period',"b""Montant d'Amortissement au cours de la p\xc3\xa9riode"""
+b'apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py +43',b'Disabled template must not be default template',b'Un Mod\xc3\xa8le D\xc3\xa9sactiv\xc3\xa9 ne doit pas \xc3\xaatre un Mod\xc3\xa8le par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +314',b'For row {0}: Enter planned qty',b'Pour la ligne {0}: entrez la quantit\xc3\xa9 planifi\xc3\xa9e'
+b'DocType: Shareholder',b'SH-',b'SH-'
+b'DocType: Account',b'Income Account',b'Compte de Produits'
+b'DocType: Payment Request',"b""Amount in customer's currency""",b'Montant dans la devise du client'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +825',b'Delivery',b'Livraison'
+b'DocType: Volunteer',b'Weekdays',b'Jours de la semaine'
+b'DocType: Stock Reconciliation Item',b'Current Qty',b'Qt\xc3\xa9 Actuelle'
+b'DocType: Restaurant Menu',b'Restaurant Menu',b'Le menu du restaurant'
+b'apps/erpnext/erpnext/templates/generators/item_group.html +36',b'Prev',b'Pr\xc3\xa9c\xc3\xa9dent'
+b'DocType: Appraisal Goal',b'Key Responsibility Area',b'Domaine de Responsabilit\xc3\xa9s Principal'
+b'apps/erpnext/erpnext/utilities/activation.py +127',"b'Student Batches help you track attendance, assessments and fees for students'","b""Les Lots d'\xc3\x89tudiants vous aide \xc3\xa0 suivre la pr\xc3\xa9sence, les \xc3\xa9valuations et les frais pour les \xc3\xa9tudiants"""
+b'DocType: Payment Entry',b'Total Allocated Amount',b'Montant Total Allou\xc3\xa9'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +151',b'Set default inventory account for perpetual inventory',"b""Configurer le compte d'inventaire par d\xc3\xa9faut pour l'inventaire perp\xc3\xa9tuel"""
+b'DocType: Item Reorder',b'Material Request Type',b'Type de Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +252',b'Accural Journal Entry for salaries from {0} to {1}',"b""Accumulation des Journaux d'\xc3\x89critures pour les salaires de {0} \xc3\xa0 {1}"""
+b'apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js +17',b'Send Grant Review Email',b'Envoyer un avis de demande de subvention'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +848',"b'LocalStorage is full, did not save'","b'Le Stockage Local est plein, sauvegarde impossible'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +100',b'Row {0}: UOM Conversion Factor is mandatory',b'Ligne {0} : Facteur de Conversion LDM est obligatoire'
+b'apps/erpnext/erpnext/utilities/user_progress.py +235',b'Room Capacity',b'Capacit\xc3\xa9 de la Salle'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +95',b'Ref',b'R\xc3\xa9f'
+b'DocType: Lab Test',b'LP-',b'LP-'
+b'DocType: Healthcare Settings',b'Registration Fee',"b""Frais d'Inscription"""
+b'DocType: Budget',b'Cost Center',b'Centre de Co\xc3\xbbts'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +45',b'Voucher #',b'R\xc3\xa9f\xc3\xa9rence #'
+b'DocType: Notification Control',b'Purchase Order Message',b'Message du Bon de Commande'
+b'DocType: Tax Rule',b'Shipping Country',b'Pays de Livraison'
+b'DocType: Selling Settings',"b""Hide Customer's Tax Id from Sales Transactions""",b'Cacher le N\xc2\xb0 de TVA du Client des Transactions de Vente'
+b'DocType: Upload Attendance',b'Upload HTML',b'Charger HTML'
+b'DocType: Employee',b'Relieving Date',b'Date de Rel\xc3\xa8ve'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +14',"b'Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.'","b'La R\xc3\xa8gle de Tarification est faite pour remplacer la Liste de Prix / d\xc3\xa9finir le pourcentage de remise, sur la base de certains crit\xc3\xa8res.'"
+b'DocType: Serial No',b'Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt',"b""L'entrep\xc3\xb4t ne peut \xc3\xaatre modifi\xc3\xa9 que via \xc3\x89criture de Stock / Bon de Livraison / Re\xc3\xa7u d'Achat"""
+b'DocType: Employee Education',b'Class / Percentage',b'Classe / Pourcentage'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +134',b'Head of Marketing and Sales',b'Responsable du Marketing et des Ventes'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +72',b'Income Tax',b'Imp\xc3\xb4t sur le Revenu'
+b'apps/erpnext/erpnext/config/selling.py +174',b'Track Leads by Industry Type.',"b""Suivre les Prospects par Type d'Industrie"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +101',b'Go to Letterheads',b'Aller aux papiers \xc3\xa0 en-t\xc3\xaate'
+b'DocType: Item Supplier',b'Item Supplier',"b""Fournisseur de l'Article"""
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1255',b'Please enter Item Code to get batch no',"b""Veuillez entrer le Code d'Article pour obtenir n\xc2\xb0 de lot"""
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +880',b'Please select a value for {0} quotation_to {1}',b'Veuillez s\xc3\xa9lectionner une valeur pour {0} devis \xc3\xa0 {1}'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +419',b'No Items selected for transfer',b'Aucun \xc3\xa9l\xc3\xa9ment s\xc3\xa9lectionn\xc3\xa9 pour le transfert'
+b'apps/erpnext/erpnext/config/selling.py +46',b'All Addresses.',b'Toutes les Adresses.'
+b'DocType: Company',b'Stock Settings',b'R\xc3\xa9glages de Stock'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +183',"b'Merging is only possible if following properties are same in both records. Is Group, Root Type, Company'","b'La combinaison est possible seulement si les propri\xc3\xa9t\xc3\xa9s suivantes sont les m\xc3\xaames dans les deux dossiers. Est Groupe, Type de Racine, Soci\xc3\xa9t\xc3\xa9'"
+b'DocType: Vehicle',b'Electric',b'\xc3\x89lectrique'
+b'DocType: Task',b'% Progress',b'% de Progression'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +123',b'Gain/Loss on Asset Disposal',b'Gain/Perte sur Cessions des Immobilisations'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +117',b'Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.',"b""Le num\xc3\xa9ro de compte du compte {0} n'est pas disponible. <br> Veuillez configurer votre plan de comptes correctement."""
+b'DocType: Task',b'Depends on Tasks',b'D\xc3\xa9pend des T\xc3\xa2ches'
+b'apps/erpnext/erpnext/config/selling.py +36',b'Manage Customer Group Tree.',"b""G\xc3\xa9rer l'Arborescence des Groupes de Clients."""
+b'DocType: Shopping Cart Settings',b'Attachments can be shown without enabling the shopping cart',b'Les pi\xc3\xa8ces jointes peuvent \xc3\xaatre affich\xc3\xa9es sans autoriser le panier'
+b'DocType: Normal Test Items',b'Result Value',b'Valeur de R\xc3\xa9sultat'
+b'DocType: Hotel Room',b'Hotels',b'H\xc3\xb4tels'
+b'DocType: Supplier Quotation',b'SQTN-',b'SQTN-'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +22',b'New Cost Center Name',b'Nom du Nouveau Centre de Co\xc3\xbbts'
+b'DocType: Leave Control Panel',b'Leave Control Panel',b'Quitter le Panneau de Configuration'
+b'DocType: Project',b'Task Completion',b'Ach\xc3\xa8vement de la T\xc3\xa2che'
+b'apps/erpnext/erpnext/templates/includes/product_page.js +22',b'Not in Stock',b'En Rupture de Stock'
+b'DocType: Volunteer',b'Volunteer Skills',b'Comp\xc3\xa9tences b\xc3\xa9n\xc3\xa9voles'
+b'DocType: Appraisal',b'HR User',b'Charg\xc3\xa9 RH'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted',b'Taxes et Frais D\xc3\xa9ductibles'
+b'apps/erpnext/erpnext/hooks.py +142',b'Issues',b'Questions'
+b'apps/erpnext/erpnext/controllers/status_updater.py +12',b'Status must be one of {0}',"b""Le statut doit \xc3\xaatre l'un des {0}"""
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +64',b'Reminder to update GSTIN Sent',b'Rappel pour mettre \xc3\xa0 jour GSTIN Sent'
+b'DocType: Sales Invoice',b'Debit To',b'D\xc3\xa9bit Pour'
+b'DocType: Restaurant Menu Item',b'Restaurant Menu Item',b'\xc3\x89l\xc3\xa9ment de menu du restaurant'
+b'DocType: Delivery Note',b'Required only for sample item.',b'Requis uniquement pour les \xc3\xa9chantillons.'
+b'DocType: Stock Ledger Entry',b'Actual Qty After Transaction',b'Qt\xc3\xa9 R\xc3\xa9elle Apr\xc3\xa8s Transaction'
+,b'Pending SO Items For Purchase Request',"b""Articles de Commande Client en Attente Pour la Demande d'Achat"""
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +35',b'Student Admissions',b'Admissions des \xc3\x89tudiants'
+b'apps/erpnext/erpnext/accounts/party.py +388',b'{0} {1} is disabled',b'{0} {1} est d\xc3\xa9sactiv\xc3\xa9'
+b'DocType: Supplier',b'Billing Currency',b'Devise de Facturation'
+b'DocType: Sales Invoice',b'SINV-RET-',b'SINV-RET-'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +200',b'Extra Large',b'Extra Large'
+b'DocType: Crop',b'Scientific Name',b'Nom scientifique'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Leaves',b'Total des Cong\xc3\xa9s'
+b'DocType: Customer',"b'Reselect, if the chosen contact is edited after save'","b'Res\xc3\xa9lectionner, si le contact choisi est \xc3\xa9dit\xc3\xa9 apr\xc3\xa8s sauvegarde'"
+b'DocType: Consultation',b'In print',b'Sur impression'
+,b'Profit and Loss Statement',b'Compte de R\xc3\xa9sultat'
+b'DocType: Bank Reconciliation Detail',b'Cheque Number',b'Num\xc3\xa9ro de Ch\xc3\xa8que'
+,b'Sales Browser',b'Navigateur des Ventes'
+b'DocType: Journal Entry',b'Total Credit',b'Total Cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +542',b'Warning: Another {0} # {1} exists against stock entry {2}',"b""Attention : Un autre {0} {1} # existe pour l'\xc3\xa9criture de stock {2}"""
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +66',b'Local',b'Locale'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26',b'Loans and Advances (Assets)',b'Pr\xc3\xaats et Avances (Actif)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12',b'Debtors',b'D\xc3\xa9biteurs'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +199',b'Large',b'Grand'
+b'DocType: Homepage Featured Product',b'Homepage Featured Product',"b""Produit Pr\xc3\xa9sent\xc3\xa9 sur la Page d'Accueil"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +248',b'All Assessment Groups',"b""Tous les Groupes d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +15',b'New Warehouse Name',"b""Nouveau Nom d'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +259',b'Total {0} ({1})',b'Total {0} ({1})'
+b'DocType: C-Form Invoice Detail',b'Territory',b'R\xc3\xa9gion'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +151',b'Please mention no of visits required',b'Veuillez indiquer le nb de visites requises'
+b'DocType: Stock Settings',b'Default Valuation Method',b'M\xc3\xa9thode de Valorisation par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +26',b'Fee',b'Frais'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +154',b'Update in progress. It might take a while.',b'Mise \xc3\xa0 jour en cours. \xc3\x87a peut prendre un moment.'
+b'DocType: Production Plan Item',b'Produced Qty',b'Quantit\xc3\xa9 produite'
+b'DocType: Vehicle Log',b'Fuel Qty',b'Qt\xc3\xa9 Carburant'
+b'DocType: Stock Entry',b'Target Warehouse Name',b'Nom de l&#39;entrep\xc3\xb4t cible'
+b'DocType: Work Order Operation',b'Planned Start Time',b'Heure de D\xc3\xa9but Pr\xc3\xa9vue'
+b'DocType: Course',b'Assessment',b'\xc3\x89valuation'
+b'DocType: Payment Entry Reference',b'Allocated',b'Allou\xc3\xa9'
+b'apps/erpnext/erpnext/config/accounts.py +267',b'Close Balance Sheet and book Profit or Loss.',b'Cl\xc3\xb4turer Bilan et Compte de R\xc3\xa9sultats.'
+b'DocType: Student Applicant',b'Application Status',b'\xc3\x89tat de la Demande'
+b'DocType: Sensitivity Test Items',b'Sensitivity Test Items',b'Articles de test de sensibilit\xc3\xa9'
+b'DocType: Project Update',b'Project Update',b'Mise \xc3\xa0 jour'
+b'DocType: Fees',b'Fees',b'Honoraires'
+b'DocType: Currency Exchange',b'Specify Exchange Rate to convert one currency into another',b'Sp\xc3\xa9cifier le Taux de Change pour convertir une monnaie en une autre'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +159',b'Quotation {0} is cancelled',b'Devis {0} est annul\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +119',b'Total Outstanding Amount',b'Encours Total'
+b'DocType: Sales Partner',b'Targets',b'Cibles'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js +54',b'Please register the SIREN number in the company information file',b'Veuillez enregistrer le num\xc3\xa9ro SIREN dans le fichier d&#39;information de l&#39;entreprise'
+b'DocType: Price List',b'Price List Master',b'Donn\xc3\xa9es de Base des Listes de Prix'
+b'DocType: GST Account',b'CESS Account',b'Compte CESS'
+b'DocType: Sales Person',b'All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.',b'Toutes les Transactions de Vente peuvent \xc3\xaatre assign\xc3\xa9es \xc3\xa0 plusieurs **Commerciaux** pour configurer et surveiller les objectifs.'
+,b'S.O. No.',b'S.O. N\xc2\xb0.'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +241',b'Please create Customer from Lead {0}',b'Veuillez cr\xc3\xa9er un Client \xc3\xa0 partir du Prospect {0}'
+b'apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html +3',b'Select Patient',b'S\xc3\xa9lectionnez le Patient'
+b'DocType: Price List',b'Applicable for Countries',b'Applicable pour les Pays'
+b'DocType: Supplier Scorecard Scoring Variable',b'Parameter Name',b'Nom du Param\xc3\xa8tre'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +52',b'Student Group Name is mandatory in row {0}',"b""Nom du Groupe d'\xc3\x89tudiant est obligatoire dans la ligne {0}"""
+b'DocType: Homepage',b'Products to be shown on website homepage',b'Produits destin\xc3\xa9s \xc3\xa0 \xc3\xaatre affich\xc3\xa9s sur la page d\xe2\x80\x99accueil du site web'
+b'apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +13',b'This is a root customer group and cannot be edited.',b'C\xe2\x80\x99est un groupe de clients racine qui ne peut \xc3\xaatre modifi\xc3\xa9.'
+b'DocType: Student',b'AB-',b'AB-'
+b'DocType: POS Profile',b'Ignore Pricing Rule',b'Ignorez R\xc3\xa8gle de Prix'
+b'DocType: Employee Education',b'Graduate',b'Dipl\xc3\xb4m\xc3\xa9'
+b'DocType: Leave Block List',b'Block Days',b'Bloquer les Jours'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +83',"b'Shipping Address does not have country, which is required for this Shipping Rule'","b'L&#39;adresse de livraison n&#39;a pas de pays, ce qui est requis pour cette r\xc3\xa8gle d&#39;exp\xc3\xa9dition'"
+b'DocType: Journal Entry',b'Excise Entry',"b""\xc3\x89criture d'Accise"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +65',"b""Warning: Sales Order {0} already exists against Customer's Purchase Order {1}""",b'Attention : La Commande Client {0} existe d\xc3\xa9j\xc3\xa0 pour le Bon de Commande du Client {1}'
+b'DocType: Terms and Conditions',"b'Standard Terms and Conditions that can be added to Sales and Purchases.\n\nExamples:\n\n1. Validity of the offer.\n1. Payment Terms (In Advance, On Credit, part advance etc).\n1. What is extra (or payable by the Customer).\n1. Safety / usage warning.\n1. Warranty if any.\n1. Returns Policy.\n1. Terms of shipping, if applicable.\n1. Ways of addressing disputes, indemnity, liability, etc.\n1. Address and Contact of your Company.'","b""Termes et Conditions Standard qui peuvent \xc3\xaatre ajout\xc3\xa9s aux Ventes et Achats.\n\nExemples : \n\n1. Validit\xc3\xa9 de l'offre.\n2. Conditions de paiement (\xc3\x80 l'Avance, \xc3\x80 Cr\xc3\xa9dit, une partie en avance, etc).\n3. Qu'est-ce qui est en suppl\xc3\xa9ment (ou \xc3\xa0 payer par le Client).\n3. Avertissement d'utilisation / de s\xc3\xa9curit\xc3\xa9.\n4. Garantie, le cas \xc3\xa9ch\xc3\xa9ant.\n5. Politique de Retour.\n6. Conditions de Livraison, le cas \xc3\xa9ch\xc3\xa9ant.\n7. R\xc3\xa8glement des litiges, indemnisation, responsabilit\xc3\xa9, etc. \n8. Adresse et Contact de votre Soci\xc3\xa9t\xc3\xa9."""
+b'DocType: Issue',b'Issue Type',b'type de probleme'
+b'DocType: Attendance',b'Leave Type',b'Type de Cong\xc3\xa9'
+b'DocType: Purchase Invoice',b'Supplier Invoice Details',b'D\xc3\xa9tails de la Facture du Fournisseur'
+b'DocType: Agriculture Task',b'Ignore holidays',b'Ignorer les vacances'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +233',"b""Expense / Difference account ({0}) must be a 'Profit or Loss' account""","b""Compte de Charge / d'\xc3\x89cart ({0}) doit \xc3\xaatre un Compte \xc2\xabde R\xc3\xa9sultat\xc2\xbb"""
+b'DocType: Project',b'Copied From',b'Copi\xc3\xa9 Depuis'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +340',b'Invoice already created for all billing hours',b'Facture d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9e pour toutes les heures de facturation'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +96',b'Name error: {0}',b'Erreur de Nom: {0}'
+b'DocType: Cash Flow Mapping',b'Is Finance Cost',b'Le co\xc3\xbbt financier'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18',b'Attendance for employee {0} is already marked',"b""La pr\xc3\xa9sence de l'employ\xc3\xa9 {0} est d\xc3\xa9j\xc3\xa0 marqu\xc3\xa9e"""
+b'DocType: Packing Slip',b'If more than one package of the same type (for print)',"b""Si plus d'un paquet du m\xc3\xaame type (pour l'impression)"""
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +27',b'Please set default customer in Restaurant Settings',b'Veuillez d\xc3\xa9finir le client par d\xc3\xa9faut dans les param\xc3\xa8tres du restaurant'
+,b'Salary Register',b'Registre du Salaire'
+b'DocType: Warehouse',b'Parent Warehouse',b'Entrep\xc3\xb4t Parent'
+b'DocType: C-Form Invoice Detail',b'Net Total',b'Total Net'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +546',b'Default BOM not found for Item {0} and Project {1}',"b""La LDM par d\xc3\xa9faut n'a pas \xc3\xa9t\xc3\xa9 trouv\xc3\xa9e pour l'Article {0} et le Projet {1}"""
+b'apps/erpnext/erpnext/config/hr.py +168',b'Define various loan types',b'D\xc3\xa9finir diff\xc3\xa9rents types de pr\xc3\xaats'
+b'DocType: Bin',b'FCFS Rate',b'Montant PAPS'
+b'DocType: Opening Invoice Creation Tool Item',b'Outstanding Amount',b'Montant d\xc3\xbb'
+b'apps/erpnext/erpnext/templates/generators/bom.html +71',b'Time(in mins)',b'Temps (en min)'
+b'DocType: Project Task',b'Working',b'Travail en cours'
+b'DocType: Stock Ledger Entry',b'Stock Queue (FIFO)',"b""File d'Attente du Stock (FIFO)"""
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +127',b'Financial Year',b'Exercice Financier'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +46',b'{0} does not belong to Company {1}',"b""{0} n'appartient pas \xc3\xa0 la Soci\xc3\xa9t\xc3\xa9 {1}"""
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +66',b'Could not solve criteria score function for {0}. Make sure the formula is valid.',b'Impossible de r\xc3\xa9soudre la fonction de score de crit\xc3\xa8res pour {0}. Assurez-vous que la formule est valide.'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +122',b'Cost as on',b'Co\xc3\xbbt \xc3\xa0 partir de'
+b'DocType: Healthcare Settings',b'Out Patient Settings',b'Param\xc3\xa8tres de Patients Externes'
+b'DocType: Account',b'Round Off',b'Arrondi'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +259',b'Quantity must be positive',b'La quantit\xc3\xa9 doit \xc3\xaatre positive'
+b'DocType: Material Request Plan Item',b'Requested Qty',b'Qt\xc3\xa9 Demand\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +96',b'The fields From Shareholder and To Shareholder cannot be blank',b'Les champs De l&#39;actionnaire et de l&#39;actionnaire ne peuvent pas \xc3\xaatre vides'
+b'DocType: Tax Rule',b'Use for Shopping Cart',b'Utiliser pour le Panier'
+b'apps/erpnext/erpnext/controllers/item_variant.py +101',b'Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2}',"b""La Valeur {0} pour l'Attribut {1} n'existe pas dans la liste des Valeurs d'Attribut d\xe2\x80\x99Article valides pour l\xe2\x80\x99Article {2}"""
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +79',b'Select Serial Numbers',b'S\xc3\xa9lectionnez les Num\xc3\xa9ros de S\xc3\xa9rie'
+b'DocType: BOM Item',b'Scrap %',b'% de Rebut'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +46',"b'Charges will be distributed proportionately based on item qty or amount, as per your selection'","b""Les frais seront distribu\xc3\xa9s proportionnellement \xc3\xa0 la qt\xc3\xa9 ou au montant de l'article, selon votre s\xc3\xa9lection"""
+b'DocType: Maintenance Visit',b'Purposes',b'Objets'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +112',b'Atleast one item should be entered with negative quantity in return document',b'Au moins un article doit \xc3\xaatre saisi avec quantit\xc3\xa9 n\xc3\xa9gative dans le document de retour'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +71',"b'Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations'","b""Op\xc3\xa9ration {0} plus longue que toute heure de travail disponible dans le poste {1}, s\xc3\xa9parer l'op\xc3\xa9ration en plusieurs op\xc3\xa9rations"""
+b'DocType: Membership',b'Membership Status',b'Statut d&#39;adh\xc3\xa9sion'
+,b'Requested',b'Demand\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +93',b'No Remarks',b'Aucune Remarque'
+b'DocType: Asset',b'In Maintenance',b'En maintenance'
+b'DocType: Purchase Invoice',b'Overdue',b'En Retard'
+b'DocType: Account',b'Stock Received But Not Billed',b'Stock Re\xc3\xa7us Mais Non Factur\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +84',b'Root Account must be a group',b'Le Compte Racine doit \xc3\xaatre un groupe'
+b'DocType: Drug Prescription',b'Drug Prescription',b'Prescription M\xc3\xa9dicale'
+b'DocType: Fees',b'FEE.',b'HONORAIRES.'
+b'DocType: Employee Loan',b'Repaid/Closed',b'Rembours\xc3\xa9 / Ferm\xc3\xa9'
+b'DocType: Item',b'Total Projected Qty',b'Qt\xc3\xa9 Totale Pr\xc3\xa9vue'
+b'DocType: Monthly Distribution',b'Distribution Name',b'Nom de Distribution'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +477',"b'Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry'","b'Le taux de valorisation n&#39;a pas \xc3\xa9t\xc3\xa9 trouv\xc3\xa9 pour l&#39;\xc3\xa9l\xc3\xa9ment {0}, qui est requis pour faire des \xc3\xa9critures comptables pour {1} {2}. Si l&#39;article traite comme un \xc3\xa9l\xc3\xa9ment de taux de valorisation nulle dans le {1}, mentionnez-le dans la {1} table d&#39;\xc3\xa9l\xc3\xa9ments. Sinon, cr\xc3\xa9ez une transaction de stock entrant pour l&#39;\xc3\xa9l\xc3\xa9ment ou mentionnez le taux d&#39;\xc3\xa9valuation dans l&#39;enregistrement de l&#39;\xc3\xa9l\xc3\xa9ment, puis essayez de soumettre / annuler cette entr\xc3\xa9e'"
+b'DocType: Course',b'Course Code',b'Code de Cours'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +337',b'Quality Inspection required for Item {0}',"b""Inspection de la Qualit\xc3\xa9 requise pour l'Article {0}"""
+b'DocType: POS Settings',b'Use POS in Offline Mode',b'Utiliser PDV en Mode Hors-Ligne'
+b'DocType: Supplier Scorecard',b'Supplier Variables',b'Variables Fournisseur'
+b'DocType: Quotation',"b""Rate at which customer's currency is converted to company's base currency""",b'Taux auquel la devise client est convertie en devise client de base'
+b'DocType: Purchase Invoice Item',b'Net Rate (Company Currency)',b'Taux Net (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Salary Detail',b'Condition and Formula Help',b'Aide Condition et Formule'
+b'apps/erpnext/erpnext/config/selling.py +105',b'Manage Territory Tree.',b'G\xc3\xa9rer l\xe2\x80\x99Arborescence des R\xc3\xa9gions.'
+b'DocType: Patient Service Unit',b'Patient Service Unit',b'Unit\xc3\xa9 de service aux patients'
+b'DocType: Journal Entry Account',b'Sales Invoice',b'Facture de Vente'
+b'DocType: Journal Entry Account',b'Party Balance',b'Solde du Tiers'
+b'DocType: Cash Flow Mapper',b'Section Subtotal',b'Sous-total de la section'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +498',b'Please select Apply Discount On',b'Veuillez s\xc3\xa9lectionnez Appliquer Remise Sur'
+b'DocType: Stock Settings',b'Sample Retention Warehouse',b'Exemple d&#39;entrep\xc3\xb4t de r\xc3\xa9tention'
+b'DocType: Company',b'Default Receivable Account',b'Compte Client par D\xc3\xa9faut'
+b'DocType: Physician Schedule',b'Physician Schedule',b'Calendrier du M\xc3\xa9decin'
+b'DocType: Purchase Invoice',b'Deemed Export',b'Export Estim\xc3\xa9'
+b'DocType: Stock Entry',b'Material Transfer for Manufacture',b'Transfert de Mat\xc3\xa9riel pour la Fabrication'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +20',b'Discount Percentage can be applied either against a Price List or for all Price List.',b'Pourcentage de R\xc3\xa9duction peut \xc3\xaatre appliqu\xc3\xa9 pour une liste de prix en particulier ou pour toutes les listes de prix.'
+b'DocType: Subscription',b'Half-yearly',b'Semestriel'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +407',b'Accounting Entry for Stock',b'\xc3\x89criture Comptable pour Stock'
+b'DocType: Lab Test',b'LabTest Approver',b'Approbateur de test de laboratoire'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +61',b'You have already assessed for the assessment criteria {}.',b'Vous avez d\xc3\xa9j\xc3\xa0 \xc3\xa9valu\xc3\xa9 les crit\xc3\xa8res d&#39;\xc3\xa9valuation {}.'
+b'DocType: Vehicle Service',b'Engine Oil',b'Huile Moteur'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1005',b'Work Orders Created: {0}',b'Ordres de travail cr\xc3\xa9\xc3\xa9s: {0}'
+b'DocType: Sales Invoice',b'Sales Team1',b'\xc3\x89quipe des Ventes 1'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +547',b'Item {0} does not exist',"b""Article {0} n'existe pas"""
+b'DocType: Sales Invoice',b'Customer Address',b'Adresse du Client'
+b'DocType: Employee Loan',b'Loan Details',b'D\xc3\xa9tails du Pr\xc3\xaat'
+b'DocType: Company',b'Default Inventory Account',"b""Compte d'Inventaire par D\xc3\xa9faut"""
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +192',b'The folio numbers are not matching',b'Les num\xc3\xa9ros de folio ne correspondent pas'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +124',b'Row {0}: Completed Qty must be greater than zero.',b'Ligne {0} : Qt\xc3\xa9 Compl\xc3\xa9t\xc3\xa9e doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 z\xc3\xa9ro.'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +262',b'Payment Request for {0}',b'Demande de paiement pour {0}'
+b'DocType: Item Barcode',b'Barcode Type',b'Type de code \xc3\xa0 barres'
+b'DocType: Antibiotic',b'Antibiotic Name',"b""Nom de l'Antibiotique"""
+b'DocType: Purchase Invoice',b'Apply Additional Discount On',b'Appliquer une Remise Suppl\xc3\xa9mentaire Sur'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +66',b'Select Type...',b'S\xc3\xa9lectionner le Type...'
+b'DocType: Crop Cycle',b'A link to all the Land Units in which the Crop is growing',b'Un lien vers toutes les parcelles dans lesquelles la culture se d\xc3\xa9veloppe'
+b'DocType: Account',b'Root Type',b'Type de Racine'
+b'DocType: Item',b'FIFO',"b'FIFO (Premier entr\xc3\xa9, Premier sorti)'"
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +136',b'Row # {0}: Cannot return more than {1} for Item {2}',b'Ligne # {0} : Vous ne pouvez pas retourner plus de {1} pour l\xe2\x80\x99Article {2}'
+b'DocType: Item Group',b'Show this slideshow at the top of the page',b'Afficher ce diaporama en haut de la page'
+b'DocType: BOM',b'Item UOM',"b""UDM de l'Article"""
+b'DocType: Sales Taxes and Charges',b'Tax Amount After Discount Amount (Company Currency)',b'Montant de la Taxe Apr\xc3\xa8s Remise (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +177',b'Target warehouse is mandatory for row {0}',b'L\xe2\x80\x99Entrep\xc3\xb4t cible est obligatoire pour la ligne {0}'
+b'DocType: Cheque Print Template',b'Primary Settings',b'R\xc3\xa9glages Principaux'
+b'DocType: Purchase Invoice',b'Select Supplier Address',"b""S\xc3\xa9lectionner l'Adresse du Fournisseur"""
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +397',b'Add Employees',b'Ajouter des Employ\xc3\xa9s'
+b'DocType: Purchase Invoice Item',b'Quality Inspection',b'Inspection de la Qualit\xc3\xa9'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +196',b'Extra Small',b'Tr\xc3\xa8s Petit'
+b'DocType: Company',b'Standard Template',b'Mod\xc3\xa8le Standard'
+b'DocType: Training Event',b'Theory',b'Th\xc3\xa9orie'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +806',b'Warning: Material Requested Qty is less than Minimum Order Qty',b'Attention : La Quantit\xc3\xa9 de Mat\xc3\xa9riel Command\xc3\xa9 est inf\xc3\xa9rieure \xc3\xa0 la Qt\xc3\xa9 Minimum de Commande'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +211',b'Account {0} is frozen',b'Le compte {0} est gel\xc3\xa9'
+b'DocType: Company',b'Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.',"b""Entit\xc3\xa9 Juridique / Filiale avec un Plan de Comptes diff\xc3\xa9rent appartenant \xc3\xa0 l'Organisation."""
+b'DocType: Payment Request',b'Mute Email',b'Email Silencieux'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +29',"b'Food, Beverage & Tobacco'","b'Alimentation, Boissons et Tabac'"
+b'DocType: Account',b'Account Number',b'Num\xc3\xa9ro de compte'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +752',b'Can only make payment against unbilled {0}',"b""Le paiement n'est possible qu'avec les {0} non factur\xc3\xa9s"""
+b'apps/erpnext/erpnext/controllers/selling_controller.py +102',b'Commission rate cannot be greater than 100',b'Taux de commission ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 100'
+b'DocType: Volunteer',b'Volunteer',b'B\xc3\xa9n\xc3\xa9vole'
+b'DocType: Stock Entry',b'Subcontract',b'Sous-traiter'
+b'apps/erpnext/erpnext/public/js/utils/party.js +166',b'Please enter {0} first',b'Veuillez d\xe2\x80\x99abord entrer {0}'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py +104',b'No replies from',b'Pas de r\xc3\xa9ponse de'
+b'DocType: Work Order Operation',b'Actual End Time',b'Heure de Fin R\xc3\xa9elle'
+b'DocType: Item',b'Manufacturer Part Number',b'Num\xc3\xa9ro de Pi\xc3\xa8ce du Fabricant'
+b'DocType: Work Order Operation',b'Estimated Time and Cost',b'Dur\xc3\xa9e et Co\xc3\xbbt Estim\xc3\xa9s'
+b'DocType: Bin',b'Bin',b'Bo\xc3\xaete'
+b'DocType: Crop',b'Crop Name',b'Nom de la culture'
+b'DocType: SMS Log',b'No of Sent SMS',b'Nb de SMS Envoy\xc3\xa9s'
+b'DocType: Antibiotic',b'Healthcare Administrator',b'Administrateur de Sant\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/user_progress.py +47',b'Set a Target',b'D\xc3\xa9finissez une cible'
+b'DocType: Dosage Strength',b'Dosage Strength',b'Force du Dosage'
+b'DocType: Account',b'Expense Account',b'Compte de Charge'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +49',b'Software',b'Logiciel'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +203',b'Colour',b'Couleur'
+b'DocType: Assessment Plan Criteria',b'Assessment Plan Criteria',"b""Crit\xc3\xa8res du Plan d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +118',b'Expiry date is mandatory for selected item',b'La date d&#39;expiration est obligatoire pour l&#39;article s\xc3\xa9lectionn\xc3\xa9'
+b'DocType: Supplier Scorecard Scoring Standing',b'Prevent Purchase Orders',"b""Interdire les Bons de Commande d'Achat"""
+b'apps/erpnext/erpnext/healthcare/setup.py +258',b'Susceptible',b'Sensible'
+b'DocType: Patient Appointment',b'Scheduled',b'Pr\xc3\xa9vu'
+b'apps/erpnext/erpnext/config/buying.py +18',b'Request for quotation.',"b""Appel d'Offre"""
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js +13',"b'Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle'","b'Veuillez s\xc3\xa9lectionner un Article o\xc3\xb9 ""Est un Article Stock\xc3\xa9"" est ""Non"" et ""Est un Article \xc3\xa0 Vendre"" est ""Oui"" et il n\'y a pas d\'autre Groupe de Produits'"
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js +148',b'Select Customer',b'S\xc3\xa9lectionnez un client'
+b'DocType: Student Log',b'Academic',b'Acad\xc3\xa9mique'
+b'DocType: Patient',b'Personal and Social History',b'Ant\xc3\xa9c\xc3\xa9dents Personnels et Sociaux'
+b'apps/erpnext/erpnext/education/doctype/guardian/guardian.py +51',b'User {0} created',b'Utilisateur {0} cr\xc3\xa9\xc3\xa9'
+b'DocType: Fee Schedule',b'Fee Breakup for each student',b'R\xc3\xa9partition des Honoraires pour chaque \xc3\xa9l\xc3\xa8ve'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +541',b'Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2})',b'Avance totale ({0}) pour la Commande {1} ne peut pas \xc3\xaatre sup\xc3\xa9rieure au Total G\xc3\xa9n\xc3\xa9ral ({2})'
+b'DocType: Sales Partner',b'Select Monthly Distribution to unevenly distribute targets across months.',b'S\xc3\xa9lectionner une R\xc3\xa9partition Mensuelle afin de repartir uniform\xc3\xa9ment les objectifs sur le mois.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +78',b'Change Code',b'Modifier le Code'
+b'DocType: Purchase Invoice Item',b'Valuation Rate',b'Taux de Valorisation'
+b'DocType: Stock Reconciliation',b'SR/',b'SR/'
+b'DocType: Vehicle',b'Diesel',b'Diesel'
+b'apps/erpnext/erpnext/stock/get_item_details.py +388',b'Price List Currency not selected',b'Devise de la Liste de Prix non s\xc3\xa9lectionn\xc3\xa9e'
+b'DocType: Purchase Invoice',b'Availed ITC Cess',b'Cess ITC Cess'
+,b'Student Monthly Attendance Sheet',b'Feuille de Pr\xc3\xa9sence Mensuelle des \xc3\x89tudiants'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +96',b'Shipping rule only applicable for Selling',b'R\xc3\xa8gle d&#39;exp\xc3\xa9dition applicable uniquement pour la vente'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30',b'Project Start Date',b'Date de D\xc3\xa9but du Projet'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +23',b'Until',"b""Jusqu'\xc3\xa0"""
+b'DocType: Rename Tool',b'Rename Log',b'Journal des Renommages'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +27',b'Student Group or Course Schedule is mandatory',"b""Le Ggroupe d'\xc3\x89tudiants ou le Calendrier des Cours est obligatoire"""
+b'DocType: HR Settings',b'Maintain Billing Hours and Working Hours Same on Timesheet',b'Maintenir les Heures Facturables et les Heures de Travail sur la m\xc3\xaame Feuille de Temps'
+b'DocType: Maintenance Visit Purpose',b'Against Document No',b'Pour le Document N\xc2\xb0'
+b'DocType: BOM',b'Scrap',b'Mettre au Rebut'
+b'apps/erpnext/erpnext/utilities/user_progress.py +217',b'Go to Instructors',b'Aller aux Instructeurs'
+b'apps/erpnext/erpnext/config/selling.py +110',b'Manage Sales Partners.',b'G\xc3\xa9rer les Partenaires Commerciaux.'
+b'DocType: Quality Inspection',b'Inspection Type',"b""Type d'Inspection"""
+b'DocType: Fee Validity',b'Visited yet',b'D\xc3\xa9j\xc3\xa0 Visit\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +134',b'Warehouses with existing transaction can not be converted to group.',b'Les entrep\xc3\xb4ts avec des transactions existantes ne peuvent pas \xc3\xaatre convertis en groupe.'
+b'DocType: Assessment Result Tool',b'Result HTML',b'R\xc3\xa9sultat HTML'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +35',b'Expires On',b'Expire Le'
+b'apps/erpnext/erpnext/utilities/activation.py +117',b'Add Students',b'Ajouter des \xc3\x89tudiants'
+b'apps/erpnext/erpnext/public/js/utils.js +270',b'Please select {0}',b'Veuillez s\xc3\xa9lectionner {0}'
+b'DocType: C-Form',b'C-Form No',b'Formulaire-C N\xc2\xba'
+b'DocType: BOM',b'Exploded_items',b'Articles-\xc3\xa9clat\xc3\xa9s'
+b'apps/erpnext/erpnext/utilities/user_progress.py +139',b'List your products or services that you buy or sell.',b'Listez les produits ou services que vous achetez ou vendez.'
+b'DocType: Water Analysis',b'Storage Temperature',b'Temp\xc3\xa9rature de stockage'
+b'DocType: Employee Attendance Tool',b'Unmarked Attendance',b'Participation Non Marqu\xc3\xa9e'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +137',b'Researcher',b'Chercheur'
+b'DocType: Program Enrollment Tool Student',b'Program Enrollment Tool Student',"b""Outil d'Inscription au Programme \xc3\x89udiant"""
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py +16',b'Start date should be less than end date for task {0}',b'La date de d\xc3\xa9but doit \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 la date de fin de la t\xc3\xa2che {0}'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +25',b'Name or Email is mandatory',b'Nom ou Email est obligatoire'
+b'DocType: Member',b'MEM-',b'MEM-'
+b'DocType: Instructor',b'Instructor Log',b'Journal de l&#39;instructeur'
+b'DocType: Purchase Order Item',b'Returned Qty',b'Qt\xc3\xa9 Retourn\xc3\xa9e'
+b'DocType: Student',b'Exit',b'Quitter'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +156',b'Root Type is mandatory',b'Le Type de Racine est obligatoire'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +29',b'Failed to install presets',b'\xc3\x89chec de l&#39;installation des pr\xc3\xa9r\xc3\xa9glages'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +44',"b'{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.'","b""{0} est actuellement associ\xc3\xa9e avec une fiche d'\xc3\xa9valuation fournisseur {1}. Les appels d'offres pour ce fournisseur doivent \xc3\xaatre \xc3\xa9dit\xc3\xa9s avec pr\xc3\xa9caution."""
+b'DocType: Chapter',b'Non Profit Manager',b'Gestionnaire \xc3\xa0 but non lucratif'
+b'DocType: BOM',b'Total Cost(Company Currency)',b'Co\xc3\xbbt Total (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +315',b'Serial No {0} created',b'N\xc2\xb0 de S\xc3\xa9rie {0} cr\xc3\xa9\xc3\xa9'
+b'DocType: Homepage',b'Company Description for website homepage',"b""Description de la Soci\xc3\xa9t\xc3\xa9 pour la page d'accueil du site web"""
+b'DocType: Item Customer Detail',"b'For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes'","b""Pour la commodit\xc3\xa9 des clients, ces codes peuvent \xc3\xaatre utilis\xc3\xa9s dans des formats d'impression comme les Factures et les Bons de Livraison"""
+b'apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py +18',b'Suplier Name',b'Nom du Fournisseur'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +174',b'Could not retrieve information for {0}.',b'Impossible de r\xc3\xa9cup\xc3\xa9rer les informations pour {0}.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +134',b'Opening Entry Journal',b'Ouverture du journal d&#39;entr\xc3\xa9e'
+b'DocType: Sales Invoice',b'Time Sheet List',b'Liste de Feuille de Temps'
+b'DocType: Employee',b'You can enter any date manually',b'Vous pouvez entrer une date manuellement'
+b'DocType: Healthcare Settings',b'Result Printed',b'R\xc3\xa9sultat Imprim\xc3\xa9'
+b'DocType: Asset Category Account',b'Depreciation Expense Account',b'Compte de Dotations aux Amortissement'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +233',b'Probationary Period',b'P\xc3\xa9riode d\xe2\x80\x99Essai'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +32',b'View {0}',b'Voir {0}'
+b'DocType: Customer Group',b'Only leaf nodes are allowed in transaction',b'Seuls les noeuds feuilles sont autoris\xc3\xa9s dans une transaction'
+b'DocType: Project',b'Total Costing Amount (via Timesheets)',b'Montant total des co\xc3\xbbts (via les feuilles de temps)'
+b'DocType: Employee Advance',b'Expense Approver',b'Approbateur de Notes de Frais'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +136',b'Row {0}: Advance against Customer must be credit',b'Ligne {0} : L\xe2\x80\x99Avance du Client doit \xc3\xaatre un cr\xc3\xa9dit'
+b'DocType: Project',b'Hourly',b'Horaire'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.js +89',b'Non-Group to Group',b'Non-Groupe \xc3\xa0 Groupe'
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +58',b'Batch is mandatory in row {0}',b'Le lot est obligatoire dans la ligne {0}'
+b'DocType: Purchase Receipt Item Supplied',b'Purchase Receipt Item Supplied',b'Articles Fournis du Re\xc3\xa7us d\xe2\x80\x99Achat'
+b'apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py +24',b'To Datetime',b'\xc3\x80 la Date'
+b'apps/erpnext/erpnext/config/selling.py +302',b'Logs for maintaining sms delivery status',b'Journaux pour maintenir le statut de livraison des sms'
+b'DocType: Accounts Settings',b'Make Payment via Journal Entry',b'Effectuer un Paiement par une \xc3\x89criture de Journal'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +223',b'Printed On',b'Imprim\xc3\xa9 sur'
+b'DocType: Item',b'Inspection Required before Delivery',b'Inspection Requise avant Livraison'
+b'DocType: Item',b'Inspection Required before Purchase',b'Inspection Requise avant Achat'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +93',b'Pending Activities',b'Activit\xc3\xa9s en Attente'
+b'DocType: Patient Appointment',b'Reminded',b'Rappel\xc3\xa9'
+b'DocType: Patient',b'PID-',b'PID-'
+b'DocType: Chapter Member',b'Chapter Member',b'Membre du chapitre'
+b'DocType: Material Request Plan Item',b'Minimum Order Quantity',b'Quantit\xc3\xa9 minimum d&#39;achat'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +106',b'Your Organization',b'Votre Organisation'
+b'DocType: Fee Component',b'Fees Category',"b""Cat\xc3\xa9gorie d'Honoraires"""
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +134',b'Please enter relieving date.',b'Veuillez entrer la date de rel\xc3\xa8ve.'
+b'apps/erpnext/erpnext/controllers/trends.py +149',b'Amt',b'Nb'
+b'DocType: Supplier Scorecard',b'Notify Employee',"b""Notifier l'Employ\xc3\xa9"""
+b'DocType: Opportunity',b'Enter name of campaign if source of enquiry is campaign',"b""Entrez le nom de la campagne si la source de l'enqu\xc3\xaate est une campagne"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +38',b'Newspaper Publishers',b'\xc3\x89diteurs de Journaux'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +30',b'Select Fiscal Year',"b""S\xc3\xa9lectionner l'Exercice"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +115',b'Expected Delivery Date should be after Sales Order Date',b'La Date de Livraison Pr\xc3\xa9vue doit \xc3\xaatre apr\xc3\xa8s la Date indiqu\xc3\xa9e sur le Bon de Commande de Vente'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42',b'Reorder Level',b'Niveau de R\xc3\xa9approvisionnement'
+b'DocType: Company',b'Chart Of Accounts Template',b'Mod\xc3\xa8le de Plan Comptable'
+b'DocType: Attendance',b'Attendance Date',b'Date de Pr\xc3\xa9sence'
+b'apps/erpnext/erpnext/stock/get_item_details.py +352',b'Item Price updated for {0} in Price List {1}',"b""Prix de l'Article mis \xc3\xa0 jour pour {0} dans la Liste des Prix {1}"""
+b'DocType: Salary Structure',b'Salary breakup based on Earning and Deduction.',b'D\xc3\xa9tails du Salaire bas\xc3\xa9s sur les Revenus et les Pr\xc3\xa9l\xc3\xa8vements.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +128',b'Account with child nodes cannot be converted to ledger',b'Un compte avec des enfants ne peut pas \xc3\xaatre converti en grand livre'
+b'DocType: Purchase Invoice Item',b'Accepted Warehouse',b'Entrep\xc3\xb4t Accept\xc3\xa9'
+b'DocType: Bank Reconciliation Detail',b'Posting Date',b'Date de Comptabilisation'
+b'DocType: Item',b'Valuation Method',b'M\xc3\xa9thode de Valorisation'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +203',b'Mark Half Day',b'Marquer Demi-Journ\xc3\xa9e'
+b'DocType: Sales Invoice',b'Sales Team',b'\xc3\x89quipe des Ventes'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +87',b'Duplicate entry',b'\xc3\x89criture en double'
+b'DocType: Program Enrollment Tool',b'Get Students',b'Obtenir les \xc3\x89tudiants'
+b'DocType: Serial No',b'Under Warranty',b'Sous Garantie'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +516',b'[Error]',b'[Erreur]'
+b'DocType: Sales Order',b'In Words will be visible once you save the Sales Order.',b'En Toutes Lettres. Sera visible une fois que vous enregistrerez la Commande Client'
+,b'Employee Birthday',"b""Anniversaire de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py +14',b'Please select Completion Date for Completed Repair',b'Veuillez s\xc3\xa9lectionner la date d&#39;ach\xc3\xa8vement pour la r\xc3\xa9paration termin\xc3\xa9e'
+b'DocType: Student Batch Attendance Tool',b'Student Batch Attendance Tool',"b""Outil de Pr\xc3\xa9sence de Lot d'\xc3\x89tudiants"""
+b'apps/erpnext/erpnext/controllers/status_updater.py +213',b'Limit Crossed',b'Limite D\xc3\xa9pass\xc3\xa9e'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js +22',b'Scheduled Upto',b'Programm\xc3\xa9 jusqu&#39;\xc3\xa0'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +55',b'Venture Capital',b'Capital Risque'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +40',"b""An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.""","b""Une p\xc3\xa9riode universitaire avec cette 'Ann\xc3\xa9e Universitaire' {0} et 'Nom de la P\xc3\xa9riode' {1} existe d\xc3\xa9j\xc3\xa0. Veuillez modifier ces entr\xc3\xa9es et essayer \xc3\xa0 nouveau."""
+b'DocType: UOM',b'Must be Whole Number',b'Doit \xc3\xaatre un Nombre Entier'
+b'DocType: Leave Control Panel',b'New Leaves Allocated (In Days)',b'Nouvelle Allocation de Cong\xc3\xa9s (en jours)'
+b'DocType: Purchase Invoice',b'Invoice Copy',b'Copie de Facture'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +49',b'Serial No {0} does not exist',b'N\xc2\xb0 de S\xc3\xa9rie {0} n\xe2\x80\x99existe pas'
+b'DocType: Sales Invoice Item',b'Customer Warehouse (Optional)',b'Entrep\xc3\xb4t des Clients (Facultatif)'
+b'DocType: Pricing Rule',b'Discount Percentage',b'Remise en Pourcentage'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +51',b'Reserved for sub contracting',b'R\xc3\xa9serv\xc3\xa9 \xc3\xa0 la sous-traitance'
+b'DocType: Payment Reconciliation Invoice',b'Invoice Number',b'Num\xc3\xa9ro de Facture'
+b'DocType: Shopping Cart Settings',b'Orders',b'Commandes'
+b'DocType: Employee Leave Approver',b'Leave Approver',b'Approbateur de Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +285',b'Please select a batch',b'Veuillez s\xc3\xa9lectionner un lot'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +42',b'JournalLib',b'JournalLib'
+b'DocType: Assessment Group',b'Assessment Group Name',"b""Nom du Groupe d'\xc3\x89valuation"""
+b'DocType: Manufacturing Settings',b'Material Transferred for Manufacture',b'Mat\xc3\xa9riel Transf\xc3\xa9r\xc3\xa9 pour la Fabrication'
+b'DocType: Landed Cost Item',b'Receipt Document Type',b'Type de Re\xc3\xa7u'
+b'DocType: Daily Work Summary Settings',b'Select Companies',b'S\xc3\xa9lectionner les Soci\xc3\xa9t\xc3\xa9s'
+b'DocType: Antibiotic',b'Healthcare',b'Sant\xc3\xa9'
+b'DocType: Target Detail',b'Target Detail',b'D\xc3\xa9tail Cible'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +65',b'Single Variant',b'Variante unique'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +24',b'All Jobs',b'Tous les Emplois'
+b'DocType: Sales Order',b'% of materials billed against this Sales Order',b'% de mat\xc3\xa9riaux factur\xc3\xa9s pour cette Commande Client'
+b'DocType: Program Enrollment',b'Mode of Transportation',b'Mode de Transport'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +49',b'Period Closing Entry',b'\xc3\x89criture de Cl\xc3\xb4ture de la P\xc3\xa9riode'
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +72',b'Select Department...',b'S\xc3\xa9lectionnez le D\xc3\xa9partement ...'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +38',b'Cost Center with existing transactions can not be converted to group',b'Un Centre de Co\xc3\xbbts avec des transactions existantes ne peut pas \xc3\xaatre converti en groupe'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +374',b'Amount {0} {1} {2} {3}',b'Montant {0} {1} {2} {3}'
+b'DocType: Account',b'Depreciation',b'Amortissement'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +102',b'The number of shares and the share numbers are inconsistent',b'Le nombre d&#39;actions et le nombre d&#39;actions sont incoh\xc3\xa9rents'
+b'apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49',b'Supplier(s)',b'Fournisseur(s)'
+b'DocType: Employee Attendance Tool',b'Employee Attendance Tool',b'Outil de Gestion des Pr\xc3\xa9sences des Employ\xc3\xa9s'
+b'DocType: Guardian Student',b'Guardian Student',"b""Tuteur de l'\xc3\x89tudiant"""
+b'DocType: Supplier',b'Credit Limit',b'Limite de cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Selling Price List Rate',b'Taux moyen de la liste de prix de vente'
+b'DocType: Salary Component',b'Salary Component',b'Composante Salariale'
+b'apps/erpnext/erpnext/accounts/utils.py +495',b'Payment Entries {0} are un-linked',b'\xc3\x89critures de Paiement {0} ne sont pas li\xc3\xa9es'
+b'DocType: GL Entry',b'Voucher No',b'N\xc2\xb0 de R\xc3\xa9f\xc3\xa9rence'
+,b'Lead Owner Efficiency',b'Efficacit\xc3\xa9 des Responsables des Prospects'
+b'DocType: Leave Allocation',b'Leave Allocation',b'Allocation de Cong\xc3\xa9s'
+b'DocType: Payment Request',b'Recipient Message And Payment Details',b'Message du Destinataire et D\xc3\xa9tails de Paiement'
+b'DocType: Training Event',b'Trainer Email',b'Email du Formateur'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +550',b'Material Requests {0} created',b'Les Demandes de Mat\xc3\xa9rielles {0} cr\xc3\xa9\xc3\xa9es'
+b'DocType: Restaurant Reservation',b'No of People',b'Nbr de Personnes'
+b'apps/erpnext/erpnext/config/selling.py +164',b'Template of terms or contract.',b'Mod\xc3\xa8le de termes ou de contrat.'
+b'DocType: Purchase Invoice',b'Address and Contact',b'Adresse et Contact'
+b'DocType: Cheque Print Template',b'Is Account Payable',b'Est Compte Cr\xc3\xa9diteur'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +276',b'Stock cannot be updated against Purchase Receipt {0}',"b""Stock ne peut pas \xc3\xaatre mis \xc3\xa0 jour pour le Re\xc3\xa7u d'Achat {0}"""
+b'DocType: Support Settings',b'Auto close Issue after 7 days',b'Fermer automatique les Questions apr\xc3\xa8s 7 jours'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +71',"b'Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}'","b""Cong\xc3\xa9 ne peut \xc3\xaatre allou\xc3\xa9 avant le {0}, car le solde de cong\xc3\xa9s a d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 report\xc3\xa9 dans la feuille d'allocation de cong\xc3\xa9s futurs {1}"""
+b'apps/erpnext/erpnext/accounts/party.py +317',b'Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s)',b'Remarque : Date de R\xc3\xa9f\xc3\xa9rence / d\xe2\x80\x99\xc3\x89ch\xc3\xa9ance d\xc3\xa9passe le nombre de jours de cr\xc3\xa9dit client autoris\xc3\xa9 de {0} jour(s)'
+b'apps/erpnext/erpnext/education/doctype/program/program.js +8',b'Student Applicant',b'Candidature \xc3\x89tudiante'
+b'DocType: Purchase Invoice',b'ORIGINAL FOR RECIPIENT',b'ORIGINAL POUR LE DESTINATAIRE'
+b'DocType: Asset Category Account',b'Accumulated Depreciation Account',"b""Compte d'Amortissement Cumul\xc3\xa9"""
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +11',b'This email is autogenerated',b'Ce courrier \xc3\xa9lectronique est autog\xc3\xa9n\xc3\xa9r\xc3\xa9'
+b'DocType: Stock Settings',b'Freeze Stock Entries',b'Geler les Entr\xc3\xa9es de Stocks'
+b'DocType: Program Enrollment',b'Boarding Student',b'Enregistrement \xc3\x89tudiant'
+b'DocType: Asset',b'Expected Value After Useful Life',b'Valeur Attendue Apr\xc3\xa8s Utilisation Compl\xc3\xa8te'
+b'DocType: Item',b'Reorder level based on Warehouse',b'Niveau de r\xc3\xa9approvisionnement bas\xc3\xa9 sur l\xe2\x80\x99Entrep\xc3\xb4t'
+b'DocType: Activity Cost',b'Billing Rate',b'Taux de Facturation'
+,b'Qty to Deliver',b'Quantit\xc3\xa9 \xc3\xa0 Livrer'
+,b'Stock Analytics',b'Analyse du Stock'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +523',b'Operations cannot be left blank',b'Les op\xc3\xa9rations ne peuvent pas \xc3\xaatre laiss\xc3\xa9es vides'
+b'DocType: Maintenance Visit Purpose',b'Against Document Detail No',b'Pour le D\xc3\xa9tail du Document N\xc2\xb0'
+b'apps/erpnext/erpnext/regional/__init__.py +11',b'Deletion is not permitted for country {0}',b'La suppression n&#39;est pas autoris\xc3\xa9e pour le pays {0}'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +110',b'Party Type is mandatory',b'Type de Tiers Obligatoire'
+b'DocType: Quality Inspection',b'Outgoing',b'Sortant'
+b'DocType: Material Request',b'Requested For',b'Demand\xc3\xa9 Pour'
+b'DocType: Quotation Item',b'Against Doctype',b'Contre Doctype'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +404',b'{0} {1} is cancelled or closed',b'{0} {1} est annul\xc3\xa9 ou ferm\xc3\xa9'
+b'DocType: Asset',b'Calculate Depreciation',b'Calculer la d\xc3\xa9pr\xc3\xa9ciation'
+b'DocType: Delivery Note',b'Track this Delivery Note against any Project',b'Suivre ce Bon de Livraison pour tous les Projets'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +35',b'Net Cash from Investing',b'Tr\xc3\xa9sorerie Nette des Investissements'
+b'DocType: Work Order',b'Work-in-Progress Warehouse',b'Entrep\xc3\xb4t des Travaux en Cours'
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +111',b'Asset {0} must be submitted',"b""L'actif {0} doit \xc3\xaatre soumis"""
+b'DocType: Fee Schedule Program',b'Total Students',b'Total \xc3\x89tudiants'
+b'apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py +56',b'Attendance Record {0} exists against Student {1}',"b""Registre des pr\xc3\xa9sences {0} existe pour l'\xc3\x89tudiant {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +354',b'Reference #{0} dated {1}',b'R\xc3\xa9f\xc3\xa9rence #{0} dat\xc3\xa9e du {1}'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +164',b'Depreciation Eliminated due to disposal of assets',"b""Amortissement Elimin\xc3\xa9 en raison de cessions d'actifs"""
+b'DocType: Member',b'Member',b'Membre'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_address.html +15',b'Manage Addresses',b'G\xc3\xa9rer les Adresses'
+b'DocType: Work Order Item',b'Work Order Item',b'Poste de commande'
+b'DocType: Pricing Rule',b'Item Code',"b""Code de l'Article"""
+b'DocType: Serial No',b'Warranty / AMC Details',b'Garantie / D\xc3\xa9tails AMC'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.js +116',b'Select students manually for the Activity based Group',"b""S\xc3\xa9lectionner les \xc3\xa9l\xc3\xa8ves manuellement pour un Groupe bas\xc3\xa9 sur l'Activit\xc3\xa9"""
+b'DocType: Journal Entry',b'User Remark',"b""Remarque de l'Utilisateur"""
+b'DocType: Lead',b'Market Segment',b'Part de March\xc3\xa9'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture Manager',b'Directeur de l&#39;agriculture'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +966',b'Paid Amount cannot be greater than total negative outstanding amount {0}',b'Le Montant Pay\xc3\xa9 ne peut pas \xc3\xaatre sup\xc3\xa9rieur au montant impay\xc3\xa9 restant {0}'
+b'DocType: Supplier Scorecard Period',b'Variables',b'Variables'
+b'DocType: Employee Internal Work History',b'Employee Internal Work History',"b""Ant\xc3\xa9c\xc3\xa9dents Professionnels Interne de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +249',b'Closing (Dr)',b'Fermeture (Dr)'
+b'DocType: Cheque Print Template',b'Cheque Size',b'Taille du Ch\xc3\xa8que'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232',b'Serial No {0} not in stock',"b""N\xc2\xb0 de S\xc3\xa9rie {0} n'est pas en stock"""
+b'apps/erpnext/erpnext/config/selling.py +169',b'Tax template for selling transactions.',b'Mod\xc3\xa8le de taxe pour les op\xc3\xa9rations de vente.'
+b'DocType: Sales Invoice',b'Write Off Outstanding Amount',b'Encours de Reprise'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py +27',b'Account {0} does not match with Company {1}',b'Le Compte {0} ne correspond pas \xc3\xa0 la Soci\xc3\xa9t\xc3\xa9 {1}'
+b'DocType: Education Settings',b'Current Academic Year',b'Ann\xc3\xa9e Acad\xc3\xa9mique Actuelle'
+b'DocType: Stock Settings',b'Default Stock UOM',b'UDM par D\xc3\xa9faut des Articles'
+b'DocType: Asset',b'Number of Depreciations Booked',b'Nombre d\xe2\x80\x99Amortissements Comptabilis\xc3\xa9s'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +71',b'Qty Total',b'Quantit\xc3\xa9 totale'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +32',b'Against Employee Loan: {0}',b'Pour le Pr\xc3\xaat Employ\xc3\xa9 : {0}'
+b'DocType: Landed Cost Item',b'Receipt Document',b'Re\xc3\xa7u'
+b'DocType: Employee Education',b'School/University',b'\xc3\x89cole/Universit\xc3\xa9'
+b'DocType: Payment Request',b'Reference Details',b'D\xc3\xa9tails de la R\xc3\xa9f\xc3\xa9rence'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +56',b'Expected Value After Useful Life must be less than Gross Purchase Amount',"b""Valeur Attendue Apr\xc3\xa8s Utilisation Compl\xc3\xa8te doit \xc3\xaatre inf\xc3\xa9rieure au Montant d'Achat Brut"""
+b'DocType: Sales Invoice Item',b'Available Qty at Warehouse',"b""Qt\xc3\xa9 Disponible \xc3\xa0 l'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py +20',b'Billed Amount',b'Montant Factur\xc3\xa9'
+b'DocType: Share Transfer',b'(including)',b'(comprenant)'
+b'DocType: Asset',b'Double Declining Balance',b'Double Solde D\xc3\xa9gressif'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +180',b'Closed order cannot be cancelled. Unclose to cancel.',b'Les commandes ferm\xc3\xa9es ne peuvent \xc3\xaatre annul\xc3\xa9es. R\xc3\xa9ouvrir pour annuler.'
+b'DocType: Student Guardian',b'Father',b'P\xc3\xa8re'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +627',"b""'Update Stock' cannot be checked for fixed asset sale""","b""'Mettre \xc3\xa0 Jour Le Stock\xe2\x80\x99 ne peut pas \xc3\xaatre coch\xc3\xa9 pour la vente d'actifs immobilis\xc3\xa9s"""
+b'DocType: Bank Reconciliation',b'Bank Reconciliation',b'R\xc3\xa9conciliation Bancaire'
+b'DocType: Attendance',b'On Leave',b'En Cong\xc3\xa9'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +7',b'Get Updates',b'Obtenir les Mises \xc3\xa0 jour'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +96',b'{0} {1}: Account {2} does not belong to Company {3}',b'{0} {1} : Compte {2} ne fait pas partie de la Soci\xc3\xa9t\xc3\xa9 {3}'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +397',b'Select at least one value from each of the attributes.',b'S\xc3\xa9lectionnez au moins une valeur de chacun des attributs.'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +166',b'Material Request {0} is cancelled or stopped',b'Demande de Mat\xc3\xa9riel {0} est annul\xc3\xa9 ou arr\xc3\xaat\xc3\xa9'
+b'apps/erpnext/erpnext/config/hr.py +314',b'Leave Management',b'Gestion des Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +118',b'Group by Account',b'Grouper par Compte'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.py +21',b'Please select Employee',b'Veuillez s\xc3\xa9lectionner un employ\xc3\xa9'
+b'DocType: Sales Order',b'Fully Delivered',b'Enti\xc3\xa8rement Livr\xc3\xa9'
+b'DocType: Lead',b'Lower Income',b'Revenu bas'
+b'DocType: Restaurant Order Entry',b'Current Order',b'Ordre Actuel'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +196',b'Source and target warehouse cannot be same for row {0}',"b""L'entrep\xc3\xb4t source et destination ne peuvent \xc3\xaatre similaire dans la ligne {0}"""
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +243',"b'Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry'","b""Le Compte d\xe2\x80\x99\xc3\x89cart doit \xc3\xaatre un compte de type Actif / Passif, puisque cette R\xc3\xa9conciliation de Stock est une \xc3\xa9criture d'\xc3\xa0-nouveau"""
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +107',b'Disbursed Amount cannot be greater than Loan Amount {0}',b'Le Montant Rembours\xc3\xa9 ne peut pas \xc3\xaatre sup\xc3\xa9rieur au Montant du Pr\xc3\xaat {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +176',b'Go to Programs',b'Aller aux Programmes'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +205',b'Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2}',b'La ligne {0} # Montant allou\xc3\xa9 {1} ne peut pas \xc3\xaatre sup\xc3\xa9rieure au montant non r\xc3\xa9clam\xc3\xa9 {2}'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +89',b'Purchase Order number required for Item {0}',"b""Num\xc3\xa9ro de Bon de Commande requis pour l'Article {0}"""
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18',"b""'From Date' must be after 'To Date'""",b'La \xe2\x80\x98Date de D\xc3\xa9but\xe2\x80\x99 doit \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la \xe2\x80\x98Date de Fin\xe2\x80\x99'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py +39',b'Cannot change status as student {0} is linked with student application {1}',"b""Impossible de changer le statut car l'\xc3\xa9tudiant {0} est li\xc3\xa9 \xc3\xa0 la candidature de l'\xc3\xa9tudiant {1}"""
+b'DocType: Asset',b'Fully Depreciated',b'Compl\xc3\xa8tement D\xc3\xa9pr\xc3\xa9ci\xc3\xa9'
+b'DocType: Item Barcode',b'UPC-A',b'UPC-A'
+,b'Stock Projected Qty',b'Qt\xc3\xa9 de Stock Projet\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +444',b'Customer {0} does not belong to project {1}',b'Le Client {0} ne fait pas parti du projet {1}'
+b'DocType: Employee Attendance Tool',b'Marked Attendance HTML',b'HTML des Pr\xc3\xa9sences Valid\xc3\xa9es'
+b'apps/erpnext/erpnext/utilities/activation.py +73',"b'Quotations are proposals, bids you have sent to your customers'","b'Les devis sont des propositions, offres que vous avez envoy\xc3\xa9es \xc3\xa0 vos clients'"
+b'DocType: Sales Invoice',"b""Customer's Purchase Order""",b'N\xc2\xb0 de Bon de Commande du Client'
+b'DocType: Consultation',b'Patient',b'Patient'
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +47',b'Bypass credit check at Sales Order ',b'Contr\xc3\xb4le de cr\xc3\xa9dit de contournement \xc3\xa0 la commande client'
+b'DocType: Land Unit',b'Check if it is a hydroponic unit',b'V\xc3\xa9rifiez s&#39;il s&#39;agit d&#39;une unit\xc3\xa9 hydroponique'
+b'apps/erpnext/erpnext/config/stock.py +109',b'Serial No and Batch',b'N\xc2\xb0 de S\xc3\xa9rie et lot'
+b'DocType: Warranty Claim',b'From Company',b'De la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py +52',b'Sum of Scores of Assessment Criteria needs to be {0}.',"b""Somme des Scores de Crit\xc3\xa8res d'\xc3\x89valuation doit \xc3\xaatre {0}."""
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +77',b'Please set Number of Depreciations Booked',b'Veuillez d\xc3\xa9finir le Nombre d\xe2\x80\x99Amortissements Comptabilis\xc3\xa9s'
+b'DocType: Supplier Scorecard Period',b'Calculations',b'Calculs'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +86',b'Value or Qty',b'Valeur ou Qt\xc3\xa9'
+b'DocType: Payment Terms Template',b'Payment Terms',b'Termes de paiement'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +449',b'Productions Orders cannot be raised for:',b'Les Ordres de Production ne peuvent pas \xc3\xaatre cr\xc3\xa9\xc3\xa9s pour:'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Minute',b'Minute'
+b'DocType: Purchase Invoice',b'Purchase Taxes and Charges',b'Taxes et Frais d\xe2\x80\x99Achats'
+b'DocType: Chapter',b'Meetup Embed HTML',b'Meetup Embed HTML'
+b'apps/erpnext/erpnext/utilities/user_progress.py +121',b'Go to Suppliers',b'Aller aux Fournisseurs'
+,b'Qty to Receive',b'Quantit\xc3\xa9 \xc3\xa0 Recevoir'
+b'DocType: Leave Block List',b'Leave Block List Allowed',b'Liste de Blocage des Cong\xc3\xa9s Autoris\xc3\xa9e'
+b'DocType: Grading Scale Interval',b'Grading Scale Interval',"b""Intervalle de l'\xc3\x89chelle de Notation"""
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +49',b'Expense Claim for Vehicle Log {0}',b'Note de Frais pour Ind\xc3\xa9mnit\xc3\xa9 Kilom\xc3\xa9trique {0}'
+b'DocType: Sales Invoice Item',b'Discount (%) on Price List Rate with Margin',b'Remise (%) sur le Tarif de la Liste de Prix avec la Marge'
+b'apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py +59',b'All Warehouses',b'Tous les Entrep\xc3\xb4ts'
+b'DocType: Sales Partner',b'Retailer',b'D\xc3\xa9taillant'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +115',b'Credit To account must be a Balance Sheet account',b'Le compte \xc3\x80 Cr\xc3\xa9diter doit \xc3\xaatre un compte de Bilan'
+b'apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +118',b'All Supplier Types',b'Tous les Types de Fournisseurs'
+b'DocType: Donor',b'Donor',b'Donneur'
+b'DocType: Global Defaults',b'Disable In Words',"b'D\xc3\xa9sactiver ""En Lettres""'"
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +60',b'Item Code is mandatory because Item is not automatically numbered',"b""Le code de l'Article est obligatoire car l'Article n'est pas num\xc3\xa9rot\xc3\xa9 automatiquement"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +98',b'Quotation {0} not of type {1}',"b""Le devis {0} n'est pas du type {1}"""
+b'DocType: Maintenance Schedule Item',b'Maintenance Schedule Item',"b""Article de Calendrier d'Entretien"""
+b'DocType: Sales Order',b'%  Delivered',b'% Livr\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/fees/fees.js +105',b'Please set the Email ID for the Student to send the Payment Request',"b""Configurez l'ID de courrier \xc3\xa9lectronique pour que l'\xc3\x89l\xc3\xa8ve envoie la Demande de Paiement"""
+b'DocType: Patient',b'Medical History',b'Ant\xc3\xa9c\xc3\xa9dents m\xc3\xa9dicaux'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +157',b'Bank Overdraft Account',b'Compte de D\xc3\xa9couvert Bancaire'
+b'DocType: Patient',b'Patient ID',b'Identification du patient'
+b'DocType: Physician Schedule',b'Schedule Name',b'Nom du calendrier'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js +48',b'Make Salary Slip',b'Cr\xc3\xa9er une Fiche de Paie'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +840',b'Add All Suppliers',b'Ajouter tous les Fournisseurs'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +94',b'Row #{0}: Allocated Amount cannot be greater than outstanding amount.',b'Ligne # {0}: montant attribu\xc3\xa9 ne peut pas \xc3\xaatre sup\xc3\xa9rieur au montant en souffrance.'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +75',b'Browse BOM',b'Parcourir la LDM'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +155',b'Secured Loans',b'Pr\xc3\xaats Garantis'
+b'DocType: Purchase Invoice',b'Edit Posting Date and Time',"b""Modifier la Date et l'Heure de la Publication"""
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +101',b'Please set Depreciation related Accounts in Asset Category {0} or Company {1}',b'Veuillez d\xc3\xa9finir le Compte relatif aux Amortissements dans la Cat\xc3\xa9gorie d\xe2\x80\x99Actifs {0} ou la Soci\xc3\xa9t\xc3\xa9 {1}'
+b'DocType: Lab Test Groups',b'Normal Range',b'Plage normale'
+b'DocType: Academic Term',b'Academic Year',b'Ann\xc3\xa9e Acad\xc3\xa9mique'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +72',b'Available Selling',b'Vente disponible'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +169',b'Opening Balance Equity',b'Ouverture de la Balance des Capitaux Propres'
+b'DocType: Lead',b'CRM',b'CRM'
+b'DocType: Purchase Invoice',b'N',b'N'
+b'apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py +175',b'Remaining',b'Restant'
+b'DocType: Appraisal',b'Appraisal',b'Estimation'
+b'DocType: Purchase Invoice',b'GST Details',b'D\xc3\xa9tails de la GST'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +156',b'Email sent to supplier {0}',b'Email envoy\xc3\xa9 au fournisseur {0}'
+b'DocType: Item',b'Default Sales Unit of Measure',b'Unit\xc3\xa9 de Mesure par d\xc3\xa9faut \xc3\xa0 la Vente'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +9',b'Academic Year: ',b'Ann\xc3\xa9e acad\xc3\xa9mique:'
+b'DocType: Opportunity',b'OPTY-',b'OPTY-'
+b'apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +19',b'Date is repeated',b'La Date est r\xc3\xa9p\xc3\xa9t\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +27',b'Authorized Signatory',b'Signataire Autoris\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js +64',b'Create Fees',b'Cr\xc3\xa9er des Honoraires'
+b'DocType: Project',b'Total Purchase Cost (via Purchase Invoice)',"b""Co\xc3\xbbt d'Achat Total (via Facture d'Achat)"""
+b'DocType: Training Event',b'Start Time',b'Heure de D\xc3\xa9but'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +400',b'Select Quantity',b'S\xc3\xa9lectionner Quantit\xc3\xa9'
+b'DocType: Customs Tariff Number',b'Customs Tariff Number',b'Tarifs Personnalis\xc3\xa9s'
+b'DocType: Patient Appointment',b'Patient Appointment',b'Rendez-vous patient'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34',b'Approving Role cannot be same as role the rule is Applicable To',b'Le R\xc3\xb4le Approbateur ne peut pas \xc3\xaatre identique au r\xc3\xb4le dont la r\xc3\xa8gle est Applicable'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +64',b'Unsubscribe from this Email Digest',b'Se D\xc3\xa9sinscire de ce Compte Rendu par Email'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +830',b'Get Suppliers By',b'Obtenir des Fournisseurs'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +173',b'{0} not found for Item {1}',b'{0} introuvable pour l&#39;\xc3\xa9l\xc3\xa9ment {1}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +197',b'Go to Courses',b'Aller aux Cours'
+b'DocType: Accounts Settings',b'Show Inclusive Tax In Print',b'Afficher la taxe inclusive en impression'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +17',"b'Bank Account, From Date and To Date are Mandatory'","b'Compte bancaire, de date et \xc3\xa0 date sont obligatoires'"
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js +28',b'Message Sent',b'Message Envoy\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +98',b'Account with child nodes cannot be set as ledger',b'Les comptes avec des n\xc5\x93uds enfants ne peuvent pas \xc3\xaatre d\xc3\xa9fini comme grand livre'
+b'DocType: C-Form',b'II',b'II'
+b'DocType: Sales Invoice',"b""Rate at which Price list currency is converted to customer's base currency""",b'Taux auquel la devise de la Liste de prix est convertie en devise du client de base'
+b'DocType: Purchase Invoice Item',b'Net Amount (Company Currency)',b'Montant Net (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Physician',b'Physician Schedules',b'Horaires du m\xc3\xa9decin'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +215',b'Total advance amount cannot be greater than total sanctioned amount',"b""Le montant total de l'avance ne peut \xc3\xaatre sup\xc3\xa9rieur au montant total approuv\xc3\xa9"""
+b'DocType: Salary Slip',b'Hour Rate',b'Tarif Horaire'
+b'DocType: Stock Settings',b'Item Naming By',"b""Nomenclature d'Article Par"""
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +46',b'Another Period Closing Entry {0} has been made after {1}',b'Une autre Entr\xc3\xa9e de Cl\xc3\xb4ture de P\xc3\xa9riode {0} a \xc3\xa9t\xc3\xa9 faite apr\xc3\xa8s {1}'
+b'DocType: Work Order',b'Material Transferred for Manufacturing',b'Mat\xc3\xa9riel Transf\xc3\xa9r\xc3\xa9 pour la Fabrication'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +41',b'Account {0} does not exists',"b""Le compte {0} n'existe pas"""
+b'DocType: Project',b'Project Type',b'Type de Projet'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +153',b'Child Task exists for this Task. You can not delete this Task.',b'Une t\xc3\xa2che enfant existe pour cette t\xc3\xa2che. Vous ne pouvez pas supprimer cette t\xc3\xa2che.'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +48',b'DateLet',b'DateLet'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16',b'Either target qty or target amount is mandatory.',b'Soit la qt\xc3\xa9 cible soit le montant cible est obligatoire.'
+b'apps/erpnext/erpnext/config/projects.py +56',b'Cost of various activities',"b""Co\xc3\xbbt des diff\xc3\xa9rents types d'activit\xc3\xa9s."""
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +60',"b'Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}'","b""D\xc3\xa9finir les \xc3\x89v\xc3\xa9nements \xc3\xa0 {0}, puisque l'employ\xc3\xa9 attach\xc3\xa9 au Commercial ci-dessous n'a pas d'ID Utilisateur {1}"""
+b'DocType: Timesheet',b'Billing Details',b'D\xc3\xa9tails de la Facturation'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +163',b'Source and target warehouse must be different',b'Entrep\xc3\xb4t source et destination doivent \xc3\xaatre diff\xc3\xa9rents'
+b'apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py +140',b'Payment Failed. Please check your GoCardless Account for more details',b'Paiement \xc3\xa9chou\xc3\xa9. Veuillez v\xc3\xa9rifier votre compte GoCardless pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +101',b'Not allowed to update stock transactions older than {0}',b'Non autoris\xc3\xa9 \xc3\xa0 mettre \xc3\xa0 jour les transactions du stock ant\xc3\xa9rieures \xc3\xa0 {0}'
+b'DocType: BOM',b'Inspection Required',b'Inspection obligatoire'
+b'DocType: Purchase Invoice Item',b'PR Detail',b'D\xc3\xa9tail PR'
+b'DocType: Driving License Category',b'Class',b'Classe'
+b'DocType: Sales Order',b'Fully Billed',b'Enti\xc3\xa8rement Factur\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +426',b'Work Order cannot be raised against a Item Template',b'L&#39;ordre de travail ne peut pas \xc3\xaatre d\xc3\xa9clench\xc3\xa9 par rapport \xc3\xa0 un mod\xc3\xa8le d&#39;\xc3\xa9l\xc3\xa9ment'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +101',b'Shipping rule only applicable for Buying',b'R\xc3\xa8gle d&#39;exp\xc3\xa9dition applicable uniquement pour l&#39;achat'
+b'DocType: Vital Signs',b'BMI',b'IMC'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20',b'Cash In Hand',b'Liquidit\xc3\xa9s'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +137',b'Delivery warehouse required for stock item {0}',b'Entrep\xc3\xb4t de Livraison requis pour article du stock {0}'
+b'DocType: Packing Slip',b'The gross weight of the package. Usually net weight + packaging material weight. (for print)',"b""Le poids brut du colis. Habituellement poids net + poids du mat\xc3\xa9riau d'emballage. (Pour l'impression)"""
+b'DocType: Assessment Plan',b'Program',b'Programme'
+b'DocType: Accounts Settings',b'Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts',b'Les utilisateurs ayant ce r\xc3\xb4le sont autoris\xc3\xa9s \xc3\xa0 d\xc3\xa9finir les comptes gel\xc3\xa9s et \xc3\xa0 cr\xc3\xa9er / modifier des \xc3\xa9critures comptables sur des comptes gel\xc3\xa9s'
+b'DocType: Serial No',b'Is Cancelled',b'Est Annul\xc3\xa9e'
+b'DocType: Student Group',b'Group Based On',b'Groupe bas\xc3\xa9 sur'
+b'DocType: Journal Entry',b'Bill Date',b'Date de la Facture'
+b'DocType: Healthcare Settings',b'Laboratory SMS Alerts',b'Alertes SMS de laboratoire'
+b'apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py +20',"b'Service Item,Type,frequency and expense amount are required'","b'Un Article de Service, le Type, la fr\xc3\xa9quence et le montant des frais sont exig\xc3\xa9s'"
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +45',"b'Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:'","b""M\xc3\xaame s'il existe plusieurs R\xc3\xa8gles de Tarification avec une plus haute priorit\xc3\xa9, les priorit\xc3\xa9s internes suivantes sont appliqu\xc3\xa9es :"""
+b'DocType: Plant Analysis Criteria',b'Plant Analysis Criteria',b'Crit\xc3\xa8res d&#39;analyse des plantes'
+b'DocType: Cheque Print Template',b'Cheque Height',b'Hauteur du Ch\xc3\xa8que'
+b'DocType: Supplier',b'Supplier Details',b'D\xc3\xa9tails du Fournisseur'
+b'DocType: Setup Progress',b'Setup Progress',"b""Progression de l'Installation"""
+b'DocType: Hub Settings',b'Publish Items to Hub',b'Publier les articles sur le Hub'
+b'apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +35',b'From value must be less than to value in row {0}',b'De la Valeur doit \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 la valeur de la ligne {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +182',b'Wire Transfer',b'Virement'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +92',b'Check all',b'Cochez tout'
+,b'Issued Items Against Work Order',b'Objets \xc3\xa9mis contre l&#39;ordre de travail'
+b'DocType: Vehicle Log',b'Invoice Ref',b'Facture Ref'
+b'DocType: Company',b'Default Income Account',b'Compte de Produits par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +32',b'Customer Group / Customer',b'Groupe de Clients / Client'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +37',b'Unclosed Fiscal Years Profit / Loss (Credit)',b'B\xc3\xa9n\xc3\xa9fice / Perte (Cr\xc3\xa9dit) des Exercices Non Clos'
+b'DocType: Sales Invoice',b'Time Sheets',b'Feuilles de Temps'
+b'DocType: Lab Test Template',b'Change In Item',"b""Modification dans l'Article"""
+b'DocType: Payment Gateway Account',b'Default Payment Request Message',b'Message de Demande de Paiement par D\xc3\xa9faut'
+b'DocType: Item Group',b'Check this if you want to show in website',b'Cochez cette case si vous souhaitez afficher sur le site'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +338',b'Balance ({0})',b'Solde ({0})'
+b'apps/erpnext/erpnext/config/accounts.py +134',b'Banking and Payments',b'Banque et Paiements'
+,b'Welcome to ERPNext',b'Bienvenue sur ERPNext'
+b'apps/erpnext/erpnext/config/learn.py +102',b'Lead to Quotation',b'Du Prospect au Devis'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +34',b'Email Reminders will be sent to all parties with email contacts',b'Les rappels par courriel seront envoy\xc3\xa9s \xc3\xa0 toutes les parties avec des contacts par courriel'
+b'DocType: Project',b'Twice Daily',b'Deux fois par jour'
+b'DocType: Patient',b'A Negative',b'A N\xc3\xa9gatif'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +45',b'Nothing more to show.',b'Rien de plus \xc3\xa0 montrer.'
+b'DocType: Lead',b'From Customer',b'Du Client'
+b'apps/erpnext/erpnext/demo/setup/setup_data.py +327',b'Calls',b'Appels'
+b'apps/erpnext/erpnext/utilities/user_progress.py +143',b'A Product',b'Un Produit'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +207',b'Batches',b'Lots'
+b'apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js +34',b'Make Fee Schedule',"b""Faire un Ech\xc3\xa9ancier d'Honoraires"""
+b'DocType: Purchase Order Item Supplied',b'Stock UOM',b'UDM du Stock'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +233',b'Purchase Order {0} is not submitted',b'Le Bon de Commande {0} n\xe2\x80\x99est pas soumis'
+b'DocType: Vital Signs',b'Normal reference range for an adult is 16\xe2\x80\x9320 breaths/minute (RCP 2012)',b'La plage de r\xc3\xa9f\xc3\xa9rence normale pour un adulte est de 16-20 respirations / minute (RCP 2012)'
+b'DocType: Customs Tariff Number',b'Tariff Number',b'Tarif'
+b'DocType: Work Order Item',b'Available Qty at WIP Warehouse',"b""Qt\xc3\xa9 disponible \xc3\xa0 l'Entrep\xc3\xb4t de Travaux en Cours"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +39',b'Projected',b'Projet\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +222',b'Serial No {0} does not belong to Warehouse {1}',b'N\xc2\xb0 de S\xc3\xa9rie {0} ne fait pas partie de l\xe2\x80\x99Entrep\xc3\xb4t {1}'
+b'apps/erpnext/erpnext/controllers/status_updater.py +177',b'Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0',b'Remarque : Le syst\xc3\xa8me ne v\xc3\xa9rifiera pas les sur-livraisons et les sur-r\xc3\xa9servations pour l\xe2\x80\x99Article {0} car la quantit\xc3\xa9 ou le montant est \xc3\xa9gal \xc3\xa0 0'
+b'DocType: Notification Control',b'Quotation Message',b'Message du Devis'
+b'DocType: Employee Loan',b'Employee Loan Application',"b""Demande de Pr\xc3\xaat d'un Employ\xc3\xa9"""
+b'DocType: Issue',b'Opening Date',"b""Date d'Ouverture"""
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +86',b'Please save the patient first',b'S&#39;il vous pla\xc3\xaet sauver le patient d&#39;abord'
+b'apps/erpnext/erpnext/education/api.py +80',b'Attendance has been marked successfully.',b'La pr\xc3\xa9sence a \xc3\xa9t\xc3\xa9 marqu\xc3\xa9e avec succ\xc3\xa8s.'
+b'DocType: Program Enrollment',b'Public Transport',b'Transports Publics'
+b'DocType: Soil Texture',b'Silt Composition (%)',b'Composition de limon (%)'
+b'DocType: Journal Entry',b'Remark',b'Remarque'
+b'DocType: Healthcare Settings',b'Avoid Confirmation',b'\xc3\x89viter la Confirmation'
+b'DocType: Purchase Receipt Item',b'Rate and Amount',b'Prix et Montant'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +176',b'Account Type for {0} must be {1}',b'Le Type de Compte pour {0} doit \xc3\xaatre {1}'
+b'DocType: Healthcare Settings',b'Default income accounts to be used if not set in Physician to book Consultation charges.',b'Comptes de Revenu par d\xc3\xa9faut \xc3\xa0 utiliser si non d\xc3\xa9finis dans la fiche du M\xc3\xa9decin pour enregistrer les honoraires li\xc3\xa9s \xc3\xa0 la consultation.'
+b'apps/erpnext/erpnext/config/hr.py +55',b'Leaves and Holiday',b'Cong\xc3\xa9s et Vacances'
+b'DocType: Education Settings',b'Current Academic Term',b'Terme Acad\xc3\xa9mique Actuel'
+b'DocType: Sales Order',b'Not Billed',b'Non Factur\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +76',b'Both Warehouse must belong to same Company',b'Les deux Entrep\xc3\xb4t doivent appartenir \xc3\xa0 la m\xc3\xaame Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/public/js/templates/contact_list.html +34',b'No contacts added yet.',b'Aucun contact ajout\xc3\xa9.'
+b'DocType: Purchase Invoice Item',b'Landed Cost Voucher Amount',b'Montant de la R\xc3\xa9f\xc3\xa9rence de Co\xc3\xbbt au D\xc3\xa9barquement'
+,b'Item Balance (Simple)',b'Solde de l&#39;objet (simple)'
+b'apps/erpnext/erpnext/config/accounts.py +17',b'Bills raised by Suppliers.',b'Factures \xc3\xa9mises par des Fournisseurs.'
+b'DocType: POS Profile',b'Write Off Account',b'Compte de Reprise'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Debit Note Amt',b'Mnt de la Note de D\xc3\xa9bit'
+b'apps/erpnext/erpnext/templates/print_formats/includes/taxes.html +5',b'Discount Amount',b'Remise'
+b'DocType: Purchase Invoice',b'Return Against Purchase Invoice',b'Retour contre Facture d\xe2\x80\x99Achat'
+b'DocType: Item',b'Warranty Period (in days)',b'P\xc3\xa9riode de Garantie (en jours)'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +61',b'Failed to set defaults',b'\xc3\x89chec de la d\xc3\xa9finition des valeurs par d\xc3\xa9faut'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +56',b'Relation with Guardian1',b'Relation avec Tuteur1'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +786',b'Please select BOM against item {0}',b'Veuillez s\xc3\xa9lectionner la nomenclature par rapport \xc3\xa0 l&#39;\xc3\xa9l\xc3\xa9ment {0}'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +18',b'Make Invoices',b'Faire des factures'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +23',b'Net Cash from Operations',b'Tr\xc3\xa9sorerie Nette des Op\xc3\xa9rations'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +26',b'Item 4',b'Article 4'
+b'DocType: Student Admission',b'Admission End Date',"b""Date de Fin de l'Admission"""
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py +30',b'Sub-contracting',b'Sous-traitant'
+b'DocType: Journal Entry Account',b'Journal Entry Account',b'Compte d\xe2\x80\x99\xc3\x89criture de Journal'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js +3',b'Student Group',b'Groupe \xc3\x89tudiant'
+b'DocType: Shopping Cart Settings',b'Quotation Series',b'S\xc3\xa9ries de Devis'
+b'apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +57',"b'An item exists with same name ({0}), please change the item group name or rename the item'","b""Un article existe avec le m\xc3\xaame nom ({0}), veuillez changer le nom du groupe d'article ou renommer l'article"""
+b'DocType: Soil Analysis Criteria',b'Soil Analysis Criteria',b'Crit\xc3\xa8res d&#39;analyse des sols'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2041',b'Please select customer',b'Veuillez s\xc3\xa9lectionner un client'
+b'DocType: C-Form',b'I',b'I'
+b'DocType: Company',b'Asset Depreciation Cost Center',"b""Centre de Co\xc3\xbbts de l'Amortissement d'Actifs"""
+b'DocType: Production Plan Sales Order',b'Sales Order Date',b'Date de la Commande Client'
+b'DocType: Sales Invoice Item',b'Delivered Qty',b'Qt\xc3\xa9 Livr\xc3\xa9e'
+b'DocType: Assessment Plan',b'Assessment Plan',"b""Plan d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +90',b'Customer {0} is created.',b'Le client {0} est cr\xc3\xa9\xc3\xa9.'
+b'DocType: Stock Settings',b'Limit Percent',b'Pourcentage Limite'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +82',b' Currently no stock available in any warehouse',"b'Actuellement, aucun stock disponible dans aucun entrep\xc3\xb4t'"
+,b'Payment Period Based On Invoice Date',b'P\xc3\xa9riode de Paiement bas\xc3\xa9e sur la Date de la Facture'
+b'DocType: Sample Collection',b'No. of print',"b""Nbre d'impressions"""
+b'DocType: Hotel Room Reservation Item',b'Hotel Room Reservation Item',b'Objet de r\xc3\xa9servation de chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +58',b'Missing Currency Exchange Rates for {0}',b'Taux de Change Manquant pour {0}'
+b'DocType: Health Insurance',b'Health Insurance Name',b'Nom de l&#39;assurance maladie'
+b'DocType: Assessment Plan',b'Examiner',b'Examinateur'
+b'DocType: Student',b'Siblings',b'Fr\xc3\xa8res et S\xc5\x93urs'
+b'DocType: Journal Entry',b'Stock Entry',b'\xc3\x89criture de Stock'
+b'DocType: Payment Entry',b'Payment References',b'R\xc3\xa9f\xc3\xa9rences de Paiement'
+b'DocType: C-Form',b'C-FORM-',b'FORMULAIRE-C-'
+b'DocType: Vehicle',b'Insurance Details',b'D\xc3\xa9tails Assurance'
+b'DocType: Account',b'Payable',b'Cr\xc3\xa9diteur'
+b'DocType: Share Balance',b'Share Type',b'Type de partage'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +113',b'Please enter Repayment Periods',b'Veuillez entrer les P\xc3\xa9riodes de Remboursement'
+b'apps/erpnext/erpnext/shopping_cart/cart.py +378',b'Debtors ({0})',b'D\xc3\xa9biteurs ({0})'
+b'DocType: Pricing Rule',b'Margin',b'Marge'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57',b'New Customers',b'Nouveaux Clients'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +74',b'Gross Profit %',b'B\xc3\xa9n\xc3\xa9fice Brut %'
+b'DocType: Appraisal Goal',b'Weightage (%)',b'Poids (%)'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +503',b'Change POS Profile',b'Modifier le profil POS'
+b'DocType: Bank Reconciliation Detail',b'Clearance Date',b'Date de Compensation'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +7',b'Assessment Report',"b""Rapport d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +59',b'Gross Purchase Amount is mandatory',"b""Montant d'Achat Brut est obligatoire"""
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +95',b'Company name not same',b'Nom de l&#39;entreprise pas le m\xc3\xaame'
+b'DocType: Lead',b'Address Desc',b'Adresse Desc'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +113',b'Party is mandatory',b'Le Tiers est obligatoire'
+b'DocType: Journal Entry',b'JV-',b'JV-'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +712',b'Rows with duplicate due dates in other rows were found: {list}',b'Des lignes avec des dates d&#39;\xc3\xa9ch\xc3\xa9ance en double dans les autres lignes ont \xc3\xa9t\xc3\xa9 trouv\xc3\xa9es: {list}'
+b'DocType: Topic',b'Topic Name',b'Nom du Sujet'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37',b'Atleast one of the Selling or Buying must be selected',b'Au moins Vente ou Achat doit \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +290',b'Select an employee to get the employee advance.',b'S\xc3\xa9lectionnez un employ\xc3\xa9 pour faire avancer l&#39;employ\xc3\xa9.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +56',b'Please select a valid Date',b'S&#39;il vous pla\xc3\xaet s\xc3\xa9lectionnez une date valide'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +36',b'Select the nature of your business.',b'S\xc3\xa9lectionner la nature de votre entreprise.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +24',b'Please setup Employee Naming System in Human Resource &gt; HR Settings',b'Veuillez configurer le syst\xc3\xa8me de d\xc3\xa9nomination des employ\xc3\xa9s dans Ressources humaines&gt; Param\xc3\xa8tres RH'
+b'DocType: Lab Test Template',"b'Single for results which require only a single input, result UOM and normal value \n<br>\nCompound for results which require multiple input fields with corresponding event names, result UOMs and normal values\n<br>\nDescriptive for tests which have multiple result components and corresponding result entry fields. \n<br>\nGrouped for test templates which are a group of other test templates.\n<br>\nNo Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.'","b""Single pour les r\xc3\xa9sultats qui ne n\xc3\xa9cessitent qu'une seule entr\xc3\xa9e, r\xc3\xa9sultat UOM et valeur normale <br> Compos\xc3\xa9 pour les r\xc3\xa9sultats qui n\xc3\xa9cessitent plusieurs champs d'entr\xc3\xa9e avec les noms d'\xc3\xa9v\xc3\xa9nement correspondants, les UOM de r\xc3\xa9sultat et les valeurs normales <br> Descriptif pour les tests qui ont plusieurs composants de r\xc3\xa9sultat et les champs de saisie des r\xc3\xa9sultats correspondants. <br> Group\xc3\xa9s pour les mod\xc3\xa8les de test qui sont un groupe d'autres mod\xc3\xa8les de test. <br> Aucun r\xc3\xa9sultat pour les tests sans r\xc3\xa9sultat. En outre, aucun test de laboratoire n'est cr\xc3\xa9\xc3\xa9. par exemple. Sous-tests pour les r\xc3\xa9sultats group\xc3\xa9s."""
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +86',b'Row #{0}: Duplicate entry in References {1} {2}',b'Ligne # {0}: entr\xc3\xa9e en double dans les r\xc3\xa9f\xc3\xa9rences {1} {2}'
+b'apps/erpnext/erpnext/config/manufacturing.py +57',b'Where manufacturing operations are carried.',b'L\xc3\xa0 o\xc3\xb9 les op\xc3\xa9rations de fabrication sont r\xc3\xa9alis\xc3\xa9es.'
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +18',b'As Examiner',b'En tant qu&#39;examinateur'
+b'DocType: Appointment Type',b'Default Duration',b'Dur\xc3\xa9e par d\xc3\xa9faut'
+b'DocType: Asset Movement',b'Source Warehouse',b'Entrep\xc3\xb4t Source'
+b'DocType: Installation Note',b'Installation Date',"b""Date d'Installation"""
+b'apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js +30',b'Share Ledger',b'Registre des actions'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +606',b'Row #{0}: Asset {1} does not belong to company {2}',b'Ligne #{0} : L\xe2\x80\x99Actif {1} n\xe2\x80\x99appartient pas \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 {2}'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +206',b'Sales Invoice {0} created',b'Facture de Vente {0} cr\xc3\xa9\xc3\xa9e'
+b'DocType: Employee',b'Confirmation Date',b'Date de Confirmation'
+b'DocType: C-Form',b'Total Invoiced Amount',b'Montant Total Factur\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +50',b'Min Qty can not be greater than Max Qty',b'Qt\xc3\xa9 Min ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 Qt\xc3\xa9 Max'
+b'DocType: Soil Texture',b'Silty Clay',b'Argile limoneuse'
+b'DocType: Account',b'Accumulated Depreciation',b'Amortissement Cumul\xc3\xa9'
+b'DocType: Supplier Scorecard Scoring Standing',b'Standing Name',b'Nom du Classement'
+b'DocType: Stock Entry',b'Customer or Supplier Details',b'D\xc3\xa9tails du Client ou du Fournisseur'
+b'DocType: Employee Loan Application',b'Required by Date',b'Requis \xc3\xa0 cette Date'
+b'DocType: Lead',b'Lead Owner',b'Responsable du Prospect'
+b'DocType: Production Plan',b'Sales Orders Detail',b'D\xc3\xa9tail des commandes'
+b'DocType: Bin',b'Requested Quantity',b'Quantit\xc3\xa9 Demand\xc3\xa9e'
+b'DocType: Patient',b'Marital Status',b'\xc3\x89tat Civil'
+b'DocType: Stock Settings',b'Auto Material Request',b'Demande de Mat\xc3\xa9riel Automatique'
+b'DocType: Delivery Note Item',b'Available Batch Qty at From Warehouse',"b""Qt\xc3\xa9 de Lot Disponible Depuis l'Entrep\xc3\xb4t"""
+b'DocType: Customer',b'CUST-',b'CUST-'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Idevise',b'Idevise'
+b'DocType: Salary Slip',b'Gross Pay - Total Deduction - Loan Repayment',b'Salaire Brut - D\xc3\xa9ductions Totales - Remboursement de Pr\xc3\xaat'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +29',b'Current BOM and New BOM can not be same',b'La LDM actuelle et la nouvelle LDM ne peuvent \xc3\xaatre pareilles'
+b'apps/erpnext/erpnext/hr/report/salary_register/salary_register.py +47',b'Salary Slip ID',b'ID Fiche de Paie'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +118',b'Date Of Retirement must be greater than Date of Joining',"b""La Date de D\xc3\xa9part \xc3\xa0 la Retraite doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 Date d'Embauche"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +68',b'Multiple Variants',b'Variantes multiples'
+b'DocType: Sales Invoice',b'Against Income Account',b'Pour le Compte de Produits'
+b'apps/erpnext/erpnext/controllers/website_list_for_contact.py +117',b'{0}% Delivered',b'{0}% Livr\xc3\xa9'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +107',b'Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).',"b""L'article {0} : Qt\xc3\xa9 command\xc3\xa9e {1} ne peut pas \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 la qt\xc3\xa9 de commande minimum {2} (d\xc3\xa9fini dans l'Article)."""
+b'DocType: Monthly Distribution Percentage',b'Monthly Distribution Percentage',b'Pourcentage de R\xc3\xa9partition Mensuelle'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +49',b'Please login as another user.',b'Veuillez vous connecter en tant qu&#39;un autre utilisateur.'
+b'DocType: Daily Work Summary Group User',b'Daily Work Summary Group User',b'Utilisateur du groupe R\xc3\xa9sum\xc3\xa9 du travail quotidien'
+b'DocType: Territory',b'Territory Targets',b'Objectifs R\xc3\xa9gionaux'
+b'DocType: Soil Analysis',b'Ca/Mg',b'Ca / Mg'
+b'DocType: Delivery Note',b'Transporter Info',b'Infos Transporteur'
+b'apps/erpnext/erpnext/accounts/utils.py +502',b'Please set default {0} in Company {1}',b'Veuillez d\xc3\xa9finir {0} par d\xc3\xa9faut dans la Soci\xc3\xa9t\xc3\xa9 {1}'
+b'DocType: Cheque Print Template',b'Starting position from top edge',b'Position initiale depuis bord haut'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +33',b'Same supplier has been entered multiple times',b'Le m\xc3\xaame fournisseur a \xc3\xa9t\xc3\xa9 saisi plusieurs fois'
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py +152',b'Gross Profit / Loss',b'B\xc3\xa9n\xc3\xa9fice/Perte Brut'
+,b'Warehouse wise Item Balance Age and Value',b'Stocker sage article \xc3\xa9quilibre \xc3\xa2ge et valeur'
+b'DocType: Purchase Order Item Supplied',b'Purchase Order Item Supplied',b'Article Fourni du Bon de Commande'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +94',b'Company Name cannot be Company',b'Nom de la Soci\xc3\xa9t\xc3\xa9 ne peut pas \xc3\xaatre Company'
+b'apps/erpnext/erpnext/config/setup.py +27',b'Letter Heads for print templates.',"b""En-T\xc3\xaates pour les mod\xc3\xa8les d'impression."""
+b'apps/erpnext/erpnext/config/setup.py +32',b'Titles for print templates e.g. Proforma Invoice.',"b""Titres pour les mod\xc3\xa8les d'impression e.g. Facture Proforma."""
+b'DocType: Program Enrollment',b'Walking',b'En Marchant'
+b'DocType: Student Guardian',b'Student Guardian',"b""Tuteur d'\xc3\x89tudiant"""
+b'DocType: Member',b'Member Name',b'Nom de membre'
+b'DocType: Stock Settings',b'Use Naming Series',b'Utiliser la s\xc3\xa9rie de noms'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +218',b'Valuation type charges can not marked as Inclusive',b'Frais de type valorisation ne peuvent pas \xc3\xaatre marqu\xc3\xa9s comme inclus'
+b'DocType: POS Profile',b'Update Stock',b'Mettre \xc3\xa0 Jour le Stock'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'in the subscription',b'dans l&#39;abonnement'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100',b'Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.',b'Diff\xc3\xa9rentes UDM pour les articles conduira \xc3\xa0 un Poids Net (Total) incorrect . Assurez-vous que le Poids Net de chaque article a la m\xc3\xaame unit\xc3\xa9 de mesure .'
+b'DocType: Membership',b'Payment Details',b'D\xc3\xa9tails de paiement'
+b'apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39',b'BOM Rate',b'Taux LDM'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +225',"b'Stopped Work Order cannot be cancelled, Unstop it first to cancel'","b'Ordre de travail arr\xc3\xaat\xc3\xa9 ne peut \xc3\xaatre annul\xc3\xa9, D\xc3\xa9truire le premier \xc3\xa0 annuler'"
+b'DocType: Asset',b'Journal Entry for Scrap',b'\xc3\x89criture de Journal pour la Mise au Rebut'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +83',b'Please pull items from Delivery Note',b'Veuillez r\xc3\xa9cup\xc3\xa9rer les articles des Bons de Livraison'
+b'apps/erpnext/erpnext/accounts/utils.py +472',b'Journal Entries {0} are un-linked',b'Les \xc3\x89critures de Journal {0} ne sont pas li\xc3\xa9es'
+b'apps/erpnext/erpnext/config/crm.py +92',"b'Record of all communications of type email, phone, chat, visit, etc.'","b'Enregistrement de toutes les communications de type email, t\xc3\xa9l\xc3\xa9phone, chat, visite, etc.'"
+b'DocType: Supplier Scorecard Scoring Standing',b'Supplier Scorecard Scoring Standing',"b""Classement de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'DocType: Manufacturer',b'Manufacturers used in Items',b'Fabricants utilis\xc3\xa9s dans les Articles'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +170',b'Please mention Round Off Cost Center in Company',b'Veuillez indiquer le Centre de Co\xc3\xbbts d\xe2\x80\x99Arrondi de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Purchase Invoice',b'Terms',b'Termes'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +10',b'Select Days',b'Choisissez des jours'
+b'DocType: Academic Term',b'Term Name',b'Nom du Terme'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +332',b'Credit ({0})',b'Cr\xc3\xa9dit ({0})'
+b'DocType: Buying Settings',b'Purchase Order Required',b'Bon de Commande Requis'
+,b'Item-wise Sales History',b'Historique des Ventes par Article'
+b'DocType: Expense Claim',b'Total Sanctioned Amount',b'Montant Total Valid\xc3\xa9'
+b'DocType: Land Unit',b'Land Unit',b'Parcelle'
+,b'Purchase Analytics',b'Analyses des Achats'
+b'DocType: Sales Invoice Item',b'Delivery Note Item',b'Bon de Livraison article'
+b'DocType: Asset Maintenance Log',b'Task',b'T\xc3\xa2che'
+b'DocType: Purchase Taxes and Charges',b'Reference Row #',b'Ligne de R\xc3\xa9f\xc3\xa9rence #'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +76',b'Batch number is mandatory for Item {0}',"b""Le num\xc3\xa9ro de lot est obligatoire pour l'Article {0}"""
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +13',b'This is a root sales person and cannot be edited.',b'C\xe2\x80\x99est un commercial racine qui ne peut \xc3\xaatre modifi\xc3\xa9.'
+b'DocType: Salary Detail',"b""If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ""","b'Si cette option est s\xc3\xa9lectionn\xc3\xa9e, la valeur sp\xc3\xa9cifi\xc3\xa9e ou calcul\xc3\xa9e dans ce composant ne contribuera pas aux gains ou aux d\xc3\xa9ductions. Cependant, sa valeur peut \xc3\xaatre r\xc3\xa9f\xc3\xa9renc\xc3\xa9e par d&#39;autres composants qui peuvent \xc3\xaatre ajout\xc3\xa9s ou d\xc3\xa9duits.'"
+b'DocType: Asset Settings',b'Number of Days in Fiscal Year',b'Nombre de jours dans l&#39;exercice'
+,b'Stock Ledger',"b""Livre d'Inventaire"""
+b'apps/erpnext/erpnext/templates/includes/cart/cart_items.html +29',b'Rate: {0}',b'Prix: {0}'
+b'DocType: Company',b'Exchange Gain / Loss Account',b'Compte de Profits / Pertes sur Change'
+b'apps/erpnext/erpnext/config/hr.py +7',b'Employee and Attendance',b'Employ\xc3\xa9 et Participation'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +93',b'Purpose must be one of {0}',"b""L'Objet doit \xc3\xaatre parmi {0}"""
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +100',b'Fill the form and save it',b'Remplissez et enregistrez le formulaire'
+b'apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html +26',b'Community Forum',b'Forum de la Communaut\xc3\xa9'
+b'apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js +52',b'Actual qty in stock',b'Qt\xc3\xa9 r\xc3\xa9elle en stock'
+b'DocType: Homepage',"b'URL for ""All Products""'","b'URL pour ""Tous les Produits""'"
+b'DocType: Leave Application',b'Leave Balance Before Application',b'Solde de Cong\xc3\xa9s Avant Demande'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +46',b'Send SMS',b'Envoyer un SMS'
+b'DocType: Supplier Scorecard Criteria',b'Max Score',b'Score Maximal'
+b'DocType: Cheque Print Template',b'Width of amount in word',b'Largeur du montant en toutes lettres'
+b'DocType: Company',b'Default Letter Head',b'En-T\xc3\xaate de Courrier par D\xc3\xa9faut'
+b'DocType: Purchase Order',b'Get Items from Open Material Requests',b'Obtenir des Articles de Demandes Mat\xc3\xa9rielles Ouvertes'
+b'DocType: Hotel Room Amenity',b'Billable',b'Facturable'
+b'DocType: Lab Test Template',b'Standard Selling Rate',b'Prix de Vente Standard'
+b'DocType: Account',b'Rate at which this tax is applied',b'Taux auquel cette taxe est appliqu\xc3\xa9e'
+b'DocType: Cash Flow Mapper',b'Section Name',b'Nom de la section'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +77',b'Reorder Qty',b'Qt\xc3\xa9 de R\xc3\xa9approvisionnement'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +28',b'Current Job Openings',"b""Offres d'Emploi Actuelles"""
+b'DocType: Company',b'Stock Adjustment Account',"b""Compte d'Ajustement du Stock"""
+b'apps/erpnext/erpnext/public/js/payment/pos_payment.html +17',b'Write Off',b'Reprise'
+b'DocType: Patient Service Unit',b'Allow Overlap',b'Autoriser le chevauchement'
+b'DocType: Timesheet Detail',b'Operation ID',"b""ID de l'Op\xc3\xa9ration"""
+b'DocType: Employee',"b'System User (login) ID. If set, it will become default for all HR forms.'","b""L'ID (de connexion) de l'Utilisateur Syst\xc3\xa8me. S'il est d\xc3\xa9fini, il deviendra la valeur par d\xc3\xa9faut pour tous les formulaires des RH."""
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16',b'{0}: From {1}',b'{0}: De {1}'
+b'DocType: Task',b'depends_on',b'D\xc3\xa9pend de'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +60',b'Queued for updating latest price in all Bill of Materials. It may take a few minutes.',"b""Mise \xc3\xa0 jour des prix les plus r\xc3\xa9cents dans toutes les Listes de Mat\xc3\xa9riaux en file d'attente. Cela peut prendre quelques minutes."""
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +26',"b""Name of new Account. Note: Please don't create accounts for Customers and Suppliers""",b'Nom du Nouveau Compte. Note: Veuillez ne pas cr\xc3\xa9er de comptes Clients et Fournisseurs'
+b'apps/erpnext/erpnext/config/setup.py +37',b'Country wise default Address Templates',"b""Mod\xc3\xa8les d'Adresse par d\xc3\xa9faut en fonction du pays"""
+b'DocType: Water Analysis',b'Appearance',b'Apparence'
+b'apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py +70',b'Avg. Buying Price List Rate',"b""Moyenne de la liste de prix d'achat"""
+b'DocType: Sales Order Item',b'Supplier delivers to Customer',b'Fournisseur livre au Client'
+b'apps/erpnext/erpnext/config/non_profit.py +23',b'Member information.',b'Informations sur le membre'
+b'apps/erpnext/erpnext/utilities/bot.py +34',b'[{0}](#Form/Item/{0}) is out of stock',b'[{0}] (#Formulaire/Article/{0}) est en rupture de stock'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +58',b'Asset Maintenance',b'Maintenance des Actifs'
+,b'Sales Payment Summary',b'R\xc3\xa9sum\xc3\xa9 du paiement des ventes'
+b'DocType: Restaurant',b'Restaurant',b'Restaurant'
+b'apps/erpnext/erpnext/accounts/party.py +320',b'Due / Reference Date cannot be after {0}',b'Date d\xe2\x80\x99\xc3\xa9ch\xc3\xa9ance / de r\xc3\xa9f\xc3\xa9rence ne peut pas \xc3\xaatre apr\xc3\xa8s le {0}'
+b'apps/erpnext/erpnext/config/setup.py +51',b'Data Import and Export',b'Importer et Exporter des Donn\xc3\xa9es'
+b'DocType: Patient',b'Account Details',b'D\xc3\xa9tails du compte'
+b'DocType: Crop',b'Materials Required',b'Mat\xc3\xa9riaux n\xc3\xa9cessaires'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +76',b'No students Found',b'Aucun \xc3\xa9tudiant Trouv\xc3\xa9'
+b'DocType: Medical Department',b'Medical Department',b'D\xc3\xa9partement m\xc3\xa9dical'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Supplier Scorecard Scoring Criteria',"b""Crit\xc3\xa8res de Notation de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +55',b'Invoice Posting Date',b'Date d\xe2\x80\x99Envois de la Facture'
+b'apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py +25',b'Sell',b'Vendre'
+b'DocType: Purchase Invoice',b'Rounded Total',b'Total Arrondi'
+b'DocType: Product Bundle',b'List items that form the package.',b'Liste des articles qui composent le paquet.'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py +39',b'Not permitted. Please disable the Test Template',b'Pas permis. Veuillez d\xc3\xa9sactiver le mod\xc3\xa8le de test'
+b'apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26',b'Percentage Allocation should be equal to 100%',"b""Pourcentage d'Allocation doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 100 %"""
+b'DocType: Crop Cycle',b'Linked Land Unit',b'Parcelle li\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +584',b'Please select Posting Date before selecting Party',b'Veuillez s\xc3\xa9lectionner la Date de Comptabilisation avant de s\xc3\xa9lectionner le Tiers'
+b'DocType: Program Enrollment',b'School House',"b""Maison de l'\xc3\x89cole"""
+b'DocType: Serial No',b'Out of AMC',b'Sur AMC'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +82',b'Number of Depreciations Booked cannot be greater than Total Number of Depreciations',"b""Nombre d\xe2\x80\x99Amortissements Comptabilis\xc3\xa9s ne peut pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 Nombre Total d'Amortissements"""
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js +47',b'Make Maintenance Visit',"b""Effectuer une Visite d'Entretien"""
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +215',b'Please contact to the user who have Sales Master Manager {0} role',"b""Veuillez contactez l'utilisateur qui a le r\xc3\xb4le de Directeur des Ventes {0}"""
+b'DocType: Company',b'Default Cash Account',b'Compte de Caisse par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/config/accounts.py +62',b'Company (not Customer or Supplier) master.',b'Donn\xc3\xa9es de base de la Soci\xc3\xa9t\xc3\xa9 (ni les Clients ni les Fournisseurs)'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +6',b'This is based on the attendance of this Student',b'Bas\xc3\xa9 sur la pr\xc3\xa9sence de cet \xc3\x89tudiant'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +178',b'No Students in',b'Aucun \xc3\xa9tudiant dans'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +179',b'Add more items or open full form',"b""Ajouter plus d'articles ou ouvrir le formulaire complet"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +212',b'Delivery Notes {0} must be cancelled before cancelling this Sales Order',b'Bons de Livraison {0} doivent \xc3\xaatre annul\xc3\xa9s avant d\xe2\x80\x99annuler cette Commande Client'
+b'apps/erpnext/erpnext/utilities/user_progress.py +259',b'Go to Users',b'Aller aux Utilisateurs'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85',b'Paid amount + Write Off Amount can not be greater than Grand Total',b'Le Montant Pay\xc3\xa9 + Montant Repris ne peut pas \xc3\xaatre sup\xc3\xa9rieur au Total G\xc3\xa9n\xc3\xa9ral'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +78',b'{0} is not a valid Batch Number for Item {1}',"b""{0} n'est pas un Num\xc3\xa9ro de Lot valide pour l\xe2\x80\x99Article {1}"""
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +130',b'Note: There is not enough leave balance for Leave Type {0}',b'Remarque : Le solde de cong\xc3\xa9 est insuffisant pour le Type de Cong\xc3\xa9 {0}'
+b'apps/erpnext/erpnext/regional/india/utils.py +16',b'Invalid GSTIN or Enter NA for Unregistered',"b""GSTIN invalide ou Entrez NA si vous n'\xc3\xaates pas Enregistr\xc3\xa9"""
+b'DocType: Training Event',b'Seminar',b'S\xc3\xa9minaire'
+b'DocType: Program Enrollment Fee',b'Program Enrollment Fee',"b""Frais d'Inscription au Programme"""
+b'DocType: Item',b'Supplier Items',b'Articles Fournisseur'
+b'DocType: Opportunity',b'Opportunity Type',"b""Type d'Opportunit\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js +16',b'New Company',b'Nouvelle Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +17',b'Transactions can only be deleted by the creator of the Company',b'Les Transactions ne peuvent \xc3\xaatre supprim\xc3\xa9es que par le cr\xc3\xa9ateur de la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +21',b'Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.',"b""Nombre incorrect d'\xc3\x89critures Grand Livre trouv\xc3\xa9es. Vous avez peut-\xc3\xaatre choisi le mauvais Compte dans la transaction."""
+b'DocType: Employee',b'Prefered Contact Email',b'Email de Contact Pr\xc3\xa9f\xc3\xa9r\xc3\xa9'
+b'DocType: Cheque Print Template',b'Cheque Width',b'Largeur du Ch\xc3\xa8que'
+b'DocType: Selling Settings',b'Validate Selling Price for Item against Purchase Rate or Valuation Rate',"b""Valider le Prix de Vente de l'Article avec le Prix d'Achat ou le Taux de Valorisation"""
+b'DocType: Fee Schedule',b'Fee Schedule',"b""Bar\xc3\xa8me d'Honoraires"""
+b'DocType: Hub Settings',b'Publish Availability',b'Publier la Disponibilit\xc3\xa9'
+b'DocType: Company',b'Create Chart Of Accounts Based On',b'Cr\xc3\xa9er un Plan Comptable Bas\xc3\xa9 Sur'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +91',b'Cannot convert it to non-group. Child Tasks exist.',b'Impossible de le convertir en non-groupe. Des t\xc3\xa2ches enfants existent.'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +112',b'Date of Birth cannot be greater than today.',b'Date de Naissance ne peut \xc3\xaatre apr\xc3\xa8s la Date du Jour.'
+,b'Stock Ageing',b'Viellissement du Stock'
+b'apps/erpnext/erpnext/education/doctype/student/student.py +40',b'Student {0} exist against student applicant {1}',"b""\xc3\x89tudiant {0} existe pour la candidature d'un \xc3\xa9tudiant {1}"""
+b'DocType: Purchase Invoice',b'Rounding Adjustment (Company Currency)',b'Arrondi (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/projects/doctype/task/task.js +39',b'Timesheet',b'Feuille de Temps'
+b'apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html +243',b'Batch: ',b'Lot:'
+b'DocType: Volunteer',b'Afternoon',b'Apr\xc3\xa8s-midi'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +258',"b""{0} '{1}' is disabled""","b""{0} '{1}' est d\xc3\xa9sactiv\xc3\xa9(e)"""
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13',b'Set as Open',b'D\xc3\xa9finir comme Ouvert'
+b'DocType: Cheque Print Template',b'Scanned Cheque',b'Ch\xc3\xa8que Num\xc3\xa9ris\xc3\xa9'
+b'DocType: Notification Control',b'Send automatic emails to Contacts on Submitting transactions.',b'Envoyer des emails automatiques aux Contacts sur les Transactions soumises.'
+b'DocType: Timesheet',b'Total Billable Amount',b'Montant Total Facturable'
+b'DocType: Customer',b'Credit Limit and Payment Terms',b'Limite de cr\xc3\xa9dit et conditions de paiement'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +20',b'Item 3',b'Article 3'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js +6',b'Order Entry',b'Saisie de Commande'
+b'DocType: Purchase Order',b'Customer Contact Email',b'Email Contact Client'
+b'DocType: Warranty Claim',b'Item and Warranty Details',"b""D\xc3\xa9tails de l'Article et de la Garantie"""
+b'DocType: Chapter',b'Chapter Members',b'Membres du chapitre'
+b'DocType: Sales Team',b'Contribution (%)',b'Contribution (%)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +102',"b""Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified""","b""Remarque : \xc3\x89criture de Paiement ne sera pas cr\xc3\xa9\xc3\xa9e car le compte 'Compte Bancaire ou de Caisse' n'a pas \xc3\xa9t\xc3\xa9 sp\xc3\xa9cifi\xc3\xa9"""
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +70',b'Project {0} already exists',b'Le projet {0} existe d\xc3\xa9j\xc3\xa0'
+b'DocType: Medical Department',b'Nursing User',b'Utilisateur Infirmier'
+b'DocType: Plant Analysis',b'Plant Analysis Criterias',b'Crit\xc3\xa8res d&#39;analyse des plantes'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +239',b'Responsibilities',b'Responsabilit\xc3\xa9s'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +125',b'Validity period of this quotation has ended.',b'La p\xc3\xa9riode de validit\xc3\xa9 de ce devis a pris fin.'
+b'DocType: Expense Claim Account',b'Expense Claim Account',b'Compte de Note de Frais'
+b'DocType: Accounts Settings',b'Allow Stale Exchange Rates',b'Autoriser les Taux de Change Existants'
+b'DocType: Sales Person',b'Sales Person Name',b'Nom du Vendeur'
+b'apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54',b'Please enter atleast 1 invoice in the table',b'Veuillez entrer au moins 1 facture dans le tableau'
+b'apps/erpnext/erpnext/utilities/user_progress.py +247',b'Add Users',b'Ajouter des Utilisateurs'
+b'DocType: POS Item Group',b'Item Group',"b""Groupe d'Article"""
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +16',b'Student Group: ',b'Groupe d&#39;\xc3\xa9tudiants:'
+b'DocType: Item',b'Safety Stock',b'Stock de S\xc3\xa9curit\xc3\xa9'
+b'DocType: Healthcare Settings',b'Healthcare Settings',b'Param\xc3\xa8tres de Sant\xc3\xa9'
+b'apps/erpnext/erpnext/projects/doctype/task/task.py +54',b'Progress % for a task cannot be more than 100.',b'% de Progression pour une t\xc3\xa2che ne peut pas \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 100.'
+b'DocType: Stock Reconciliation Item',b'Before reconciliation',b'Avant la r\xc3\xa9conciliation'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py +12',b'To {0}',b'\xc3\x80 {0}'
+b'DocType: Purchase Invoice',b'Taxes and Charges Added (Company Currency)',b'Taxes et Frais Additionnels (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +476',b'Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable',"b""La Ligne de Taxe d'Article {0} doit indiquer un compte de type Taxes ou Produit ou Charge ou Facturable"""
+b'DocType: Sales Order',b'Partly Billed',b'Partiellement Factur\xc3\xa9'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +43',b'Item {0} must be a Fixed Asset Item',"b""L'article {0} doit \xc3\xaatre une Immobilisation"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +372',b'Make Variants',b'Faire des variantes'
+b'DocType: Item',b'Default BOM',b'LDM par D\xc3\xa9faut'
+b'DocType: Project',b'Total Billed Amount (via Sales Invoices)',b'Montant total factur\xc3\xa9 (via les factures de vente)'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +118',b'Debit Note Amount',b'Montant de la Note de D\xc3\xa9bit'
+b'DocType: Project Update',b'Not Updated',b'Pas \xc3\xa0 jour'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +106',"b'There are inconsistencies between the rate, no of shares and the amount calculated'","b'Il existe des incoh\xc3\xa9rences entre le taux, le nombre d&#39;actions et le montant calcul\xc3\xa9'"
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +89',b'Please re-type company name to confirm',b'Veuillez saisir \xc3\xa0 nouveau le nom de la soci\xc3\xa9t\xc3\xa9 pour confirmer'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +216',b'Total Outstanding Amt',b'Encours Total'
+b'DocType: Journal Entry',b'Printing Settings',"b""R\xc3\xa9glages d'Impression"""
+b'DocType: Employee Advance',b'Advance Account',b'Compte d&#39;avances'
+b'DocType: Job Offer',b'Job Offer Terms',b'Conditions d&#39;offre d&#39;emploi'
+b'DocType: Sales Invoice',b'Include Payment (POS)',b'Inclure Paiement (PDV)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +292',b'Total Debit must be equal to Total Credit. The difference is {0}',b'Le Total du D\xc3\xa9bit doit \xc3\xaatre \xc3\xa9gal au Total du Cr\xc3\xa9dit. La diff\xc3\xa9rence est de {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +11',b'Automotive',b'Automobile'
+b'DocType: Vehicle',b'Insurance Company',"b""Compagnie d'Assurance"""
+b'DocType: Asset Category Account',b'Fixed Asset Account',"b""Compte d'Actif Immobilis\xc3\xa9"""
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +414',b'Variable',b'Variable'
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js +47',b'From Delivery Note',b'Du Bon de Livraison'
+b'DocType: Chapter',b'Members',b'Membres'
+b'DocType: Student',b'Student Email Address',"b""Adresse Email de l'\xc3\x89tudiant"""
+b'DocType: Item',b'Hub Warehouse',b'Entrep\xc3\xb4t du Hub'
+b'DocType: Assessment Plan',b'From Time',b'Horaire de D\xc3\xa9but'
+b'DocType: Hotel Settings',b'Hotel Settings',b'Param\xc3\xa8tres de l&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/public/js/pos/pos_bill_item.html +12',b'In Stock: ',b'En Stock :'
+b'DocType: Notification Control',b'Custom Message',b'Message Personnalis\xc3\xa9'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +33',b'Investment Banking',"b""Banque d'Investissement"""
+b'DocType: Purchase Invoice',b'input',b'contribution'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +79',b'Cash or Bank Account is mandatory for making payment entry',b'Esp\xc3\xa8ces ou Compte Bancaire est obligatoire pour r\xc3\xa9aliser une \xc3\xa9criture de paiement'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +54',b'Student Address',"b""Adresse de l'\xc3\x89l\xc3\xa8ve"""
+b'DocType: Purchase Invoice',b'Price List Exchange Rate',b'Taux de Change de la Liste de Prix'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +251',b'Account Number {0} already used in account {1}',b'Num\xc3\xa9ro de compte {0} d\xc3\xa9j\xc3\xa0 utilis\xc3\xa9 dans le compte {1}'
+b'DocType: GoCardless Mandate',b'Mandate',b'Mandat'
+b'DocType: POS Profile',b'POS Profile Name',b'Nom du profil PDV'
+b'DocType: Hotel Room Reservation',b'Booked',b'R\xc3\xa9serv\xc3\xa9'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +45',b'CompAuxLib',b'CompAuxLib'
+b'DocType: Purchase Invoice Item',b'Rate',b'Taux'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +104',b'Intern',b'Interne'
+b'DocType: Delivery Stop',b'Address Name',"b""Nom de l'Adresse"""
+b'DocType: Stock Entry',b'From BOM',b'De LDM'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +639',b'Splitting {0} units of {1}',b'Division de {0} unit\xc3\xa9s de {1}'
+b'DocType: Assessment Code',b'Assessment Code',"b""Code de l'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +73',b'Basic',b'de Base'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +94',b'Stock transactions before {0} are frozen',b'Les transactions du stock avant {0} sont gel\xc3\xa9es'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +219',"b""Please click on 'Generate Schedule'""","b'Veuillez cliquer sur ""G\xc3\xa9n\xc3\xa9rer calendrier\'\''"
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +122',b'Reference No is mandatory if you entered Reference Date',b'N\xc2\xb0 de R\xc3\xa9f\xc3\xa9rence obligatoire si vous avez entr\xc3\xa9 une date'
+b'DocType: Bank Reconciliation Detail',b'Payment Document',b'Document de Paiement'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py +37',b'Error evaluating the criteria formula',"b""Erreur lors de l'\xc3\xa9valuation de la formule du crit\xc3\xa8re"""
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +115',b'Date of Joining must be greater than Date of Birth',"b""La Date d'Embauche doit \xc3\xaatre apr\xc3\xa8s \xc3\xa0 la Date de Naissance"""
+b'DocType: Salary Slip',b'Salary Structure',b'Grille des Salaires'
+b'DocType: Account',b'Bank',b'Banque'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +9',b'Airline',b'Compagnie A\xc3\xa9rienne'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +853',b'Issue Material',b'Probl\xc3\xa8me Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +3',b'An error occured while creating recurring',"b""Une erreur s'est produite lors de la cr\xc3\xa9ation de la r\xc3\xa9currence"""
+b'DocType: Material Request Item',b'For Warehouse',b'Pour l\xe2\x80\x99Entrep\xc3\xb4t'
+b'DocType: Employee',b'Offer Date',b'Date de la Proposition'
+b'apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py +33',b'Quotations',b'Devis'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +735',b'You are in offline mode. You will not be able to reload until you have network.',"b""Vous \xc3\xaates en mode hors connexion. Vous ne serez pas en mesure de recharger jusqu'\xc3\xa0 ce que vous ayez du r\xc3\xa9seau."""
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +47',b'No Student Groups created.',"b""Aucun Groupe d'\xc3\x89tudiants cr\xc3\xa9\xc3\xa9."""
+b'DocType: Purchase Invoice Item',b'Serial No',b'N\xc2\xb0 de S\xc3\xa9rie'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan/employee_loan.py +119',b'Monthly Repayment Amount cannot be greater than Loan Amount',b'Montant du Remboursement Mensuel ne peut pas \xc3\xaatre sup\xc3\xa9rieur au Montant du Pr\xc3\xaat'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +143',b'Please enter Maintaince Details first',b'Veuillez d\xe2\x80\x99abord entrer les D\xc3\xa9tails de Maintenance'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +56',b'Row #{0}: Expected Delivery Date cannot be before Purchase Order Date',b'Ligne {0}: la date de livraison pr\xc3\xa9vue ne peut pas \xc3\xaatre avant la date de commande'
+b'DocType: Purchase Invoice',b'Print Language',b'Langue d\xe2\x80\x99Impression'
+b'DocType: Salary Slip',b'Total Working Hours',b'Total des Heures Travaill\xc3\xa9es'
+b'DocType: Sales Invoice',b'Customer PO Details',b'D\xc3\xa9tails du bon de commande client'
+b'DocType: Subscription',b'Next Schedule Date',b'Prochaine Date Programm\xc3\xa9e'
+b'DocType: Stock Entry',b'Including items for sub assemblies',b'Incluant les articles pour des sous-ensembles'
+b'DocType: Opening Invoice Creation Tool Item',b'Temporary Opening Account',b'Compte d&#39;ouverture temporaire'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1964',b'Enter value must be positive',b'La valeur entr\xc3\xa9e doit \xc3\xaatre positive'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py +446',b'All Territories',b'Tous les Territoires'
+b'apps/erpnext/erpnext/projects/doctype/task/task_tree.js +49',b'Add Multiple Tasks',b'Ajouter plusieurs t\xc3\xa2ches'
+b'DocType: Purchase Invoice',b'Items',b'Articles'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py +34',b'Student is already enrolled.',"b""L'\xc3\xa9tudiant est d\xc3\xa9j\xc3\xa0 inscrit."""
+b'DocType: Fiscal Year',b'Year Name',"b""Nom de l'Ann\xc3\xa9e"""
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +241',b'There are more holidays than working days this month.',b'Il y a plus de vacances que de jours travaill\xc3\xa9s ce mois-ci.'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +78',b'PDC/LC Ref',b'PDC / LC Ref'
+b'DocType: Product Bundle Item',b'Product Bundle Item',"b""Article d'un Ensemble de Produits"""
+b'DocType: Sales Partner',b'Sales Partner Name',b'Nom du Partenaire de Vente'
+b'apps/erpnext/erpnext/hooks.py +136',b'Request for Quotations',b'Appel d\xe2\x80\x99Offres'
+b'DocType: Payment Reconciliation',b'Maximum Invoice Amount',b'Montant Maximal de la Facture'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +50',b'Montantdevise',b'Montantdevise'
+b'apps/erpnext/erpnext/healthcare/setup.py +210',b'Haematology',b'H\xc3\xa9matologie'
+b'DocType: Normal Test Items',b'Normal Test Items',b'Articles de Test Normal'
+b'DocType: Student Language',b'Student Language',b'Langue des \xc3\x89tudiants'
+b'apps/erpnext/erpnext/config/selling.py +23',b'Customers',b'Clients'
+b'DocType: Cash Flow Mapping',b'Is Working Capital',b'Est le capital de travail'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +24',b'Order/Quot %',b'Commande / Devis %'
+b'apps/erpnext/erpnext/config/healthcare.py +25',b'Record Patient Vitals',b'Enregistrer les Signes Vitaux du Patient'
+b'DocType: Fee Schedule',b'Institution',b'Institution'
+b'DocType: Asset',b'Partially Depreciated',b'Partiellement D\xc3\xa9pr\xc3\xa9ci\xc3\xa9'
+b'DocType: Issue',b'Opening Time',"b""Horaire d'Ouverture"""
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +89',b'From and To dates required',b'Les date Du et Au sont requises'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +46',b'Securities & Commodity Exchanges',b'Bourses de Valeurs Mobili\xc3\xa8res et de Marchandises'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +689',"b""Default Unit of Measure for Variant '{0}' must be same as in Template '{1}'""","b""L\xe2\x80\x99Unit\xc3\xa9 de mesure par d\xc3\xa9faut pour la variante '{0}' doit \xc3\xaatre la m\xc3\xaame que dans le Mod\xc3\xa8le '{1}'"""
+b'DocType: Shipping Rule',b'Calculate Based On',b'Calculer en fonction de'
+b'DocType: Delivery Note Item',b'From Warehouse',"b""De l'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +59',b'No employees for the mentioned criteria',b'Aucun employ\xc3\xa9 pour les crit\xc3\xa8res mentionn\xc3\xa9s'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +955',b'No Items with Bill of Materials to Manufacture',b'Aucun Article avec une Liste de Mat\xc3\xa9riel \xc3\xa0 Fabriquer'
+b'DocType: Hotel Settings',b'Default Customer',b'Client par D\xc3\xa9faut'
+b'DocType: Assessment Plan',b'Supervisor Name',b'Nom du Superviseur'
+b'DocType: Healthcare Settings',b'Do not confirm if appointment is created for the same day',b'Ne confirmez pas si le rendez-vous est cr\xc3\xa9\xc3\xa9 pour le m\xc3\xaame jour'
+b'DocType: Program Enrollment Course',b'Program Enrollment Course',"b""Cours d'Inscription au Programme"""
+b'DocType: Purchase Taxes and Charges',b'Valuation and Total',b'Valorisation et Total'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py +11',b'Scorecards',"b""Fiches d'\xc3\x89valuation"""
+b'DocType: Tax Rule',b'Shipping City',b'Ville de Livraison'
+b'DocType: Notification Control',b'Customize the Notification',b'Personnaliser la Notification'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +24',b'Cash Flow from Operations',b'Flux de Tr\xc3\xa9sorerie provenant des Op\xc3\xa9rations'
+b'DocType: Purchase Invoice',b'Shipping Rule',b'R\xc3\xa8gle de Livraison'
+b'DocType: Patient Relation',b'Spouse',b'\xc3\x89poux'
+b'DocType: Lab Test Groups',b'Add Test',b'Ajouter un Test'
+b'DocType: Manufacturer',b'Limited to 12 characters',b'Limit\xc3\xa9 \xc3\xa0 12 caract\xc3\xa8res'
+b'DocType: Journal Entry',b'Print Heading',b'Imprimer Titre'
+b'apps/erpnext/erpnext/config/stock.py +146',b'Delivery Trip service tours to customers.',b'Service de livraison aux clients.'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +57',b'Total cannot be zero',b'Total ne peut pas \xc3\xaatre z\xc3\xa9ro'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +16',"b""'Days Since Last Order' must be greater than or equal to zero""","b""'Jours Depuis La Derni\xc3\xa8re Commande' doit \xc3\xaatre sup\xc3\xa9rieur ou \xc3\xa9gal \xc3\xa0 z\xc3\xa9ro"""
+b'DocType: Plant Analysis Criteria',b'Maximum Permissible Value',b'Valeur maximale autoris\xc3\xa9e'
+b'DocType: Journal Entry Account',b'Employee Advance',b'Avances des employ\xc3\xa9s'
+b'DocType: Payroll Entry',b'Payroll Frequency',b'Fr\xc3\xa9quence de la Paie'
+b'DocType: Lab Test Template',b'Sensitivity',b'Sensibilit\xc3\xa9'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +941',b'Raw Material',b'Mati\xc3\xa8res Premi\xc3\xa8res'
+b'DocType: Leave Application',b'Follow via Email',b'Suivre par E-mail'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +55',b'Plants and Machineries',b'Usines et Machines'
+b'DocType: Purchase Taxes and Charges',b'Tax Amount After Discount Amount',b'Montant de la Taxe apr\xc3\xa8s Remise'
+b'DocType: Daily Work Summary Settings',b'Daily Work Summary Settings',b'Param\xc3\xa8tres du R\xc3\xa9capitulatif Quotidien'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +447',b'Please enter Reqd by Date',b'Veuillez entrer Reqd par date'
+b'DocType: Payment Entry',b'Internal Transfer',b'Transfert Interne'
+b'DocType: Asset Maintenance',b'Maintenance Tasks',b'T\xc3\xa2ches de maintenance'
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.py +19',b'Either target qty or target amount is mandatory',b'Soit la qt\xc3\xa9 cible soit le montant cible est obligatoire'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +366',b'Please select Posting Date first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner la Date de Comptabilisation'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +209',b'Opening Date should be before Closing Date',"b""Date d'Ouverture devrait \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de Cl\xc3\xb4ture"""
+b'DocType: Leave Control Panel',b'Carry Forward',b'Reporter'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +30',b'Cost Center with existing transactions can not be converted to ledger',b'Un Centre de Co\xc3\xbbts avec des transactions existantes ne peut pas \xc3\xaatre converti en grand livre'
+b'DocType: Department',b'Days for which Holidays are blocked for this department.',b'Jours pour lesquels les Vacances sont bloqu\xc3\xa9es pour ce d\xc3\xa9partement.'
+b'DocType: GoCardless Mandate',b'ERPNext Integrations',b'Int\xc3\xa9grations ERPNext'
+b'DocType: Crop Cycle',b'Detected Disease',b'Maladie d\xc3\xa9tect\xc3\xa9e'
+,b'Produced',b'Produit'
+b'DocType: Item',b'Item Code for Suppliers',"b""Code de l'Article pour les Fournisseurs"""
+b'DocType: Issue',b'Raised By (Email)',b'Cr\xc3\xa9\xc3\xa9 par (Email)'
+b'DocType: Training Event',b'Trainer Name',b'Nom du Formateur'
+b'DocType: Mode of Payment',b'General',b'G\xc3\xa9n\xc3\xa9ral'
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +28',b'Last Communication',b'Derni\xc3\xa8re Communication'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +372',"b""Cannot deduct when category is for 'Valuation' or 'Valuation and Total'""","b""D\xc3\xa9duction impossible lorsque la cat\xc3\xa9gorie est pour '\xc3\x89valuation' ou 'Vaulation et Total'"""
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +234',b'Serial Nos Required for Serialized Item {0}',b'N\xc2\xb0 de S\xc3\xa9ries Requis pour Article S\xc3\xa9rialis\xc3\xa9 {0}'
+b'apps/erpnext/erpnext/config/accounts.py +144',b'Match Payments with Invoices',b'Rapprocher les Paiements avec les Factures'
+b'DocType: Journal Entry',b'Bank Entry',b'\xc3\x89criture Bancaire'
+b'DocType: Authorization Rule',b'Applicable To (Designation)',b'Applicable \xc3\x80 (D\xc3\xa9signation)'
+,b'Profitability Analysis',b'Analyse de Profitabilit\xc3\xa9'
+b'DocType: Fees',b'Student Email',"b""Email de l'\xc3\x89tudiant"""
+b'DocType: Supplier',b'Prevent POs',"b""Interdire les Bons de Commande d'Achat"""
+b'DocType: Patient',"b'Allergies, Medical and Surgical History'","b'Allergies, ant\xc3\xa9c\xc3\xa9dents m\xc3\xa9dicaux et chirurgicaux'"
+b'apps/erpnext/erpnext/templates/generators/item.html +77',b'Add to Cart',b'Ajouter au Panier'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28',b'Group By',b'Grouper Par'
+b'DocType: Guardian',b'Interests',b'Int\xc3\xa9r\xc3\xaats'
+b'apps/erpnext/erpnext/config/accounts.py +298',b'Enable / disable currencies.',b'Activer / D\xc3\xa9sactiver les devises'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +105',b'Dr {0} on Half day Leave on {1}',b'Dr {0} sur une demi-journ\xc3\xa9e de cong\xc3\xa9 le {1}'
+b'DocType: Production Plan',b'Get Material Request',b'Obtenir la Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111',b'Postal Expenses',b'Frais Postaux'
+b'apps/erpnext/erpnext/controllers/trends.py +19',b'Total(Amt)',b'Total (Mnt)'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +26',b'Entertainment & Leisure',b'Divertissement et Loisir'
+,b'Item Variant Details',b'D\xc3\xa9tails de la variante de l&#39;article'
+b'DocType: Quality Inspection',b'Item Serial No',"b""No de S\xc3\xa9rie de l'Article"""
+b'apps/erpnext/erpnext/utilities/activation.py +135',b'Create Employee Records',b'Cr\xc3\xa9er les Dossiers des Employ\xc3\xa9s'
+b'apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +68',b'Total Present',b'Total des Pr\xc3\xa9sents'
+b'apps/erpnext/erpnext/config/accounts.py +105',b'Accounting Statements',b'\xc3\x89tats Financiers'
+b'DocType: Drug Prescription',b'Hour',b'Heure'
+b'DocType: Restaurant Order Entry',b'Last Sales Invoice',b'Derni\xc3\xa8re Facture de Vente'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +788',b'Please select Qty against item {0}',b'Veuillez s\xc3\xa9lectionner Qt\xc3\xa9 par rapport \xc3\xa0 l&#39;\xc3\xa9l\xc3\xa9ment {0}'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +29',b'New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt',"b""Les Nouveaux N\xc2\xb0 de S\xc3\xa9rie ne peuvent avoir d'entrepot. L'Entrep\xc3\xb4t doit \xc3\xaatre \xc3\xa9tabli par \xc3\x89criture de Stock ou Re\xc3\xa7us d'Achat"""
+b'DocType: Lead',b'Lead Type',b'Type de Prospect'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +114',b'You are not authorized to approve leaves on Block Dates',"b""Vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 approuver les cong\xc3\xa9s sur les Dates Bloqu\xc3\xa9es"""
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +394',b'All these items have already been invoiced',b'Tous ces articles ont d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 factur\xc3\xa9s'
+b'DocType: Company',b'Monthly Sales Target',b'Objectif de Vente Mensuel'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37',b'Can be approved by {0}',b'Peut \xc3\xaatre approuv\xc3\xa9 par {0}'
+b'DocType: Hotel Room',b'Hotel Room Type',b'Type de chambre d&#39;h\xc3\xb4tel'
+b'DocType: Item',b'Default Material Request Type',b'Type de Requ\xc3\xaate de Mat\xc3\xa9riaux par D\xc3\xa9faut'
+b'DocType: Supplier Scorecard',b'Evaluation Period',"b""P\xc3\xa9riode d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js +13',b'Unknown',b'Inconnu'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +954',b'Work Order not created',b'Ordre de travail non cr\xc3\xa9\xc3\xa9'
+b'DocType: Shipping Rule',b'Shipping Rule Conditions',b'Conditions de la R\xc3\xa8gle de Livraison'
+b'DocType: Purchase Invoice',b'Export Type',"b""Type d'Exportation"""
+b'DocType: Salary Slip Loan',b'Salary Slip Loan',b'Salaire Slip Loan'
+b'DocType: BOM Update Tool',b'The new BOM after replacement',b'La nouvelle LDM apr\xc3\xa8s remplacement'
+,b'Point of Sale',b'Point de Vente'
+b'DocType: Payment Entry',b'Received Amount',b'Montant Re\xc3\xa7u'
+b'DocType: Patient',b'Widow',b'Veuve'
+b'DocType: GST Settings',b'GSTIN Email Sent On',b'Email GSTIN Envoy\xc3\xa9 Le'
+b'DocType: Program Enrollment',b'Pick/Drop by Guardian',b'D\xc3\xa9pos\xc3\xa9/R\xc3\xa9cup\xc3\xa9r\xc3\xa9 par le Tuteur'
+b'DocType: Crop',b'Planting UOM',b'Plantation d&#39;UOM'
+b'DocType: Account',b'Tax',b'Taxe'
+b'apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py +45',b'Not Marked',b'Non Marqu\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html +1',b'Opening Invoices Summary',b'Ouverture des factures R\xc3\xa9sum\xc3\xa9'
+b'DocType: Education Settings',b'Education Manager',b'Gestionnaire de l&#39;\xc3\xa9ducation'
+b'DocType: Crop Cycle',b'The minimum length between each plant in the field for optimum growth',b'La longueur minimale entre chaque plante sur le terrain pour une croissance optimale'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +152',"b'Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry'","b""L'article de Lot {0} ne peut pas \xc3\xaatre mis \xc3\xa0 jour \xc3\xa0 l'aide de la r\xc3\xa9conciliation des stocks, \xc3\xa0 la place, utilisez l'Entr\xc3\xa9e de Stock"""
+b'DocType: Quality Inspection',b'Report Date',b'Date du Rapport'
+b'DocType: Student',b'Middle Name',b'Deuxi\xc3\xa8me Nom'
+b'DocType: C-Form',b'Invoices',b'Factures'
+b'DocType: Water Analysis',b'Type of Sample',b'Type d&#39;\xc3\xa9chantillon'
+b'DocType: Batch',b'Source Document Name',b'Nom du Document Source'
+b'DocType: Production Plan',b'Get Raw Materials For Production',b'Obtenez des mati\xc3\xa8res premi\xc3\xa8res pour la production'
+b'DocType: Job Opening',b'Job Title',"b""Titre de l'Emploi"""
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py +84',"b'{0} indicates that {1} will not provide a quotation, but all items \\\n\t\t\t\t\thave been quoted. Updating the RFQ quote status.'","b'{0} indique que {1} ne fournira pas de devis, mais tous les articles \\ ont \xc3\xa9t\xc3\xa9 \xc3\xa9valu\xc3\xa9s. Mise \xc3\xa0 jour du statut de devis RFQ.'"
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +1026',b'Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.',b'Nombre maximum d&#39;\xc3\xa9chantillons - {0} ont d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 conserv\xc3\xa9s pour le lot {1} et l&#39;article {2} dans le lot {3}.'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +125',b'Please Set Supplier Type in Buying Settings.',b'Veuillez d\xc3\xa9finir le type de fournisseur dans les param\xc3\xa8tres d&#39;achat.'
+b'DocType: Manufacturing Settings',b'Update BOM Cost Automatically',b'Mettre \xc3\xa0 jour automatiquement le co\xc3\xbbt de la LDM'
+b'DocType: Lab Test',b'Test Name',b'Nom du Test'
+b'apps/erpnext/erpnext/utilities/activation.py +99',b'Create Users',b'Cr\xc3\xa9er des Utilisateurs'
+b'apps/erpnext/erpnext/utilities/user_progress.py +147',b'Gram',b'Gramme'
+b'DocType: Supplier Scorecard',b'Per Month',b'Par Mois'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +433',b'Quantity to Manufacture must be greater than 0.',b'Quantit\xc3\xa9 \xc3\xa0 Fabriquer doit \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 0.'
+b'DocType: Asset Settings',b'Calculate Prorated Depreciation Schedule Based on Fiscal Year',b'Calculer le calendrier d&#39;amortissement au prorata selon l&#39;exercice financier'
+b'apps/erpnext/erpnext/config/maintenance.py +17',b'Visit report for maintenance call.',b'Rapport de visite pour appel de maintenance'
+b'DocType: Stock Entry',b'Update Rate and Availability',b'Mettre \xc3\xa0 Jour le Prix et la Disponibilit\xc3\xa9'
+b'DocType: Stock Settings',b'Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.',b'Pourcentage que vous \xc3\xaates autoris\xc3\xa9 \xc3\xa0 recevoir ou \xc3\xa0 livrer en plus de la quantit\xc3\xa9 command\xc3\xa9e. Par exemple : Si vous avez command\xc3\xa9 100 unit\xc3\xa9s et que votre allocation est de 10% alors que vous \xc3\xaates autoris\xc3\xa9 \xc3\xa0 recevoir 110 unit\xc3\xa9s.'
+b'DocType: POS Customer Group',b'Customer Group',b'Groupe de Clients'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +217',b'Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Time Logs',b'Ligne # {0}: l&#39;op\xc3\xa9ration {1} n&#39;est pas termin\xc3\xa9e pour {2} quantit\xc3\xa9 de produits finis dans le bon de commande {3}. Veuillez mettre \xc3\xa0 jour l&#39;\xc3\xa9tat de l&#39;op\xc3\xa9ration via les journaux de temps'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +128',b'New Batch ID (Optional)',b'Nouveau Num\xc3\xa9ro de Lot (Optionnel)'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +201',b'Expense account is mandatory for item {0}',"b""Compte de charge est obligatoire pour l'article {0}"""
+b'DocType: BOM',b'Website Description',b'Description du Site Web'
+b'apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py +47',b'Net Change in Equity',b'Variation Nette de Capitaux Propres'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +220',b'Please cancel Purchase Invoice {0} first',"b""Veuillez d\xe2\x80\x99abord annuler la Facture d'Achat {0}"""
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +43',"b'Email Address must be unique, already exists for {0}'","b'Adresse Email doit \xc3\xaatre unique, existe d\xc3\xa9j\xc3\xa0 pour {0}'"
+b'DocType: Serial No',b'AMC Expiry Date',"b""Date d'Expiration CMA"""
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +880',b'Receipt',b'Re\xc3\xa7u'
+,b'Sales Register',b'Registre des Ventes'
+b'DocType: Daily Work Summary Group',b'Send Emails At',b'Envoyer Emails \xc3\x80'
+b'DocType: Quotation',b'Quotation Lost Reason',b'Raison de la Perte du Devis'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +381',b'Transaction reference no {0} dated {1}',b'R\xc3\xa9f\xc3\xa9rence de la transaction n\xc2\xb0 {0} dat\xc3\xa9e du {1}'
+b'apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5',b'There is nothing to edit.',"b""Il n'y a rien \xc3\xa0 modifier."""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +116',b'Summary for this month and pending activities',b'R\xc3\xa9sum\xc3\xa9 du mois et des activit\xc3\xa9s en suspens'
+b'apps/erpnext/erpnext/utilities/user_progress.py +248',"b'Add users to your organization, other than yourself.'","b'Ajoutez des utilisateurs, autres que vous-m\xc3\xaame, \xc3\xa0 votre organisation.'"
+b'DocType: Customer Group',b'Customer Group Name',b'Nom du Groupe Client'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +109',b'No Customers yet!',b'Pas encore de Clients!'
+b'apps/erpnext/erpnext/public/js/financial_statements.js +56',b'Cash Flow Statement',b'\xc3\x89tats des Flux de Tr\xc3\xa9sorerie'
+b'apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py +473',b'No material request created',b'Aucune demande de mat\xc3\xa9riel cr\xc3\xa9\xc3\xa9e'
+b'apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py +23',b'Loan Amount cannot exceed Maximum Loan Amount of {0}',b'Le Montant du pr\xc3\xaat ne peut pas d\xc3\xa9passer le Montant Maximal du Pr\xc3\xaat de {0}'
+b'apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py +22',b'License',b'Licence'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +491',b'Please remove this Invoice {0} from C-Form {1}',b'Veuillez retirez cette Facture {0} du C-Form {1}'
+b'DocType: Leave Control Panel',"b""Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year""","b""Veuillez s\xc3\xa9lectionnez Report si vous souhaitez \xc3\xa9galement inclure le solde des cong\xc3\xa9s de l'exercice pr\xc3\xa9c\xc3\xa9dent \xc3\xa0 cet exercice"""
+b'DocType: GL Entry',b'Against Voucher Type',b'Pour le Type de Bon'
+b'DocType: Physician',b'Phone (R)',b'T\xc3\xa9l\xc3\xa9phone (R)'
+b'apps/erpnext/erpnext/healthcare/doctype/physician_schedule/physician_schedule.js +56',b'Time slots added',b'Cr\xc3\xa9neaux Horaires Ajout\xc3\xa9s'
+b'DocType: Item',b'Attributes',b'Attributs'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +31',b'Enable Template',b'Activer le Mod\xc3\xa8le'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +226',b'Please enter Write Off Account',b'Veuillez entrer un Compte de Reprise'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +71',b'Last Order Date',b'Date de la Derni\xc3\xa8re Commande'
+b'DocType: Patient',b'B Negative',b'B N\xc3\xa9gatif'
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +25',b'Maintenance Status has to be Cancelled or Completed to Submit',b'Le statut de maintenance doit \xc3\xaatre annul\xc3\xa9 ou compl\xc3\xa9t\xc3\xa9 pour pouvoir \xc3\xaatre envoy\xc3\xa9'
+b'DocType: Hotel Room',b'Hotel Room',b'Chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +47',b'Account {0} does not belongs to company {1}',"b""Le compte {0} n'appartient pas \xc3\xa0 la soci\xc3\xa9t\xc3\xa9 {1}"""
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +884',b'Serial Numbers in row {0} does not match with Delivery Note',b'Les Num\xc3\xa9ros de S\xc3\xa9rie dans la ligne {0} ne correspondent pas au Bon de Livraison'
+b'DocType: Student',b'Guardian Details',b'D\xc3\xa9tails du Tuteur'
+b'DocType: C-Form',b'C-Form',b'Formulaire-C'
+b'apps/erpnext/erpnext/config/hr.py +18',b'Mark Attendance for multiple employees',b'Valider la Pr\xc3\xa9sence de plusieurs employ\xc3\xa9s'
+b'DocType: Agriculture Task',b'Start Day',b'Commence jour'
+b'DocType: Vehicle',b'Chassis No',b'N \xc2\xb0 de Ch\xc3\xa2ssis'
+b'DocType: Payment Request',b'Initiated',b'Initi\xc3\xa9'
+b'DocType: Production Plan Item',b'Planned Start Date',b'Date de D\xc3\xa9but Pr\xc3\xa9vue'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +618',b'Please select a BOM',b'Veuillez s\xc3\xa9lectionner une LDM'
+b'DocType: Purchase Invoice',b'Availed ITC Integrated Tax',b'Avoir int\xc3\xa9gr\xc3\xa9 l&#39;imp\xc3\xb4t int\xc3\xa9gr\xc3\xa9 de l&#39;ITC'
+b'DocType: Serial No',b'Creation Document Type',b'Type de Document de Cr\xc3\xa9ation'
+b'DocType: Project Task',b'View Timesheet',b'Afficher la feuille de temps'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +54',b'End date must be greater than start date',b'La date de fin doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 la date de d\xc3\xa9but'
+b'DocType: Leave Type',b'Is Encash',b'Est Encaissement'
+b'DocType: Leave Allocation',b'New Leaves Allocated',b'Nouvelle Allocation de Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/controllers/trends.py +269',b'Project-wise data is not available for Quotation',b'Les donn\xc3\xa9es par projet ne sont pas disponibles pour un devis'
+b'apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html +30',b'End on',b'Termine le'
+b'DocType: Project',b'Expected End Date',b'Date de Fin Pr\xc3\xa9vue'
+b'DocType: Budget Account',b'Budget Amount',b'Montant Budg\xc3\xa9taire'
+b'DocType: Donor',b'Donor Name',b'Nom du donateur'
+b'DocType: Appraisal Template',b'Appraisal Template Title',"b""Titre du mod\xc3\xa8le d'\xc3\xa9valuation"""
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +39',"b""From Date {0} for Employee {1} cannot be before employee's joining Date {2}""",b'La Date {0} pour l\xe2\x80\x99Employ\xc3\xa9 {1} ne peut pas \xc3\xaatre avant la Date d\xe2\x80\x99embauche {2} de l\xe2\x80\x99employ\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/user_progress_utils.py +29',b'Commercial',b'Commercial'
+b'DocType: Patient',b'Alcohol Current Use',"b""Consommation Actuelle d'Alcool"""
+b'DocType: Student Admission Program',b'Student Admission Program',b'Programme d&#39;admission des \xc3\xa9tudiants'
+b'DocType: Payment Entry',b'Account Paid To',b'Compte Pay\xc3\xa9 Au'
+b'apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py +24',b'Parent Item {0} must not be a Stock Item',"b""L'Article Parent {0} ne doit pas \xc3\xaatre un \xc3\x89l\xc3\xa9ment de Stock"""
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +466',b'Could not submit any Salary Slip <br>\\\n\t\t\tPossible reasons: <br>\\\n\t\t\t1. Net pay is less than 0. <br>\\\n\t\t\t2. Company Email Address specified in employee master is not valid. <br>',"b""Impossible de soumettre un bordereau de salaire <br> \\ Raisons possibles: <br> \\ 1. Le salaire net est inf\xc3\xa9rieur \xc3\xa0 0. <br> \\ 2. L'adresse e-mail de l'entreprise sp\xc3\xa9cifi\xc3\xa9e dans la fiche employ\xc3\xa9 n'est pas valide. <br>"""
+b'apps/erpnext/erpnext/config/selling.py +57',b'All Products or Services.',b'Tous les Produits ou Services.'
+b'DocType: Expense Claim',b'More Details',b'Plus de D\xc3\xa9tails'
+b'DocType: Supplier Quotation',b'Supplier Address',b'Adresse du Fournisseur'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +128',b'{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5}',b'{0} le Budget du Compte {1} pour {2} {3} est de {4}. Il d\xc3\xa9passera de {5}'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +695',"b""Row {0}# Account must be of type 'Fixed Asset'""","b""Ligne {0} # Le compte doit \xc3\xaatre de type \xe2\x80\x98Actif Immobilis\xc3\xa9'"""
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Out Qty',b'Qt\xc3\xa9 Sortante'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'and unchcked Disabled in the',b'et d\xc3\xa9sactiv\xc3\xa9 dans le'
+b'apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +41',b'Series is mandatory',b'S\xc3\xa9rie est obligatoire'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +28',b'Financial Services',b'Services Financiers'
+b'DocType: Student Sibling',b'Student ID',"b""Carte d'\xc3\x89tudiant"""
+b'apps/erpnext/erpnext/config/projects.py +51',b'Types of activities for Time Logs',"b""Types d'activit\xc3\xa9s pour Journaux de Temps"""
+b'DocType: Opening Invoice Creation Tool',b'Sales',b'Ventes'
+b'DocType: Stock Entry Detail',b'Basic Amount',b'Montant de Base'
+b'DocType: Training Event',b'Exam',b'Examen'
+b'DocType: Complaint',b'Complaint',b'Plainte'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +462',b'Warehouse required for stock Item {0}',"b""L\xe2\x80\x99entrep\xc3\xb4t est obligatoire pour l'article du stock {0}"""
+b'DocType: Leave Allocation',b'Unused leaves',b'Cong\xc3\xa9s non utilis\xc3\xa9s'
+b'DocType: Patient',b'Alcohol Past Use',"b""Consommation Pass\xc3\xa9e d'Alcool"""
+b'DocType: Fertilizer Content',b'Fertilizer Content',b'Contenu d&#39;engrais'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +187',b'Cr',b'Cr'
+b'DocType: Project Update',b'Problematic/Stuck',b'Probl\xc3\xa9matique / coinc\xc3\xa9'
+b'DocType: Tax Rule',b'Billing State',b'\xc3\x89tat de la Facturation'
+b'DocType: Share Transfer',b'Transfer',b'Transf\xc3\xa9rer'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +252',b'Work Order {0} must be cancelled before cancelling this Sales Order',b'Le bon de travail {0} doit \xc3\xaatre annul\xc3\xa9 avant d&#39;annuler cette commande client'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +917',b'Fetch exploded BOM (including sub-assemblies)',b'R\xc3\xa9cup\xc3\xa9rer la LDM \xc3\xa9clat\xc3\xa9e (y compris les sous-ensembles)'
+b'DocType: Authorization Rule',b'Applicable To (Employee)',b'Applicable \xc3\x80 (Employ\xc3\xa9)'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +137',b'Due Date is mandatory',b'La Date d\xe2\x80\x99\xc3\x89ch\xc3\xa9ance est obligatoire'
+b'apps/erpnext/erpnext/controllers/item_variant.py +82',b'Increment for Attribute {0} cannot be 0',"b""Incr\xc3\xa9ment pour l'Attribut {0} ne peut pas \xc3\xaatre 0"""
+b'apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py +19',b'Rooms Booked',b'Chambres r\xc3\xa9serv\xc3\xa9es'
+b'apps/erpnext/erpnext/crm/doctype/lead/lead.py +57',b'Ends On date cannot be before Next Contact Date.',b'Se termine le jour ne peut pas \xc3\xaatre avant la prochaine date de contact.'
+b'DocType: Journal Entry',b'Pay To / Recd From',b'Pay\xc3\xa9 \xc3\x80 / Re\xc3\xa7u De'
+b'DocType: Naming Series',b'Setup Series',b'Configuration des S\xc3\xa9ries'
+b'DocType: Payment Reconciliation',b'To Invoice Date',b'Date de Facture Finale'
+b'DocType: Shareholder',b'Contact HTML',b'HTML du Contact'
+b'apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py +19',b'Registration fee can not be Zero',b'Les frais d&#39;inscription ne peuvent pas \xc3\xaatre z\xc3\xa9ro'
+b'DocType: Disease',b'Treatment Period',b'P\xc3\xa9riode de traitement'
+b'apps/erpnext/erpnext/education/api.py +338',b'Result already Submitted',b'R\xc3\xa9sultat d\xc3\xa9j\xc3\xa0 soumis'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +169',b'Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied',b'L&#39;entrep\xc3\xb4t r\xc3\xa9serv\xc3\xa9 est obligatoire pour l&#39;article {0} dans les mati\xc3\xa8res premi\xc3\xa8res fournies'
+,b'Inactive Customers',b'Clients Inactifs'
+b'DocType: Student Admission Program',b'Maximum Age',b'\xc3\x82ge Maximum'
+b'apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py +28',b'Please wait 3 days before resending the reminder.',b'Veuillez patienter 3 jours avant de renvoyer le rappel.'
+b'DocType: Landed Cost Voucher',b'LCV',b'LCV'
+b'DocType: Landed Cost Voucher',b'Purchase Receipts',"b""Re\xc3\xa7us d'Achats"""
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +29',b'How Pricing Rule is applied?',b'Comment la R\xc3\xa8gle de Prix doit-elle \xc3\xaatre appliqu\xc3\xa9e ?'
+b'DocType: Stock Entry',b'Delivery Note No',b'Bon de Livraison N\xc2\xb0'
+b'DocType: Cheque Print Template',b'Message to show',b'Message \xc3\xa0 afficher'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +28',b'Retail',b'Vente de D\xc3\xa9tail'
+b'DocType: Student Attendance',b'Absent',b'Absent'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +591',b'Product Bundle',b'Ensemble de Produits'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +38',b'Unable to find score starting at {0}. You need to have standing scores covering 0 to 100',b'Impossible de trouver un score d\xc3\xa9marrant \xc3\xa0 {0}. Vous devez avoir des scores couvrant 0 \xc3\xa0 100'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +212',b'Row {0}: Invalid reference {1}',b'Ligne {0} : R\xc3\xa9f\xc3\xa9rence {1} non valide'
+b'DocType: Purchase Taxes and Charges Template',b'Purchase Taxes and Charges Template',"b""Mod\xc3\xa8le de Taxe et Frais d'Achat"""
+b'DocType: Timesheet',b'TS-',b'TS-'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61',b'{0} {1}: Either debit or credit amount is required for {2}',b'{0} {1} : Un montant est requis au d\xc3\xa9bit ou au cr\xc3\xa9dit pour {2}'
+b'DocType: GL Entry',b'Remarks',b'Remarques'
+b'DocType: Hotel Room Amenity',b'Hotel Room Amenity',b'\xc3\x89quipement de la chambre de l&#39;h\xc3\xb4tel'
+b'DocType: Payment Entry',b'Account Paid From',b'Compte Pay\xc3\xa9 Du'
+b'DocType: Purchase Order Item Supplied',b'Raw Material Item Code',b'Code d\xe2\x80\x99Article de Mati\xc3\xa8re Premi\xc3\xa8re'
+b'DocType: Task',b'Parent Task',b'T\xc3\xa2che Parente'
+b'DocType: Journal Entry',b'Write Off Based On',b'Reprise Bas\xc3\xa9e Sur'
+b'apps/erpnext/erpnext/utilities/activation.py +65',b'Make Lead',b'Faire un Prospect'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +112',b'Print and Stationery',b'Impression et Papeterie'
+b'DocType: Stock Settings',b'Show Barcode Field',b'Afficher Champ Code Barre'
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +809',b'Send Supplier Emails',b'Envoyer des Emails au Fournisseur'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +96',"b'Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.'","b'Salaire d\xc3\xa9j\xc3\xa0 trait\xc3\xa9 pour la p\xc3\xa9riode entre {0} et {1}, La p\xc3\xa9riode de demande de cong\xc3\xa9 ne peut pas \xc3\xaatre entre cette plage de dates.'"
+b'DocType: Chapter Member',b'Leave Reason',b'Laissez la raison'
+b'DocType: Guardian Interest',b'Guardian Interest',b'Part du Tuteur'
+b'DocType: Volunteer',b'Availability',b'Disponibilit\xc3\xa9'
+b'apps/erpnext/erpnext/config/accounts.py +319',b'Setup default values for POS Invoices',b'Configurer les valeurs par d\xc3\xa9faut pour les factures de point de vente'
+b'apps/erpnext/erpnext/config/hr.py +182',b'Training',b'Formation'
+b'DocType: Project',b'Time to send',b'Temps d&#39;envoyer'
+b'DocType: Timesheet',b'Employee Detail',b'D\xc3\xa9tail Employ\xc3\xa9'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +58',b'Guardian1 Email ID',b'ID Email du Tuteur1'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +68',"b""Next Date's day and Repeat on Day of Month must be equal""",b'Le jour de la Date Suivante et le Jour de R\xc3\xa9p\xc3\xa9tition du Mois doivent \xc3\xaatre \xc3\xa9gal'
+b'DocType: Lab Prescription',b'Test Code',b'Code de Test'
+b'apps/erpnext/erpnext/config/website.py +11',b'Settings for website homepage',"b""R\xc3\xa9glages pour la page d'accueil du site"""
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +40',b'RFQs are not allowed for {0} due to a scorecard standing of {1}',"b""Les Appels d'Offres ne sont pas autoris\xc3\xa9s pour {0} en raison d'une note de {1} sur la fiche d'\xc3\xa9valuation"""
+b'DocType: Job Offer',b'Awaiting Response',b'Attente de R\xc3\xa9ponse'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +60',b'Above',b'Au-dessus'
+b'apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js +1466',b'Total Amount {0}',b'Montant Total {0}'
+b'apps/erpnext/erpnext/controllers/item_variant.py +306',b'Invalid attribute {0} {1}',b'Attribut invalide {0} {1}'
+b'DocType: Supplier',b'Mention if non-standard payable account',"b""Veuillez mentionner s'il s'agit d'un compte cr\xc3\xa9diteur non standard"""
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py +25',"b""Please select the assessment group other than 'All Assessment Groups'""","b""S\xc3\xa9lectionnez un groupe d'\xc3\xa9valuation autre que \xc2\xabTous les Groupes d'\xc3\x89valuation\xc2\xbb"""
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +67',b'Row {0}: Cost center is required for an item {1}',b'Ligne {0}: le Centre de Co\xc3\xbbts est requis pour un article {1}'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureDate',b'EcritureDate'
+b'DocType: Training Event Employee',b'Optional',b'Optionnel'
+b'DocType: Salary Slip',b'Earning & Deduction',b'Revenus et D\xc3\xa9duction'
+b'DocType: Agriculture Analysis Criteria',b'Water Analysis',b'Analyse de l&#39;eau'
+b'DocType: Chapter',b'Region',b'R\xc3\xa9gion'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +38',b'Optional. This setting will be used to filter in various transactions.',b'Facultatif. Ce param\xc3\xa8tre sera utilis\xc3\xa9 pour filtrer diff\xc3\xa9rentes transactions.'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +110',b'Negative Valuation Rate is not allowed',"b""Taux de Valorisation N\xc3\xa9gatif n'est pas autoris\xc3\xa9"""
+b'DocType: Holiday List',b'Weekly Off',b'Jours de Cong\xc3\xa9 Hebdomadaire'
+b'apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js +7',b'Reload Linked Analysis',b'Recharger l&#39;analyse li\xc3\xa9e'
+b'DocType: Fiscal Year',"b'For e.g. 2012, 2012-13'","b'Par exemple: 2012, 2012-13'"
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +96',b'Provisional Profit / Loss (Credit)',b'Gain / Perte (Cr\xc3\xa9dit) Provisoire'
+b'DocType: Sales Invoice',b'Return Against Sales Invoice',b'Retour contre Facture de Vente'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +32',b'Item 5',b'Article 5'
+b'DocType: Serial No',b'Creation Time',b'Date de Cr\xc3\xa9ation'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62',b'Total Revenue',b'Revenu Total'
+b'DocType: Patient',b'Other Risk Factors',b'Autres facteurs de risque'
+b'DocType: Sales Invoice',b'Product Bundle Help',b'Aide pour les Ensembles de Produits'
+,b'Monthly Attendance Sheet',b'Feuille de Pr\xc3\xa9sence Mensuelle'
+b'apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py +15',b'No record found',b'Aucun enregistrement trouv\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +140',b'Cost of Scrapped Asset',b'Co\xc3\xbbt des Immobilisations Mises au Rebut'
+b'apps/erpnext/erpnext/controllers/stock_controller.py +236',b'{0} {1}: Cost Center is mandatory for Item {2}',b'{0} {1}: Centre de Co\xc3\xbbts est obligatoire pour l\xe2\x80\x99Article {2}'
+b'DocType: Vehicle',b'Policy No',b'Politique N\xc2\xb0'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +686',b'Get Items from Product Bundle',b'Obtenir les Articles du Produit Group\xc3\xa9'
+b'DocType: Asset',b'Straight Line',b'Lin\xc3\xa9aire'
+b'DocType: Project User',b'Project User',b'Utilisateur du Projet'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +72',b'Split',b'Fractionner'
+b'DocType: GL Entry',b'Is Advance',b'Est Accompte'
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +21',b'Attendance From Date and Attendance To Date is mandatory',"b""La Date de Pr\xc3\xa9sence Depuis et la Date de Pr\xc3\xa9sence Jusqu'\xc3\xa0 sont obligatoires"""
+b'apps/erpnext/erpnext/controllers/buying_controller.py +156',"b""Please enter 'Is Subcontracted' as Yes or No""","b""Veuillez entrer Oui ou Non pour 'Est sous-trait\xc3\xa9e'"""
+b'DocType: Item',b'Default Purchase Unit of Measure',"b""Unit\xc3\xa9 de Mesure par d\xc3\xa9faut \xc3\xa0 l'Achat"""
+b'apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py +29',b'Last Communication Date',b'Date de la Derni\xc3\xa8re Communication'
+b'DocType: Sales Team',b'Contact No.',b'N\xc2\xb0 du Contact'
+b'DocType: Bank Reconciliation',b'Payment Entries',b'\xc3\x89critures de Paiement'
+b'DocType: Land Unit',b'Land Unit Details',b'D\xc3\xa9tails de la parcelle'
+b'DocType: Land Unit',b'Latitude',b'Latitude'
+b'DocType: Work Order',b'Scrap Warehouse',b'Entrep\xc3\xb4t de Rebut'
+b'DocType: Work Order',b'Check if material transfer entry is not required',"b""V\xc3\xa9rifiez si une un transfert de mat\xc3\xa9riel n'est pas requis"""
+b'DocType: Program Enrollment Tool',b'Get Students From',b'Obtenir les \xc3\x89tudiants De'
+b'apps/erpnext/erpnext/config/learn.py +263',b'Publish Items on Website',b'Publier les Articles sur le Site Web'
+b'apps/erpnext/erpnext/utilities/activation.py +126',b'Group your students in batches',b'Regrouper vos \xc3\xa9tudiants en lots'
+b'DocType: Authorization Rule',b'Authorization Rule',"b""R\xc3\xa8gle d'Autorisation"""
+b'DocType: POS Profile',b'Offline POS Section',b'Section PDV Hors Ligne'
+b'DocType: Sales Invoice',b'Terms and Conditions Details',b'D\xc3\xa9tails des Termes et Conditions'
+b'apps/erpnext/erpnext/templates/generators/item.html +100',b'Specifications',b'Caract\xc3\xa9ristiques'
+b'DocType: Sales Taxes and Charges Template',b'Sales Taxes and Charges Template',b'Mod\xc3\xa8le de Taxes et Frais de Vente'
+b'apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +68',b'Total (Credit)',b'Total (Cr\xc3\xa9dit)'
+b'DocType: Repayment Schedule',b'Payment Date',b'Date de Paiement'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +122',b'New Batch Qty',b'Nouvelle Qt\xc3\xa9 de Lot'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +10',b'Apparel & Accessories',b'V\xc3\xaatements & Accessoires'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py +91',b'Could not solve weighted score function. Make sure the formula is valid.',b'Impossible de r\xc3\xa9soudre la fonction de score pond\xc3\xa9r\xc3\xa9. Assurez-vous que la formule est valide.'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +67',b'Number of Order',b'Nombre de Commandes'
+b'DocType: Item Group',b'HTML / Banner that will show on the top of product list.',b'HTML / banni\xc3\xa8re qui appara\xc3\xaetra sur le haut de la liste des produits.'
+b'DocType: Shipping Rule',b'Specify conditions to calculate shipping amount',b'Sp\xc3\xa9cifier les conditions pour calculer le montant de la livraison'
+b'DocType: Program Enrollment',"b""Institute's Bus""",b'Bus de l&#39;Institut'
+b'DocType: Accounts Settings',b'Role Allowed to Set Frozen Accounts & Edit Frozen Entries',b'R\xc3\xb4le Autoris\xc3\xa9 \xc3\xa0 Geler des Comptes & \xc3\xa0 \xc3\x89diter des \xc3\x89critures Gel\xc3\xa9es'
+b'DocType: Supplier Scorecard Scoring Variable',b'Path',b'Chemin'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28',b'Cannot convert Cost Center to ledger as it has child nodes',b'Conversion impossible du Centre de Co\xc3\xbbts en livre car il poss\xc3\xa8de des n\xc5\x93uds enfants'
+b'DocType: Production Plan',b'Total Planned Qty',b'Quantit\xc3\xa9 totale pr\xc3\xa9vue'
+b'apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +68',b'Opening Value',"b""Valeur d'Ouverture"""
+b'DocType: Salary Detail',b'Formula',b'Formule'
+b'apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +47',b'Serial #',b'S\xc3\xa9rie #'
+b'DocType: Lab Test Template',b'Lab Test Template',b'Mod\xc3\xa8le de test de laboratoire'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +181',b'Sales Account',b'Compte de vente'
+b'DocType: Purchase Invoice Item',b'Total Weight',b'Poids total'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +94',b'Commission on Sales',b'Commission sur les Ventes'
+b'DocType: Job Offer Term',b'Value / Description',b'Valeur / Description'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +630',"b'Row #{0}: Asset {1} cannot be submitted, it is already {2}'","b'Ligne #{0} : L\xe2\x80\x99Actif {1} ne peut pas \xc3\xaatre soumis, il est d\xc3\xa9j\xc3\xa0 {2}'"
+b'DocType: Tax Rule',b'Billing Country',b'Pays de Facturation'
+b'DocType: Purchase Order Item',b'Expected Delivery Date',b'Date de Livraison Pr\xc3\xa9vue'
+b'DocType: Restaurant Order Entry',b'Restaurant Order Entry',b'Entr\xc3\xa9e de commande de restaurant'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +134',b'Debit and Credit not equal for {0} #{1}. Difference is {2}.',b'D\xc3\xa9bit et Cr\xc3\xa9dit non \xc3\xa9gaux pour {0} # {1}. La diff\xc3\xa9rence est de {2}.'
+b'DocType: Asset Maintenance Task',b'Assign To Name',b'Attribuer au nom'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +98',b'Entertainment Expenses',b'Charges de Repr\xc3\xa9sentation'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +98',b'Make Material Request',b'Faire une Demande de Mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html +20',b'Open Item {0}',"b""Ouvrir l'Article {0}"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +222',b'Sales Invoice {0} must be cancelled before cancelling this Sales Order',"b""Facture de Vente {0} doit \xc3\xaatre annul\xc3\xa9e avant l'annulation de cette Commande Client"""
+b'DocType: Consultation',b'Age',b'\xc3\x82ge'
+b'DocType: Sales Invoice Timesheet',b'Billing Amount',b'Montant de Facturation'
+b'DocType: Cash Flow Mapping',b'Select Maximum Of 1',b'S\xc3\xa9lectionnez Maximum de 1'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84',b'Invalid quantity specified for item {0}. Quantity should be greater than 0.',"b""Quantit\xc3\xa9 sp\xc3\xa9cifi\xc3\xa9e invalide pour l'\xc3\xa9l\xc3\xa9ment {0}. Quantit\xc3\xa9 doit \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 0."""
+b'DocType: Company',b'Default Employee Advance Account',b'Compte d&#39;avances pour employ\xc3\xa9s par d\xc3\xa9faut'
+b'apps/erpnext/erpnext/config/hr.py +60',b'Applications for leave.',b'Demandes de cong\xc3\xa9.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +164',b'Account with existing transaction can not be deleted',b'Un compte contenant une transaction ne peut pas \xc3\xaatre supprim\xc3\xa9'
+b'DocType: Vehicle',b'Last Carbon Check',b'Derni\xc3\xa8re V\xc3\xa9rification Carbone'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102',b'Legal Expenses',b'Frais Juridiques'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +140',b'Please select quantity on row ',b'Veuillez s\xc3\xa9lectionner la quantit\xc3\xa9 sur la ligne'
+b'apps/erpnext/erpnext/config/accounts.py +277',b'Make Opening Sales and Purchase Invoices',b'Faire l&#39;ouverture des ventes et des factures d&#39;achat'
+b'DocType: Purchase Invoice',b'Posting Time',b'Heure de Publication'
+b'DocType: Timesheet',b'% Amount Billed',b'% Montant Factur\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +118',b'Telephone Expenses',b'Frais T\xc3\xa9l\xc3\xa9phoniques'
+b'DocType: Sales Partner',b'Logo',b'Logo'
+b'DocType: Naming Series',b'Check this if you want to force the user to select a series before saving. There will be no default if you check this.',"b""Cochez cette case si vous voulez forcer l'utilisateur \xc3\xa0 s\xc3\xa9lectionner une s\xc3\xa9rie avant de l'enregistrer. Il n'y aura pas de s\xc3\xa9rie par d\xc3\xa9faut si vous cochez cette case."""
+b'apps/erpnext/erpnext/stock/get_item_details.py +131',b'No Item with Serial No {0}',b'Aucun Article avec le N\xc2\xb0 de S\xc3\xa9rie {0}'
+b'DocType: Email Digest',b'Open Notifications',b'Ouvrir les Notifications'
+b'DocType: Payment Entry',b'Difference Amount (Company Currency)',b'\xc3\x89cart de Montant (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +79',b'Direct Expenses',b'Charges Directes'
+b'apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60',b'New Customer Revenue',b'Nouveaux Revenus de Client\xc3\xa8le'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +119',b'Travel Expenses',b'Frais de D\xc3\xa9placement'
+b'DocType: Maintenance Visit',b'Breakdown',b'Panne'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +50',b'Add custom field Subscription in the doctype {0}',b'Ajouter un champ personnalis\xc3\xa9 Abonnement dans le doctype {0}'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +820',b'Account: {0} with currency: {1} can not be selected',b'Compte : {0} avec la devise : {1} ne peut pas \xc3\xaatre s\xc3\xa9lectionn\xc3\xa9'
+b'DocType: Purchase Receipt Item',b'Sample Quantity',b'Quantit\xc3\xa9 d&#39;\xc3\xa9chantillon'
+b'DocType: Manufacturing Settings',"b'Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.'","b""Mettre \xc3\xa0 jour le co\xc3\xbbt de la LDM automatiquement via le Planificateur, en fonction du dernier taux de valorisation / tarif de la liste de prix / dernier prix d'achat des mati\xc3\xa8res premi\xc3\xa8res."""
+b'DocType: Bank Reconciliation Detail',b'Cheque Date',b'Date du Ch\xc3\xa8que'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +50',b'Account {0}: Parent account {1} does not belong to company: {2}',"b""Compte {0}: Le Compte parent {1} n'appartient pas \xc3\xa0 l'entreprise: {2}"""
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +106',b'Successfully deleted all transactions related to this company!',b'Suppression de toutes les transactions li\xc3\xa9es \xc3\xa0 cette soci\xc3\xa9t\xc3\xa9 avec succ\xc3\xa8s !'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27',b'As on Date',b'Comme \xc3\xa0 la date'
+b'DocType: Appraisal',b'HR',b'RH'
+b'DocType: Program Enrollment',b'Enrollment Date',"b""Date de l'Inscription"""
+b'DocType: Healthcare Settings',b'Out Patient SMS Alerts',b'Alertes SMS pour Patients'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +100',b'Probation',b'Essai'
+b'apps/erpnext/erpnext/config/hr.py +115',b'Salary Components',b'Composantes Salariales'
+b'DocType: Program Enrollment Tool',b'New Academic Year',b'Nouvelle Ann\xc3\xa9e Acad\xc3\xa9mique'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +811',b'Return / Credit Note',b'Retour / Note de Cr\xc3\xa9dit'
+b'DocType: Stock Settings',b'Auto insert Price List rate if missing',b'Insertion automatique du taux de la Liste de Prix si manquante'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +117',b'Total Paid Amount',b'Montant Total Pay\xc3\xa9'
+b'DocType: GST Settings',b'B2C Limit',b'Limite B2C'
+b'DocType: Work Order Item',b'Transferred Qty',b'Quantit\xc3\xa9 Transf\xc3\xa9r\xc3\xa9e'
+b'apps/erpnext/erpnext/config/learn.py +11',b'Navigating',b'Naviguer'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +188',b'Planning',b'Planification'
+b'DocType: Share Balance',b'Issued',b'Publi\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/student/student_dashboard.py +14',b'Student Activity',b'Activit\xc3\xa9 \xc3\x89tudiante'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +80',b'Supplier Id',b'ID du Fournisseur'
+b'DocType: Payment Request',b'Payment Gateway Details',b'D\xc3\xa9tails de la Passerelle de Paiement'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +276',b'Quantity should be greater than 0',b'Quantit\xc3\xa9 doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 0'
+b'DocType: Journal Entry',b'Cash Entry',b'\xc3\x89criture de Caisse'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js +17',"b""Child nodes can be only created under 'Group' type nodes""",b'Les noeuds enfants peuvent \xc3\xaatre cr\xc3\xa9\xc3\xa9s uniquement dans les n\xc5\x93uds de type &#39;Groupe&#39;'
+b'DocType: Leave Application',b'Half Day Date',b'Date de Demi-Journ\xc3\xa9e'
+b'DocType: Academic Year',b'Academic Year Name',"b""Nom de l'Ann\xc3\xa9e Acad\xc3\xa9mique"""
+b'DocType: Sales Partner',b'Contact Desc',b'Desc. du Contact'
+b'apps/erpnext/erpnext/config/hr.py +65',"b'Type of leaves like casual, sick etc.'","b'Type de cong\xc3\xa9 comme courant, maladie, etc.'"
+b'DocType: Email Digest',b'Send regular summary reports via Email.',b'Envoyer r\xc3\xa9guli\xc3\xa8rement des rapports de synth\xc3\xa8se par Email.'
+b'DocType: Payment Entry',b'PE-',b'PE-'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +282',b'Please set default account in Expense Claim Type {0}',b'Veuillez d\xc3\xa9finir le compte par d\xc3\xa9faut dans le Type de Note de Frais {0}'
+b'DocType: Assessment Result',b'Student Name',"b""Nom de l'\xc3\x89tudiant"""
+b'DocType: Brand',b'Item Manager',"b""Gestionnaire d'Article"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143',b'Payroll Payable',b'Paie \xc3\xa0 Payer'
+b'DocType: Buying Settings',b'Default Supplier Type',b'Type de Fournisseur par D\xc3\xa9faut'
+b'DocType: Plant Analysis',b'Collection Datetime',b'Collection Datetime'
+b'DocType: Work Order',b'Total Operating Cost',"b""Co\xc3\xbbt d'Exploitation Total"""
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +171',b'Note: Item {0} entered multiple times',b'Remarque : Article {0} saisi plusieurs fois'
+b'apps/erpnext/erpnext/config/selling.py +41',b'All Contacts.',b'Tous les Contacts.'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Company Abbreviation',b'Abr\xc3\xa9viation de la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/healthcare/doctype/physician/physician.py +47',b'User {0} does not exist',"b""Utilisateur {0} n'existe pas"""
+b'DocType: Payment Term',b'Day(s) after invoice date',b'Jour (s) apr\xc3\xa8s la date de la facture'
+b'DocType: Payment Schedule',b'Payment Schedule',b'Calendrier de paiement'
+b'DocType: Subscription',b'SUB-',b'SOUS-'
+b'DocType: Item Attribute Value',b'Abbreviation',b'Abr\xc3\xa9viation'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +195',b'Payment Entry already exists',b'L\xe2\x80\x99\xc3\x89criture de Paiement existe d\xc3\xa9j\xc3\xa0'
+b'apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36',b'Not authroized since {0} exceeds limits',b'Non autoris\xc3\xa9 car {0} d\xc3\xa9passe les limites'
+b'apps/erpnext/erpnext/config/hr.py +110',b'Salary template master.',b'Base du mod\xc3\xa8le de salaire.'
+b'apps/erpnext/erpnext/healthcare/setup.py +241',b'Pathology',b'Pathologie'
+b'DocType: Restaurant Order Entry',b'Restaurant Table',b'Table de restaurant'
+b'DocType: Hotel Room',b'Hotel Manager',b'Directeur de l&#39;h\xc3\xb4tel'
+b'DocType: Leave Type',b'Max Days Leave Allowed',b'Nombre Max de Jours de Cong\xc3\xa9 Autoris\xc3\xa9'
+b'apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +63',b'Set Tax Rule for shopping cart',"b""D\xc3\xa9finir la R\xc3\xa8gle d'Imp\xc3\xb4t pour le panier"""
+b'DocType: Purchase Invoice',b'Taxes and Charges Added',b'Taxes et Frais Additionnels'
+,b'Sales Funnel',b'Entonnoir de Vente'
+b'apps/erpnext/erpnext/setup/doctype/company/company.py +49',b'Abbreviation is mandatory',b'Abr\xc3\xa9viation est obligatoire'
+b'DocType: Project',b'Task Progress',b'Progression de la T\xc3\xa2che'
+b'apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html +7',b'Cart',b'Panier'
+,b'Qty to Transfer',b'Qt\xc3\xa9 \xc3\xa0 Transf\xc3\xa9rer'
+b'apps/erpnext/erpnext/config/selling.py +13',b'Quotes to Leads or Customers.',b'Devis de Prospects ou Clients.'
+b'DocType: Stock Settings',b'Role Allowed to edit frozen stock',b'R\xc3\xb4le Autoris\xc3\xa9 \xc3\xa0 modifier un stock gel\xc3\xa9'
+,b'Territory Target Variance Item Group-Wise',b'Variance de l\xe2\x80\x99Objectif par R\xc3\xa9gion et par Groupe d\xe2\x80\x99Article'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +143',b'All Customer Groups',b'Tous les Groupes Client'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +114',b'Accumulated Monthly',b'Cumul Mensuel'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +781',b'{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.',"b""{0} est obligatoire. Peut-\xc3\xaatre qu\xe2\x80\x99un enregistrement de Taux de Change n'est pas cr\xc3\xa9\xc3\xa9 pour {1} et {2}."""
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +44',b'Tax Template is mandatory.',b'Un Mod\xc3\xa8le de Taxe est obligatoire.'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +44',b'Account {0}: Parent account {1} does not exist',"b""Compte {0}: Le Compte parent {1} n'existe pas"""
+b'DocType: Purchase Invoice Item',b'Price List Rate (Company Currency)',b'Taux de la Liste de Prix (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Products Settings',b'Products Settings',b'R\xc3\xa9glages des Produits'
+,b'Item Price Stock',b'Article Prix Stock'
+b'DocType: Lab Prescription',b'Test Created',b'Test Cr\xc3\xa9\xc3\xa9'
+b'DocType: Healthcare Settings',b'Custom Signature in Print',b'Signature personnalis\xc3\xa9e dans l&#39;impression'
+b'DocType: Account',b'Temporary',b'Temporaire'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +107',b'Customer LPO No.',b'Num\xc3\xa9ro d&#39;ordre client'
+b'DocType: Program',b'Courses',b'Cours'
+b'DocType: Monthly Distribution Percentage',b'Percentage Allocation',b'Allocation en Pourcentage'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +128',b'Secretary',b'Secr\xc3\xa9taire'
+b'DocType: Global Defaults',"b""If disable, 'In Words' field will not be visible in any transaction""","b""Si coch\xc3\xa9, le champ 'En Lettre' ne sera visible dans aucune transaction"""
+b'DocType: Serial No',b'Distinct unit of an Item',"b""Unit\xc3\xa9 distincte d'un Article"""
+b'DocType: Supplier Scorecard Criteria',b'Criteria Name',b'Nom du Crit\xc3\xa8re'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +1295',b'Please set Company',b'Veuillez s\xc3\xa9lectionner une Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Pricing Rule',b'Buying',b'Achat'
+b'apps/erpnext/erpnext/config/agriculture.py +24',b'Diseases & Fertilizers',b'Maladies et engrais'
+b'DocType: HR Settings',b'Employee Records to be created by',"b""Dossiers de l'Employ\xc3\xa9s ont \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9es par"""
+b'DocType: Patient',b'AB Negative',b'AB N\xc3\xa9gatif'
+b'DocType: Sample Collection',b'SMPL-',b'SMPL-'
+b'DocType: POS Profile',b'Apply Discount On',b'Appliquer R\xc3\xa9duction Sur'
+b'DocType: Member',b'Membership Type',b'Type d&#39;adh\xc3\xa9sion'
+,b'Reqd By Date',b'Requis par Date'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +140',b'Creditors',b'Cr\xc3\xa9diteurs'
+b'DocType: Assessment Plan',b'Assessment Name',"b""Nom de l'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js +94',b'Show PDC in Print',b'Afficher PDC dans Imprimer'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +97',b'Row # {0}: Serial No is mandatory',b'Ligne # {0} : N\xc2\xb0 de s\xc3\xa9rie est obligatoire'
+b'DocType: Purchase Taxes and Charges',b'Item Wise Tax Detail',b'D\xc3\xa9tail des Taxes par Article'
+b'apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13',b'Job Offer',b'Offre d&#39;emploi'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +71',b'Institute Abbreviation',"b""Abr\xc3\xa9viation de l'Institut"""
+,b'Item-wise Price List Rate',b'Taux de la Liste des Prix par Article'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1082',b'Supplier Quotation',b'Devis Fournisseur'
+b'DocType: Quotation',b'In Words will be visible once you save the Quotation.',b'En Toutes Lettres. Sera visible une fois que vous enregistrerez le Devis.'
+b'apps/erpnext/erpnext/utilities/transaction_base.py +164',b'Quantity ({0}) cannot be a fraction in row {1}',b'La quantit\xc3\xa9 ({0}) ne peut pas \xc3\xaatre une fraction dans la ligne {1}'
+b'DocType: Consultation',b'C-',b'C-'
+b'DocType: Attendance',b'ATT-',b'ATT-'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +492',b'Barcode {0} already used in Item {1}',"b""Le Code Barre {0} est d\xc3\xa9j\xc3\xa0 utilis\xc3\xa9 dans l'article {1}"""
+b'apps/erpnext/erpnext/config/selling.py +86',b'Rules for adding shipping costs.',"b""R\xc3\xa8gles pour l'ajout de frais de port."""
+b'DocType: Hotel Room',b'Extra Bed Capacity',b'Capacit\xc3\xa9 de lit suppl\xc3\xa9mentaire'
+b'DocType: Item',b'Opening Stock',"b""Stock d'Ouverture"""
+b'apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20',b'Customer is required',b'Client est requis'
+b'DocType: Lab Test',b'Result Date',b'Date de R\xc3\xa9sultat'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +77',b'PDC/LC Date',b'PDC / LC Date'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +20',b'{0} is mandatory for Return',b'{0} est obligatoire pour un Retour'
+b'DocType: Purchase Order',b'To Receive',b'\xc3\x80 Recevoir'
+b'apps/erpnext/erpnext/utilities/user_progress.py +252',b'user@example.com',b'utilisateur@exemple.com'
+b'DocType: Asset',b'Asset Owner',"b""Propri\xc3\xa9taire de l'Actif"""
+b'DocType: Employee',b'Personal Email',b'Email Personnel'
+b'apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +57',b'Total Variance',b'Variance Totale'
+b'DocType: Accounts Settings',"b'If enabled, the system will post accounting entries for inventory automatically.'","b""Si activ\xc3\xa9, le syst\xc3\xa8me publiera automatiquement les \xc3\xa9critures comptables pour l'inventaire."""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +15',b'Brokerage',b'Courtage'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +195',b'Attendance for employee {0} is already marked for this day',"b""La pr\xc3\xa9sence de l'employ\xc3\xa9 {0} est d\xc3\xa9j\xc3\xa0 marqu\xc3\xa9e pour cette journ\xc3\xa9e"""
+b'DocType: Work Order Operation',"b""in Minutes\nUpdated via 'Time Log'""","b""en Minutes Mises \xc3\xa0 Jour via le 'Journal des Temps'"""
+b'DocType: Customer',b'From Lead',b'Du Prospect'
+b'apps/erpnext/erpnext/config/manufacturing.py +13',b'Orders released for production.',b'Commandes valid\xc3\xa9es pour la production.'
+b'apps/erpnext/erpnext/public/js/account_tree_grid.js +65',b'Select Fiscal Year...',b'S\xc3\xa9lectionner Exercice ...'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +567',b'POS Profile required to make POS Entry',b'Profil PDV n\xc3\xa9cessaire pour faire une \xc3\xa9criture de PDV'
+b'DocType: Program Enrollment Tool',b'Enroll Students',b'Inscrire des \xc3\x89tudiants'
+b'DocType: Lab Test',b'Approved Date',b'Date Approuv\xc3\xa9e'
+b'apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py +21',b'Standard Selling',b'Vente Standard'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165',b'Atleast one warehouse is mandatory',b'Au moins un entrep\xc3\xb4t est obligatoire'
+b'DocType: Serial No',b'Out of Warranty',b'Hors Garantie'
+b'DocType: BOM Update Tool',b'Replace',b'Remplacer'
+b'apps/erpnext/erpnext/templates/includes/product_list.js +42',b'No products found.',b'Aucun Produit trouv\xc3\xa9.'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +360',b'{0} against Sales Invoice {1}',b'{0} pour la Facture de Vente {1}'
+b'DocType: Antibiotic',b'Laboratory User',b'Utilisateur de laboratoire'
+b'DocType: Sales Invoice',b'SINV-',b'SINV-'
+b'DocType: Request for Quotation Item',b'Project Name',b'Nom du Projet'
+b'DocType: Customer',b'Mention if non-standard receivable account',"b""Mentionner si le compte d\xc3\xa9biteur n'est pas standard"""
+b'DocType: Journal Entry Account',b'If Income or Expense',b'Si Produits ou Charges'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py +288',b'Select interest income account in employee loan {0}',b'S\xc3\xa9lectionnez le compte de revenu d&#39;int\xc3\xa9r\xc3\xaats dans le pr\xc3\xaat-emploi {0}'
+b'DocType: Work Order',b'Required Items',b'Articles Requis'
+b'DocType: Stock Ledger Entry',b'Stock Value Difference',b'Diff\xc3\xa9rence de Valeur du Sock'
+b'apps/erpnext/erpnext/config/learn.py +229',b'Human Resource',b'Ressource Humaine'
+b'DocType: Payment Reconciliation Payment',b'Payment Reconciliation Payment',b'Paiement de R\xc3\xa9conciliation des Paiements'
+b'DocType: Disease',b'Treatment Task',b'T\xc3\xa2che de traitement'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +38',b'Tax Assets',"b""Actifs d'Imp\xc3\xb4ts"""
+b'DocType: BOM Item',b'BOM No',b'N\xc2\xb0 LDM'
+b'DocType: Instructor',b'INS/',b'INS/'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +160',b'Journal Entry {0} does not have account {1} or already matched against other voucher',"b""L\xe2\x80\x99\xc3\x89criture de Journal {0} n'a pas le compte {1} ou est d\xc3\xa9j\xc3\xa0 r\xc3\xa9concili\xc3\xa9e avec une autre pi\xc3\xa8ce justificative"""
+b'DocType: Item',b'Moving Average',b'Moyenne Mobile'
+b'DocType: BOM Update Tool',b'The BOM which will be replaced',b'La LDM qui sera remplac\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +46',b'Electronic Equipments',b'Equipements \xc3\x89lectroniques'
+b'DocType: Asset',b'Maintenance Required',b'Maintenance requise'
+b'DocType: Account',b'Debit',b'D\xc3\xa9bit'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +49',b'Leaves must be allocated in multiples of 0.5',"b'Les Cong\xc3\xa9s doivent \xc3\xaatre allou\xc3\xa9s par multiples de 0,5'"
+b'DocType: Work Order',b'Operation Cost',"b""Co\xc3\xbbt de l'Op\xc3\xa9ration"""
+b'apps/erpnext/erpnext/config/hr.py +29',b'Upload attendance from a .csv file',"b""Charger les participations \xc3\xa0 partir d'un fichier .csv"""
+b'apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +45',b'Outstanding Amt',b'Montant en suspens'
+b'DocType: Sales Person',b'Set targets Item Group-wise for this Sales Person.',"b""D\xc3\xa9finir des objectifs par Groupe d'Articles pour ce Commercial"""
+b'DocType: Stock Settings',b'Freeze Stocks Older Than [Days]',b'Geler les Articles plus Anciens que [Jours]'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +600',b'Row #{0}: Asset is mandatory for fixed asset purchase/sale',b'Ligne #{0} : L\xe2\x80\x99Actif est obligatoire pour les achats / ventes d\xe2\x80\x99actifs immobilis\xc3\xa9s'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Name',b'Nom de l&#39;\xc3\xa9quipe de maintenance'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +42',"b'If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.'","b""Si deux R\xc3\xa8gles de Prix ou plus sont trouv\xc3\xa9es sur la base des conditions ci-dessus, une Priorit\xc3\xa9 est appliqu\xc3\xa9e. La Priorit\xc3\xa9 est un nombre compris entre 0 et 20 avec une valeur par d\xc3\xa9faut de z\xc3\xa9ro (vide). Les nombres les plus \xc3\xa9l\xc3\xa9v\xc3\xa9s sont prioritaires s'il y a plusieurs R\xc3\xa8gles de Prix avec m\xc3\xaames conditions."""
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +197',"b""Customer is mandatory if 'Opportunity From' is selected as Customer""",b'Le client est obligatoire si l&#39;option &quot;Opportunit\xc3\xa9 de&quot; est s\xc3\xa9lectionn\xc3\xa9e en tant que client'
+b'apps/erpnext/erpnext/controllers/trends.py +36',b'Fiscal Year: {0} does not exists',"b""Exercice Fiscal: {0} n'existe pas"""
+b'DocType: Currency Exchange',b'To Currency',b'Devise Finale'
+b'DocType: Leave Block List',b'Allow the following users to approve Leave Applications for block days.',b'Autoriser les utilisateurs suivant \xc3\xa0 approuver les demandes de cong\xc3\xa9s durant les jours bloqu\xc3\xa9s.'
+b'apps/erpnext/erpnext/config/hr.py +137',b'Types of Expense Claim.',b'Types de Notes de Frais.'
+b'apps/erpnext/erpnext/controllers/selling_controller.py +148',b'Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2}',"b""Le prix de vente pour l'\xc3\xa9l\xc3\xa9ment {0} est inf\xc3\xa9rieur \xc3\xa0 son {1}. Le prix de vente devrait \xc3\xaatre au moins {2}"""
+b'DocType: Item',b'Taxes',b'Taxes'
+b'DocType: Purchase Invoice',b'capital goods',b'biens d&#39;\xc3\xa9quipement'
+b'DocType: Purchase Invoice Item',b'Weight Per Unit',b'Poids par unit\xc3\xa9'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +344',b'Paid and Not Delivered',b'Pay\xc3\xa9 et Non Livr\xc3\xa9'
+b'DocType: Project',b'Default Cost Center',b'Centre de Co\xc3\xbbts par D\xc3\xa9faut'
+b'DocType: Bank Guarantee',b'End Date',b'Date de Fin'
+b'apps/erpnext/erpnext/config/stock.py +7',b'Stock Transactions',b'Transactions du Stock'
+b'DocType: Budget',b'Budget Accounts',b'Comptes de Budgets'
+b'DocType: Employee',b'Internal Work History',b'Historique de Travail Interne'
+b'DocType: Depreciation Schedule',b'Accumulated Depreciation Amount',"b""Montant d'Amortissement Cumul\xc3\xa9"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +42',b'Private Equity',b'Capital Risque'
+b'DocType: Supplier Scorecard Variable',b'Supplier Scorecard Variable',"b""Variable de la Fiche d'\xc3\x89valuation Fournisseur"""
+b'DocType: Employee Loan',b'Fully Disbursed',b'Enti\xc3\xa8rement Rembours\xc3\xa9'
+b'DocType: Employee Advance',b'Due Advance Amount',b'Montant anticip\xc3\xa9 d\xc3\xbb'
+b'DocType: Maintenance Visit',b'Customer Feedback',"b""Retour d'Exp\xc3\xa9rience Client"""
+b'DocType: Account',b'Expense',b'Charges'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js +54',b'Score cannot be greater than Maximum Score',b'Score ne peut pas \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 Score maximum'
+b'apps/erpnext/erpnext/utilities/user_progress.py +129',b'Customers and Suppliers',b'Clients et Fournisseurs'
+b'DocType: Item Attribute',b'From Range',b'Plage Initiale'
+b'DocType: BOM',b'Set rate of sub-assembly item based on BOM',b'D\xc3\xa9finir le prix des articles de sous-assemblage en fonction de la LDM'
+b'DocType: Hotel Room Reservation',b'Invoiced',b'Factur\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +98',b'Syntax error in formula or condition: {0}',b'Erreur de syntaxe dans la formule ou condition : {0}'
+b'DocType: Daily Work Summary Settings Company',b'Daily Work Summary Settings Company',b'Param\xc3\xa8tres du R\xc3\xa9capitulatif Quotidien de la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/stock/utils.py +125',b'Item {0} ignored since it is not a stock item',"b""L'article {0} est ignor\xc3\xa9 puisqu'il n'est pas en stock"""
+b'DocType: Appraisal',b'APRSL',b'EVAL'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +23',"b'To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.'","b'Pour ne pas appliquer la R\xc3\xa8gle de Tarification dans une transaction particuli\xc3\xa8re, toutes les R\xc3\xa8gles de Tarification applicables doivent \xc3\xaatre d\xc3\xa9sactiv\xc3\xa9es.'"
+b'DocType: Payment Term',b'Day(s) after the end of the invoice month',b'Jour (s) apr\xc3\xa8s la fin du mois de facture'
+b'DocType: Assessment Group',b'Parent Assessment Group',b'Groupe d\xe2\x80\x99\xc3\x89valuation Parent'
+b'apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py +27',b'Jobs',b'Emplois'
+,b'Sales Order Trends',b'Tendances des Commandes Client'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51',"b""The 'From Package No.' field must neither be empty nor it's value less than 1.""","b""Le 'No de Paquet .' Le champ ne doit pas \xc3\xaatre vide ni sa valeur \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 1."""
+b'DocType: Employee',b'Held On',b'Tenu le'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js +36',b'Production Item',b'Article de Production'
+,b'Employee Information',"b""Renseignements sur l'Employ\xc3\xa9"""
+b'DocType: Stock Entry Detail',b'Additional Cost',b'Frais Suppl\xc3\xa9mentaire'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +48',"b'Can not filter based on Voucher No, if grouped by Voucher'","b'Impossible de filtrer sur la base du N\xc2\xb0 de Coupon, si les lignes sont regroup\xc3\xa9es par Coupon'"
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js +918',b'Make Supplier Quotation',b'Cr\xc3\xa9er un Devis Fournisseur'
+b'DocType: Quality Inspection',b'Incoming',b'Entrant'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +70',b'Default tax templates for sales and purchase are created.',b'Les mod\xc3\xa8les de taxe par d\xc3\xa9faut pour les ventes et les achats sont cr\xc3\xa9\xc3\xa9s.'
+b'apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py +57',b'Assessment Result record {0} already exists.',"b""Le R\xc3\xa9sultat d'\xc3\x89valuation {0} existe d\xc3\xa9j\xc3\xa0."""
+b'DocType: BOM',b'Materials Required (Exploded)',b'Mat\xc3\xa9riel Requis (\xc3\x89clat\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py +60',"b""Please set Company filter blank if Group By is 'Company'""","b""Veuillez laisser le filtre de la Soci\xc3\xa9t\xc3\xa9 vide si Group By est 'Soci\xc3\xa9t\xc3\xa9'"""
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +66',b'Posting Date cannot be future date',b'La Date de Publication ne peut pas \xc3\xaatre une date future'
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +102',b'Row # {0}: Serial No {1} does not match with {2} {3}',b'Ligne # {0} : N\xc2\xb0 de s\xc3\xa9rie {1} ne correspond pas \xc3\xa0 {2} {3}'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +10',b'for generating the recurring',b'pour g\xc3\xa9n\xc3\xa9rer le document r\xc3\xa9current'
+b'DocType: Stock Entry',b'Target Warehouse Address',b'Adresse de l&#39;entrep\xc3\xb4t cible'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +86',b'Casual Leave',b'Cong\xc3\xa9 Occasionnel'
+b'DocType: Agriculture Task',b'End Day',b'Jour de fin'
+b'DocType: Batch',b'Batch ID',b'ID du Lot'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +380',b'Note: {0}',b'Note : {0}'
+,b'Delivery Note Trends',b'Tendance des Bordereaux de Livraisons'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +112',"b""This Week's Summary""",b'R\xc3\xa9sum\xc3\xa9 Hebdomadaire'
+b'apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py +22',b'In Stock Qty',b'Qt\xc3\xa9 En Stock'
+b'DocType: Delivery Trip',b'Calculate Estimated Arrival Times',b'Calculer les heures d&#39;arriv\xc3\xa9e estim\xc3\xa9es'
+b'apps/erpnext/erpnext/accounts/general_ledger.py +113',b'Account: {0} can only be updated via Stock Transactions',b'Compte : {0} peut uniquement \xc3\xaatre mis \xc3\xa0 jour via les Mouvements de Stock'
+b'DocType: Student Group Creation Tool',b'Get Courses',b'Obtenir les Cours'
+b'DocType: GL Entry',b'Party',b'Tiers'
+b'DocType: Healthcare Settings',b'Patient Name',b'Nom du patient'
+b'DocType: Variant Field',b'Variant Field',b'Champ de Variante'
+b'DocType: Sales Order',b'Delivery Date',b'Date de Livraison'
+b'DocType: Opportunity',b'Opportunity Date',"b""Date d'Opportunit\xc3\xa9"""
+b'DocType: Employee',b'Health Insurance Provider',b'Fournisseur d&#39;assurance maladie'
+b'DocType: Purchase Receipt',b'Return Against Purchase Receipt',"b""Retour contre Re\xc3\xa7u d'Achat"""
+b'DocType: Water Analysis',b'Person Responsible',b'Personne responsable'
+b'DocType: Request for Quotation Item',b'Request for Quotation Item',"b""Article de l'Appel d'Offre"""
+b'DocType: Purchase Order',b'To Bill',b'\xc3\x80 Facturer'
+b'DocType: Material Request',b'% Ordered',b'% Command\xc3\xa9'
+b'DocType: Education Settings',"b'For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.'","b'Pour un groupe \xc3\xa9tudiant bas\xc3\xa9 sur un cours, le cours sera valid\xc3\xa9 pour chaque \xc3\xa9l\xc3\xa8ve inscrit aux cours du programme.'"
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +103',b'Piecework',b'Travail \xc3\xa0 la Pi\xc3\xa8ce'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70',b'Avg. Buying Rate',"b""Moy. Taux d'achat"""
+b'DocType: Share Balance',b'From No',b'De Non'
+b'DocType: Task',b'Actual Time (in Hours)',b'Temps R\xc3\xa9el (en Heures)'
+b'DocType: Employee',b'History In Company',b'Anciennet\xc3\xa9 dans la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +270',b'New Message from {sender}',b'Nouveau message de {exp\xc3\xa9diteur}'
+b'DocType: Customer',b'Customer Primary Address',b'Adresse principale du client'
+b'apps/erpnext/erpnext/config/learn.py +107',b'Newsletters',b'Newsletters'
+b'DocType: Drug Prescription',b'Description/Strength',b'Description / Force'
+b'DocType: Share Balance',b'Is Company',b'Est Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Stock Ledger Entry',b'Stock Ledger Entry',"b""\xc3\x89criture du Livre d'Inventaire"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +83',b'Same item has been entered multiple times',b'Le m\xc3\xaame article a \xc3\xa9t\xc3\xa9 saisi plusieurs fois'
+b'DocType: Department',b'Leave Block List',b'Liste de Blocage des Cong\xc3\xa9s'
+b'DocType: Purchase Invoice',b'Tax ID',"b""Num\xc3\xa9ro d'Identification Fiscale"""
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +192',b'Item {0} is not setup for Serial Nos. Column must be blank',"b""L'article {0} n'est pas configur\xc3\xa9 pour un Num\xc3\xa9ros de S\xc3\xa9rie. La colonne doit \xc3\xaatre vide"""
+b'DocType: Accounts Settings',b'Accounts Settings',b'Param\xc3\xa8tres des Comptes'
+b'apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js +11',b'Approve',b'Approuver'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +69',"b'Malformatted address for {0}, please fix to continue.'","b'Adresse malformat\xc3\xa9e pour {0}, veuillez corriger pour continuer.'"
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +28',"b'Number of new Account, it will be included in the account name as a prefix'","b'Num\xc3\xa9ro du nouveau compte, il sera inclus dans le nom du compte en tant que pr\xc3\xa9fixe'"
+b'DocType: Maintenance Team Member',b'Team Member',b'Membre de l&#39;\xc3\xa9quipe'
+b'apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js +151',b'No Result to submit',b'Aucun r\xc3\xa9sultat \xc3\xa0 soumettre'
+b'DocType: Customer',b'Sales Partner and Commission',b'Partenaire Commercial et Commission'
+b'DocType: Employee Loan',b'Rate of Interest (%) / Year',"b""Taux d'Int\xc3\xa9r\xc3\xaat (%) / Ann\xc3\xa9e"""
+,b'Project Quantity',b'Quantit\xc3\xa9 de Projet'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +79',"b""Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'""","b'Le Total {0} pour tous les articles est nul, peut-\xc3\xaatre devriez-vous modifier \xe2\x80\x98Distribuez les Frais sur la Base de\xe2\x80\x99'"
+b'DocType: Opportunity',b'To Discuss',b'\xc3\x80 Discuter'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +377',b'{0} units of {1} needed in {2} to complete this transaction.',b'{0} unit\xc3\xa9s de {1} n\xc3\xa9cessaires dans {2} pour compl\xc3\xa9ter cette transaction.'
+b'DocType: Loan Type',b'Rate of Interest (%) Yearly',"b""Taux d'Int\xc3\xa9r\xc3\xaat (%) Annuel"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +71',b'Temporary Accounts',b'Comptes Temporaires'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +207',b'Black',b'Noir'
+b'DocType: BOM Explosion Item',b'BOM Explosion Item',b'Article Eclat\xc3\xa9 LDM'
+b'DocType: Shareholder',b'Contact List',b'Liste de contacts'
+b'DocType: Account',b'Auditor',b'Auditeur'
+b'DocType: Project',b'Frequency To Collect Progress',b'Fr\xc3\xa9quence pour collecter les progr\xc3\xa8s'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +132',b'{0} items produced',b'{0} articles produits'
+b'apps/erpnext/erpnext/utilities/user_progress.py +58',b'Learn More',b'Apprendre Plus'
+b'DocType: Cheque Print Template',b'Distance from top edge',b'Distance du bord sup\xc3\xa9rieur'
+b'apps/erpnext/erpnext/stock/get_item_details.py +367',b'Price List {0} is disabled or does not exist',"b""Liste des Prix {0} est d\xc3\xa9sactiv\xc3\xa9e ou n'existe pas"""
+b'DocType: Purchase Invoice',b'Return',b'Retour'
+b'DocType: Pricing Rule',b'Disable',b'D\xc3\xa9sactiver'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +180',b'Mode of payment is required to make a payment',b'Mode de paiement est requis pour effectuer un paiement'
+b'DocType: Project Task',b'Pending Review',b'Revue en Attente'
+b'apps/erpnext/erpnext/public/js/utils/item_quick_entry.js +14',"b'Edit in full page for more options like assets, serial nos, batches etc.'","b'Modifier en pleine page pour plus d&#39;options comme les actifs, les num\xc3\xa9ros de s\xc3\xa9rie, les lots, etc.'"
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py +10',b'Appointments and Consultations',b'Rendez-Vous et Consultations'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +41',b'{0} - {1} is not enrolled in the Batch {2}',"b""{0} - {1} n'est pas inscrit dans le Lot {2}"""
+b'apps/erpnext/erpnext/assets/doctype/asset/depreciation.py +113',"b'Asset {0} cannot be scrapped, as it is already {1}'","b""L'actif {0} ne peut pas \xc3\xaatre mis au rebut, car il est d\xc3\xa9j\xc3\xa0 {1}"""
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +77',b'Cheques Required',b'Ch\xc3\xa8ques requis'
+b'DocType: Task',b'Total Expense Claim (via Expense Claim)',b'Total des Notes de Frais (via Note de Frais)'
+b'apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js +177',b'Mark Absent',b'Marquer Absent'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +40',b'Failed to setup company',b'\xc3\x89chec de la configuration de la soci\xc3\xa9t\xc3\xa9'
+b'DocType: Asset Repair',b'Asset Repair',"b""R\xc3\xa9paration d'Actif"""
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +143',b'Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2}',b'Ligne {0} : La devise de la LDM #{1} doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 la devise s\xc3\xa9lectionn\xc3\xa9e {2}'
+b'DocType: Journal Entry Account',b'Exchange Rate',b'Taux de Change'
+b'DocType: Patient',b'Additional information regarding the patient',b'Informations compl\xc3\xa9mentaires concernant le patient'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +585',b'Sales Order {0} is not submitted',"b""Commande Client {0} n'a pas \xc3\xa9t\xc3\xa9 transmise"""
+b'DocType: Homepage',b'Tag Line',b'Ligne de Tag'
+b'DocType: Fee Component',b'Fee Component',"b""Composant d'Honoraires"""
+b'apps/erpnext/erpnext/config/hr.py +204',b'Fleet Management',b'Gestion de Flotte'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +1080',b'Add items from',b'Ajouter des articles de'
+b'apps/erpnext/erpnext/config/agriculture.py +7',b'Crops & Lands',b'Cultures et terres'
+b'DocType: Cheque Print Template',b'Regular',b'Ordinaire'
+b'DocType: Fertilizer',b'Density (if liquid)',b'Densit\xc3\xa9 (si liquide)'
+b'apps/erpnext/erpnext/education/doctype/course/course.py +20',b'Total Weightage of all Assessment Criteria must be 100%',"b""Le total des pond\xc3\xa9rations de tous les Crit\xc3\xa8res d'\xc3\x89valuation doit \xc3\xaatre \xc3\xa9gal \xc3\xa0 100%"""
+b'DocType: Purchase Order Item',b'Last Purchase Rate',"b""Dernier Prix d'Achat"""
+b'DocType: Account',b'Asset',b'Actif'
+b'DocType: Project Task',b'Task ID',b'T\xc3\xa2che ID'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +84',b'Stock cannot exist for Item {0} since has variants',"b""Stock ne peut pas exister pour l'Article {0} puisqu'il a des variantes"""
+b'DocType: Lab Test',b'Mobile',b'Mobile'
+,b'Sales Person-wise Transaction Summary',b'R\xc3\xa9sum\xc3\xa9 des Transactions par Commerciaux'
+b'DocType: Training Event',b'Contact Number',b'Num\xc3\xa9ro de Contact'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +73',b'Warehouse {0} does not exist',"b""L'entrep\xc3\xb4t {0} n'existe pas"""
+b'DocType: Monthly Distribution',b'Monthly Distribution Percentages',b'Pourcentages de R\xc3\xa9partition Mensuelle'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.py +110',b'The selected item cannot have Batch',b'L\xe2\x80\x99article s\xc3\xa9lectionn\xc3\xa9 ne peut pas avoir de Lot'
+b'DocType: Delivery Note',b'% of materials delivered against this Delivery Note',b'% de mat\xc3\xa9riaux livr\xc3\xa9s pour ce Bon de Livraison'
+b'DocType: Asset Maintenance Log',b'Has Certificate',b'A un certificat'
+b'DocType: Project',b'Customer Details',b'D\xc3\xa9tails du client'
+b'DocType: Asset',b'Check if Asset requires Preventive Maintenance or Calibration',b'V\xc3\xa9rifier si l&#39;actif n\xc3\xa9cessite une maintenance pr\xc3\xa9ventive ou un \xc3\xa9talonnage'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +87',b'Company Abbreviation cannot have more than 5 characters',b'L&#39;abr\xc3\xa9viation de l&#39;entreprise ne peut pas comporter plus de 5 caract\xc3\xa8res'
+b'DocType: Employee',b'Reports to',b'Rapports \xc3\x80'
+,b'Unpaid Expense Claim',b'Note de Frais Impay\xc3\xa9e'
+b'DocType: Payment Entry',b'Paid Amount',b'Montant Pay\xc3\xa9'
+b'apps/erpnext/erpnext/utilities/user_progress.py +158',b'Explore Sales Cycle',b'Explorez le Cycle de Vente'
+b'DocType: Assessment Plan',b'Supervisor',b'Superviseur'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +869',b'Retention Stock Entry',b'Entr\xc3\xa9e de Stock de r\xc3\xa9tention'
+,b'Available Stock for Packing Items',"b""Stock Disponible pour les Articles d'Emballage"""
+b'DocType: Item Variant',b'Item Variant',"b""Variante de l'Article"""
+,b'Work Order Stock Report',b'Rapport de stock de commande'
+b'DocType: Assessment Result Tool',b'Assessment Result Tool',"b""Outil de R\xc3\xa9sultat d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/education/doctype/instructor/instructor.js +24',b'As Supervisor',b'En tant que superviseur'
+b'DocType: BOM Scrap Item',b'BOM Scrap Item',b'Article Mis au Rebut LDM'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +895',b'Submitted orders can not be deleted',b'Commandes Soumises ne peuvent pas \xc3\xaatre supprim\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +114',"b""Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'""","b""Le solde du compte est d\xc3\xa9j\xc3\xa0 d\xc3\xa9biteur, vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 d\xc3\xa9finir 'Solde Doit \xc3\x8atre' comme 'Cr\xc3\xa9diteur'"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +118',b'Quality Management',b'Gestion de la Qualit\xc3\xa9'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +41',b'Item {0} has been disabled',"b""L'article {0} a \xc3\xa9t\xc3\xa9 d\xc3\xa9sactiv\xc3\xa9"""
+b'DocType: Project',b'Total Billable Amount (via Timesheets)',b'Montant total facturable (via les feuilles de temps)'
+b'DocType: Agriculture Task',b'Previous Business Day',b'Jour ouvrable pr\xc3\xa9c\xc3\xa9dent'
+b'DocType: Employee Loan',b'Repay Fixed Amount per Period',b'Rembourser un Montant Fixe par P\xc3\xa9riode'
+b'DocType: Employee',b'Health Insurance No',b'Assurance-maladie Non'
+b'apps/erpnext/erpnext/buying/utils.py +47',b'Please enter quantity for Item {0}',"b""Veuillez entrer une quantit\xc3\xa9 pour l'article {0}"""
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +215',b'Credit Note Amt',b'Mnt de la Note de Cr\xc3\xa9dit'
+b'DocType: Employee External Work History',b'Employee External Work History',"b""Ant\xc3\xa9c\xc3\xa9dents Professionnels de l'Employ\xc3\xa9"""
+b'DocType: Opening Invoice Creation Tool',b'Purchase',b'Achat'
+b'apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +37',b'Balance Qty',b'Solde de la Qt\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +20',b'Goals cannot be empty',b'Les objectifs ne peuvent pas \xc3\xaatre vides'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js +15',b'Enrolling students',b'Inscription des \xc3\xa9tudiants'
+b'DocType: Item Group',b'Parent Item Group',b'Groupe d\xe2\x80\x99Articles Parent'
+b'DocType: Appointment Type',b'Appointment Type',b'Type de Rendez-Vous'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +21',b'{0} for {1}',b'{0} pour {1}'
+b'DocType: Healthcare Settings',b'Valid number of days',b'Nombre de Jours Ouvr\xc3\xa9s'
+b'apps/erpnext/erpnext/setup/doctype/company/company.js +39',b'Cost Centers',b'Centres de Co\xc3\xbbts'
+b'DocType: Land Unit',b'Linked Plant Analysis',b'Analyse des plantes li\xc3\xa9es'
+b'DocType: Purchase Receipt',"b""Rate at which supplier's currency is converted to company's base currency""",b'Taux auquel la devise du fournisseur est convertie en devise soci\xc3\xa9t\xc3\xa9 de base'
+b'apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36',b'Row #{0}: Timings conflicts with row {1}',b'Ligne #{0}: Minutage en conflit avec la ligne {1}'
+b'DocType: Purchase Invoice Item',b'Allow Zero Valuation Rate',b'Autoriser un Taux de Valorisation \xc3\x89gal \xc3\xa0 Z\xc3\xa9ro'
+b'DocType: Training Event Employee',b'Invited',b'Invit\xc3\xa9'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +178',b'Multiple active Salary Structures found for employee {0} for the given dates',"b""Plusieurs Grilles de Salaires Actives trouv\xc3\xa9es pour l'employ\xc3\xa9 {0} pour les dates donn\xc3\xa9es"""
+b'apps/erpnext/erpnext/config/accounts.py +308',b'Setup Gateway accounts.',b'Configuration des Comptes passerelle.'
+b'DocType: Employee',b'Employment Type',"b""Type d'Emploi"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +42',b'Fixed Assets',b'Actifs Immobilis\xc3\xa9s'
+b'DocType: Payment Entry',b'Set Exchange Gain / Loss',b'D\xc3\xa9finir le change Gain / Perte'
+,b'GST Purchase Register',"b""Registre d'Achat GST"""
+,b'Cash Flow',b'Flux de Tr\xc3\xa9sorerie'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +25',b'Combined invoice portion must equal 100%',b'La portion combin\xc3\xa9e de la facture doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 100%'
+b'DocType: Item Group',b'Default Expense Account',b'Compte de Charges par D\xc3\xa9faut'
+b'DocType: GST Account',b'CGST Account',b'Compte CGST'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +53',b'Student Email ID',"b""ID Email de l'\xc3\x89tudiant"""
+b'DocType: Employee',b'Notice (days)',b'Pr\xc3\xa9avis (jours)'
+b'DocType: Tax Rule',b'Sales Tax Template',b'Mod\xc3\xa8le de la Taxe de Vente'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +2510',b'Select items to save the invoice',b'S\xc3\xa9lectionner les articles pour sauvegarder la facture'
+b'DocType: Employee',b'Encashment Date',"b""Date de l'Encaissement"""
+b'DocType: Training Event',b'Internet',b'Internet'
+b'DocType: Special Test Template',b'Special Test Template',b'Mod\xc3\xa8le de Test Sp\xc3\xa9cial'
+b'DocType: Account',b'Stock Adjustment',b'Ajustement du Stock'
+b'apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +34',b'Default Activity Cost exists for Activity Type - {0}',b'Un Co\xc3\xbbt d\xe2\x80\x99Activit\xc3\xa9 par d\xc3\xa9fault existe pour le Type d\xe2\x80\x99Activit\xc3\xa9 {0}'
+b'DocType: Work Order',b'Planned Operating Cost',b'Co\xc3\xbbts de Fonctionnement Pr\xc3\xa9vus'
+b'DocType: Academic Term',b'Term Start Date',b'Date de D\xc3\xa9but du Terme'
+b'apps/erpnext/erpnext/config/accounts.py +471',b'List of all share transactions',b'Liste de toutes les transactions sur actions'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +18',b'Opp Count',"b""Compte d'Opportunit\xc3\xa9s"""
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +244',b'Please find attached {0} #{1}',b'Veuillez trouver ci-joint {0} # {1}'
+b'apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py +52',b'Average Rate',b'Taux moyen'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +728',b'Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total',"b""Le montant total du paiement dans l'\xc3\xa9ch\xc3\xa9ancier doit \xc3\xaatre \xc3\xa9gal au Total G\xc3\xa9n\xc3\xa9ral / Total Arrondi"""
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +34',b'Bank Statement balance as per General Ledger',b'Solde du Relev\xc3\xa9 Bancaire d\xe2\x80\x99apr\xc3\xa8s le Grand Livre'
+b'DocType: Job Applicant',b'Applicant Name',b'Nom du Candidat'
+b'DocType: Authorization Rule',b'Customer / Item Name',"b""Nom du Client / de l'Article"""
+b'DocType: Buying Settings',"b'If enabled, last purchase details of items will not be fetched from previous purchase order or purchase receipt'","b'Si cette option est activ\xc3\xa9e, les derniers d\xc3\xa9tails d&#39;achat des articles ne seront pas r\xc3\xa9cup\xc3\xa9r\xc3\xa9s \xc3\xa0 partir du bon de commande pr\xc3\xa9c\xc3\xa9dent ou du re\xc3\xa7u d&#39;achat.'"
+b'DocType: Product Bundle',"b'Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. \n\nThe package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".\n\nFor Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.\n\nNote: BOM = Bill of Materials'","b'Regroupement d\' **Articles** dans un autre **Article**. Ceci est utile si vous regroupez certains **Articles** dans un lot et que vous maintenez l\'inventaire des **Articles** du lot et non de l\'**Article** compos\xc3\xa9. L\'**Article** compos\xc3\xa9 aura ""Article En Stock"" \xc3\xa0 ""Non"" et ""Article \xc3\x80 Vendre"" \xc3\xa0 ""Oui"". Exemple : Si vous vendez des Ordinateurs Portables et Sacs \xc3\xa0 Dos s\xc3\xa9par\xc3\xa9ment et qu\'il y a un prix sp\xc3\xa9cial si le client ach\xc3\xa8te les deux, alors l\'Ordinateur Portable + le Sac \xc3\xa0 Dos sera un nouveau Produit Group\xc3\xa9. Remarque: LDM = Liste\nDes Mat\xc3\xa9riaux'"
+b'apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +42',b'Serial No is mandatory for Item {0}',"b""N\xc2\xb0 de S\xc3\xa9rie est obligatoire pour l'Article {0}"""
+b'DocType: Item Variant Attribute',b'Attribute',b'Attribut'
+b'apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +43',b'Please specify from/to range',b'Veuillez pr\xc3\xa9ciser la plage de / \xc3\xa0'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js +28',b'Opening {0} Invoice created',b'Ouverture {0} Facture cr\xc3\xa9\xc3\xa9e'
+b'DocType: Serial No',b'Under AMC',b'Sous AMC'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +55',b'Item valuation rate is recalculated considering landed cost voucher amount',"b""Le taux d'\xc3\xa9valuation de l'article est recalcul\xc3\xa9 compte tenu du montant du bon de prix au d\xc3\xa9barquement"""
+b'apps/erpnext/erpnext/config/selling.py +153',b'Default settings for selling transactions.',b'Param\xc3\xa8tres par d\xc3\xa9faut pour les transactions de vente.'
+b'DocType: Guardian',b'Guardian Of ',b'Tuteur De'
+b'DocType: Grading Scale Interval',b'Threshold',b'Seuil'
+b'DocType: BOM Update Tool',b'Current BOM',b'LDM Actuelle'
+b'apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +32',b'Balance (Dr - Cr)',b'Balance (Dr - Cr)'
+b'apps/erpnext/erpnext/public/js/utils.js +55',b'Add Serial No',b'Ajouter un Num\xc3\xa9ro de s\xc3\xa9rie'
+b'DocType: Work Order Item',b'Available Qty at Source Warehouse',"b""Qt\xc3\xa9 Disponible \xc3\xa0 l'Entrep\xc3\xb4t Source"""
+b'apps/erpnext/erpnext/config/support.py +22',b'Warranty',b'Garantie'
+b'DocType: Purchase Invoice',b'Debit Note Issued',b'Notes de D\xc3\xa9bit \xc3\x89mises'
+b'DocType: Work Order',b'Warehouses',b'Entrep\xc3\xb4ts'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +18',b'{0} asset cannot be transferred',b'{0} actif ne peut pas \xc3\xaatre transf\xc3\xa9r\xc3\xa9'
+b'DocType: Hotel Room Pricing',b'Hotel Room Pricing',b'Prix de la chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +80',b'This Item is a Variant of {0} (Template).',b'Cet article est une Variante de {0} (Mod\xc3\xa8le).'
+b'DocType: Workstation',b'per hour',b'par heure'
+b'apps/erpnext/erpnext/config/buying.py +7',b'Purchasing',b'Achat'
+b'DocType: Announcement',b'Announcement',b'Annonce'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +84',b'Customer LPO',b'LPO client'
+b'DocType: Education Settings',"b'For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.'","b'Pour un groupe \xc3\xa9tudiant bas\xc3\xa9 sur un lot, le lot \xc3\xa9tudiant sera valid\xc3\xa9 pour chaque \xc3\xa9l\xc3\xa8ve inscrit au programme.'"
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +50',b'Warehouse can not be deleted as stock ledger entry exists for this warehouse.',"b""L'entrep\xc3\xb4t ne peut pas \xc3\xaatre supprim\xc3\xa9 car une \xc3\xa9criture existe dans le Livre d'Inventaire pour cet entrep\xc3\xb4t."""
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +25',b'Distribution',b'Distribution'
+b'DocType: Expense Claim Advance',b'Expense Claim Advance',b'Demande de remboursement anticip\xc3\xa9'
+b'DocType: Lab Test',b'Report Preference',b'Pr\xc3\xa9f\xc3\xa9rence de Rapport'
+b'apps/erpnext/erpnext/config/non_profit.py +43',b'Volunteer information.',b'Informations sur le b\xc3\xa9n\xc3\xa9volat'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +133',b'Project Manager',b'Chef de Projet'
+,b'Quoted Item Comparison',"b""Comparaison d'Article Soumis"""
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +34',b'Overlap in scoring between {0} and {1}',b'Chevauchement dans la notation entre {0} et {1}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +114',b'Dispatch',b'Envoi'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +74',b'Max discount allowed for item: {0} is {1}%',"b""R\xc3\xa9duction max autoris\xc3\xa9e pour l'article : {0} est de {1} %"""
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +176',b'Net Asset value as on',b'Valeur Nette des Actifs au'
+b'DocType: Crop',b'Produce',b'Produire'
+b'DocType: Hotel Settings',b'Default Taxes and Charges',b'Taxes et frais de d\xc3\xa9faut'
+b'DocType: Account',b'Receivable',b'Cr\xc3\xa9ance'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +308',b'Row #{0}: Not allowed to change Supplier as Purchase Order already exists',b'Ligne #{0} : Changement de Fournisseur non autoris\xc3\xa9 car un Bon de Commande existe d\xc3\xa9j\xc3\xa0'
+b'DocType: Accounts Settings',b'Role that is allowed to submit transactions that exceed credit limits set.',b'R\xc3\xb4le qui est autoris\xc3\xa9 \xc3\xa0 soumettre des transactions qui d\xc3\xa9passent les limites de cr\xc3\xa9dit fix\xc3\xa9es.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +989',b'Select Items to Manufacture',b'S\xc3\xa9lectionner les Articles \xc3\xa0 Fabriquer'
+b'DocType: Delivery Stop',b'Delivery Stop',b'Arr\xc3\xaat de Livraison'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +963',"b'Master data syncing, it might take some time'","b'Donn\xc3\xa9es de base en cours de synchronisation, cela peut prendre un certain temps'"
+b'DocType: Item',b'Material Issue',b'Sortie de Mat\xc3\xa9riel'
+b'DocType: Employee Education',b'Qualification',b'Qualification'
+b'apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js +42',b'View Salary Slips',b'Voir les bulletins de salaire'
+b'DocType: Item Price',b'Item Price',"b""Prix de l'Article"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +48',b'Soap & Detergent',b'Savons & D\xc3\xa9tergents'
+b'DocType: BOM',b'Show Items',b'Afficher les Articles'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py +30',b'From Time cannot be greater than To Time.',b'L\xe2\x80\x99Horaire Initial ne peut pas \xc3\xaatre post\xc3\xa9rieur \xc3\xa0 l\xe2\x80\x99Horaire Final'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +92',b'Do you want to notify all the customers by email?',b'Voulez-vous informer tous les clients par courriel?'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +36',b'Motion Picture & Video',b'Cin\xc3\xa9ma & Vid\xc3\xa9o'
+b'apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5',b'Ordered',b'Command\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js +51',b'Resume',b'CV'
+b'DocType: Salary Detail',b'Component',b'Composant'
+b'DocType: Assessment Criteria',b'Assessment Criteria Group',"b""Groupe de Crit\xc3\xa8re d'\xc3\x89valuation"""
+b'DocType: Healthcare Settings',b'Patient Name By',b'Nom du patient par'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +72',b'Opening Accumulated Depreciation must be less than equal to {0}',"b""Amortissement Cumul\xc3\xa9 d'Ouverture doit \xc3\xaatre inf\xc3\xa9rieur ou \xc3\xa9gal \xc3\xa0 {0}"""
+b'DocType: Warehouse',b'Warehouse Name',"b""Nom de l'Entrep\xc3\xb4t"""
+b'DocType: Naming Series',b'Select Transaction',b'S\xc3\xa9lectionner la Transaction'
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30',b'Please enter Approving Role or Approving User',b'Veuillez entrer un R\xc3\xb4le Approbateur ou un R\xc3\xb4le Utilisateur'
+b'DocType: Journal Entry',b'Write Off Entry',b'\xc3\x89criture de Reprise'
+b'DocType: BOM',b'Rate Of Materials Based On',b'Prix des Mat\xc3\xa9riaux Bas\xc3\xa9 sur'
+b'apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21',b'Support Analtyics',b'Analyse du Support'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +102',b'Uncheck all',b'D\xc3\xa9cocher tout'
+b'DocType: POS Profile',b'Terms and Conditions',b'Termes et Conditions'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +49',b'To Date should be within the Fiscal Year. Assuming To Date = {0}',"b""La Date Finale doit \xc3\xaatre dans l'exercice. En supposant Date Finale = {0}"""
+b'DocType: Employee',"b'Here you can maintain height, weight, allergies, medical concerns etc'","b'Ici vous pouvez conserver la hauteur, le poids, les allergies, les pr\xc3\xa9occupations m\xc3\xa9dicales etc.'"
+b'DocType: Leave Block List',b'Applies to Company',"b""S'applique \xc3\xa0 la Soci\xc3\xa9t\xc3\xa9"""
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +231',b'Cannot cancel because submitted Stock Entry {0} exists',"b""Impossible d'annuler car l'\xc3\x89criture de Stock soumise {0} existe"""
+b'DocType: Employee Loan',b'Disbursement Date',b'Date de D\xc3\xa9caissement'
+b'apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py +80',"b""'Recipients' not specified""",b'\xc2\xabDestinataires\xc2\xbb non sp\xc3\xa9cifi\xc3\xa9s'
+b'DocType: BOM Update Tool',b'Update latest price in all BOMs',b'Mettre \xc3\xa0 jour le prix le plus r\xc3\xa9cent dans toutes les LDMs'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +23',b'Medical Record',b'Dossier m\xc3\xa9dical'
+b'DocType: Vehicle',b'Vehicle',b'V\xc3\xa9hicule'
+b'DocType: Purchase Invoice',b'In Words',b'En Toutes Lettres'
+b'apps/erpnext/erpnext/hr/doctype/training_result/training_result.py +15',b'{0} must be submitted',b'{0} doit \xc3\xaatre soumis'
+b'DocType: POS Profile',b'Item Groups',b'Groupes d&#39;articles'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +221',"b""Today is {0}'s birthday!""","b""Aujourd'hui c'est l\xe2\x80\x99anniversaire de {0} !"""
+b'DocType: Sales Order Item',b'For Production',b'Pour la Production'
+b'DocType: Payment Request',b'payment_url',b'payment_url'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +186',b'Please add a Temporary Opening account in Chart of Accounts',b'Veuillez ajouter un compte d&#39;ouverture temporaire dans le plan comptable'
+b'DocType: Customer',b'Customer Primary Contact',b'Contact principal du client'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +154',b'Period Closing Journal',b'P\xc3\xa9riode Cl\xc3\xb4ture Journal'
+b'DocType: Project Task',b'View Task',b'Voir T\xc3\xa2che'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +22',b'Opp/Lead %',b'Opp / Prospect %'
+b'DocType: Material Request',b'MREQ-',b'MREQ-'
+b'DocType: Payment Schedule',b'Invoice Portion',b'Portion de facture'
+,b'Asset Depreciations and Balances',"b""Amortissements et Soldes d'Actif"""
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +370',b'Amount {0} {1} transferred from {2} to {3}',b'Montant {0} {1} transf\xc3\xa9r\xc3\xa9 de {2} \xc3\xa0 {3}'
+b'DocType: Sales Invoice',b'Get Advances Received',b'Obtenir Acomptes Re\xc3\xa7us'
+b'DocType: Email Digest',b'Add/Remove Recipients',b'Ajouter/Supprimer des Destinataires'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19',"b""To set this Fiscal Year as Default, click on 'Set as Default'""","b'Pour d\xc3\xa9finir cet Exercice Fiscal par d\xc3\xa9faut, cliquez sur ""D\xc3\xa9finir par d\xc3\xa9faut""'"
+b'DocType: Production Plan',b'Include Subcontracted Items',b'Inclure les articles sous-trait\xc3\xa9s'
+b'apps/erpnext/erpnext/projects/doctype/project/project.py +220',b'Join',b'Joindre'
+b'apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +21',b'Shortage Qty',b'Qt\xc3\xa9 de P\xc3\xa9nurie'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +672',b'Cannot change Variant properties after stock transction. You will have to make a new Item to do this.',"b""Impossible de modifier les propri\xc3\xa9t\xc3\xa9s de la variante suite \xc3\xa0 des mouvements d'inventaire. Vous devrez cr\xc3\xa9er un nouvel objet pour le faire."""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +714',b'Item variant {0} exists with same attributes',"b""La variante de l'article {0} existe avec les m\xc3\xaames caract\xc3\xa9ristiques"""
+b'DocType: Employee Loan',b'Repay from Salary',b'Rembourser avec le Salaire'
+b'DocType: Leave Application',b'LAP/',b'LAP/'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +360',b'Requesting payment against {0} {1} for amount {2}',b'Demande de Paiement pour {0} {1} pour le montant {2}'
+b'DocType: Salary Slip',b'Salary Slip',b'Fiche de Paie'
+b'DocType: Lead',b'Lost Quotation',b'Devis Perdu'
+b'apps/erpnext/erpnext/utilities/user_progress.py +221',b'Student Batches',"b""Lots d'\xc3\x89tudiants"""
+b'DocType: Pricing Rule',b'Margin Rate or Amount',b'Taux de Marge ou Montant'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +48',"b""'To Date' is required""","b""'Date de Fin' est requise"""
+b'DocType: Packing Slip',"b'Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.'","b'G\xc3\xa9n\xc3\xa9rer les bordereaux des colis \xc3\xa0 livrer. Utilis\xc3\xa9 pour indiquer le num\xc3\xa9ro de colis, le contenu et son poids.'"
+b'DocType: Sales Invoice Item',b'Sales Order Item',b'Article de la Commande Client'
+b'DocType: Salary Slip',b'Payment Days',b'Jours de Paiement'
+b'DocType: Stock Settings',b'Convert Item Description to Clean HTML',b'Convertir la description de l&#39;\xc3\xa9l\xc3\xa9ment pour nettoyer le code HTML'
+b'DocType: Patient',b'Dormant',b'Dormant'
+b'DocType: Salary Slip',b'Total Interest Amount',b'Montant total de l&#39;int\xc3\xa9r\xc3\xaat'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +124',b'Warehouses with child nodes cannot be converted to ledger',b'Les entrep\xc3\xb4ts avec n\xc5\x93uds enfants ne peuvent pas \xc3\xaatre convertis en livre'
+b'DocType: BOM',b'Manage cost of operations',"b""G\xc3\xa9rer les co\xc3\xbbts d'exploitation"""
+b'DocType: Accounts Settings',b'Stale Days',b'Journ\xc3\xa9es Pass\xc3\xa9es'
+b'DocType: Notification Control',"b'When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.'","b'Lorsque certaines des transactions contr\xc3\xb4l\xc3\xa9es sont ""Soumises"", une pop-up email s\'ouvre automatiquement pour envoyer un email au ""Contact"" associ\xc3\xa9 dans cette transaction, avec la transaction en pi\xc3\xa8ce jointe. L\'utilisateur peut ou peut ne pas envoyer l\'email.'"
+b'apps/erpnext/erpnext/config/setup.py +14',b'Global Settings',b'Param\xc3\xa8tres Globaux'
+b'DocType: Crop',b'Row Spacing UOM',b'UOM d&#39;espacement des lignes'
+b'DocType: Assessment Result Detail',b'Assessment Result Detail',"b""D\xc3\xa9tails des R\xc3\xa9sultats d'\xc3\x89valuation"""
+b'DocType: Employee Education',b'Employee Education',"b""Formation de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +53',b'Duplicate item group found in the item group table',"b""Groupe d\xe2\x80\x99articles en double trouv\xc3\xa9 dans la table des groupes d'articles"""
+b'DocType: Land Unit',b'Parent Land Unit',b'Parcelle parente'
+b'apps/erpnext/erpnext/public/js/controllers/transaction.js +1113',b'It is needed to fetch Item Details.',"b""N\xc3\xa9cessaire pour aller chercher les D\xc3\xa9tails de l'Article."""
+b'DocType: Fertilizer',b'Fertilizer Name',b'Nom de l&#39;engrais'
+b'DocType: Salary Slip',b'Net Pay',b'Salaire Net'
+b'DocType: Cash Flow Mapping Accounts',b'Account',b'Compte'
+b'apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +217',b'Serial No {0} has already been received',b'N\xc2\xb0 de S\xc3\xa9rie {0} a d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 re\xc3\xa7u'
+,b'Requested Items To Be Transferred',b'Articles Demand\xc3\xa9s \xc3\xa0 Transf\xc3\xa9rer'
+b'DocType: Expense Claim',b'Vehicle Log',b'Journal du V\xc3\xa9hicule'
+b'DocType: Vital Signs',b'Presence of a fever (temp &gt; 38.5 \xc2\xb0C/101.3 \xc2\xb0F or sustained temp &gt; 38 \xc2\xb0C/100.4 \xc2\xb0F)',b'Pr\xc3\xa9sence de fi\xc3\xa8vre (temp&gt; 38.5 \xc2\xb0 C / 101.3 \xc2\xb0 F ou temp\xc3\xa9rature soutenue&gt; 38 \xc2\xb0 C / 100.4 \xc2\xb0 F)'
+b'DocType: Customer',b'Sales Team Details',"b""D\xc3\xa9tails de l'\xc3\x89quipe des Ventes"""
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1352',b'Delete permanently?',b'Supprimer d\xc3\xa9finitivement ?'
+b'DocType: Expense Claim',b'Total Claimed Amount',b'Montant Total R\xc3\xa9clam\xc3\xa9'
+b'apps/erpnext/erpnext/config/crm.py +17',b'Potential opportunities for selling.',b'Opportunit\xc3\xa9s potentielles de vente.'
+b'DocType: Shareholder',b'Folio no.',b'Folio no.'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +246',b'Invalid {0}',b'Invalide {0}'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +90',b'Sick Leave',b'Cong\xc3\xa9 Maladie'
+b'DocType: Email Digest',b'Email Digest',b'Envoyer par Mail le Compte Rendu'
+b'DocType: Delivery Note',b'Billing Address Name',"b""Nom de l'Adresse de Facturation"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +22',b'Department Stores',b'Grands Magasins'
+,b'Item Delivery Date',"b""Date de Livraison de l'Article"""
+b'DocType: Production Plan',b'Material Requested',b'Mat\xc3\xa9riel demand\xc3\xa9'
+b'DocType: Warehouse',b'PIN',b'PIN'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py +116',"b""Error '{0}' occured. Arguments {1}.""",b'Une erreur &#39;{0}&#39; s&#39;est produite. Arguments {1}.'
+b'DocType: Bin',b'Reserved Qty for sub contract',b'Qt\xc3\xa9 r\xc3\xa9serv\xc3\xa9e pour le sous-contrat'
+b'DocType: Patient Service Unit',b'Patinet Service Unit',b'Unit\xc3\xa9 de service Patinet'
+b'DocType: Sales Invoice',b'Base Change Amount (Company Currency)',b'Montant de Base \xc3\xa0 Rendre (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +304',b'No accounting entries for the following warehouses',b'Pas d\xe2\x80\x99\xc3\xa9critures comptables pour les entrep\xc3\xb4ts suivants'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +95',b'Save the document first.',"b""Enregistrez le document d'abord."""
+b'apps/erpnext/erpnext/shopping_cart/cart.py +74',b'Only {0} in stock for item {1}',b'Seulement {0} en stock pour l&#39;article {1}'
+b'DocType: Account',b'Chargeable',b'Facturable'
+b'DocType: Company',b'Change Abbreviation',"b""Changer l'Abr\xc3\xa9viation"""
+b'apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py +66',b'Pay {0} {1}',b'Payer {0} {1}'
+b'DocType: Expense Claim Detail',b'Expense Date',b'Date de la Note de Frais'
+b'DocType: Item',b'Max Discount (%)',b'R\xc3\xa9duction Max (%)'
+b'apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py +30',b'Credit Days cannot be a negative number',b'Les jours de cr\xc3\xa9dit ne peuvent pas \xc3\xaatre un nombre n\xc3\xa9gatif'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +70',b'Last Order Amount',b'Montant de la Derni\xc3\xa8re Commande'
+b'DocType: Cash Flow Mapper',b'e.g Adjustments for:',b'par exemple des ajustements pour:'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +275',"b' {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item'","b'{0} Conserver l&#39;\xc3\xa9chantillon est bas\xc3\xa9 sur le lot, s&#39;il vous pla\xc3\xaet v\xc3\xa9rifier A Lot non pour conserver l&#39;\xc3\xa9chantillon de l&#39;article'"
+b'DocType: Task',b'Is Milestone',b'Est un Jalon'
+b'DocType: Delivery Stop',b'Email Sent To',b'Email Envoy\xc3\xa9 \xc3\x80'
+b'DocType: Budget',b'Warn',b'Avertir'
+b'apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.js +81',b'Are you sure you want to unregister?',b'\xc3\x8ates-vous s\xc3\xbbr de vouloir vous d\xc3\xa9sinscrire?'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +797',b'All items have already been transferred for this Work Order.',b'Tous les articles ont d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 transf\xc3\xa9r\xc3\xa9s pour ce bon de travail.'
+b'DocType: Appraisal',"b'Any other remarks, noteworthy effort that should go in the records.'","b'Toute autre remarque, effort remarquable qui devrait aller dans les dossiers.'"
+b'DocType: Asset Maintenance',b'Manufacturing User',b'Charg\xc3\xa9 de Fabrication'
+b'DocType: Purchase Invoice',b'Raw Materials Supplied',b'Mati\xc3\xa8res Premi\xc3\xa8res Fournies'
+b'DocType: C-Form',b'Series',b'S\xc3\xa9ries'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +282',b'Currency of the price list {0} must be {1} or {2}',b'La devise de la liste de prix {0} doit \xc3\xaatre {1} ou {2}'
+b'DocType: Appraisal',b'Appraisal Template',b'Mod\xc3\xa8le d&#39;\xc3\xa9valuation'
+b'DocType: Soil Texture',b'Ternary Plot',b'Trac\xc3\xa9 ternaire'
+b'DocType: Item Group',b'Item Classification',"b""Classification de l'Article"""
+b'DocType: Driver',b'License Number',b'Num\xc3\xa9ro de licence'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +131',b'Business Development Manager',b'Directeur Commercial'
+b'DocType: Maintenance Visit Purpose',b'Maintenance Visit Purpose',"b""Objectif de la Visite d'Entretien"""
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.js +19',b'Invoice Patient Registration',b'Enregistrement de la Facture du Patient'
+b'DocType: Crop',b'Period',b'P\xc3\xa9riode'
+b'apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js +27',b'General Ledger',b'Grand Livre'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +33',b'Employee {0} on Leave on {1}',b'Employ\xc3\xa9 {0} en Cong\xc3\xa9 le {1}'
+b'apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10',b'View Leads',b'Voir Prospects'
+b'DocType: Program Enrollment Tool',b'New Program',b'Nouveau Programme'
+b'DocType: Item Attribute Value',b'Attribute Value',"b""Valeur de l'Attribut"""
+,b'Itemwise Recommended Reorder Level',b'Renouvellement Recommand\xc3\xa9 par Article'
+b'DocType: Salary Detail',b'Salary Detail',b'D\xc3\xa9tails du Salaire'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1070',b'Please select {0} first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner {0}'
+b'DocType: Appointment Type',b'Physician',b'M\xc3\xa9decin'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +872',b'Batch {0} of Item {1} has expired.',"b""Lot {0} de l'Article {1} a expir\xc3\xa9."""
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py +11',b'Consultations',b'Consultations'
+b'DocType: Sales Invoice',b'Commission',b'Commission'
+b'apps/erpnext/erpnext/config/manufacturing.py +27',b'Time Sheet for manufacturing.',b'Feuille de Temps pour la Fabrication.'
+b'apps/erpnext/erpnext/templates/pages/cart.html +37',b'Subtotal',b'Sous-Total'
+b'apps/erpnext/erpnext/config/erpnext_integrations.py +18',b'GoCardless SEPA Mandate',b'GoCardless SEPA Mandat'
+b'DocType: Physician',b'Charges',b'Charges'
+b'DocType: Production Plan',b'Get Items For Work Order',b'Obtenir des articles pour la commande de travail'
+b'DocType: Salary Detail',b'Default Amount',b'Montant par D\xc3\xa9faut'
+b'DocType: Lab Test Template',b'Descriptive',b'Descriptif'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +95',b'Warehouse not found in the system',"b""L'entrep\xc3\xb4t n'a pas \xc3\xa9t\xc3\xa9 trouv\xc3\xa9 dans le syst\xc3\xa8me"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +115',"b""This Month's Summary""",b'R\xc3\xa9sum\xc3\xa9 Mensuel'
+b'DocType: Quality Inspection Reading',b'Quality Inspection Reading',b'Libell\xc3\xa9 du Contr\xc3\xb4le de Qualit\xc3\xa9'
+b'apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +25',b'`Freeze Stocks Older Than` should be smaller than %d days.',b'`Geler les stocks datant de plus` doit \xc3\xaatre inf\xc3\xa9rieur \xc3\xa0 %d jours.'
+b'DocType: Tax Rule',b'Purchase Tax Template',b'Mod\xc3\xa8le de Taxes pour les Achats'
+b'apps/erpnext/erpnext/utilities/user_progress.py +48',"b""Set a sales goal you'd like to achieve for your company.""","b""D\xc3\xa9finissez l'objectif de ventes que vous souhaitez atteindre pour votre entreprise."""
+,b'Project wise Stock Tracking',b'Suivi des Stocks par Projet'
+b'DocType: GST HSN Code',b'Regional',b'R\xc3\xa9gional'
+b'apps/erpnext/erpnext/config/healthcare.py +40',b'Laboratory',b'Laboratoire'
+b'DocType: Stock Entry Detail',b'Actual Qty (at source/target)',b'Qt\xc3\xa9 R\xc3\xa9elle (\xc3\xa0 la source/cible)'
+b'DocType: Item Customer Detail',b'Ref Code',b'Code de R\xc3\xa9f.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +75',b'Customer Group is Required in POS Profile',b'Le Groupe de Clients est Requis dans le Profil POS'
+b'apps/erpnext/erpnext/config/hr.py +12',b'Employee records.',"b""Dossiers de l'Employ\xc3\xa9."""
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +98',b'Please set Next Depreciation Date',b'Veuillez d\xc3\xa9finir la Prochaine Date d\xe2\x80\x99Amortissement'
+b'DocType: HR Settings',b'Payroll Settings',b'R\xc3\xa9glages de la Paie'
+b'apps/erpnext/erpnext/config/accounts.py +146',b'Match non-linked Invoices and Payments.',b'Rapprocher les Factures non li\xc3\xa9es avec les Paiements.'
+b'DocType: POS Settings',b'POS Settings',b'Param\xc3\xa8tres PDV'
+b'apps/erpnext/erpnext/templates/pages/cart.html +16',b'Place Order',b'Passer la Commande'
+b'DocType: Email Digest',b'New Purchase Orders',b'Nouveaux Bons de Commande'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +24',b'Root cannot have a parent cost center',b'Racine ne peut pas avoir un centre de co\xc3\xbbts parent'
+b'apps/erpnext/erpnext/public/js/stock_analytics.js +54',b'Select Brand...',b'S\xc3\xa9lectionner une Marque ...'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +32',b'Non Profit (beta)',b'Non lucratif (b\xc3\xaata)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +18',b'Training Events/Results',b'\xc3\x89v\xc3\xa9nements de Formation/R\xc3\xa9sultats'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py +152',b'Accumulated Depreciation as on',b'Amortissement Cumul\xc3\xa9 depuis'
+b'DocType: Sales Invoice',b'C-Form Applicable',b'Formulaire-C Applicable'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +438',b'Operation Time must be greater than 0 for Operation {0}',"b""Temps de l'Op\xc3\xa9ration doit \xc3\xaatre sup\xc3\xa9rieur \xc3\xa0 0 pour l'Op\xc3\xa9ration {0}"""
+b'apps/erpnext/erpnext/controllers/sales_and_purchase_return.py +107',b'Warehouse is mandatory',"b""L'entrep\xc3\xb4t est obligatoire"""
+b'DocType: Shareholder',b'Address and Contacts',b'Adresse et Contacts'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +67',b'Failed to create website',b'\xc3\x89chec de la cr\xc3\xa9ation du site Web'
+b'DocType: Soil Analysis',b'Mg/K',b'Mg / K'
+b'DocType: UOM Conversion Detail',b'UOM Conversion Detail',"b""D\xc3\xa9tails de Conversion de l'UDM"""
+b'apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +924',b'Retention Stock Entry already created or Sample Quantity not provided',b'Saisie de stock de r\xc3\xa9tention d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9e ou quantit\xc3\xa9 d&#39;\xc3\xa9chantillon non fournie'
+b'DocType: Program',b'Program Abbreviation',b'Abr\xc3\xa9viation du Programme'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +52',b'Charges are updated in Purchase Receipt against each item',"b""Les frais sont mis \xc3\xa0 jour dans le Re\xc3\xa7u d'Achat pour chaque article"""
+b'DocType: Warranty Claim',b'Resolved By',b'R\xc3\xa9solu Par'
+b'DocType: Bank Guarantee',b'Start Date',b'Date de D\xc3\xa9but'
+b'apps/erpnext/erpnext/config/hr.py +75',b'Allocate leaves for a period.',b'Allouer des cong\xc3\xa9s pour une p\xc3\xa9riode.'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42',b'Cheques and Deposits incorrectly cleared',b'Ch\xc3\xa8ques et D\xc3\xa9p\xc3\xb4ts incorrectement compens\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +46',b'Account {0}: You can not assign itself as parent account',b'Compte {0}: Vous ne pouvez pas assigner un compte comme son propre parent'
+b'DocType: Purchase Invoice Item',b'Price List Rate',b'Taux de la Liste des Prix'
+b'apps/erpnext/erpnext/utilities/activation.py +72',b'Create customer quotes',b'Cr\xc3\xa9er les devis client'
+b'DocType: Item',"b'Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.'","b'Afficher ""En stock"" ou ""Pas en stock"" bas\xc3\xa9 sur le stock disponible dans cet entrep\xc3\xb4t.'"
+b'apps/erpnext/erpnext/config/manufacturing.py +38',b'Bill of Materials (BOM)',b'Liste de Mat\xc3\xa9riaux (LDM)'
+b'DocType: Item',b'Average time taken by the supplier to deliver',b'D\xc3\xa9lai moyen de livraison par le fournisseur'
+b'DocType: Sample Collection',b'Collected By',b'Collect\xc3\xa9 par'
+b'apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js +35',b'Assessment Result',"b""R\xc3\xa9sultat de l'\xc3\x89valuation"""
+b'DocType: Hotel Room Package',b'Hotel Room Package',b'Forfait chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html +13',b'Hours',b'Heures'
+b'DocType: Project',b'Expected Start Date',b'Date de D\xc3\xa9but Pr\xc3\xa9vue'
+b'DocType: Purchase Invoice',b'04-Correction in Invoice',b'04-Correction dans la facture'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +963',b'Work Order already created for all items with BOM',b'Ordre de travail d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9 pour tous les articles avec nomenclature'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +60',b'Variant Details Report',b'Rapport d\xc3\xa9taill\xc3\xa9 des variantes'
+b'DocType: Setup Progress Action',b'Setup Progress Action',"b""Action de Progression de l'Installation"""
+b'apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py +36',b'Buying Price List',b'Liste de prix d&#39;achat'
+b'apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +49',b'Remove item if charges is not applicable to that item',"b""Retirer l'article si les charges ne lui sont pas applicables"""
+b'apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py +21',b'Please select Maintenance Status as Completed or remove Completion Date',b'Veuillez s\xc3\xa9lectionner le statut de maintenance comme termin\xc3\xa9 ou supprimer la date de fin'
+b'DocType: Supplier',b'Default Payment Terms Template',b'Mod\xc3\xa8le de termes de paiement par d\xc3\xa9faut'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +34',b'Transaction currency must be same as Payment Gateway currency',b'La devise de la Transaction doit \xc3\xaatre la m\xc3\xaame que la devise de la Passerelle de Paiement'
+b'DocType: Payment Entry',b'Receive',b'Recevoir'
+b'apps/erpnext/erpnext/templates/pages/rfq.html +75',b'Quotations: ',b'Devis :'
+b'DocType: Maintenance Visit',b'Fully Completed',b'Enti\xc3\xa8rement Compl\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/projects/doctype/project/project_list.js +6',b'{0}% Complete',b'{0}% Compl\xc3\xa9t\xc3\xa9'
+b'DocType: Employee',b'Educational Qualification',"b""Qualification pour l'\xc3\x89ducation"""
+b'DocType: Workstation',b'Operating Costs',"b""Co\xc3\xbbts d'Exploitation"""
+b'DocType: Budget',b'Action if Accumulated Monthly Budget Exceeded',b'Action si le Budget Mensuel Cumul\xc3\xa9 est D\xc3\xa9pass\xc3\xa9'
+b'DocType: Subscription',b'Submit on creation',b'Soumettre \xc3\xa0 la Cr\xc3\xa9ation'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +483',b'Currency for {0} must be {1}',b'Devise pour {0} doit \xc3\xaatre {1}'
+b'DocType: Asset',b'Disposal Date',b'Date d\xe2\x80\x99\xc3\x89limination'
+b'DocType: Daily Work Summary Settings',"b'Emails will be sent to all Active Employees of the company at the given hour, if they do not have holiday. Summary of responses will be sent at midnight.'","b""Les Emails seront envoy\xc3\xa9s \xc3\xa0 tous les Employ\xc3\xa9s Actifs de la soci\xc3\xa9t\xc3\xa9 \xc3\xa0 l'heure donn\xc3\xa9e, s'ils ne sont pas en vacances. Le r\xc3\xa9sum\xc3\xa9 des r\xc3\xa9ponses sera envoy\xc3\xa9 \xc3\xa0 minuit."""
+b'DocType: Employee Leave Approver',b'Employee Leave Approver',"b""Approbateur des Cong\xc3\xa9s de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +510',b'Row {0}: An Reorder entry already exists for this warehouse {1}',b'Ligne {0} : Une \xc3\xa9criture de R\xc3\xa9approvisionnement existe d\xc3\xa9j\xc3\xa0 pour cet entrep\xc3\xb4t {1}'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +99',"b'Cannot declare as lost, because Quotation has been made.'","b'Impossible de d\xc3\xa9clarer comme perdu, parce que le Devis a \xc3\xa9t\xc3\xa9 fait.'"
+b'apps/erpnext/erpnext/hr/doctype/training_event/training_event.js +16',b'Training Feedback',"b""Retour d'Exp\xc3\xa9rience sur la Formation"""
+b'DocType: Supplier Scorecard Criteria',b'Supplier Scorecard Criteria',"b""Crit\xc3\xa8res de Fiche d'\xc3\x89valuation Fournisseur"""
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +149',b'Please select Start Date and End Date for Item {0}',"b""Veuillez s\xc3\xa9lectionner la Date de D\xc3\xa9but et Date de Fin pour l'Article {0}"""
+b'apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py +55',b'Course is mandatory in row {0}',b'Cours est obligatoire \xc3\xa0 la ligne {0}'
+b'apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16',b'To date cannot be before from date',b'La date de fin ne peut \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date de d\xc3\xa9but'
+b'DocType: Supplier Quotation Item',b'Prevdoc DocType',b'DocPr\xc3\xa9c DocType'
+b'DocType: Cash Flow Mapper',b'Section Footer',b'Pied de section'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +304',b'Add / Edit Prices',b'Ajouter / Modifier Prix'
+b'DocType: Batch',b'Parent Batch',b'Lot Parent'
+b'DocType: Cheque Print Template',b'Cheque Print Template',"b""Mod\xc3\xa8les d'Impression de Ch\xc3\xa8ques"""
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +36',b'Chart of Cost Centers',b'Tableau des Centres de Co\xc3\xbbts'
+b'DocType: Lab Test Template',b'Sample Collection',"b""Collecte d'\xc3\x89chantillons"""
+,b'Requested Items To Be Ordered',b'Articles Demand\xc3\xa9s \xc3\xa0 Commander'
+b'apps/erpnext/erpnext/public/js/hub/hub_page.js +137',b'My Orders',b'Mes Commandes'
+b'DocType: Price List',b'Price List Name',b'Nom de la Liste de Prix'
+b'DocType: BOM',b'Manufacturing',b'Fabrication'
+,b'Ordered Items To Be Delivered',b'Articles Command\xc3\xa9s \xc3\xa0 Livrer'
+b'DocType: Account',b'Income',b'Revenus'
+b'DocType: Industry Type',b'Industry Type',"b""Secteur d'Activit\xc3\xa9"""
+b'apps/erpnext/erpnext/templates/includes/cart.js +150',b'Something went wrong!',b'Quelque chose a mal tourn\xc3\xa9 !'
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +105',b'Warning: Leave application contains following block dates',b'Attention : la demande de cong\xc3\xa9 contient les dates bloqu\xc3\xa9es suivantes'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275',b'Sales Invoice {0} has already been submitted',b'La Facture Vente {0} a d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 transmise'
+b'DocType: Supplier Scorecard Scoring Criteria',b'Score',b'Score'
+b'apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +25',b'Fiscal Year {0} does not exist',"b""Exercice Fiscal {0} n'existe pas"""
+b'DocType: Asset Maintenance Log',b'Completion Date',"b""Date d'Ach\xc3\xa8vement"""
+b'DocType: Purchase Invoice Item',b'Amount (Company Currency)',b'Montant (Devise de la Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Agriculture Analysis Criteria',b'Agriculture User',b'Utilisateur Agricole'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +38',b'Valid till date cannot be before transaction date',b'La date de validit\xc3\xa9 ne peut pas \xc3\xaatre avant la date de transaction'
+b'apps/erpnext/erpnext/stock/stock_ledger.py +381',b'{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.',b'{0} unit\xc3\xa9s de {1} n\xc3\xa9cessaires dans {2} sur {3} {4} pour {5} pour compl\xc3\xa9ter cette transaction.'
+b'DocType: Fee Schedule',b'Student Category',b'Cat\xc3\xa9gorie \xc3\x89tudiant'
+b'DocType: Announcement',b'Student',b'\xc3\x89tudiant'
+b'apps/erpnext/erpnext/config/hr.py +238',b'Organization unit (department) master.',"b""Base d'unit\xc3\xa9 d'organisation (d\xc3\xa9partement)."""
+b'DocType: Shipping Rule',b'Shipping Rule Type',b'Type de r\xc3\xa8gle d&#39;exp\xc3\xa9dition'
+b'apps/erpnext/erpnext/utilities/user_progress.py +239',b'Go to Rooms',b'Aller aux Salles'
+b'apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +75',b'Please enter message before sending',"b""Veuillez entrer le message avant d'envoyer"""
+b'DocType: Purchase Invoice',b'DUPLICATE FOR SUPPLIER',b'DUPLICATA POUR LE FOURNISSEUR'
+b'DocType: Email Digest',b'Pending Quotations',b'Devis en Attente'
+b'apps/erpnext/erpnext/config/accounts.py +318',b'Point-of-Sale Profile',b'Profil de Point-De-Vente'
+b'apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py +25',b'{0} should be a value between 0 and 100',b'{0} devrait \xc3\xaatre une valeur comprise entre 0 et 100'
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.py +94',b'Next Depreciation Date cannot be before Available-for-use Date',b'La prochaine date d&#39;amortissement ne peut \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date de disponibilit\xc3\xa9.'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +156',b'Unsecured Loans',b'Pr\xc3\xaats Non Garantis'
+b'DocType: Cost Center',b'Cost Center Name',b'Nom du centre de co\xc3\xbbts'
+b'DocType: Student',b'B+',b'B +'
+b'DocType: HR Settings',b'Max working hours against Timesheet',b'Heures de Travail Max pour une Feuille de Temps'
+b'DocType: Maintenance Schedule Detail',b'Scheduled Date',b'Date Pr\xc3\xa9vue'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +214',b'Total Paid Amt',b'Mnt Total Pay\xc3\xa9'
+b'DocType: SMS Center',b'Messages greater than 160 characters will be split into multiple messages',b'Message de plus de 160 caract\xc3\xa8res sera d\xc3\xa9coup\xc3\xa9 en plusieurs messages'
+b'DocType: Purchase Receipt Item',b'Received and Accepted',b'Re\xc3\xa7us et Accept\xc3\xa9s'
+b'DocType: Hub Settings',b'Company and Seller Profile',b'Profil de l&#39;entreprise et du vendeur'
+,b'GST Itemised Sales Register',b'Registre de Vente D\xc3\xa9taill\xc3\xa9 GST'
+b'DocType: Soil Texture',b'Silt Loam',b'Limon de limon'
+,b'Serial No Service Contract Expiry',b'Expiration du Contrat de Service du N\xc2\xb0 de S\xc3\xa9rie'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299',b'You cannot credit and debit same account at the same time',b'Vous ne pouvez pas cr\xc3\xa9diter et d\xc3\xa9biter le m\xc3\xaame compte simultan\xc3\xa9ment'
+b'DocType: Vital Signs',"b""Adults' pulse rate is anywhere between 50 and 80 beats per minute.""","b""Le pouls d'un adulte est compris entre 50 et 80 battements par minute."""
+b'DocType: Naming Series',b'Help HTML',b'Aide HTML'
+b'DocType: Student Group Creation Tool',b'Student Group Creation Tool',"b""Outil de Cr\xc3\xa9ation de Groupe d'\xc3\x89tudiants"""
+b'DocType: Item',b'Variant Based On',b'Variante Bas\xc3\xa9e Sur'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +53',b'Total weightage assigned should be 100%. It is {0}',b'Le total des pond\xc3\xa9rations attribu\xc3\xa9es devrait \xc3\xaatre de 100 %. Il est {0}'
+b'apps/erpnext/erpnext/utilities/user_progress.py +109',b'Your Suppliers',b'Vos Fournisseurs'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +6',b'Please correct the',b'Veuillez corriger le'
+b'apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +80',b'Cannot set as Lost as Sales Order is made.',"b""Impossible de d\xc3\xa9finir comme perdu alors qu'un Bon de Commande a \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9."""
+b'DocType: Request for Quotation Item',b'Supplier Part No',b'N\xc2\xb0 de Pi\xc3\xa8ce du Fournisseur'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +382',"b""Cannot deduct when category is for 'Valuation' or 'Vaulation and Total'""","b""Vous ne pouvez pas d\xc3\xa9duire lorsqu'une cat\xc3\xa9gorie est pour '\xc3\x89valuation' ou '\xc3\x89valuation et Total'"""
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +377',b'Received From',b'Re\xc3\xa7u De'
+b'DocType: Lead',b'Converted',b'Converti'
+b'DocType: Item',b'Has Serial No',b'A un N\xc2\xb0 de S\xc3\xa9rie'
+b'DocType: Employee',b'Date of Issue',"b""Date d'\xc3\x89mission"""
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +222',"b""As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}""","b""D'apr\xc3\xa8s les Param\xc3\xa8tres d'Achat, si Re\xc3\xa7u d'Achat Requis == 'OUI', alors l'utilisateur doit d'abord cr\xc3\xa9er un Re\xc3\xa7u d'Achat pour l'article {0} pour pouvoir cr\xc3\xa9er une Facture d'Achat"""
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +167',b'Row #{0}: Set Supplier for item {1}',b'Ligne #{0} : D\xc3\xa9finir Fournisseur pour l\xe2\x80\x99article {1}'
+b'apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py +121',b'Row {0}: Hours value must be greater than zero.',b'Ligne {0} : La valeur des heures doit \xc3\xaatre sup\xc3\xa9rieure \xc3\xa0 z\xc3\xa9ro.'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +195',b'Website Image {0} attached to Item {1} cannot be found',"b""Image pour le Site Web {0} attach\xc3\xa9e \xc3\xa0 l'Article {1} ne peut pas \xc3\xaatre trouv\xc3\xa9e"""
+b'DocType: Issue',b'Content Type',b'Type de Contenu'
+b'DocType: Asset',b'Assets',b'Actifs'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +17',b'Computer',b'Ordinateur'
+b'DocType: Item',b'List this Item in multiple groups on the website.',b'Liste cet article dans plusieurs groupes sur le site.'
+b'DocType: Payment Term',b'Due Date Based On',b'Date d&#39;\xc3\xa9ch\xc3\xa9ance bas\xc3\xa9e sur'
+b'apps/erpnext/erpnext/healthcare/doctype/patient/patient.py +82',b'Please set default customer group and territory in Selling Settings',b'Configurez le groupe de clients et le territoire par d\xc3\xa9faut dans les param\xc3\xa8tres de vente'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +214',b'{0} {1} does not exist',"b""{0} {1} n'existe pas"""
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +323',b'Please check Multi Currency option to allow accounts with other currency',"b""Veuillez v\xc3\xa9rifier l'option Multi-Devises pour permettre les comptes avec une autre devise"""
+b'apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +88',b'Item: {0} does not exist in the system',"b""Article : {0} n'existe pas dans le syst\xc3\xa8me"""
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +106',b'You are not authorized to set Frozen value',"b""Vous n'\xc3\xaates pas autoris\xc3\xa9 \xc3\xa0 d\xc3\xa9finir des valeurs gel\xc3\xa9es"""
+b'DocType: Payment Reconciliation',b'Get Unreconciled Entries',b'Obtenir les \xc3\x89critures non R\xc3\xa9concilli\xc3\xa9es'
+b'DocType: Payment Reconciliation',b'From Invoice Date',b'De la Date de la Facture'
+b'DocType: Healthcare Settings',b'Laboratory Settings',b'Param\xc3\xa8tres de laboratoire'
+b'DocType: Patient Appointment',b'Service Unit',b'Unit\xc3\xa9 de service'
+b'apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js +97',b'Successfully Set Supplier',b'D\xc3\xa9finir avec succ\xc3\xa8s le fournisseur'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +75',b'Leave Encashment',b'Cong\xc3\xa9s Accumul\xc3\xa9s \xc3\xa0 Encaisser'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +114',b'What does it do?',"b""Qu'est-ce que \xc3\xa7a fait ?"""
+b'DocType: Crop',b'Byproducts',"b'Sous-produits, d\xc3\xa9riv\xc3\xa9'"
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +84',b'To Warehouse',"b""\xc3\x80 l'Entrep\xc3\xb4t"""
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +26',b'All Student Admissions',b'Toutes les Admissions des \xc3\x89tudiants'
+,b'Average Commission Rate',b'Taux Moyen de la Commission'
+b'DocType: Share Balance',b'No of Shares',b'Nombre d&#39;actions'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +448',"b""'Has Serial No' can not be 'Yes' for non-stock item""","b""'A un Num\xc3\xa9ro de S\xc3\xa9rie' ne peut pas \xc3\xaatre 'Oui' pour un article hors-stock"""
+b'apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js +59',b'Select Status',b'S\xc3\xa9lectionnez le Statut'
+b'apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +41',b'Attendance can not be marked for future dates',b'La pr\xc3\xa9sence ne peut pas \xc3\xaatre marqu\xc3\xa9e pour les dates \xc3\xa0 venir'
+b'DocType: Pricing Rule',b'Pricing Rule Help',b'Aide pour les R\xc3\xa8gles de Tarification'
+b'DocType: School House',b'House Name',b'Nom de la Maison'
+b'DocType: Fee Schedule',b'Total Amount per Student',b'Montant total par \xc3\xa9tudiant'
+b'DocType: Purchase Taxes and Charges',b'Account Head',b'Compte Principal'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +153',b'Electrical',b'\xc3\x89lectrique'
+b'apps/erpnext/erpnext/utilities/activation.py +100',b'Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts',"b""Ajouter le reste de votre organisation en tant qu'utilisateurs. Vous pouvez aussi inviter des Clients sur votre portail en les ajoutant depuis les Contacts"""
+b'DocType: Stock Entry',b'Total Value Difference (Out - In)',b'Diff\xc3\xa9rence Valeur Totale (Sor - En)'
+b'DocType: Grant Application',b'Requested Amount',b'Quantit\xc3\xa9 exig\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +348',b'Row {0}: Exchange Rate is mandatory',b'Ligne {0} : Le Taux de Change est obligatoire'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27',b'User ID not set for Employee {0}',"b""ID de l'Utilisateur non d\xc3\xa9fini pour l'Employ\xc3\xa9 {0}"""
+b'DocType: Vehicle',b'Vehicle Value',b'Valeur du V\xc3\xa9hicule'
+b'DocType: Crop Cycle',b'Detected Diseases',b'Maladies d\xc3\xa9tect\xc3\xa9es'
+b'DocType: Stock Entry',b'Default Source Warehouse',b'Entrep\xc3\xb4t Source par D\xc3\xa9faut'
+b'DocType: Item',b'Customer Code',b'Code Client'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +220',b'Birthday Reminder for {0}',"b""Rappel d'Anniversaire pour {0}"""
+b'DocType: Asset Maintenance Task',b'Last Completion Date',b'Derni\xc3\xa8re date d&#39;ach\xc3\xa8vement'
+b'apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py +72',b'Days Since Last Order',b'Jours Depuis la Derni\xc3\xa8re Commande'
+b'apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +365',b'Debit To account must be a Balance Sheet account',b'Le compte de d\xc3\xa9bit doit \xc3\xaatre un compte de Bilan'
+b'DocType: Buying Settings',b'Naming Series',b'Nom de la S\xc3\xa9rie'
+b'DocType: GoCardless Settings',b'GoCardless Settings',b'Param\xc3\xa8tres GoCardless'
+b'DocType: Leave Block List',b'Leave Block List Name',b'Nom de la Liste de Blocage des Cong\xc3\xa9s'
+b'apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py +14',b'Insurance Start date should be less than Insurance End date',"b""Date de D\xc3\xa9but d'Assurance devrait \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de Fin d'Assurance"""
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32',b'Stock Assets',b'Actifs du Stock'
+b'DocType: Restaurant',b'Active Menu',b'Menu Actif'
+b'DocType: Target Detail',b'Target Qty',b'Qt\xc3\xa9 Cible'
+b'DocType: Shopping Cart Settings',b'Checkout Settings',b'R\xc3\xa9glages R\xc3\xa8glement'
+b'DocType: Student Attendance',b'Present',b'Pr\xc3\xa9sent'
+b'apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +37',b'Delivery Note {0} must not be submitted',b'Bon de Livraison {0} ne doit pas \xc3\xaatre soumis'
+b'DocType: Notification Control',b'Sales Invoice Message',b'Message de la Facture de Vente'
+b'apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +27',b'Closing Account {0} must be of type Liability / Equity',b'Le Compte Cl\xc3\xb4tur\xc3\xa9 {0} doit \xc3\xaatre de type Passif / Capitaux Propres'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +325',b'Salary Slip of employee {0} already created for time sheet {1}',"b""Fiche de Paie de l'employ\xc3\xa9 {0} d\xc3\xa9j\xc3\xa0 cr\xc3\xa9\xc3\xa9e pour la feuille de temps {1}"""
+b'DocType: Vehicle Log',b'Odometer',b'Odom\xc3\xa8tre'
+b'DocType: Production Plan Item',b'Ordered Qty',b'Qt\xc3\xa9 Command\xc3\xa9e'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +744',b'Item {0} is disabled',b'Article {0} est d\xc3\xa9sactiv\xc3\xa9'
+b'DocType: Stock Settings',b'Stock Frozen Upto',"b""Stock Gel\xc3\xa9 Jusqu'au"""
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +930',b'BOM does not contain any stock item',b'LDM ne contient aucun article en stock'
+b'DocType: Chapter',b'Chapter Head',b'Chef de chapitre'
+b'DocType: Payment Term',b'Month(s) after the end of the invoice month',b'Mois (s) apr\xc3\xa8s la fin du mois de la facture'
+b'apps/erpnext/erpnext/config/projects.py +24',b'Project activity / task.',b'Activit\xc3\xa9 du projet / t\xc3\xa2che.'
+b'DocType: Vehicle Log',b'Refuelling Details',b'D\xc3\xa9tails de Ravitaillement'
+b'apps/erpnext/erpnext/config/hr.py +104',b'Generate Salary Slips',b'G\xc3\xa9n\xc3\xa9rer les Fiches de Paie'
+b'apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py +25',b'Lab result datetime cannot be before testing datetime',b'Le r\xc3\xa9sultat de laboratoire datetime ne peut pas \xc3\xaatre avant de tester datetime'
+b'DocType: POS Profile',b'Allow user to edit Discount',b'Autoriser l&#39;utilisateur \xc3\xa0 modifier'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +55',b'Get customers from',b'Obtenez des clients de'
+b'DocType: Purchase Invoice Item',b'Include Exploded Items',b'Inclure les \xc3\xa9l\xc3\xa9ments \xc3\xa9clat\xc3\xa9s'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +45',"b'Buying must be checked, if Applicable For is selected as {0}'","b'Achat doit \xc3\xaatre v\xc3\xa9rifi\xc3\xa9, si Applicable Pour {0} est s\xc3\xa9lectionn\xc3\xa9'"
+b'apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40',b'Discount must be less than 100',b'La remise doit \xc3\xaatre inf\xc3\xa9rieure \xc3\xa0 100'
+b'DocType: Shipping Rule',b'Restrict to Countries',b'Restreindre aux pays'
+b'DocType: Purchase Invoice',b'Write Off Amount (Company Currency)',b'Montant de la Reprise (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Sales Invoice Timesheet',b'Billing Hours',b'Heures Factur\xc3\xa9es'
+b'DocType: Project',b'Total Sales Amount (via Sales Order)',b'Montant total des ventes (via la commande client)'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py +548',b'Default BOM for {0} not found',b'LDM par d\xc3\xa9faut {0} introuvable'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +514',b'Row #{0}: Please set reorder quantity',b'Ligne #{0} : Veuillez d\xc3\xa9finir la quantit\xc3\xa9 de r\xc3\xa9approvisionnement'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +20',b'Tap items to add them here',b'Choisissez des articles pour les ajouter ici'
+b'DocType: Fees',b'Program Enrollment',b'Inscription au Programme'
+b'DocType: Share Transfer',b'To Folio No',b'Pour Folio Non'
+b'DocType: Landed Cost Voucher',b'Landed Cost Voucher',b'R\xc3\xa9f\xc3\xa9rence de Co\xc3\xbbt au D\xc3\xa9barquement'
+b'apps/erpnext/erpnext/public/js/queries.js +39',b'Please set {0}',b'Veuillez d\xc3\xa9finir {0}'
+b'apps/erpnext/erpnext/education/doctype/student_group/student_group.py +37',b'{0} - {1} is inactive student',b'{0} - {1} est un \xc3\xa9tudiant inactif'
+b'DocType: Employee',b'Health Details',b'D\xc3\xa9tails de Sant\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py +24',b'To create a Payment Request reference document is required',"b'Pour cr\xc3\xa9er une Demande de Paiement, un document de r\xc3\xa9f\xc3\xa9rence est requis'"
+b'DocType: Soil Texture',b'Sandy Clay',b'Sol argileux'
+b'DocType: Grant Application',b'Assessment  Manager',b'Gestionnaire d&#39;\xc3\xa9valuation'
+b'DocType: Payment Entry',b'Allocate Payment Amount',b'Allouer le Montant du Paiement'
+b'DocType: Employee External Work History',b'Salary',b'Salaire'
+b'DocType: Serial No',b'Delivery Document Type',b'Type de Document de Livraison'
+b'DocType: Sales Order',b'Partly Delivered',b'Livr\xc3\xa9 en Partie'
+b'apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +48',b'Item Code &gt; Item Group &gt; Brand',b'Code de l&#39;article&gt; Groupe de produits&gt; Marque'
+b'DocType: Item Variant Settings',b'Do not update variants on save',b'Ne pas mettre \xc3\xa0 jour les variantes lors de la sauvegarde'
+b'DocType: Email Digest',b'Receivables',b'Cr\xc3\xa9ances'
+b'DocType: Lead Source',b'Lead Source',b'Source du Prospect'
+b'DocType: Customer',b'Additional information regarding the customer.',b'Informations suppl\xc3\xa9mentaires concernant le client.'
+b'DocType: Quality Inspection Reading',b'Reading 5',b'Reading 5'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +236',"b'{0} {1} is associated with {2}, but Party Account is {3}'","b'{0} {1} est associ\xc3\xa9 \xc3\xa0 {2}, mais le compte tiers est {3}'"
+b'apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js +7',b'View Lab Tests',b'Afficher les tests de laboratoire'
+b'DocType: Purchase Invoice',b'Y',b'Y'
+b'DocType: Maintenance Visit',b'Maintenance Date',"b""Date de l'Entretien"""
+b'DocType: Purchase Invoice Item',b'Rejected Serial No',b'N\xc2\xb0 de S\xc3\xa9rie Rejet\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +82',b'Year start date or end date is overlapping with {0}. To avoid please set company',"b""Ann\xc3\xa9e de d\xc3\xa9but ou de fin chevauche avec {0}. Pour l'\xc3\xa9viter veuillez d\xc3\xa9finir la soci\xc3\xa9t\xc3\xa9"""
+b'apps/erpnext/erpnext/selling/doctype/customer/customer.py +122',b'Please mention the Lead Name in Lead {0}',b'Veuillez mentionner le nom du Prospect dans le Prospect {0}'
+b'apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py +156',b'Start date should be less than end date for Item {0}',"b""La date de d\xc3\xa9but doit \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date de fin pour l'Article {0}"""
+b'DocType: Item',"b'Example: ABCD.#####\nIf series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.'","b""Exemple:. ABCD ##### Si la s\xc3\xa9rie est d\xc3\xa9finie et que le N\xc2\xb0 de s\xc3\xa9rie n'est pas mentionn\xc3\xa9 dans les transactions, alors un num\xc3\xa9ro de s\xc3\xa9rie automatique sera cr\xc3\xa9\xc3\xa9 bas\xc3\xa9 sur cette s\xc3\xa9rie. Si vous voulez toujours mentionner explicitement les num\xc3\xa9ros de s\xc3\xa9rie pour ce produit. laissez ce champ vide."""
+b'DocType: Upload Attendance',b'Upload Attendance',b'Charger Fr\xc3\xa9quentation'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +579',b'BOM and Manufacturing Quantity are required',b'LDM et Quantit\xc3\xa9 de Fabrication sont n\xc3\xa9cessaires'
+b'apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +50',b'Ageing Range 2',b'Balance Ag\xc3\xa9e 2'
+b'DocType: SG Creation Tool Course',b'Max Strength',b'Force Max'
+b'apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py +28',b'Installing presets',b'Installation de presets'
+b'apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js +85',b'No Delivery Note selected for Customer {}',b'Aucun bon de livraison s\xc3\xa9lectionn\xc3\xa9 pour le client {}'
+b'apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py +25',b'BOM replaced',b'LDM Remplac\xc3\xa9e'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +1052',b'Select Items based on Delivery Date',b'S\xc3\xa9lectionnez les articles en fonction de la Date de Livraison'
+b'DocType: Grant Application',b'Has any past Grant Record',b'A un record de subvention pass\xc3\xa9'
+,b'Sales Analytics',b'Analyse des Ventes'
+b'apps/erpnext/erpnext/stock/dashboard/item_dashboard.js +127',b'Available {0}',b'Disponible {0}'
+,b'Prospects Engaged But Not Converted',b'Prospects Contact\xc3\xa9s mais non Convertis'
+b'DocType: Manufacturing Settings',b'Manufacturing Settings',b'Param\xc3\xa8tres de Fabrication'
+b'apps/erpnext/erpnext/config/setup.py +56',b'Setting up Email',"b""Configurer l'Email"""
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +57',b'Guardian1 Mobile No',b'N\xc2\xb0 du Mobile du Tuteur 1'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +106',b'Please enter default currency in Company Master',b'Veuillez entrer la devise par d\xc3\xa9faut dans les Donn\xc3\xa9es de Base de la Soci\xc3\xa9t\xc3\xa9'
+b'DocType: Stock Entry Detail',b'Stock Entry Detail',"b""D\xc3\xa9tails de l'\xc3\x89criture de Stock"""
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +109',b'Daily Reminders',b'Rappels Quotidiens'
+b'DocType: Products Settings',b'Home Page is Products',"b""La Page d'Accueil est Produits"""
+,b'Asset Depreciation Ledger',"b""Livre d'Amortissements d'Actifs"""
+b'apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py +91',b'Tax Rule Conflicts with {0}',b'R\xc3\xa8gle de Taxation est en Conflit avec {0}'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +25',b'New Account Name',b'Nouveau Nom de Compte'
+b'DocType: Purchase Invoice Item',b'Raw Materials Supplied Cost',b'Co\xc3\xbbt des Mati\xc3\xa8res Premi\xc3\xa8res Fournies'
+b'DocType: Selling Settings',b'Settings for Selling Module',b'R\xc3\xa9glages pour le Module Vente'
+b'DocType: Hotel Room Reservation',b'Hotel Room Reservation',b'R\xc3\xa9servation de chambre d&#39;h\xc3\xb4tel'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +115',b'Customer Service',b'Service Client'
+b'DocType: BOM',b'Thumbnail',b'Vignette'
+b'DocType: Item Customer Detail',b'Item Customer Detail',"b""D\xc3\xa9tail de l'Article Client"""
+b'apps/erpnext/erpnext/config/hr.py +50',b'Offer candidate a Job.',b'Proposer un Emploi au candidat'
+b'DocType: Notification Control',b'Prompt for Email on Submission of',b'Demander l\xe2\x80\x99Email lors de la Soumission de'
+b'apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +88',b'Total allocated leaves are more than days in the period',b'Le Total des feuilles attribu\xc3\xa9es est sup\xc3\xa9rieur au nombre de jours dans la p\xc3\xa9riode'
+b'DocType: Land Unit',b'Linked Soil Analysis',b'Analyse de sol li\xc3\xa9e'
+b'DocType: Pricing Rule',b'Percentage',b'Pourcentage'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +70',b'Item {0} must be a stock Item',"b""L'article {0} doit \xc3\xaatre un article en stock"""
+b'DocType: Manufacturing Settings',b'Default Work In Progress Warehouse',b'Entrep\xc3\xb4t de Travail en Cours par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/config/accounts.py +288',b'Default settings for accounting transactions.',b'Param\xc3\xa8tres par d\xc3\xa9faut pour les op\xc3\xa9rations comptables .'
+b'DocType: Maintenance Visit',b'MV',b'MV'
+b'DocType: Restaurant',b'Default Tax Template',b'Mod\xc3\xa8le de Taxes par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py +66',b'{0} Students have been enrolled',b'{0} Les \xc3\xa9tudiants ont \xc3\xa9t\xc3\xa9 inscrits'
+b'DocType: Fees',b'Student Details',"b""D\xc3\xa9tails de l'\xc3\x89tudiant"""
+b'DocType: Purchase Invoice Item',b'Stock Qty',b'Qt\xc3\xa9 en Stock'
+b'DocType: Employee Loan',b'Repayment Period in Months',b'P\xc3\xa9riode de Remboursement en Mois'
+b'apps/erpnext/erpnext/templates/includes/footer/footer_extension.html +26',b'Error: Not a valid id?',b'Erreur : Pas un identifiant valide ?'
+b'DocType: Naming Series',b'Update Series Number',b'Mettre \xc3\xa0 Jour la S\xc3\xa9rie'
+b'DocType: Account',b'Equity',b'Capitaux Propres'
+b'apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +78',"b""{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry""",b'{0} {1}: Compte {2} de type \xe2\x80\x98Pertes et Profits\xe2\x80\x99 non admis en \xc3\x89criture d\xe2\x80\x99Ouverture'
+b'DocType: Sales Order',b'Printing Details',"b""D\xc3\xa9tails d'Impression"""
+b'DocType: Task',b'Closing Date',b'Date de Cl\xc3\xb4ture'
+b'DocType: Sales Order Item',b'Produced Quantity',b'Quantit\xc3\xa9 Produite'
+b'DocType: Timesheet',b'Work Detail',b'D\xc3\xa9tail du travail'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +126',b'Engineer',b'Ing\xc3\xa9nieur'
+b'DocType: Journal Entry',b'Total Amount Currency',b'Montant Total en Devise'
+b'apps/erpnext/erpnext/stock/report/bom_search/bom_search.js +38',b'Search Sub Assemblies',b'Rechercher les Sous-Ensembles'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +171',b'Item Code required at Row No {0}',"b""Code de l'Article est requis \xc3\xa0 la Ligne No {0}"""
+b'DocType: GST Account',b'SGST Account',b'Compte SGST'
+b'apps/erpnext/erpnext/utilities/user_progress.py +154',b'Go to Items',b'Aller aux Articles'
+b'DocType: Sales Partner',b'Partner Type',b'Type de Partenaire'
+b'DocType: Purchase Taxes and Charges',b'Actual',b'R\xc3\xa9el'
+b'DocType: Restaurant Menu',b'Restaurant Manager',b'G\xc3\xa9rant de restaurant'
+b'DocType: Authorization Rule',b'Customerwise Discount',b'Remise en fonction du Client'
+b'apps/erpnext/erpnext/config/projects.py +46',b'Timesheet for tasks.',b'Feuille de Temps pour les t\xc3\xa2ches.'
+b'DocType: Purchase Invoice',b'Against Expense Account',b'Pour le Compte de Charges'
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +282',b'Installation Note {0} has already been submitted',"b""Note d'Installation {0} \xc3\xa0 d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 sousmise"""
+b'DocType: Bank Reconciliation',b'Get Payment Entries',b'Obtenir les \xc3\x89critures de Paiement'
+b'DocType: Quotation Item',b'Against Docname',b'Pour le docName'
+b'DocType: SMS Center',b'All Employee (Active)',b'Tous les Employ\xc3\xa9s (Actifs)'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9',b'View Now',b'Voir Maintenant'
+b'DocType: BOM',b'Raw Material Cost',b'Co\xc3\xbbt de Mati\xc3\xa8re Premi\xc3\xa8re'
+b'DocType: Item Reorder',b'Re-Order Level',b'Niveau de R\xc3\xa9approvisionnement'
+b'apps/erpnext/erpnext/projects/doctype/project/project.js +54',b'Gantt Chart',b'Diagramme de Gantt'
+b'DocType: Crop Cycle',b'Cycle Type',b'Type de cycle'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +99',b'Part-time',b'Temps-Partiel'
+b'DocType: Employee',b'Applicable Holiday List',b'Liste de Vacances Valable'
+b'DocType: Employee',b'Cheque',b'Ch\xc3\xa8que'
+b'DocType: Training Event',b'Employee Emails',"b""Emails de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +60',b'Series Updated',b'S\xc3\xa9rie Mise \xc3\xa0 Jour'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +159',b'Report Type is mandatory',b'Le Type de Rapport est n\xc3\xa9cessaire'
+b'DocType: Item',b'Serial Number Series',b'S\xc3\xa9ries de Num\xc3\xa9ros de S\xc3\xa9rie'
+b'apps/erpnext/erpnext/buying/utils.py +68',b'Warehouse is mandatory for stock Item {0} in row {1}',"b""L\xe2\x80\x99entrep\xc3\xb4t est obligatoire pour l'Article du stock {0} dans la ligne {1}"""
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +45',b'Retail & Wholesale',b'Vente de D\xc3\xa9tail & en Gros'
+b'DocType: Issue',b'First Responded On',b'Premi\xc3\xa8re R\xc3\xa9ponse Le'
+b'DocType: Website Item Group',b'Cross Listing of Item in multiple groups',"b""Liste Crois\xc3\xa9e d'Articles dans plusieurs groupes"""
+b'apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +90',b'Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0}',"b""La Date de D\xc3\xa9but et la Date de Fin de l'Exercice Fiscal sont d\xc3\xa9j\xc3\xa0 d\xc3\xa9finies dans l'Ann\xc3\xa9e Fiscale {0}"""
+b'DocType: Projects Settings',b'Ignore User Time Overlap',b'Ignorer le chevauchement du temps utilisateur'
+b'apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +113',b'Clearance Date updated',b'Date de Compensation mise \xc3\xa0 jour'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +146',b'Split Batch',b'Lot Fractionn\xc3\xa9'
+b'DocType: Stock Settings',b'Batch Identification',b'Identification par lots'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +132',b'Successfully Reconciled',b'R\xc3\xa9concili\xc3\xa9 avec Succ\xc3\xa8s'
+b'DocType: Request for Quotation Supplier',b'Download PDF',b'T\xc3\xa9l\xc3\xa9charger au Format PDF'
+b'DocType: Work Order',b'Planned End Date',b'Date de Fin Pr\xc3\xa9vue'
+b'DocType: Shareholder',b'Hidden list maintaining the list of contacts linked to Shareholder',b'Liste cach\xc3\xa9e maintenant la liste des contacts li\xc3\xa9s \xc3\xa0 l&#39;actionnaire'
+b'apps/erpnext/erpnext/config/non_profit.py +63',b'Donor Type information.',b'Informations sur le type de donneur.'
+b'DocType: Request for Quotation',b'Supplier Detail',b'D\xc3\xa9tails du Fournisseur'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +100',b'Error in formula or condition: {0}',b'Erreur dans la formule ou dans la condition : {0}'
+b'apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +99',b'Invoiced Amount',b'Montant Factur\xc3\xa9'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +47',b'Criteria weights must add up to 100%',b'Le total des pond\xc3\xa9rations des crit\xc3\xa8res doit \xc3\xaatre \xc3\xa9gal \xc3\xa0 100%'
+b'apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js +7',b'Attendance',b'Pr\xc3\xa9sence'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +115',b'Stock Items',b'Articles de Stock'
+b'DocType: BOM',b'Materials',b'Mat\xc3\xa9riels'
+b'DocType: Leave Block List',"b'If not checked, the list will have to be added to each Department where it has to be applied.'","b'Si d\xc3\xa9coch\xc3\xa9e, la liste devra \xc3\xaatre ajout\xc3\xa9e \xc3\xa0 chaque d\xc3\xa9partement o\xc3\xb9 elle doit \xc3\xaatre appliqu\xc3\xa9e.'"
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +111',b'Creating {0}',b'Cr\xc3\xa9ation de {0}'
+b'apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py +28',b'Source and Target Warehouse cannot be same',b'Entrep\xc3\xb4t Source et Destination ne peuvent pas \xc3\xaatre le m\xc3\xaame'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +586',b'Posting date and posting time is mandatory',b'La Date et l\xe2\x80\x99heure de comptabilisation sont obligatoires'
+b'apps/erpnext/erpnext/config/buying.py +76',b'Tax template for buying transactions.',b'Mod\xc3\xa8le de taxe pour les op\xc3\xa9rations d\xe2\x80\x99achat.'
+,b'Item Prices',b'Prix des Articles'
+b'DocType: Purchase Order',b'In Words will be visible once you save the Purchase Order.',b'En Toutes Lettres. Sera visible une fois que vous enregistrerez le Bon de Commande.'
+b'DocType: Period Closing Voucher',b'Period Closing Voucher',b'Bon de Cl\xc3\xb4ture de la P\xc3\xa9riode'
+b'DocType: Consultation',b'Review Details',"b""D\xc3\xa9tails de l'Examen"""
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +185',b'The shareholder does not belong to this company',b'L&#39;actionnaire n&#39;appartient pas \xc3\xa0 cette soci\xc3\xa9t\xc3\xa9'
+b'DocType: Dosage Form',b'Dosage Form',b'Formulaire de Dosage'
+b'apps/erpnext/erpnext/config/selling.py +67',b'Price List master.',b'Donn\xc3\xa9es de Base des Listes de Prix'
+b'DocType: Task',b'Review Date',b'Date de Revue'
+b'DocType: Company',b'Series for Asset Depreciation Entry (Journal Entry)',"b""S\xc3\xa9rie pour la D\xc3\xa9pr\xc3\xa9ciation d'Actifs (Entr\xc3\xa9e de Journal)"""
+b'DocType: Membership',b'Member Since',b'Membre depuis'
+b'DocType: Purchase Invoice',b'Advance Payments',b'Paiements Anticip\xc3\xa9s'
+b'DocType: Purchase Taxes and Charges',b'On Net Total',b'Sur le Total Net'
+b'apps/erpnext/erpnext/controllers/item_variant.py +92',b'Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4}',"b""Valeur pour l'attribut {0} doit \xc3\xaatre dans la gamme de {1} \xc3\xa0 {2} dans les incr\xc3\xa9ments de {3} pour le poste {4}"""
+b'DocType: Restaurant Reservation',b'Waitlisted',"b""En liste d'attente"""
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +124',b'Currency can not be changed after making entries using some other currency',b'Devise ne peut \xc3\xaatre modifi\xc3\xa9e apr\xc3\xa8s avoir fait des entr\xc3\xa9es en utilisant une autre devise'
+b'DocType: Shipping Rule',b'Fixed',b'Fix\xc3\xa9'
+b'DocType: Vehicle Service',b'Clutch Plate',"b""Plaque d'Embrayage"""
+b'DocType: Company',b'Round Off Account',b'Compte d\xe2\x80\x99Arrondi'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93',b'Administrative Expenses',b'Charges Administratives'
+b'apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py +18',b'Consulting',b'Consultant'
+b'DocType: Customer Group',b'Parent Customer Group',b'Groupe Client Parent'
+b'DocType: Journal Entry',b'Subscription',b'Abonnement'
+b'DocType: Purchase Invoice',b'Contact Email',b'Email du Contact'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +11',b'Fee Creation Pending',"b""Cr\xc3\xa9ation d'honoraires en attente"""
+b'DocType: Appraisal Goal',b'Score Earned',b'Score Gagn\xc3\xa9'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +241',b'Notice Period',b'P\xc3\xa9riode de Pr\xc3\xa9avis'
+b'DocType: Asset Category',b'Asset Category Name',"b""Nom de Cat\xc3\xa9gorie d'Actif"""
+b'apps/erpnext/erpnext/setup/doctype/territory/territory.js +13',b'This is a root territory and cannot be edited.',b'Il s\xe2\x80\x99agit d\xe2\x80\x99une r\xc3\xa9gion racine qui ne peut \xc3\xaatre modifi\xc3\xa9e.'
+b'apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js +5',b'New Sales Person Name',b'Nouveau Nom de Commercial'
+b'DocType: Packing Slip',b'Gross Weight UOM',b'UDM du Poids Brut'
+b'DocType: Asset Maintenance Task',b'Preventive Maintenance',b'Maintenance pr\xc3\xa9ventive'
+b'DocType: Delivery Note Item',b'Against Sales Invoice',b'Pour la Facture de Vente'
+b'DocType: Purchase Invoice',b'07-Others',b'07-Autres'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +151',b'Please enter serial numbers for serialized item ',"b""Veuillez entrer les num\xc3\xa9ros de s\xc3\xa9rie pour l'\xc3\xa9l\xc3\xa9ment s\xc3\xa9rialis\xc3\xa9"""
+b'DocType: Bin',b'Reserved Qty for Production',b'Qt\xc3\xa9 R\xc3\xa9serv\xc3\xa9e pour la Production'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +43',b'EcritureNum',b'EcritureNum'
+b'DocType: Student Group Creation Tool',"b""Leave unchecked if you don't want to consider batch while making course based groups. """,b'Laisser d\xc3\xa9sactiv\xc3\xa9 si vous ne souhaitez pas consid\xc3\xa9rer les lots en faisant des groupes bas\xc3\xa9s sur les cours.'
+b'DocType: Asset',b'Frequency of Depreciation (Months)',b'Fr\xc3\xa9quence des Amortissements (Mois)'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +500',b'Credit Account',b'Compte Cr\xc3\xa9diteur'
+b'DocType: Landed Cost Item',b'Landed Cost Item',"b""Co\xc3\xbbt de l'Article au D\xc3\xa9barquement"""
+b'apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js +57',b'Show zero values',b'Afficher les valeurs nulles'
+b'DocType: BOM',b'Quantity of item obtained after manufacturing / repacking from given quantities of raw materials',b'Quantit\xc3\xa9 de produit obtenue apr\xc3\xa8s fabrication / reconditionnement des quantit\xc3\xa9s donn\xc3\xa9es de mati\xc3\xa8res premi\xc3\xa8res'
+b'DocType: Lab Test',b'Test Group',b'Groupe de Test'
+b'DocType: Payment Reconciliation',b'Receivable / Payable Account',b'Compte D\xc3\xa9biteur / Cr\xc3\xa9diteur'
+b'DocType: Delivery Note Item',b'Against Sales Order Item',"b""Pour l'Article de la Commande Client"""
+b'DocType: Company',b'Company Logo',b'Logo d&#39;entreprise'
+b'apps/erpnext/erpnext/stock/doctype/item/item.py +709',b'Please specify Attribute Value for attribute {0}',"b""Veuillez sp\xc3\xa9cifier une Valeur d\xe2\x80\x99Attribut pour l'attribut {0}"""
+b'DocType: Item',b'Default Warehouse',b'Entrep\xc3\xb4t par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/accounts/doctype/budget/budget.py +45',b'Budget cannot be assigned against Group Account {0}',b'Budget ne peut pas \xc3\xaatre attribu\xc3\xa9 pour le Compte de Groupe {0}'
+b'DocType: Healthcare Settings',b'Patient Registration',b'Inscription du patient'
+b'apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22',b'Please enter parent cost center',b'Veuillez entrer le centre de co\xc3\xbbt parent'
+b'DocType: Delivery Note',b'Print Without Amount',b'Imprimer Sans Montant'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +57',b'Depreciation Date',b'Date d\xe2\x80\x99Amortissement'
+,b'Work Orders in Progress',b'Ordres de travail en cours'
+b'DocType: Issue',b'Support Team',b'\xc3\x89quipe de Support'
+b'apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py +36',b'Expiry (In Days)',b'Expiration (En Jours)'
+b'DocType: Appraisal',b'Total Score (Out of 5)',b'Score Total (sur 5)'
+b'DocType: Fee Structure',b'FS.',b'FS.'
+b'DocType: Student Attendance Tool',b'Batch',b'Lot'
+b'DocType: Donor',b'Donor Type',b'Type de donneur'
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +27',b'Balance',b'Solde'
+b'apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py +66',b'Please select the Company',b'Veuillez s\xc3\xa9lectionner la soci\xc3\xa9t\xc3\xa9'
+b'DocType: Room',b'Seating Capacity',b'Nombre de places'
+b'DocType: Issue',b'ISS-',b'ISS-'
+b'DocType: Lab Test Groups',b'Lab Test Groups',b'Groupes de test de laboratoire'
+b'DocType: Project',b'Total Expense Claim (via Expense Claims)',b'Total des Notes de Frais (via Notes de Frais)'
+b'DocType: GST Settings',b'GST Summary',b'R\xc3\xa9sum\xc3\xa9 GST'
+b'apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py +16',b'Please enable default incoming account before creating Daily Work Summary Group',b'Veuillez activer le compte entrant par d\xc3\xa9faut avant de cr\xc3\xa9er le groupe de travail R\xc3\xa9sum\xc3\xa9 quotidien'
+b'DocType: Assessment Result',b'Total Score',b'Score Total'
+b'DocType: Journal Entry',b'Debit Note',b'Note de D\xc3\xa9bit'
+b'DocType: Stock Entry',b'As per Stock UOM',b'Selon UDM du Stock'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7',b'Not Expired',b'Non Expir\xc3\xa9'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +49',b'ValidDate',b'Date valide'
+b'DocType: Student Log',b'Achievement',b'R\xc3\xa9alisation'
+b'DocType: Batch',b'Source Document Type',b'Type de Document Source'
+b'apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js +24',b'Following course schedules were created',b'Les horaires de cours suivants ont \xc3\xa9t\xc3\xa9 cr\xc3\xa9\xc3\xa9s'
+b'DocType: Journal Entry',b'Total Debit',b'Total D\xc3\xa9bit'
+b'DocType: Manufacturing Settings',b'Default Finished Goods Warehouse',b'Entrep\xc3\xb4t de Produits Finis par D\xc3\xa9faut'
+b'apps/erpnext/erpnext/healthcare/doctype/consultation/consultation.js +108',b'Please select Patient',b'Veuillez s\xc3\xa9lectionner Patient'
+b'apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +76',b'Sales Person',b'Vendeur'
+b'DocType: Hotel Room Package',b'Amenities',b'\xc3\x89quipements'
+b'apps/erpnext/erpnext/config/accounts.py +233',b'Budget and Cost Center',b'Centre de Budget et Co\xc3\xbbts'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +65',b'Multiple default mode of payment is not allowed',b'De multiples modes de paiement par d\xc3\xa9faut ne sont pas autoris\xc3\xa9s'
+b'apps/erpnext/erpnext/templates/emails/recurring_document_failed.html +5',b'for the',b'pour le'
+,b'Appointment Analytics',b'Analyse des Rendez-Vous'
+b'DocType: Vehicle Service',b'Half Yearly',b'Semestriel'
+b'DocType: Lead',b'Blog Subscriber',b'Abonn\xc3\xa9 au Blog'
+b'DocType: Guardian',b'Alternate Number',b'Autre Num\xc3\xa9ro'
+b'DocType: Healthcare Settings',b'Consultations in valid days',b'Consultations en Jours Ouvr\xc3\xa9s'
+b'DocType: Assessment Plan Criteria',b'Maximum Score',b'Score Maximum'
+b'apps/erpnext/erpnext/config/setup.py +83',b'Create rules to restrict transactions based on values.',b'Cr\xc3\xa9er des r\xc3\xa8gles pour restreindre les transactions bas\xc3\xa9es sur les valeurs .'
+b'DocType: Cash Flow Mapping Accounts',b'Cash Flow Mapping Accounts',b'Comptes de cartographie des flux de tr\xc3\xa9sorerie'
+b'apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py +49',b' Group Roll No',b'N\xc2\xb0 de R\xc3\xb4le du Groupe'
+b'DocType: Batch',b'Manufacturing Date',b'Date de fabrication'
+b'apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js +9',b'Fee Creation Failed',b'La cr\xc3\xa9ation des honoraires a \xc3\xa9chou\xc3\xa9'
+b'DocType: Opening Invoice Creation Tool',b'Create Missing Party',b'Cr\xc3\xa9er une partie manquante'
+b'DocType: Student Group Creation Tool',b'Leave blank if you make students groups per year',"b""Laisser vide si vous faites des groupes d'\xc3\xa9tudiants par ann\xc3\xa9e"""
+b'DocType: HR Settings',"b'If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day'","b'Si coch\xc3\xa9e, Le nombre total de Jours Ouvr\xc3\xa9s comprendra les vacances, ce qui r\xc3\xa9duira la valeur du Salaire Par Jour'"
+b'DocType: Purchase Invoice',b'Total Advance',b'Total Avance'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +27',b'Change Template Code',b'Modifier le Code du Mod\xc3\xa8le'
+b'apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py +23',b'The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.',b'La Date de Fin de Terme ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de D\xc3\xa9but de Terme. Veuillez corriger les dates et essayer \xc3\xa0 nouveau.'
+b'apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py +19',b'Quot Count',b'Compte de Devis'
+,b'BOM Stock Report',b'Rapport de Stock de LDM'
+b'DocType: Stock Reconciliation Item',b'Quantity Difference',b'Diff\xc3\xa9rence de Quantit\xc3\xa9'
+b'DocType: Employee Advance',b'EA-',b'EA-'
+b'DocType: Opportunity Item',b'Basic Rate',b'Taux de Base'
+b'DocType: GL Entry',b'Credit Amount',b'Montant du Cr\xc3\xa9dit'
+b'DocType: Cheque Print Template',b'Signatory Position',b'Position Signataire'
+b'apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +173',b'Set as Lost',b'D\xc3\xa9finir comme Perdu'
+b'DocType: Timesheet',b'Total Billable Hours',b'Total des Heures Facturables'
+b'apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html +4',b'Payment Receipt Note',b'Bon de R\xc3\xa9ception du Paiement'
+b'apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py +6',b'This is based on transactions against this Customer. See timeline below for details',b'Bas\xc3\xa9 sur les transactions avec ce client. Voir la chronologie ci-dessous pour plus de d\xc3\xa9tails'
+b'apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +162',b'Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2}',b'Ligne {0} : Le montant allou\xc3\xa9 {1} doit \xc3\xaatre inf\xc3\xa9rieur ou \xc3\xa9gal au montant du Paiement {2}'
+b'DocType: Program Enrollment Tool',b'New Academic Term',b'Nouveau terme acad\xc3\xa9mique'
+,b'Course wise Assessment Report',"b""Rapport d'\xc3\x89valuation par Cours"""
+b'DocType: Purchase Invoice',b'Availed ITC State/UT Tax',b'\xc3\x89tat de taxe ITC / UT \xc3\xa9puis\xc3\xa9'
+b'DocType: Tax Rule',b'Tax Rule',b'R\xc3\xa8gle de Taxation'
+b'DocType: Selling Settings',b'Maintain Same Rate Throughout Sales Cycle',b'Maintenir le M\xc3\xaame Taux Durant le Cycle de Vente'
+b'DocType: Manufacturing Settings',b'Plan time logs outside Workstation Working Hours.',b'Planifier les journaux de temps en dehors des Heures de Travail du Bureau.'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py +115',b'Dr {0} does not have a Physician Schedule. Add it in Physician master',"b""Le Dr {0} n'a pas d'emploi du temps. Ajoutez-en un dans ses donn\xc3\xa9es de base"""
+b'apps/erpnext/erpnext/public/js/pos/pos.html +98',b'Customers in Queue',"b""Clients dans la File d'Attente"""
+b'DocType: Driver',b'Issuing Date',b'Date d&#39;\xc3\xa9mission'
+b'DocType: Student',b'Nationality',b'Nationalit\xc3\xa9'
+b'apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js +109',b'Submit this Work Order for further processing.',b'Soumettez ce bon de travail pour un traitement ult\xc3\xa9rieur.'
+,b'Items To Be Requested',b'Articles \xc3\x80 Demander'
+b'DocType: Purchase Order',b'Get Last Purchase Rate',"b""Obtenir le Dernier Tarif d'Achat"""
+b'DocType: Company',b'Company Info',b'Informations sur la Soci\xc3\xa9t\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1385',b'Select or add new customer',b'S\xc3\xa9lectionner ou ajoutez nouveau client'
+b'apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +173',b'Cost center is required to book an expense claim',b'Un centre de co\xc3\xbbt est requis pour comptabiliser une note de frais'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9',b'Application of Funds (Assets)',b'Emplois des Ressources (Actifs)'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py +6',b'This is based on the attendance of this Employee',b'Bas\xc3\xa9 sur la pr\xc3\xa9sence de cet Employ\xc3\xa9'
+b'DocType: Assessment Result',b'Summary',b'R\xc3\xa9sum\xc3\xa9'
+b'apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js +112',b'Mark Attendance',b'Noter la Pr\xc3\xa9sence'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +494',b'Debit Account',b'Compte de D\xc3\xa9bit'
+b'DocType: Fiscal Year',b'Year Start Date',"b""Date de D\xc3\xa9but de l'Exercice"""
+b'DocType: Attendance',b'Employee Name',"b""Nom de l'Employ\xc3\xa9"""
+b'DocType: Restaurant Order Entry Item',b'Restaurant Order Entry Item',b'Poste de commande de restaurant'
+b'DocType: Purchase Invoice',b'Rounded Total (Company Currency)',b'Total Arrondi (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +96',b'Cannot covert to Group because Account Type is selected.',b'Conversion impossible en Groupe car le Type de Compte est s\xc3\xa9lectionn\xc3\xa9.'
+b'apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +260',b'{0} {1} has been modified. Please refresh.',b'{0} {1} a \xc3\xa9t\xc3\xa9 modifi\xc3\xa9. Veuillez actualiser.'
+b'DocType: Leave Block List',b'Stop users from making Leave Applications on following days.',b'Emp\xc3\xaacher les utilisateurs de faire des Demandes de Cong\xc3\xa9 les jours suivants.'
+b'DocType: Asset Maintenance Team',b'Maintenance Team Members',b'Membres de l&#39;\xc3\xa9quipe de maintenance'
+b'apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +63',b'Purchase Amount',"b""Montant de l'Achat"""
+b'apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +261',b'Supplier Quotation {0} created',b'Devis Fournisseur {0} cr\xc3\xa9\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/report/financial_statements.py +103',b'End Year cannot be before Start Year',"b""L'Ann\xc3\xa9e de Fin ne peut pas \xc3\xaatre avant l'Ann\xc3\xa9e de D\xc3\xa9but"""
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +234',b'Employee Benefits',"b""Avantages de l'Employ\xc3\xa9"""
+b'apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +264',b'Packed quantity must equal quantity for Item {0} in row {1}',"b""La quantit\xc3\xa9 emball\xc3\xa9e doit \xc3\xaatre \xc3\xa9gale \xc3\xa0 la quantit\xc3\xa9 pour l'Article {0} \xc3\xa0 la ligne {1}"""
+b'DocType: Work Order',b'Manufactured Qty',b'Qt\xc3\xa9 Fabriqu\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py +78',"b""The shares don't exist with the {0}""",b'Les partages n&#39;existent pas avec le {0}'
+b'apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py +64',b'Invoice Created',b'Facture Cr\xc3\xa9\xc3\xa9e'
+b'DocType: Asset',b'Out of Order',b'Hors service'
+b'DocType: Purchase Receipt Item',b'Accepted Quantity',b'Quantit\xc3\xa9 Accept\xc3\xa9e'
+b'DocType: Projects Settings',b'Ignore Workstation Time Overlap',b'Ignorer le chevauchement de temps de poste de travail'
+b'apps/erpnext/erpnext/hr/doctype/employee/employee.py +242',b'Please set a default Holiday List for Employee {0} or Company {1}',"b""Veuillez d\xc3\xa9finir une Liste de Vacances par d\xc3\xa9faut pour l'Employ\xc3\xa9 {0} ou la Soci\xc3\xa9t\xc3\xa9 {1}"""
+b'apps/erpnext/erpnext/accounts/party.py +30',b'{0}: {1} does not exists',b'{0} : {1} n\xe2\x80\x99existe pas'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +76',b'Select Batch Numbers',b'S\xc3\xa9lectionnez les Num\xc3\xa9ros de Lot'
+b'apps/erpnext/erpnext/config/accounts.py +12',b'Bills raised to Customers.',b'Factures \xc3\xa9mises pour des Clients.'
+b'apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26',b'Project Id',b'ID du Projet'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +534',b'Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2}',b'Ligne N\xc2\xb0 {0}: Le montant ne peut \xc3\xaatre sup\xc3\xa9rieur au Montant en Attente pour la Note de Frais {1}. Le Montant en Attente est de {2}'
+b'DocType: Patient Service Unit',b'Medical Administrator',b'Administrateur m\xc3\xa9dical'
+b'DocType: Assessment Plan',b'Schedule',b'Calendrier'
+b'DocType: Account',b'Parent Account',b'Compte Parent'
+b'apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js +266',b'Available',b'disponible'
+b'DocType: Quality Inspection Reading',b'Reading 3',b'Reading 3'
+b'DocType: Stock Entry',b'Source Warehouse Address',b'Adresse de l&#39;entrep\xc3\xb4t source'
+,b'Hub',b'Hub'
+b'DocType: GL Entry',b'Voucher Type',b'Type de R\xc3\xa9f\xc3\xa9rence'
+b'apps/erpnext/erpnext/accounts/page/pos/pos.js +1717',b'Price List not found or disabled',b'Liste de Prix introuvable ou desactiv\xc3\xa9e'
+b'DocType: Student Applicant',b'Approved',b'Approuv\xc3\xa9'
+b'apps/erpnext/erpnext/public/js/pos/pos_selected_item.html +15',b'Price',b'Prix'
+b'apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +267',"b""Employee relieved on {0} must be set as 'Left'""","b""Employ\xc3\xa9 d\xc3\xa9gag\xc3\xa9 de {0} doit \xc3\xaatre d\xc3\xa9fini comme 'Gauche'"""
+b'DocType: Hub Settings',b'Last Sync On',b'Derni\xc3\xa8re synchronisation le'
+b'DocType: Guardian',b'Guardian',b'Tuteur'
+b'DocType: Opening Invoice Creation Tool',b'Create missing customer or supplier.',b'Cr\xc3\xa9er un client ou un fournisseur manquant'
+b'apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +42',b'Appraisal {0} created for Employee {1} in the given date range',"b""\xc3\x89valuation {0} cr\xc3\xa9\xc3\xa9e pour l'Employ\xc3\xa9 {1} dans l'intervalle de dates donn\xc3\xa9"""
+b'DocType: Academic Term',b'Education',b'Education'
+b'apps/erpnext/erpnext/public/js/pos/pos.html +89',b'Del',b'Supp'
+b'DocType: Selling Settings',b'Campaign Naming By',b'Campagne Nomm\xc3\xa9e Par'
+b'DocType: Employee',b'Current Address Is',"b""L'Adresse Actuelle est"""
+b'apps/erpnext/erpnext/utilities/user_progress.py +51',b'Monthly Sales Target (',b'Objectif de vente mensuel ('
+b'DocType: Physician Service Unit Schedule',b'Physician Service Unit Schedule',b'Horaire des unit\xc3\xa9s de service de m\xc3\xa9decin'
+b'apps/erpnext/erpnext/templates/includes/projects/project_tasks.html +9',b'modified',b'modifi\xc3\xa9'
+b'apps/erpnext/erpnext/accounts/doctype/account/account_tree.js +43',"b""Optional. Sets company's default currency, if not specified.""","b""Optionnel. D\xc3\xa9fini la devise par d\xc3\xa9faut de l'entreprise, si non sp\xc3\xa9cifi\xc3\xa9."""
+b'DocType: Sales Invoice',b'Customer GSTIN',b'GSTIN Client'
+b'DocType: Crop Cycle',"b""List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ""","b'Liste des maladies d\xc3\xa9tect\xc3\xa9es sur le terrain. Une fois s\xc3\xa9lectionn\xc3\xa9, il ajoutera automatiquement une liste de t\xc3\xa2ches pour faire face \xc3\xa0 la maladie'"
+b'DocType: Asset Repair',b'Repair Status',b'\xc3\x89tat de r\xc3\xa9paration'
+b'apps/erpnext/erpnext/config/accounts.py +67',b'Accounting journal entries.',b'Les \xc3\xa9critures comptables.'
+b'DocType: Delivery Note Item',b'Available Qty at From Warehouse',"b""Qt\xc3\xa9 Disponible Depuis l'Entrep\xc3\xb4t"""
+b'DocType: POS Profile',b'Account for Change Amount',b'Compte pour le Rendu de Monnaie'
+b'DocType: Purchase Invoice',b'input service',b'service d&#39;entr\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +217',b'Row {0}: Party / Account does not match with {1} / {2} in {3} {4}',b'Ligne {0} : Tiers / Compte ne correspond pas \xc3\xa0 {1} / {2} en {3} {4}'
+b'DocType: Maintenance Team Member',b'Maintenance Team Member',b'Membre de l&#39;\xc3\xa9quipe de maintenance'
+b'DocType: Agriculture Analysis Criteria',b'Soil Analysis',b'Analyse du sol'
+b'apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html +13',b'Course Code: ',b'Code du Cours:'
+b'apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +240',b'Please enter Expense Account',b'Veuillez entrer un Compte de Charges'
+b'DocType: Account',b'Stock',b'Stock'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +1095',"b'Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry'","b""Ligne #{0} : Type de Document de R\xc3\xa9f\xc3\xa9rence doit \xc3\xaatre un Bon de Commande, une Facture d'Achat ou une \xc3\x89criture de Journal"""
+b'DocType: Employee',b'Current Address',b'Adresse Actuelle'
+b'DocType: Item',"b'If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified'","b""Si l'article est une variante d'un autre article, alors la description, l'image, le prix, les taxes etc seront fix\xc3\xa9s \xc3\xa0 partir du mod\xc3\xa8le sauf si sp\xc3\xa9cifi\xc3\xa9s explicitement"""
+b'DocType: Serial No',b'Purchase / Manufacture Details',b'Achat / Fabrication D\xc3\xa9tails'
+b'DocType: Assessment Group',b'Assessment Group',"b""Groupe d'\xc3\x89valuation"""
+b'apps/erpnext/erpnext/config/stock.py +329',b'Batch Inventory',b'Inventaire du Lot'
+b'DocType: Employee',b'Contract End Date',b'Date de Fin de Contrat'
+b'DocType: Sales Order',b'Track this Sales Order against any Project',b'Suivre cette Commande de Vente pour tous les Projets'
+b'DocType: Sales Invoice Item',b'Discount and Margin',b'Remise et Marge'
+b'DocType: Lab Test',b'Prescription',b'Ordonnance'
+b'DocType: Project',b'Second Email',b'Deuxi\xc3\xa8me Email'
+b'apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js +111',b'Not Available',b'Indisponible'
+b'DocType: Pricing Rule',b'Min Qty',b'Qt\xc3\xa9 Min'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.js +36',b'Disable Template',b'D\xc3\xa9sactiver le Mod\xc3\xa8le'
+b'DocType: GL Entry',b'Transaction Date',b'Date de la Transaction'
+b'DocType: Production Plan Item',b'Planned Qty',b'Qt\xc3\xa9 Planifi\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +121',b'Total Tax',b'Total des Taxes'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204',b'For Quantity (Manufactured Qty) is mandatory',b'Pour Quantit\xc3\xa9 (Qt\xc3\xa9 Fabriqu\xc3\xa9) est obligatoire'
+b'DocType: Stock Entry',b'Default Target Warehouse',b'Entrep\xc3\xb4t Cible par D\xc3\xa9faut'
+b'DocType: Purchase Invoice',b'Net Total (Company Currency)',b'Total Net (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py +14',b'The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.',"b""La Date de Fin d'Ann\xc3\xa9e ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la Date de D\xc3\xa9but d\xe2\x80\x99Ann\xc3\xa9e. Veuillez corriger les dates et essayer \xc3\xa0 nouveau."""
+b'DocType: Notification Control',b'Purchase Receipt Message',b'Message du Re\xc3\xa7u d\xe2\x80\x99Achat'
+b'DocType: BOM',b'Scrap Items',b'Mettre au Rebut des Articles'
+b'DocType: Work Order',b'Actual Start Date',b'Date de D\xc3\xa9but R\xc3\xa9elle'
+b'DocType: Sales Order',b'% of materials delivered against this Sales Order',b'% de mat\xc3\xa9riaux livr\xc3\xa9s pour cette Commande Client'
+b'apps/erpnext/erpnext/config/manufacturing.py +18',b'Generate Material Requests (MRP) and Work Orders.',b'G\xc3\xa9n\xc3\xa9rer des demandes de mat\xc3\xa9riel (MRP) et des ordres de travail.'
+b'apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py +62',b'Set default mode of payment',b'D\xc3\xa9finir le mode de paiement par d\xc3\xa9faut'
+b'DocType: Grant Application',b'Withdrawn',b'Retir\xc3\xa9'
+b'DocType: Hub Settings',b'Hub Settings',b'Param\xc3\xa8tres du Hub'
+b'DocType: Project',b'Gross Margin %',b'Marge Brute %'
+b'DocType: BOM',b'With Operations',b'Avec des Op\xc3\xa9rations'
+b'apps/erpnext/erpnext/accounts/party.py +259',b'Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.',b'Des \xc3\xa9critures comptables ont d\xc3\xa9j\xc3\xa0 \xc3\xa9t\xc3\xa9 r\xc3\xa9alis\xc3\xa9es en devise {0} pour la soci\xc3\xa9t\xc3\xa9 {1}. Veuillez s\xc3\xa9lectionner un compte de cr\xc3\xa9dit ou de d\xc3\xa9bit  en devise {0}.'
+b'DocType: Asset',b'Is Existing Asset',b'Est Actif Existant'
+b'DocType: Salary Detail',b'Statistical Component',b'Composante Statistique'
+b'DocType: Warranty Claim',b'If different than customer address',"b""Si diff\xc3\xa9rente de l'adresse du client"""
+b'DocType: Purchase Invoice',b'Without Payment of Tax',b'Sans Paiement de Taxe'
+b'DocType: BOM Operation',b'BOM Operation',b'Op\xc3\xa9ration LDM'
+b'apps/erpnext/erpnext/config/stock.py +141',b'Fulfilment',b'Accomplissement'
+b'DocType: Purchase Taxes and Charges',b'On Previous Row Amount',b'Le Montant de la Rang\xc3\xa9e Pr\xc3\xa9c\xc3\xa9dente'
+b'DocType: Item',b'Has Expiry Date',"b""A une date d'expiration"""
+b'apps/erpnext/erpnext/assets/doctype/asset/asset.js +282',b'Transfer Asset',"b""Transfert d'Actifs"""
+b'DocType: POS Profile',b'POS Profile',b'Profil PDV'
+b'DocType: Training Event',b'Event Name',"b""Nom de l'\xc3\x89v\xc3\xa9nement"""
+b'DocType: Physician',b'Phone (Office)',b'T\xc3\xa9l\xc3\xa9phone (Bureau)'
+b'apps/erpnext/erpnext/hooks.py +151',b'Admission',b'Admission'
+b'apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py +29',b'Admissions for {0}',b'Admissions pour {0}'
+b'apps/erpnext/erpnext/config/accounts.py +257',"b'Seasonality for setting budgets, targets etc.'","b""Saisonnalit\xc3\xa9 de l'\xc3\xa9tablissement des budgets, des objectifs, etc."""
+b'DocType: Supplier Scorecard Scoring Variable',b'Variable Name',b'Nom de la Variable'
+b'apps/erpnext/erpnext/stock/get_item_details.py +144',"b'Item {0} is a template, please select one of its variants'","b""L'article {0} est un mod\xc3\xa8le, veuillez s\xc3\xa9lectionner l'une de ses variantes"""
+b'DocType: Asset',b'Asset Category',"b""Cat\xc3\xa9gorie d'Actif"""
+b'apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +31',b'Net pay cannot be negative',b'Salaire Net ne peut pas \xc3\xaatre n\xc3\xa9gatif'
+b'DocType: Purchase Order',b'Advance Paid',b'Avance Pay\xc3\xa9e'
+b'DocType: Item',b'Item Tax',"b""Taxe sur l'Article"""
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +883',b'Material to Supplier',b'Du Mat\xc3\xa9riel au Fournisseur'
+b'DocType: Soil Texture',b'Loamy Sand',b'Sable limoneux'
+b'DocType: Production Plan',b'Material Request Planning',b'Planification des demandes de mat\xc3\xa9riel'
+b'apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +638',b'Excise Invoice',"b""Facture d'Accise"""
+b'apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py +16',b'Treshold {0}% appears more than once',"b""Le seuil {0}% appara\xc3\xaet plus d'une fois"""
+b'DocType: Expense Claim',b'Employees Email Id',b'Identifiants Email des employ\xc3\xa9s'
+b'DocType: Employee Attendance Tool',b'Marked Attendance',b'Pr\xc3\xa9sence Valid\xc3\xa9e'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +138',b'Current Liabilities',b'Dettes Actuelles'
+b'apps/erpnext/erpnext/config/selling.py +297',b'Send mass SMS to your contacts',b'Envoyer un SMS en masse \xc3\xa0 vos contacts'
+b'DocType: Patient',b'A Positive',b'A Positif'
+b'DocType: Program',b'Program Name',b'Nom du Programme'
+b'DocType: Purchase Taxes and Charges',b'Consider Tax or Charge for',b'Tenir Compte de la Taxe et des Frais pour'
+b'DocType: Driver',b'Driving License Category',b'Cat\xc3\xa9gorie de permis de conduire'
+b'apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py +158',b'No Reference',b'Aucune r\xc3\xa9f\xc3\xa9rence'
+b'apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +57',b'Actual Qty is mandatory',b'Qt\xc3\xa9 R\xc3\xa9elle est obligatoire'
+b'apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +92',"b'{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.'","b""{0} est actuellement associ\xc3\xa9 avec une fiche d'\xc3\xa9valuation fournisseur {1}. Les bons de commande pour ce fournisseur doivent \xc3\xaatre \xc3\xa9dit\xc3\xa9s avec pr\xc3\xa9caution."""
+b'DocType: Asset Maintenance Team',b'Asset Maintenance Team',b'\xc3\x89quipe de Maintenance des Actifs'
+b'DocType: Employee Loan',b'Loan Type',b'Type de Pr\xc3\xaat'
+b'DocType: Scheduling Tool',b'Scheduling Tool',b'Outil de Planification'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +180',b'Credit Card',b'Carte de Cr\xc3\xa9dit'
+b'DocType: BOM',b'Item to be manufactured or repacked',b'Article \xc3\xa0 manufacturer ou \xc3\xa0 r\xc3\xa9emballer'
+b'DocType: Employee Education',b'Major/Optional Subjects',b'Sujets Principaux / En Option'
+b'DocType: Sales Invoice Item',b'Drop Ship',b'Exp\xc3\xa9dition Directe'
+b'DocType: Driver',b'Suspended',b'Suspendu'
+b'DocType: Training Event',b'Attendees',b'Participants'
+b'DocType: Employee',"b'Here you can maintain family details like name and occupation of parent, spouse and children'","b'Ici vous pouvez conserver les d\xc3\xa9tails familiaux comme le nom et la profession des parents, le conjoint et les enfants'"
+b'DocType: Academic Term',b'Term End Date',b'Date de Fin du Terme'
+b'DocType: Purchase Invoice',b'Taxes and Charges Deducted (Company Currency)',b'Taxes et Frais D\xc3\xa9ductibles (Devise Soci\xc3\xa9t\xc3\xa9)'
+b'DocType: Item Group',b'General Settings',b'Param\xc3\xa8tres G\xc3\xa9n\xc3\xa9raux'
+b'apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +23',b'From Currency and To Currency cannot be same',b'La Devise de Base et la Devise de Cotation ne peuvent pas identiques'
+b'DocType: Stock Entry',b'Repack',b'R\xc3\xa9-emballer'
+b'apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6',b'You must Save the form before proceeding',b'Vous devez sauvegarder le formulaire avant de continuer'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +113',b'Please select the Company first',b'Veuillez s\xc3\xa9lectionner la Soci\xc3\xa9t\xc3\xa9 en premier'
+b'DocType: Item Attribute',b'Numeric Values',b'Valeurs Num\xc3\xa9riques'
+b'apps/erpnext/erpnext/public/js/setup_wizard.js +56',b'Attach Logo',b'Joindre le Logo'
+b'apps/erpnext/erpnext/stock/doctype/batch/batch.js +51',b'Stock Levels',b'Niveaux du Stocks'
+b'DocType: Customer',b'Commission Rate',b'Taux de Commission'
+b'apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py +187',b'Created {0} scorecards for {1} between: ',"b""{0} fiches d'\xc3\xa9valuations cr\xc3\xa9\xc3\xa9es pour {1} entre:"""
+b'apps/erpnext/erpnext/stock/doctype/item/item.js +505',b'Make Variant',b'Faire une Variante'
+b'apps/erpnext/erpnext/config/hr.py +87',b'Block leave applications by department.',b'Bloquer les demandes de cong\xc3\xa9 par d\xc3\xa9partement'
+b'apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py +155',"b'Payment Type must be one of Receive, Pay and Internal Transfer'","b'Type de Paiement doit \xc3\xaatre Recevoir, Payer ou Transfert Interne'"
+b'apps/erpnext/erpnext/config/selling.py +184',b'Analytics',b'Analytique'
+b'apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html +25',b'Cart is Empty',b'Le panier est Vide'
+b'DocType: Vehicle',b'Model',b'Mod\xc3\xa8le'
+b'DocType: Work Order',b'Actual Operating Cost',"b""Co\xc3\xbbt d'Exploitation R\xc3\xa9el"""
+b'DocType: Payment Entry',b'Cheque/Reference No',b'Ch\xc3\xa8que/N\xc2\xb0 de R\xc3\xa9f\xc3\xa9rence'
+b'DocType: Soil Texture',b'Clay Loam',b'Terreau d&#39;argile'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +81',b'Root cannot be edited.',b'La Racine ne peut pas \xc3\xaatre modifi\xc3\xa9e.'
+b'DocType: Item',b'Units of Measure',b'Unit\xc3\xa9s de Mesure'
+b'DocType: Manufacturing Settings',b'Allow Production on Holidays',b'Autoriser la Fabrication pendant les Vacances'
+b'DocType: Sales Invoice',"b""Customer's Purchase Order Date""",b'Date du Bon de Commande du Client'
+b'apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +163',b'Capital Stock',b'Capital Social'
+b'DocType: Shopping Cart Settings',b'Show Public Attachments',b'Afficher les Pi\xc3\xa8ces Jointes Publiques'
+b'DocType: Packing Slip',b'Package Weight Details',b'D\xc3\xa9tails du Poids du Paquet'
+b'DocType: Restaurant Reservation',b'Reservation Time',b'Heure de r\xc3\xa9servation'
+b'DocType: Payment Gateway Account',b'Payment Gateway Account',b'Compte Passerelle de Paiement'
+b'DocType: Shopping Cart Settings',b'After payment completion redirect user to selected page.',"b""Le paiement termin\xc3\xa9, rediriger l'utilisateur vers la page s\xc3\xa9lectionn\xc3\xa9e."""
+b'DocType: Company',b'Existing Company',b'Soci\xc3\xa9t\xc3\xa9 Existante'
+b'DocType: Healthcare Settings',b'Result Emailed',b'R\xc3\xa9sultat envoy\xc3\xa9 par Email'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +87',"b'Tax Category has been changed to ""Total"" because all the Items are non-stock items'","b'La Cat\xc3\xa9gorie de Taxe a \xc3\xa9t\xc3\xa9 chang\xc3\xa9e \xc3\xa0 ""Total"" car tous les articles sont des articles hors stock'"
+b'apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +103',b'Please select a csv file',b'Veuillez s\xc3\xa9lectionner un fichier csv'
+b'DocType: Student Leave Application',b'Mark as Present',b'Marquer comme Pr\xc3\xa9sent'
+b'DocType: Supplier Scorecard',b'Indicator Color',"b""Couleur de l'Indicateur"""
+b'DocType: Purchase Order',b'To Receive and Bill',b'\xc3\x80 Recevoir et Facturer'
+b'apps/erpnext/erpnext/controllers/buying_controller.py +445',b'Row #{0}: Reqd by Date cannot be before Transaction Date',b'La ligne # {0}: Reqd par date ne peut pas \xc3\xaatre ant\xc3\xa9rieure \xc3\xa0 la date de la transaction'
+b'apps/erpnext/erpnext/templates/pages/home.html +14',b'Featured Products',b'Produits Pr\xc3\xa9sent\xc3\xa9s'
+b'apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py +136',b'Designer',b'Designer'
+b'apps/erpnext/erpnext/config/selling.py +163',b'Terms and Conditions Template',b'Mod\xc3\xa8le des Termes et Conditions'
+b'DocType: Serial No',b'Delivery Details',b'D\xc3\xa9tails de la Livraison'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +495',b'Cost Center is required in row {0} in Taxes table for type {1}',b'Le Centre de Co\xc3\xbbts est requis \xc3\xa0 la ligne {0} dans le tableau des Taxes pour le type {1}'
+b'DocType: Program',b'Program Code',b'Code du Programme'
+b'DocType: Terms and Conditions',b'Terms and Conditions Help',b'Aide des Termes et Conditions'
+,b'Item-wise Purchase Register',b'Registre des Achats par Article'
+b'DocType: Driver',b'Expiry Date',"b""Date d'expiration"""
+b'DocType: Healthcare Settings',b'Employee name and designation in print',"b""Nom et d\xc3\xa9signation de l'employ\xc3\xa9 sur l'imprim\xc3\xa9"""
+,b'accounts-browser',b'navigateur-de-comptes'
+b'apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +368',b'Please select Category first',b'Veuillez d\xe2\x80\x99abord s\xc3\xa9lectionner une Cat\xc3\xa9gorie'
+b'apps/erpnext/erpnext/config/projects.py +13',b'Project master.',b'Donn\xc3\xa9es de Base du Projet.'
+b'apps/erpnext/erpnext/controllers/status_updater.py +212',"b'To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.'","b'Pour permettre la sur-facturation ou la sur-commande, mettez \xc3\xa0 jour ""Indulgence"" dans les Param\xc3\xa8tres de Stock ou dans l\xe2\x80\x99Article.'"
+b'DocType: Global Defaults',b'Do not show any symbol like $ etc next to currencies.',"b'Ne plus afficher le symbole (tel que $, \xe2\x82\xac...) \xc3\xa0 c\xc3\xb4t\xc3\xa9 des montants.'"
+b'apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +431',b' (Half Day)',b'(Demi-Journ\xc3\xa9e)'
+b'DocType: Payment Term',b'Credit Days',b'Jours de Cr\xc3\xa9dit'
+b'apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js +145',b'Please select Patient to get Lab Tests',b'Veuillez s\xc3\xa9lectionner Patient pour obtenir des tests de laboratoire'
+b'apps/erpnext/erpnext/utilities/activation.py +128',b'Make Student Batch',"b""Cr\xc3\xa9er un Lot d'\xc3\x89tudiant"""
+b'DocType: Fee Schedule',b'FRQ.',b'FRQ.'
+b'DocType: Leave Type',b'Is Carry Forward',b'Est un Report'
+b'apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +841',b'Get Items from BOM',b'Obtenir les Articles depuis LDM'
+b'apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +40',b'Lead Time Days',b'Jours de D\xc3\xa9lai'
+b'DocType: Cash Flow Mapping',b'Is Income Tax Expense',b'Est-ce que l&#39;imp\xc3\xb4t sur le revenu est'
+b'apps/erpnext/erpnext/controllers/accounts_controller.py +621',b'Row #{0}: Posting Date must be same as purchase date {1} of asset {2}',"b""Ligne #{0} : La Date de Comptabilisation doit \xc3\xaatre la m\xc3\xaame que la date d'achat {1} de l\xe2\x80\x99actif {2}"""
+b'DocType: Program Enrollment',"b""Check this if the Student is residing at the Institute's Hostel.""","b""V\xc3\xa9rifiez si l'\xc3\x89tudiant r\xc3\xa9side \xc3\xa0 la R\xc3\xa9sidence de l'Institut."""
+b'apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +125',b'Please enter Sales Orders in the above table',b'Veuillez entrer des Commandes Clients dans le tableau ci-dessus'
+,b'Stock Summary',b'R\xc3\xa9sum\xc3\xa9 du Stock'
+b'apps/erpnext/erpnext/config/assets.py +54',b'Transfer an asset from one warehouse to another',"b""Transfert d'un actif d'un entrep\xc3\xb4t \xc3\xa0 un autre"""
+b'DocType: Vehicle',b'Petrol',b'Essence'
+b'apps/erpnext/erpnext/config/learn.py +217',b'Bill of Materials',b'Liste de Mat\xc3\xa9riaux'
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105',b'Row {0}: Party Type and Party is required for Receivable / Payable account {1}',b'Ligne {0} : Le Type de Tiers et le Tiers sont requis pour le compte D\xc3\xa9biteur / Cr\xc3\xa9diteur {1}'
+b'apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +94',b'Ref Date',b'Date de R\xc3\xa9f.'
+b'DocType: Employee',b'Reason for Leaving',b'Raison du D\xc3\xa9part'
+b'DocType: BOM Operation',b'Operating Cost(Company Currency)',"b""Co\xc3\xbbt d'Exploitation (Devise Soci\xc3\xa9t\xc3\xa9)"""
+b'DocType: Employee Loan Application',b'Rate of Interest',"b""Taux d'Int\xc3\xa9r\xc3\xaat"""
+b'DocType: Expense Claim Detail',b'Sanctioned Amount',b'Montant Approuv\xc3\xa9'
+b'DocType: Item',b'Shelf Life In Days',b'Dur\xc3\xa9e de conservation en jours'
+b'DocType: GL Entry',b'Is Opening',"b""\xc3\x89criture d'Ouverture"""
+b'apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +196',b'Row {0}: Debit entry can not be linked with a {1}',b'Ligne {0} : L\xe2\x80\x99\xc3\x89criture de D\xc3\xa9bit ne peut pas \xc3\xaatre li\xc3\xa9 \xc3\xa0 un {1}'
+b'DocType: Journal Entry',b'Subscription Section',b'Section Abonnement'
+b'apps/erpnext/erpnext/accounts/doctype/account/account.py +177',b'Account {0} does not exist',"b""Compte {0} n'existe pas"""
+b'DocType: Training Event',b'Training Program',b'Programme de formation'
+b'DocType: Account',b'Cash',b'Esp\xc3\xa8ces'
+b'DocType: Employee',b'Short biography for website and other publications.',"b""Courte biographie pour le site web et d'autres publications."""
