 (Half Day),(Demi-journée)
 and year: ,et l&#39;année:
""" does not exists",""" N'existe pas"
%  Delivered,Livré%
% Amount Billed,Montant Facturé%
% Billed,Facturé%
% Completed,% Terminé
% Delivered,Livré %
% Installed,Installé%
% Received,Reçus%
% of materials billed against this Purchase Order.,% De matières facturées contre ce bon de commande.
% of materials billed against this Sales Order,% De matières facturées contre cette ordonnance ventes
% of materials delivered against this Delivery Note,% Des matériaux livrés contre ce bon de livraison
% of materials delivered against this Sales Order,% Des matériaux livrés contre cette ordonnance ventes
% of materials ordered against this Material Request,% De matériaux ordonnée contre cette Demande de Matériel
% of materials received against this Purchase Order,% Des documents reçus contre ce bon de commande
'Actual Start Date' can not be greater than 'Actual End Date',« Date de Début réel » ne peut être supérieur à ' Date réelle de fin »
'Based On' and 'Group By' can not be same,"Types d'emploi ( permanent, contractuel , stagiaire , etc ) ."
'Days Since Last Order' must be greater than or equal to zero,Arbre de centres de coûts finanial .
'Entries' cannot be empty,précédent
'Expected Start Date' can not be greater than 'Expected End Date',Pas de description
'From Date' is required,Série mise à jour avec succès
'From Date' must be after 'To Date',« Date d' 'doit être après « à jour »
'Has Serial No' can not be 'Yes' for non-stock item,Un produit ou service
'Notification Email Addresses' not specified for recurring invoice,Conditions qui se chevauchent entre trouvés :
'Profit and Loss' type account {0} not allowed in Opening Entry,dépréciation
'To Case No.' cannot be less than 'From Case No.',«L&#39;affaire no &#39; ne peut pas être inférieure à &#39;De Cas n °&#39;
'To Date' is required,Compte {0} existe déjà
'Update Stock' for Sales Invoice {0} must be set,Remarque: la date d'échéance dépasse les jours de crédit accordés par {0} jour (s )
* Will be calculated in the transaction.,* Sera calculé de la transaction.
"1 Currency = [?] Fraction
For e.g. 1 USD = 100 Cent","1 devise = [?] Fraction 
 Pour exemple, 1 USD = 100 cents"
1. To maintain the customer wise item code and to make them searchable based on their code use this option,1. Pour maintenir le code de référence du client sage et de les rendre consultables en fonction de leur code d&#39;utiliser cette option
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Ajouter / Modifier < / a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Ajouter / Modifier < / a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Ajouter / Modifier < / a>"
"<h4>Default Template</h4>
<p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
<pre><code>{{ address_line1 }}&lt;br&gt;
{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}
{{ city }}&lt;br&gt;
{% if state %}{{ state }}&lt;br&gt;{% endif -%}
{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}
{{ country }}&lt;br&gt;
{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}
{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}
{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}
</code></pre>","<h4> modèle par défaut </ h4> 
 <p> Utilise <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja création de modèles </ a> et tous les domaines de l'Adresse ( y compris les champs personnalisés cas échéant) sera disponible </ p> 
 <pre> <code> {{}} address_line1 Photos 
 {% si address_line2%} {{}} address_line2 <br> { % endif -%} 
 {{ville}} Photos 
 {% si l'état%} {{état}} {% endif Photos -%} 
 {% if%} code PIN PIN: {{code PIN}} {% endif Photos -%} 
 {{pays}} Photos 
 {% si le téléphone%} Téléphone: {{phone}} {<br> % endif -%} 
 {% if%} fax Fax: {{fax}} {% endif Photos -%} 
 {% if%} email_id Email: {{}} email_id Photos ; {% endif -%} 
 </ code> </ pre>"
A Customer Group exists with same name please change the Customer name or rename the Customer Group,BOM récursivité : {0} ne peut pas être le parent ou l'enfant de {2}
A Customer exists with same name,Une clientèle existe avec le même nom
A Lead with this email id should exist,Un responsable de cette id e-mail doit exister
A Product or Service,Nouveau N ° de série ne peut pas avoir d'entrepôt . Entrepôt doit être réglé par Stock entrée ou ticket de caisse
A Supplier exists with same name,Un Fournisseur existe avec le même nom
A symbol for this currency. For e.g. $,Un symbole de cette monnaie. Pour exemple $
AMC Expiry Date,AMC Date d&#39;expiration
Abbr,Abbr
Abbreviation cannot have more than 5 characters,Compte avec la transaction existante ne peut pas être converti en groupe.
Above Value,Au-dessus de la valeur
Absent,Absent
Acceptance Criteria,Critères d&#39;acceptation
Accepted,Accepté
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Compte {0} doit être SAMES comme débit pour tenir compte de la facture de vente en ligne {0}
Accepted Quantity,Quantité acceptés
Accepted Warehouse,Entrepôt acceptés
Account,compte
Account Balance,Solde du compte
Account Created: {0},Compte créé : {0}
Account Details,Détails du compte
Account Head,Chef du compte
Account Name,Nom du compte
Account Type,Type de compte
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Le solde du compte déjà en crédit, vous n'êtes pas autorisé à mettre en 'équilibre doit être' comme 'débit'"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Le solde du compte déjà en débit, vous n'êtes pas autorisé à définir 'équilibre doit être' comme 'Crédit'"
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Compte de l'entrepôt ( de l'inventaire permanent ) sera créé sous ce compte .
Account head {0} created,Employé soulagé sur {0} doit être défini comme «gauche»
Account must be a balance sheet account,arrhes
Account with child nodes cannot be converted to ledger,Liste des prix non sélectionné
Account with existing transaction can not be converted to group.,{0} n'est pas un congé approbateur valide
Account with existing transaction can not be deleted,Compte avec la transaction existante ne peut pas être supprimé
Account with existing transaction cannot be converted to ledger,Compte avec la transaction existante ne peut pas être converti en livre
Account {0} cannot be a Group,Compte {0} ne peut pas être un groupe
Account {0} does not belong to Company {1},{0} créé
Account {0} does not belong to company: {1},Compte {0} n'appartient pas à l'entreprise: {1}
Account {0} does not exist,Votre adresse e-mail
Account {0} has been entered more than once for fiscal year {1},S'il vous plaît entrer « Répétez le jour du Mois de la« valeur de champ
Account {0} is frozen,Attention: Commande {0} existe déjà contre le même numéro de bon de commande
Account {0} is inactive,dépenses directes
Account {0} is not valid,Compte {0} n'est pas valide
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Compte {0} doit être de type ' actif fixe ' comme objet {1} est un atout article
Account {0}: Parent account {1} can not be a ledger,Compte {0}: compte de Parent {1} ne peut pas être un grand livre
Account {0}: Parent account {1} does not belong to company: {2},Compte {0}: compte de Parent {1} n'appartient pas à l'entreprise: {2}
Account {0}: Parent account {1} does not exist,Compte {0}: compte de Parent {1} n'existe pas
Account {0}: You can not assign itself as parent account,Compte {0}: Vous ne pouvez pas lui attribuer que compte parent
"Account: {0} can only be updated via \
					Stock Transactions","Compte: {0} ne peut être mise à jour via \
 Transactions de stock"
Accountant,comptable
Accounting,Comptabilité
"Accounting Entries can be made against leaf nodes, called","Écritures comptables peuvent être faites contre nœuds feuilles , appelé"
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Saisie comptable gelé jusqu&#39;à cette date, personne ne peut faire / modifier entrée sauf rôle spécifié ci-dessous."
Accounting journal entries.,Les écritures comptables.
Accounts,Comptes
Accounts Browser,comptes navigateur
Accounts Frozen Upto,Jusqu&#39;à comptes gelés
Accounts Payable,Comptes à payer
Accounts Receivable,Débiteurs
Accounts Settings,Paramètres des comptes
Active,Actif
Active: Will extract emails from ,Actif: va extraire des emails à partir de
Activity,Activité
Activity Log,Journal d&#39;activité
Activity Log:,Journal d'activité:
Activity Type,Type d&#39;activité
Actual,Réel
Actual Budget,Budget Réel
Actual Completion Date,Date d&#39;achèvement réelle
Actual Date,Date Réelle
Actual End Date,Date de fin réelle
Actual Invoice Date,Date de la facture réelle
Actual Posting Date,Date réelle d&#39;affichage
Actual Qty,Quantité réelle
Actual Qty (at source/target),Quantité réelle (à la source / cible)
Actual Qty After Transaction,Qté réel Après Transaction
Actual Qty: Quantity available in the warehouse.,Quantité réelle : Quantité disponible dans l'entrepôt .
Actual Quantity,Quantité réelle
Actual Start Date,Date de début réelle
Add,Ajouter
Add / Edit Taxes and Charges,Ajouter / Modifier Taxes et frais
Add Child,Ajouter un enfant
Add Serial No,Ajouter N ° de série
Add Taxes,Ajouter impôts
Add Taxes and Charges,Ajouter Taxes et frais
Add or Deduct,Ajouter ou déduire
Add rows to set annual budgets on Accounts.,Ajoutez des lignes d&#39;établir des budgets annuels des comptes.
Add to Cart,ERP open source construit pour le web
Add to calendar on this date,Ajouter au calendrier à cette date
Add/Remove Recipients,Ajouter / supprimer des destinataires
Address,Adresse
Address & Contact,Adresse et coordonnées
Address & Contacts,Adresse &amp; Contacts
Address Desc,Adresse Desc
Address Details,Détails de l&#39;adresse
Address HTML,Adresse HTML
Address Line 1,Adresse ligne 1
Address Line 2,Adresse ligne 2
Address Template,Adresse modèle
Address Title,Titre Adresse
Address Title is mandatory.,Vous n'êtes pas autorisé à imprimer ce document
Address Type,Type d&#39;adresse
Address master.,Ou créés par
Administrative Expenses,applicabilité
Administrative Officer,de l'administration
Advance Amount,Montant de l&#39;avance
Advance amount,Montant de l&#39;avance
Advances,Avances
Advertisement,Publicité
Advertising,publicité
Aerospace,aérospatial
After Sale Installations,Après Installations Vente
Against,Contre
Against Account,Contre compte
Against Bill {0} dated {1},Courriel invalide : {0}
Against Docname,Contre docName
Against Doctype,Contre Doctype
Against Document Detail No,Contre Détail document n
Against Document No,Contre le document n °
Against Expense Account,Contre compte de dépenses
Against Income Account,Contre compte le revenu
Against Journal Voucher,Contre Bon Journal
Against Journal Voucher {0} does not have any unmatched {1} entry,Contre Journal Bon {0} n'a pas encore inégalée {1} entrée
Against Purchase Invoice,Contre facture d&#39;achat
Against Sales Invoice,Contre facture de vente
Against Sales Order,Contre Commande
Against Voucher,Bon contre
Against Voucher Type,Contre Type de Bon
Ageing Based On,Basé sur le vieillissement
Ageing Date is mandatory for opening entry,Titres de modèles d'impression par exemple Facture pro forma.
Ageing date is mandatory for opening entry,Date vieillissement est obligatoire pour l'ouverture de l'entrée
Agent,Agent
Aging Date,Vieillissement Date
Aging Date is mandatory for opening entry,"Client requis pour ' Customerwise Discount """
Agriculture,agriculture
Airline,compagnie aérienne
All Addresses.,Toutes les adresses.
All Contact,Tout contact
All Contacts.,Tous les contacts.
All Customer Contact,Tout contact avec la clientèle
All Customer Groups,N ° de série {0} est sous contrat de maintenance jusqu'à {1}
All Day,Toute la journée
All Employee (Active),Tous les employés (Actif)
All Item Groups,Tous les groupes des ouvrages
All Lead (Open),Tous plomb (Ouvert)
All Products or Services.,Tous les produits ou services.
All Sales Partner Contact,Tout contact Sales Partner
All Sales Person,Tout Sales Person
All Supplier Contact,Toutes Contacter le fournisseur
All Supplier Types,Tous les types de fournisseurs
All Territories,Compte racine ne peut pas être supprimé
"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.","Tous les champs liés à l'exportation comme monnaie , taux de conversion , l'exportation totale , l'exportation totale grandiose etc sont disponibles dans la note de livraison , POS , offre , facture de vente , Sales Order etc"
"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.","Tous les champs importation connexes comme monnaie , taux de conversion , totale d'importation , importation grande etc totale sont disponibles en Achat réception , Fournisseur d'offre , facture d'achat , bon de commande , etc"
All items have already been invoiced,Tous les articles ont déjà été facturés
All these items have already been invoiced,Existe compte de l'enfant pour ce compte . Vous ne pouvez pas supprimer ce compte .
Allocate,Allouer
Allocate leaves for a period.,Compte temporaire ( actif)
Allocate leaves for the year.,Allouer des feuilles de l&#39;année.
Allocated Amount,Montant alloué
Allocated Budget,Budget alloué
Allocated amount,Montant alloué
Allocated amount can not be negative,Montant alloué ne peut être négatif
Allocated amount can not greater than unadusted amount,Montant alloué ne peut pas plus que la quantité unadusted
Allow Bill of Materials,Laissez Bill of Materials
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Commande {0} n'est pas valide
Allow Children,permettre aux enfants
Allow Dropbox Access,Autoriser l&#39;accès Dropbox
Allow Google Drive Access,Autoriser Google Drive accès
Allow Negative Balance,Laissez solde négatif
Allow Negative Stock,Laissez Stock Négatif
Allow Production Order,Laissez un ordre de fabrication
Allow User,Permettre à l&#39;utilisateur
Allow Users,Autoriser les utilisateurs
Allow the following users to approve Leave Applications for block days.,Autoriser les utilisateurs suivants d&#39;approuver demandes d&#39;autorisation pour les jours de bloc.
Allow user to edit Price List Rate in transactions,Permettre à l&#39;utilisateur d&#39;éditer Prix List Noter dans les transactions
Allowance Percent,Pourcentage allocation
Allowance for over-{0} crossed for Item {1},Allocation pour les plus de {0} croisés pour objet {1}
Allowance for over-{0} crossed for Item {1}.,Allocation pour les plus de {0} franchi pour objet {1}.
Allowed Role to Edit Entries Before Frozen Date,Autorisé rôle à modifier les entrées Avant Frozen date
Amended From,De modifiée
Amount,Montant
Amount (Company Currency),Montant (Société Monnaie)
Amount Paid,Montant payé
Amount to Bill,Montant du projet de loi
An Customer exists with same name,Il existe un client avec le même nom
"An Item Group exists with same name, please change the item name or rename the item group","Un groupe d'objet existe avec le même nom , s'il vous plaît changer le nom de l'élément ou de renommer le groupe de l'article"
"An item exists with same name ({0}), please change the item group name or rename the item",Le compte doit être un compte de bilan
Analyst,analyste
Annual,Nomenclature
Another Period Closing Entry {0} has been made after {1},Point Wise impôt Détail
Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Le taux de conversion ne peut pas être égal à 0 ou 1
"Any other comments, noteworthy effort that should go in the records.","D&#39;autres commentaires, l&#39;effort remarquable qui devrait aller dans les dossiers."
Apparel & Accessories,Vêtements & Accessoires
Applicability,{0} n'est pas un stock Article
Applicable For,Fixez Logo
Applicable Holiday List,Liste de vacances applicable
Applicable Territory,Territoire applicable
Applicable To (Designation),Applicable à (désignation)
Applicable To (Employee),Applicable aux (Employé)
Applicable To (Role),Applicable à (Rôle)
Applicable To (User),Applicable aux (Utilisateur)
Applicant Name,Nom du demandeur
Applicant for a Job.,Candidat à un emploi.
Application of Funds (Assets),Configuration serveur entrant pour les ventes id e-mail . (par exemple sales@example.com )
Applications for leave.,Les demandes de congé.
Applies to Company,S&#39;applique à l&#39;entreprise
Apply On,Pas autorisé à modifier compte gelé {0}
Appraisal,Évaluation
Appraisal Goal,Objectif d&#39;évaluation
Appraisal Goals,Objectifs d&#39;évaluation
Appraisal Template,Modèle d&#39;évaluation
Appraisal Template Goal,Objectif modèle d&#39;évaluation
Appraisal Template Title,Titre modèle d&#39;évaluation
Appraisal {0} created for Employee {1} in the given date range,Soulager date doit être supérieure à date d'adhésion
Apprentice,apprenti
Approval Status,Statut d&#39;approbation
Approval Status must be 'Approved' or 'Rejected',non autorisé
Approved,Approuvé
Approver,Approbateur
Approving Role,Approuver rôle
Approving Role cannot be same as role the rule is Applicable To,Vous ne pouvez pas sélectionner le type de charge comme « Sur la ligne précédente Montant » ou « Le précédent Row totale » pour la première rangée
Approving User,Approuver l&#39;utilisateur
Approving User cannot be same as user the rule is Applicable To,Approuver l'utilisateur ne peut pas être identique à l'utilisateur la règle est applicable aux
Are you sure you want to STOP ,
Are you sure you want to UNSTOP ,
Arrear Amount,Montant échu
"As Production Order can be made for this item, it must be a stock item.","Comme ordre de fabrication peut être faite de cet élément, il doit être un article en stock ."
As per Stock UOM,Selon Stock UDM
"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Is Stock Item' and 'Valuation Method'","Comme il ya des transactions boursières existantes pour cet article, vous ne pouvez pas modifier les valeurs de ' A Pas de série »,« Est- Stock Item »et« Méthode d'évaluation »"
Asset,atout
Assistant,assistant
Associate,associé
Atleast one of the Selling or Buying must be selected,Au moins un de la vente ou l'achat doit être sélectionné
Atleast one warehouse is mandatory,Atleast un entrepôt est obligatoire
Attach Image,suivant
Attach Letterhead,Fixez -tête
Attach Logo,S'il vous plaît sélectionner un fichier csv valide avec les données
Attach Your Picture,Liquidation Date non mentionné
Attendance,Présence
Attendance Date,Date de Participation
Attendance Details,Détails de présence
Attendance From Date,Participation De Date
Attendance From Date and Attendance To Date is mandatory,Participation Date de début et de présence à ce jour est obligatoire
Attendance To Date,La participation à ce jour
Attendance can not be marked for future dates,La participation ne peut pas être marqué pour les dates à venir
Attendance for employee {0} is already marked,Vous ne pouvez pas convertir au groupe parce Master Type ou Type de compte est sélectionné .
Attendance record.,Record de fréquentation.
Authorization Control,Contrôle d&#39;autorisation
Authorization Rule,Règle d&#39;autorisation
Auto Accounting For Stock Settings,Auto Comptabilité Pour les paramètres de droits
Auto Material Request,Auto Demande de Matériel
Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto-raise Demande de Matériel si la quantité va en dessous du niveau de re-commande dans un entrepôt
Automatically compose message on submission of transactions.,Composer automatiquement un message sur la soumission de transactions .
Automatically extract Job Applicants from a mail box ,
Automatically extract Leads from a mail box e.g.,Extraire automatiquement des prospects à partir d'une boîte aux lettres par exemple
Automatically updated via Stock Entry of type Manufacture/Repack,Automatiquement mis à jour via l&#39;entrée de fabrication de type Stock / Repack
Automotive,automobile
Autoreply when a new mail is received,Autoreply quand un nouveau message est reçu
Available,disponible
Available Qty at Warehouse,Qté disponible à l&#39;entrepôt
Available Stock for Packing Items,Disponible en stock pour l&#39;emballage Articles
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Disponible en nomenclature , bon de livraison , facture d'achat , ordre de production, bon de commande , bon de réception , la facture de vente , Sales Order , Stock entrée , des feuilles de temps"
Average Age,moyen âge
Average Commission Rate,Taux moyen Commission
Average Discount,D&#39;actualisation moyen
Awesome Products,"Pour suivre le nom de la marque dans la note qui suit documents de livraison , Opportunité , Demande de Matériel , article , bon de commande, bon d'achat, l'acheteur réception , offre , facture de vente , ventes BOM , Sales Order , No de série"
Awesome Services,Restrictions d'autorisation de l'utilisateur
BOM Detail No,Détail BOM Non
BOM Explosion Item,Article éclatement de la nomenclature
BOM Item,Article BOM
BOM No,Aucune nomenclature
BOM No. for a Finished Good Item,N ° nomenclature pour un produit fini Bonne
BOM Operation,Opération BOM
BOM Operations,Opérations de nomenclature
BOM Replace Tool,Outil Remplacer BOM
BOM number is required for manufactured Item {0} in row {1},Nombre BOM est nécessaire pour l'article manufacturé {0} dans la ligne {1}
BOM number not allowed for non-manufactured Item {0} in row {1},Note: La rubrique {0} est entré plusieurs fois
BOM recursion: {0} cannot be parent or child of {2},S'il vous plaît entrer une adresse valide Id
BOM replaced,BOM remplacé
BOM {0} for Item {1} in row {2} is inactive or not submitted,Dépenses de voyage
BOM {0} is not active or not submitted,Eléments requis
BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} n'est pas soumis ou inactif nomenclature pour objet {1}
Backup Manager,Gestionnaire de sauvegarde
Backup Right Now,Sauvegarde Right Now
Backups will be uploaded to,Les sauvegardes seront téléchargées sur
Balance Qty,solde Quantité
Balance Sheet,Fournisseur Type maître .
Balance Value,Valeur de balance
Balance for Account {0} must always be {1},Point {0} avec Serial Non {1} est déjà installé
Balance must be,avec des grands livres
"Balances of Accounts of type ""Bank"" or ""Cash""",Date de vieillissement est obligatoire pour l'ouverture d'entrée
Bank,Banque
Bank / Cash Account,Banque / Compte de trésorerie
Bank A/C No.,Bank A / C No.
Bank Account,Compte bancaire
Bank Account No.,N ° de compte bancaire
Bank Accounts,Comptes bancaires
Bank Clearance Summary,Banque Résumé de dégagement
Bank Draft,Projet de la Banque
Bank Name,Nom de la banque
Bank Overdraft Account,Inspection de la qualité requise pour objet {0}
Bank Reconciliation,Rapprochement bancaire
Bank Reconciliation Detail,Détail de rapprochement bancaire
Bank Reconciliation Statement,État de rapprochement bancaire
Bank Voucher,Bon Banque
Bank/Cash Balance,Banque / Balance trésorerie
Banking,bancaire
Barcode,Barcode
Barcode {0} already used in Item {1},Lettre d'information a déjà été envoyé
Based On,Basé sur
Basic,de base
Basic Info,Informations de base
Basic Information,Renseignements de base
Basic Rate,Taux de base
Basic Rate (Company Currency),Taux de base (Société Monnaie)
Batch,Lot
Batch (lot) of an Item.,Batch (lot) d&#39;un élément.
Batch Finished Date,Date de lot fini
Batch ID,ID du lot
Batch No,Aucun lot
Batch Started Date,Date de démarrage du lot
Batch Time Logs for billing.,Temps de lots des journaux pour la facturation.
Batch-Wise Balance History,Discontinu Histoire de la balance
Batched for Billing,Par lots pour la facturation
Better Prospects,De meilleures perspectives
Bill Date,Bill Date
Bill No,Le projet de loi no
Bill No {0} already booked in Purchase Invoice {1},Centre de coûts de transactions existants ne peut pas être converti en livre
Bill of Material,De la valeur doit être inférieure à la valeur à la ligne {0}
Bill of Material to be considered for manufacturing,Bill of Material être considéré pour la fabrication
Bill of Materials (BOM),Nomenclature (BOM)
Billable,Facturable
Billed,Facturé
Billed Amount,Montant facturé
Billed Amt,Bec Amt
Billing,Facturation
Billing Address,Adresse de facturation
Billing Address Name,Facturation Nom Adresse
Billing Status,Statut de la facturation
Bills raised by Suppliers.,Factures soulevé par les fournisseurs.
Bills raised to Customers.,Factures aux clients soulevé.
Bin,Boîte
Bio,Bio
Biotechnology,biotechnologie
Birthday,anniversaire
Block Date,Date de bloquer
Block Days,Bloquer les jours
Block leave applications by department.,Bloquer les demandes d&#39;autorisation par le ministère.
Blog Post,Blog
Blog Subscriber,Abonné Blog
Blood Group,Groupe sanguin
Both Warehouse must belong to same Company,Les deux Entrepôt doit appartenir à une même entreprise
Box,boîte
Branch,Branche
Brand,Marque
Brand Name,Nom de marque
Brand master.,Marque maître.
Brands,Marques
Breakdown,Panne
Broadcasting,radiodiffusion
Brokerage,courtage
Budget,Budget
Budget Allocated,Budget alloué
Budget Detail,Détail du budget
Budget Details,Détails du budget
Budget Distribution,Répartition du budget
Budget Distribution Detail,Détail Répartition du budget
Budget Distribution Details,Détails de la répartition du budget
Budget Variance Report,Rapport sur les écarts de budget
Budget cannot be set for Group Cost Centers,Imprimer et stationnaire
Build Report,construire Rapport
Bundle items at time of sale.,Regrouper des envois au moment de la vente.
Business Development Manager,Directeur du développement des affaires
Buying,Achat
Buying & Selling,Fin d'année financière Date
Buying Amount,Montant d&#39;achat
Buying Settings,Réglages d&#39;achat
"Buying must be checked, if Applicable For is selected as {0}","Achat doit être vérifiée, si pour Applicable est sélectionné comme {0}"
C-Form,C-Form
C-Form Applicable,C-Form applicable
C-Form Invoice Detail,C-Form Détail Facture
C-Form No,C-formulaire n °
C-Form records,Enregistrements C -Form
CENVAT Capital Goods,CENVAT biens d'équipement
CENVAT Edu Cess,CENVAT Edu Cess
CENVAT SHE Cess,CENVAT ELLE Cess
CENVAT Service Tax,Service Tax CENVAT
CENVAT Service Tax Cess 1,Service CENVAT impôt Cess 1
CENVAT Service Tax Cess 2,Service CENVAT impôt Cess 2
Calculate Based On,Calculer en fonction
Calculate Total Score,Calculer Score total
Calendar Events,Calendrier des événements
Call,Appeler
Calls,appels
Campaign,Campagne
Campaign Name,Nom de la campagne
Campaign Name is required,Maître à la clientèle .
Campaign Naming By,Campagne Naming par
Campaign-.####,Centre de coûts de transactions existants ne peut pas être converti en groupe
Can be approved by {0},Peut être approuvé par {0}
"Can not filter based on Account, if grouped by Account","Impossible de filtrer sur la base de compte , si regroupées par compte"
"Can not filter based on Voucher No, if grouped by Voucher","Impossible de filtrer sur la base Bon Non, si regroupés par Chèque"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Remarque : {0}
Cancel Material Visit {0} before cancelling this Customer Issue,Invalid serveur de messagerie . S'il vous plaît corriger et essayer à nouveau.
Cancel Material Visits {0} before cancelling this Maintenance Visit,S'il vous plaît créer la structure des salaires pour les employés {0}
Cancelled,Annulé
Cancelling this Stock Reconciliation will nullify its effect.,Annulation de ce stock de réconciliation annuler son effet .
Cannot Cancel Opportunity as Quotation Exists,Vous ne pouvez pas annuler Possibilité de devis Existe
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Vous ne pouvez pas approuver les congés que vous n'êtes pas autorisé à approuver les congés sur les dates de bloc
Cannot cancel because Employee {0} is already approved for {1},Vous ne pouvez pas annuler parce employés {0} est déjà approuvé pour {1}
Cannot cancel because submitted Stock Entry {0} exists,Vous ne pouvez pas annuler car soumis Stock entrée {0} existe
Cannot carry forward {0},Point {0} doit être un achat article
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Vous ne pouvez pas modifier Exercice Date de départ et de l'exercice Date de fin une fois l'exercice est enregistré.
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",Voyage
Cannot convert Cost Center to ledger as it has child nodes,Vous ne pouvez pas convertir le centre de coûts à livre car il possède des nœuds enfant
Cannot covert to Group because Master Type or Account Type is selected.,Il y avait des erreurs lors de l'envoi de courriel . S'il vous plaît essayez de nouveau .
Cannot deactive or cancle BOM as it is linked with other BOMs,Données du projet - sage n'est pas disponible d'offre
"Cannot declare as lost, because Quotation has been made.","Vous ne pouvez pas déclarer comme perdu , parce offre a été faite."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',"Vous ne pouvez pas déduire lorsqu'une catégorie est pour « évaluation » ou « évaluation et Total """
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.",Heure du journal {0} doit être « déposés »
"Cannot directly set amount. For 'Actual' charge type, use the rate field",Programme de maintenance {0} existe contre {0}
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Vous ne pouvez pas surfacturer pour objet {0} à la ligne {0} plus de {1}. Pour permettre la surfacturation, s'il vous plaît mettre dans les paramètres de droits"
Cannot produce more Item {0} than Sales Order quantity {1},effondrement
Cannot refer row number greater than or equal to current row number for this Charge type,Nos série requis pour Serialized article {0}
Cannot return more than {0} for Item {1},développer
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Point {0} a été saisi plusieurs fois avec la même description ou la date
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for valuation. You can select only 'Total' option for previous row amount or previous row total,Vous pouvez configurer un compte de la Banque de défaut en maître Société
Cannot set as Lost as Sales Order is made.,Impossible de définir aussi perdu que les ventes décret.
Cannot set authorization on basis of Discount for {0},Impossible de définir l'autorisation sur la base des prix réduits pour {0}
Capacity,Capacité
Capacity Units,Unités de capacité
Capital Account,heure
Capital Equipments,Equipements de capitaux
Carry Forward,Reporter
Carry Forwarded Leaves,Effectuer Feuilles Transmises
Case No(s) already in use. Try from Case No {0},Entrées avant {0} sont gelés
Case No. cannot be 0,Cas n ° ne peut pas être 0
Cash,Espèces
Cash In Hand,Votre exercice social commence le
Cash Voucher,Bon trésorerie
Cash or Bank Account is mandatory for making payment entry,N ° de série {0} a déjà été reçu
Cash/Bank Account,Trésorerie / Compte bancaire
Casual Leave,Règles d'application des prix et de ristournes .
Cell Number,Nombre de cellules
Change UOM for an Item.,Changer Emballage pour un article.
Change the starting / current sequence number of an existing series.,Changer le numéro de séquence de démarrage / courant d&#39;une série existante.
Channel Partner,Channel Partner
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 l'article Noter
Chargeable,À la charge
Charity and Donations,Client est tenu
Chart Name,Nom du graphique
Chart of Accounts,Plan comptable
Chart of Cost Centers,Carte des centres de coûts
Check how the newsletter looks in an email by sending it to your email.,Vérifiez comment la newsletter regarde dans un e-mail en l&#39;envoyant à votre adresse email.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Vérifiez si la facture récurrente, décochez-vous s&#39;arrête ou mis Date de fin correcte"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Vérifiez si vous avez besoin automatiques factures récurrentes. Après avoir présenté la facture de vente, l&#39;article récurrent sera visible."
Check if you want to send salary slip in mail to each employee while submitting salary slip,Vérifiez si vous voulez envoyer le bulletin de salaire dans le courrier à chaque salarié lors de la soumission bulletin de salaire
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&#39;utilisateur à sélectionner une série avant de l&#39;enregistrer. Il n&#39;y aura pas défaut si vous cochez cette.
Check this if you want to show in website,Cochez cette case si vous souhaitez afficher sur le site
Check this to disallow fractions. (for Nos),Cochez cette case pour interdire les fractions. (Pour les numéros)
Check this to pull emails from your mailbox,Cochez cette case pour extraire des emails de votre boîte aux lettres
Check to activate,Vérifiez pour activer
Check to make Shipping Address,Vérifiez l&#39;adresse de livraison
Check to make primary address,Vérifiez l&#39;adresse principale
Chemical,chimique
Cheque,Chèque
Cheque Date,Date de chèques
Cheque Number,Numéro de chèque
Child account exists for this account. You can not delete this account.,Les matières premières ne peut pas être le même que l'article principal
City,Ville
City/Town,Ville /
Claim Amount,Montant réclamé
Claims for company expense.,Les réclamations pour frais de la société.
Class / Percentage,Classe / Pourcentage
Classic,Classique
Clear Table,Effacer le tableau
Clearance Date,Date de la clairance
Clearance Date not mentioned,"Désignation des employés (par exemple de chef de la direction , directeur , etc.)"
Clearance date cannot be before check date in row {0},Chefs de lettre pour des modèles d'impression .
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Cliquez sur le bouton pour créer une nouvelle facture de vente «Facture de vente Make &#39;.
Click on a link to get options to expand get options ,Cliquer sur un lien pour voir les options
Client,Client
Close Balance Sheet and book Profit or Loss.,Fermer Bilan et livre Bénéfice ou perte .
Closed,Fermé
Closing (Cr),Fermeture (Cr)
Closing (Dr),Fermeture (Dr)
Closing Account Head,Fermeture chef Compte
Closing Account {0} must be of type 'Liability',S'il vous plaît sélectionner valide volet n ° de procéder
Closing Date,Date de clôture
Closing Fiscal Year,Clôture de l&#39;exercice
Closing Qty,Quantité de clôture
Closing Value,Valeur de clôture
CoA Help,Aide CoA
Code,Code
Cold Calling,Cold Calling
Color,Couleur
Column Break,Saut de colonne
Comma separated list of email addresses,Comma liste séparée par des adresses e-mail
Comment,Commenter
Comments,Commentaires
Commercial,Reste du monde
Commission,commission
Commission Rate,Taux de commission
Commission Rate (%),Taux de commission (%)
Commission on Sales,Commission sur les ventes
Commission rate cannot be greater than 100,Taux de commission ne peut pas être supérieure à 100
Communication,Communication
Communication HTML,Communication HTML
Communication History,Histoire de la communication
Communication log.,Journal des communications.
Communications,communications
Company,Entreprise
Company (not Customer or Supplier) master.,Fermeture compte {0} doit être de type « responsabilité »
Company Abbreviation,Abréviation de l'entreprise
Company Details,Détails de la société
Company Email,Société Email
"Company Email ID not found, hence mail not sent",Remarque: Il n'est pas assez solde de congés d'autorisation de type {0}
Company Info,Informations sur la société
Company Name,Nom de la société
Company Settings,des paramètres de société
Company is missing in warehouses {0},Société est manquant dans les entrepôts {0}
Company is required,Société est tenue
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,"Numéros d&#39;immatriculation de la Société pour votre référence. Numéros d&#39;enregistrement TVA, etc: par exemple"
Company registration numbers for your reference. Tax numbers etc.,"Numéros d&#39;immatriculation de la Société pour votre référence. Numéros de taxes, etc"
"Company, Month and Fiscal Year is mandatory","Société , le mois et l'année fiscale est obligatoire"
Compensatory Off,faire
Complete,Compléter
Complete Setup,congé de maladie
Completed,Terminé
Completed Production Orders,Terminé les ordres de fabrication
Completed Qty,Complété Quantité
Completion Date,Date d&#39;achèvement
Completion Status,L&#39;état d&#39;achèvement
Computer,ordinateur
Computers,Informatique
Confirmation Date,date de confirmation
Confirmed orders from Customers.,Confirmé commandes provenant de clients.
Consider Tax or Charge for,Prenons l&#39;impôt ou charge pour
Considered as Opening Balance,Considéré comme Solde d&#39;ouverture
Considered as an Opening Balance,Considéré comme un solde d&#39;ouverture
Consultant,Consultant
Consulting,consultant
Consumable,consommable
Consumable Cost,Coût de consommable
Consumable cost per hour,Coût de consommable par heure
Consumed Qty,Quantité consommée
Consumer Products,Produits de consommation
Contact,Contacter
Contact Control,Contactez contrôle
Contact Desc,Contacter Desc
Contact Details,Coordonnées
Contact Email,Contact Courriel
Contact HTML,Contacter HTML
Contact Info,Information de contact
Contact Mobile No,Contact Mobile Aucune
Contact Name,Contact Nom
Contact No.,Contactez No.
Contact Person,Personne à contacter
Contact Type,Type de contact
Contact master.,'N'a pas de série »ne peut pas être « Oui »pour non - article en stock
Contacts,S'il vous plaît entrer la quantité pour l'article {0}
Content,Teneur
Content Type,Type de contenu
Contra Voucher,Bon Contra
Contract,contrat
Contract End Date,Date de fin du contrat
Contract End Date must be greater than Date of Joining,Fin du contrat La date doit être supérieure à date d'adhésion
Contribution (%),Contribution (%)
Contribution to Net Total,Contribution à Total net
Conversion Factor,Facteur de conversion
Conversion Factor is required,Facture de vente {0} a déjà été soumis
Conversion factor cannot be in fractions,Installation Remarque {0} a déjà été soumis
Conversion factor for default Unit of Measure must be 1 in row {0},revenu
Conversion rate cannot be 0 or 1,Un groupe de clients existe avec le même nom s'il vous plaît changer le nom du client ou renommer le groupe de clients
Convert into Recurring Invoice,Convertir en facture récurrente
Convert to Group,Convertir en groupe
Convert to Ledger,Autre Ledger
Converted,Converti
Copy From Item Group,Copy From Group article
Cosmetics,produits de beauté
Cost Center,Centre de coûts
Cost Center Details,Coût Center Détails
Cost Center Name,Coût Nom du centre
Cost Center is required for 'Profit and Loss' account {0},Quantité de minute
Cost Center is required in row {0} in Taxes table for type {1},Livré de série n ° {0} ne peut pas être supprimé
Cost Center with existing transactions can not be converted to group,S'il vous plaît entrer les détails de l' article
Cost Center with existing transactions can not be converted to ledger,Point {0} a atteint sa fin de vie sur {1}
Cost Center {0} does not belong to Company {1},Numéro de commande requis pour objet {0}
Cost of Goods Sold,Montant payé + Write Off montant ne peut être supérieur à Total
Costing,Costing
Country,Pays
Country Name,Nom Pays
Country wise default Address Templates,Modèles pays sage d'adresses par défaut
"Country, Timezone and Currency","Pays , Fuseau horaire et devise"
Create Bank Voucher for the total salary paid for the above selected criteria,Créer Chèques de la Banque pour le salaire total payé pour les critères ci-dessus sélectionnées
Create Customer,créer clientèle
Create Material Requests,Créer des demandes de matériel
Create New,créer un nouveau
Create Opportunity,créer une opportunité
Create Production Orders,Créer des ordres de fabrication
Create Quotation,créer offre
Create Receiver List,Créer une liste Receiver
Create Salary Slip,Créer bulletin de salaire
Create Stock Ledger Entries when you submit a Sales Invoice,Créer un registre des stocks entrées lorsque vous soumettez une facture de vente
"Create and manage daily, weekly and monthly email digests.","Créer et gérer des recueils d' email quotidiens, hebdomadaires et mensuels ."
Create rules to restrict transactions based on values.,Créer des règles pour restreindre les transactions fondées sur des valeurs .
Created By,Créé par
Creates salary slip for above mentioned criteria.,Crée le bulletin de salaire pour les critères mentionnés ci-dessus.
Creation Date,date de création
Creation Document No,Création document n
Creation Document Type,Type de document de création
Creation Time,Date de création
Credentials,Lettres de créance
Credit,Crédit
Credit Amt,Crédit Amt
Credit Card,Carte de crédit
Credit Card Voucher,Bon de carte de crédit
Credit Controller,Credit Controller
Credit Days,Jours de crédit
Credit Limit,Limite de crédit
Credit Note,Note de crédit
Credit To,Crédit Pour
Currency,Monnaie
Currency Exchange,Change de devises
Currency Name,Nom de la devise
Currency Settings,Paramètres de devises
Currency and Price List,Monnaie et liste de prix
Currency exchange rate master.,Campagne . # # # #
Current Address,Adresse actuelle
Current Address Is,Adresse actuelle
Current Assets,Ordre de fabrication {0} doit être soumis
Current BOM,Nomenclature actuelle
Current BOM and New BOM can not be same,Référence # {0} {1} du
Current Fiscal Year,Exercice en cours
Current Liabilities,Le solde doit être
Current Stock,Stock actuel
Current Stock UOM,Emballage Stock actuel
Current Value,Valeur actuelle
Custom,Coutume
Custom Autoreply Message,Message personnalisé Autoreply
Custom Message,Message personnalisé
Customer,Client
Customer (Receivable) Account,Compte client (à recevoir)
Customer / Item Name,Client / Nom d&#39;article
Customer / Lead Address,Client / plomb adresse
Customer / Lead Name,Entrepôt {0} n'existe pas
Customer > Customer Group > Territory,Client> Groupe de clientèle> Territoire
Customer Account Head,Compte client Head
Customer Acquisition and Loyalty,Acquisition et fidélisation client
Customer Address,Adresse du client
Customer Addresses And Contacts,Adresses et contacts clients
Customer Addresses and Contacts,Les adresses de clients et contacts
Customer Code,Code client
Customer Codes,Codes du Client
Customer Details,Détails du client
Customer Feedback,Réactions des clients
Customer Group,Groupe de clients
Customer Group / Customer,Groupe de client / client
Customer Group Name,Nom du groupe client
Customer Intro,Intro à la clientèle
Customer Issue,Numéro client
Customer Issue against Serial No.,Numéro de la clientèle contre Serial No.
Customer Name,Nom du client
Customer Naming By,Client de nommage par
Customer Service,Service à la clientèle
Customer database.,Base de données clients.
Customer is required,Approuver rôle ne peut pas être même que le rôle de l'État est applicable aux
Customer master.,utilisateur spécifique
Customer required for 'Customerwise Discount',Colonne inconnu : {0}
Customer {0} does not belong to project {1},S'il vous plaît définir la valeur par défaut {0} dans Société {0}
Customer {0} does not exist,Client {0} n'existe pas
Customer's Item Code,Code article client
Customer's Purchase Order Date,Bon de commande de la date de clientèle
Customer's Purchase Order No,Bon de commande du client Non
Customer's Purchase Order Number,Nombre bon de commande du client
Customer's Vendor,Client Fournisseur
Customers Not Buying Since Long Time,Les clients ne pas acheter Depuis Long Time
Customerwise Discount,Remise Customerwise
Customize,Personnaliser
Customize the Notification,Personnaliser la notification
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Personnaliser le texte d&#39;introduction qui se déroule comme une partie de cet e-mail. Chaque transaction a un texte séparé d&#39;introduction.
DN Detail,Détail DN
Daily,Quotidien
Daily Time Log Summary,Daily Time Sommaire du journal
Database Folder ID,Database ID du dossier
Database of potential customers.,Base de données de clients potentiels.
Date,Date
Date Format,Format de date
Date Of Retirement,Date de la retraite
Date Of Retirement must be greater than Date of Joining,Date de la retraite doit être supérieure à date d'adhésion
Date is repeated,La date est répétée
Date of Birth,Date de naissance
Date of Issue,Date d&#39;émission
Date of Joining,Date d&#39;adhésion
Date of Joining must be greater than Date of Birth,enregistrement précédent
Date on which lorry started from supplier warehouse,Date à laquelle le camion a commencé à partir de l&#39;entrepôt fournisseur
Date on which lorry started from your warehouse,Date à laquelle le camion a commencé à partir de votre entrepôt
Dates,Dates
Days Since Last Order,Jours depuis la dernière commande
Days for which Holidays are blocked for this department.,Jours fériés pour lesquels sont bloqués pour ce département.
Dealer,Revendeur
Debit,Débit
Debit Amt,Débit Amt
Debit Note,Note de débit
Debit To,Débit Pour
Debit and Credit not equal for this voucher. Difference is {0}.,Débit et de crédit ne correspond pas à ce document . La différence est {0} .
Deduct,Déduire
Deduction,Déduction
Deduction Type,Type de déduction
Deduction1,Deduction1
Deductions,Déductions
Default,Par défaut
Default Account,Compte par défaut
Default Address Template cannot be deleted,Adresse par défaut modèle ne peut pas être supprimé
Default Amount,Montant en défaut
Default BOM,Nomenclature par défaut
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Par défaut Banque / argent compte sera automatiquement mis à jour dans la facture POS lorsque ce mode est sélectionné.
Default Bank Account,Compte bancaire par défaut
Default Buying Cost Center,Centre de coûts d'achat par défaut
Default Buying Price List,Défaut d'achat Liste des Prix
Default Cash Account,Compte de trésorerie par défaut
Default Company,Société défaut
Default Currency,Devise par défaut
Default Customer Group,Groupe de clients par défaut
Default Expense Account,Compte de dépenses par défaut
Default Income Account,Compte d&#39;exploitation par défaut
Default Item Group,Groupe d&#39;éléments par défaut
Default Price List,Liste des prix défaut
Default Purchase Account in which cost of the item will be debited.,Compte Achat par défaut dans lequel le coût de l&#39;article sera débité.
Default Selling Cost Center,Coût des marchandises vendues
Default Settings,Paramètres par défaut
Default Source Warehouse,Source d&#39;entrepôt par défaut
Default Stock UOM,Stock défaut Emballage
Default Supplier,Par défaut Fournisseur
Default Supplier Type,Fournisseur Type par défaut
Default Target Warehouse,Cible d&#39;entrepôt par défaut
Default Territory,Territoire défaut
Default Unit of Measure,Unité de mesure par défaut
"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.","Unité de mesure de défaut ne peut pas être modifié directement parce que vous avez déjà fait une transaction (s ) avec un autre UDM . Pour changer Emballage par défaut , utiliser l'outil « Emballage Remplacer Utility"" sous module de Stock ."
Default Valuation Method,Méthode d&#39;évaluation par défaut
Default Warehouse,Entrepôt de défaut
Default Warehouse is mandatory for stock Item.,{0} {1} contre le projet de loi {2} du {3}
Default settings for accounting transactions.,Les paramètres par défaut pour les opérations comptables .
Default settings for buying transactions.,non Soumis
Default settings for selling transactions.,principal
Default settings for stock transactions.,minute
Defense,défense
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Définir le budget pour ce centre de coûts. Pour définir l&#39;action budgétaire, voir <a href=""#!List/Company"">Maître Société</a>"
Del,Eff
Delete,Effacer
Delete {0} {1}?,Supprimer {0} {1} ?
Delivered,Livré
Delivered Items To Be Billed,Les articles livrés être facturé
Delivered Qty,Qté livrée
Delivered Serial No {0} cannot be deleted,médical
Delivery Date,Date de livraison
Delivery Details,Détails de la livraison
Delivery Document No,Pas de livraison de documents
Delivery Document Type,Type de document de livraison
Delivery Note,Remarque livraison
Delivery Note Item,Point de Livraison
Delivery Note Items,Articles bordereau de livraison
Delivery Note Message,Note Message de livraison
Delivery Note No,Remarque Aucune livraison
Delivery Note Required,Remarque livraison requis
Delivery Note Trends,Bordereau de livraison Tendances
Delivery Note {0} is not submitted,Livraison Remarque {0} n'est pas soumis
Delivery Note {0} must not be submitted,Pas de clients ou fournisseurs Comptes trouvé
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Quantité en ligne {0} ( {1} ) doit être la même que la quantité fabriquée {2}
Delivery Status,Delivery Status
Delivery Time,Délai de livraison
Delivery To,Pour livraison
Department,Département
Department Stores,Grands Magasins
Depends on LWP,Dépend de LWP
Depreciation,Actifs d'impôt
Description,Description
Description HTML,Description du HTML
Designation,Désignation
Designer,créateur
Detailed Breakup of the totals,Breakup détaillée des totaux
Details,Détails
Difference (Dr - Cr),Différence (Dr - Cr )
Difference Account,Compte de la différence
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Compte de la différence doit être un compte de type « responsabilité », car ce stock réconciliation est une ouverture d'entrée"
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érents Emballage des articles mènera à incorrects (Total ) Valeur de poids . Assurez-vous que poids net de chaque article se trouve dans la même unité de mesure .
Direct Expenses,{0} {1} a été modifié . S'il vous plaît rafraîchir .
Direct Income,Choisissez votre langue
Disable,"Groupe ajoutée, rafraîchissant ..."
Disable Rounded Total,Désactiver totale arrondie
Disabled,Handicapé
Discount  %,% De réduction
Discount %,% De réduction
Discount (%),Remise (%)
Discount Amount,S'il vous plaît tirer des articles de livraison Note
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Les champs d&#39;actualisation sera disponible en commande, reçu d&#39;achat, facture d&#39;achat"
Discount Percentage,Annuler Matériel Visiter {0} avant d'annuler ce numéro de client
Discount Percentage can be applied either against a Price List or for all Price List.,Pourcentage de réduction peut être appliquée contre une liste de prix ou pour toute liste de prix.
Discount must be less than 100,La remise doit être inférieure à 100
Discount(%),Remise (%)
Dispatch,envoi
Display all the individual items delivered with the main items,Afficher tous les articles individuels livrés avec les principaux postes
Distribute transport overhead across items.,Distribuer surdébit de transport pour tous les items.
Distribution,Répartition
Distribution Id,Id distribution
Distribution Name,Nom distribution
Distributor,Distributeur
Divorced,Divorcé
Do Not Contact,Ne communiquez pas avec
Do not show any symbol like $ etc next to currencies.,Ne plus afficher n&#39;importe quel symbole comme $ etc à côté de devises.
Do really want to unstop production order: ,
Do you really want to STOP ,
Do you really want to STOP this Material Request?,Voulez-vous vraiment arrêter cette Demande de Matériel ?
Do you really want to Submit all Salary Slip for month {0} and year {1},"Statut du document de transition {0} {1}, n'est pas autorisé"
Do you really want to UNSTOP ,
Do you really want to UNSTOP this Material Request?,Voulez-vous vraiment à ce unstop Demande de Matériel ?
Do you really want to stop production order: ,
Doc Name,Nom de Doc
Doc Type,Doc Type d&#39;
Document Description,Description du document
Document Type,Type de document
Documents,Documents
Domain,Domaine
Don't send Employee Birthday Reminders,Ne pas envoyer des employés anniversaire rappels
Download Materials Required,Télécharger Matériel requis
Download Reconcilation Data,Télécharger Rapprochement des données
Download Template,Télécharger le modèle
Download a report containing all raw materials with their latest inventory status,Télécharger un rapport contenant toutes les matières premières avec leur dernier état des stocks
"Download the Template, fill appropriate data and attach the modified file.","Télécharger le modèle , remplir les données appropriées et joindre le fichier modifié ."
"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","Télécharger le modèle, remplir les données appropriées et joindre le fichier modifié.
 Toutes les dates et la combinaison de l'employé dans la période sélectionnée viendront dans le modèle, avec les records de fréquentation existants"
Draft,Avant-projet
Dropbox,Dropbox
Dropbox Access Allowed,Dropbox accès autorisé
Dropbox Access Key,Dropbox Clé d&#39;accès
Dropbox Access Secret,Dropbox accès secrète
Due Date,Due Date
Due Date cannot be after {0},La date d'échéance ne peut pas être après {0}
Due Date cannot be before Posting Date,La date d'échéance ne peut être antérieure Date de publication
Duplicate Entry. Please check Authorization Rule {0},Point {0} n'est pas un objet sérialisé
Duplicate Serial No entered for Item {0},Dupliquer N ° de série entré pour objet {0}
Duplicate entry,dupliquer entrée
Duplicate row {0} with same {1},Pièces de journal {0} sont non liée
Duties and Taxes,S'il vous plaît mettre trésorerie de défaut ou d'un compte bancaire en mode de paiement {0}
ERPNext Setup,ERPNext installation
Earliest,plus tôt
Earnest Money,S'il vous plaît sélectionner le type de charge de premier
Earning,Revenus
Earning & Deduction,Gains et déduction
Earning Type,Gagner Type d&#39;
Earning1,Earning1
Edit,Éditer
Edu. Cess on Excise,Edu. Cess sur l'accise
Edu. Cess on Service Tax,Edu. Cess sur des services fiscaux
Edu. Cess on TDS,Edu. Cess sur TDS
Education,éducation
Educational Qualification,Qualification pour l&#39;éducation
Educational Qualification Details,Détails de qualification d&#39;enseignement
Eg. smsgateway.com/api/send_sms.cgi,Par exemple. smsgateway.com / api / send_sms.cgi
Either debit or credit amount is required for {0},Soit de débit ou de montant de crédit est nécessaire pour {0}
Either target qty or target amount is mandatory,Voulez-vous vraiment arrêter
Either target qty or target amount is mandatory.,annuel
Electrical,local
Electricity Cost,Coût de l'électricité
Electricity cost per hour,Coût de l'électricité par heure
Electronics,électronique
Email,Email
Email Digest,Email Digest
Email Digest Settings,Paramètres de messagerie Digest
Email Digest: ,
Email Id,Identification d&#39;email
"Email Id where a job applicant will email e.g. ""jobs@example.com""",Identification d&#39;email où un demandeur d&#39;emploi enverra par courriel par exemple &quot;jobs@example.com&quot;
Email Notifications,Notifications par courriel
Email Sent?,Envoyer envoyés?
"Email id must be unique, already exists for {0}","Email id doit être unique , existe déjà pour {0}"
Email ids separated by commas.,identifiants de messagerie séparées par des virgules.
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""",Paramètres de messagerie pour extraire des ventes Leads e-mail par exemple id &quot;sales@example.com&quot;
Emergency Contact,En cas d'urgence
Emergency Contact Details,Détails de contact d&#39;urgence
Emergency Phone,téléphone d'urgence
Employee,Employé
Employee Birthday,Anniversaire des employés
Employee Details,Détails des employés
Employee Education,Formation des employés
Employee External Work History,Antécédents de travail des employés externe
Employee Information,Renseignements sur l&#39;employé
Employee Internal Work History,Antécédents de travail des employés internes
Employee Internal Work Historys,Historys employés de travail internes
Employee Leave Approver,Congé employé approbateur
Employee Leave Balance,Congé employé Solde
Employee Name,Nom de l&#39;employé
Employee Number,Numéro d&#39;employé
Employee Records to be created by,Dossiers sur les employés à être créées par
Employee Settings,Réglages des employés
Employee Type,Type de contrat
"Employee designation (e.g. CEO, Director etc.).",Vous devez enregistrer le formulaire avant de procéder
Employee master.,Stock Emballage updatd pour objet {0}
Employee record is created using selected field. ,dossier de l&#39;employé est créé en utilisant champ sélectionné.
Employee records.,Les dossiers des employés.
Employee relieved on {0} must be set as 'Left',S'il vous plaît entrer unité de mesure par défaut
Employee {0} has already applied for {1} between {2} and {3},Employé {0} a déjà appliqué pour {1} entre {2} et {3}
Employee {0} is not active or does not exist,"Employé {0} n'est pas actif , ou n'existe pas"
Employee {0} was on leave on {1}. Cannot mark attendance.,Employé {0} a été en congé de {1} . Vous ne pouvez pas marquer la fréquentation .
Employees Email Id,Les employés Id Email
Employment Details,Détails de l&#39;emploi
Employment Type,Type d&#39;emploi
Enable / disable currencies.,Vieillissement date est obligatoire pour l'ouverture d'entrée
Enabled,Activé
Encashment Date,Date de l&#39;encaissement
End Date,Date de fin
End Date can not be less than Start Date,Évaluation de l'objet mis à jour
End date of current invoice's period,Date de fin de la période de facturation en cours
End of Life,Fin de vie
Energy,énergie
Engineer,ingénieur
Enter Verification Code,Entrez le code de vérification
Enter campaign name if the source of lead is campaign.,Entrez le nom de la campagne si la source de plomb est la campagne.
Enter department to which this Contact belongs,Entrez département auquel appartient ce contact
Enter designation of this Contact,Entrez la désignation de ce contact
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Entrez Identifiant courriels séparé par des virgules, la facture sera envoyée automatiquement à la date particulière"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Introduisez les articles et qté planifiée pour laquelle vous voulez soulever ordres de fabrication ou de télécharger des matières premières pour l&#39;analyse.
Enter name of campaign if source of enquiry is campaign,Entrez le nom de la campagne si la source de l&#39;enquête est la campagne
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Entrez les paramètres url statiques (par exemple ici sender = ERPNext, username = ERPNext, mot de passe = 1234 etc)"
Enter the company name under which Account Head will be created for this Supplier,Entrez le nom de la société en vertu de laquelle Head compte sera créé pour ce Fournisseur
Enter url parameter for message,Entrez le paramètre url pour le message
Enter url parameter for receiver nos,Entrez le paramètre url pour nos récepteurs
Entertainment & Leisure,Entertainment & Leisure
Entertainment Expenses,Frais de représentation
Entries,Entrées
Entries against ,
Entries are not allowed against this Fiscal Year if the year is closed.,Les inscriptions ne sont pas autorisés contre cette exercice si l&#39;année est fermé.
Equity,Opération {0} est répété dans le tableau des opérations
Error: {0} > {1},Erreur: {0} > {1}
Estimated Material Cost,Coût des matières premières estimée
"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 la plus haute priorité, les priorités internes alors suivantes sont appliquées:"
Everyone can read,Tout le monde peut lire
"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 réglé et n ° de série n'est pas mentionné dans les transactions, le numéro de série alors automatique sera créé sur la base de cette série. Si vous voulez toujours de mentionner explicitement série n ° de cet article. laisser ce champ vide."
Exchange Rate,Taux de change
Excise Duty 10,Droits d'accise 10
Excise Duty 14,Droits d'accise 14
Excise Duty 4,Droits d'accise 4
Excise Duty 8,Droits d'accise 8
Excise Duty @ 10,Droits d'accise @ 10
Excise Duty @ 14,Droits d'accise @ 14
Excise Duty @ 4,Droits d'accise @ 4
Excise Duty @ 8,Droits d'accise @ 8
Excise Duty Edu Cess 2,Droits d'accise Edu Cess 2
Excise Duty SHE Cess 1,Droits d'accise ELLE Cess 1
Excise Page Number,Numéro de page d&#39;accise
Excise Voucher,Bon d&#39;accise
Execution,exécution
Executive Search,Executive Search
Exemption Limit,Limite d&#39;exemption
Exhibition,Exposition
Existing Customer,Client existant
Exit,Sortie
Exit Interview Details,Quittez Détails Interview
Expected,Attendu
Expected Completion Date can not be less than Project Start Date,Pourcentage de réduction
Expected Date cannot be before Material Request Date,Date prévu ne peut pas être avant Matériel Date de la demande
Expected Delivery Date,Date de livraison prévue
Expected Delivery Date cannot be before Purchase Order Date,Une autre structure salariale {0} est active pour les employés {0} . S'il vous plaît faire son statut « inactif » pour continuer.
Expected Delivery Date cannot be before Sales Order Date,"Stock réconciliation peut être utilisé pour mettre à jour le stock à une date donnée , généralement selon l'inventaire physique ."
Expected End Date,Date de fin prévue
Expected Start Date,Date de début prévue
Expense,frais
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Dépenses / compte de la différence ({0}) doit être un compte «de résultat»
Expense Account,Compte de dépenses
Expense Account is mandatory,Compte de dépenses est obligatoire
Expense Claim,Demande d&#39;indemnité de
Expense Claim Approved,Demande d&#39;indemnité Approuvé
Expense Claim Approved Message,Demande d&#39;indemnité Approuvé message
Expense Claim Detail,Détail remboursement des dépenses
Expense Claim Details,Détails de la réclamation des frais de
Expense Claim Rejected,Demande d&#39;indemnité rejetée
Expense Claim Rejected Message,Demande d&#39;indemnité rejeté le message
Expense Claim Type,Type de demande d&#39;indemnité
Expense Claim has been approved.,Demande de remboursement a été approuvé .
Expense Claim has been rejected.,Demande de remboursement a été rejetée .
Expense Claim is pending approval. Only the Expense Approver can update status.,Remboursement de frais est en attente d'approbation . Seulement l'approbateur des frais peut mettre à jour le statut .
Expense Date,Date de frais
Expense Details,Détail des dépenses
Expense Head,Chef des frais
Expense account is mandatory for item {0},Contre le projet de loi {0} {1} daté
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Frais ou différence compte est obligatoire pour objet {0} car il impacts valeur globale des actions
Expenses,Note: Ce centre de coûts est un groupe . Vous ne pouvez pas faire les écritures comptables contre des groupes .
Expenses Booked,Dépenses Réservé
Expenses Included In Valuation,Frais inclus dans l&#39;évaluation
Expenses booked for the digest period,Charges comptabilisées pour la période digest
Expiry Date,Date d&#39;expiration
Exports,Exportations
External,Externe
Extract Emails,Extrait Emails
FCFS Rate,Taux PAPS
Failed: ,Échec:
Family Background,Antécédents familiaux
Fax,Fax
Features Setup,Features Setup
Feed,Nourrir
Feed Type,Type de flux
Feedback,Réaction
Female,Féminin
Fetch exploded BOM (including sub-assemblies),Fetch nomenclature éclatée ( y compris les sous -ensembles )
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Champ disponible dans la note de livraison, devis, facture de vente, Sales Order"
Files Folder ID,Les fichiers d&#39;identification des dossiers
Fill the form and save it,Remplissez le formulaire et l'enregistrer
Filter based on customer,Filtre basé sur le client
Filter based on item,Filtre basé sur le point
Financial / accounting year.,Point {0} a été saisi plusieurs fois contre une même opération
Financial Analytics,Financial Analytics
Financial Services,services financiers
Financial Year End Date,paire
Financial Year Start Date,Les paramètres par défaut pour la vente de transactions .
Finished Goods,Produits finis
First Name,Prénom
First Responded On,D&#39;abord répondu le
Fiscal Year,Exercice
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Exercice Date de début et de fin d'exercice la date sont réglées dans l'année fiscale {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Exercice date de début et de fin d'exercice date ne peut être plus d'un an d'intervalle.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Exercice Date de début ne doit pas être supérieure à fin d'exercice Date de
Fixed Asset,des immobilisations
Fixed Assets,Facteur de conversion est requis
Follow via Email,Suivez par e-mail
"Following table will show values if items are sub - contracted. These values will be fetched from the master of ""Bill of Materials"" of sub - contracted items.",Le tableau suivant indique les valeurs si les articles sont en sous - traitance. Ces valeurs seront extraites de la maîtrise de la «Bill of Materials&quot; de sous - traitance articles.
Food,prix
"Food, Beverage & Tobacco","Alimentation , boissons et tabac"
"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.","Pour les articles ""ventes de nomenclature», Entrepôt, N ° de série et de lot n ° sera considéré comme de la table la «Liste d'emballage. Si Entrepôt et lot n ° sont les mêmes pour tous les articles d'emballage pour tout article 'Sales nomenclature », ces valeurs peuvent être entrées dans le tableau principal de l'article, les valeurs seront copiés sur« Liste d'emballage »table."
For Company,Pour l&#39;entreprise
For Employee,Pour les employés
For Employee Name,Pour Nom de l&#39;employé
For Price List,Annuler matériaux Visites {0} avant l'annulation de cette visite d'entretien
For Production,Pour la production
For Reference Only.,Pour référence seulement.
For Sales Invoice,Pour Facture de vente
For Server Side Print Formats,Server Side Formats d&#39;impression
For Supplier,pour fournisseur
For Warehouse,Pour Entrepôt
For Warehouse is required before Submit,Warehouse est nécessaire avant Soumettre
"For e.g. 2012, 2012-13","Pour exemple, 2012, 2012-13"
For reference,Pour référence
For reference only.,À titre de référence seulement.
"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&#39;impression comme les factures et les bons de livraison"
Fraction,Fraction
Fraction Units,Unités fraction
Freeze Stock Entries,Congeler entrées en stocks
Freeze Stocks Older Than [Days],Vous ne pouvez pas entrer bon actuelle dans «Contre Journal Voucher ' colonne
Freight and Forwarding Charges,Fret et d'envoi en sus
Friday,Vendredi
From,À partir de
From Bill of Materials,De Bill of Materials
From Company,De Company
From Currency,De Monnaie
From Currency and To Currency cannot be same,De leur monnaie et à devises ne peut pas être la même
From Customer,De clientèle
From Customer Issue,De émission à la clientèle
From Date,Partir de la date
From Date cannot be greater than To Date,Date d'entrée ne peut pas être supérieur à ce jour
From Date must be before To Date,Partir de la date doit être antérieure à ce jour
From Date should be within the Fiscal Year. Assuming From Date = {0},De la date doit être dans l'exercice. En supposant Date d'= {0}
From Delivery Note,De bon de livraison
From Employee,De employés
From Lead,Du plomb
From Maintenance Schedule,De Calendrier d'entretien
From Material Request,De Demande de Matériel
From Opportunity,De Opportunity
From Package No.,De Ensemble numéro
From Purchase Order,De bon de commande
From Purchase Receipt,De ticket de caisse
From Quotation,De offre
From Sales Order,De Sales Order
From Supplier Quotation,De Fournisseur offre
From Time,From Time
From Value,De la valeur
From and To dates required,De et la date exigée
From value must be less than to value in row {0},Parent Site Web page
Frozen,Frozen
Frozen Accounts Modifier,Frozen comptes modificateur
Fulfilled,Remplies
Full Name,Nom et Prénom
Full-time,À plein temps
Fully Billed,Entièrement Qualifié
Fully Completed,Entièrement complété
Fully Delivered,Entièrement Livré
Furniture and Fixture,Meubles et articles d'ameublement
Further accounts can be made under Groups but entries can be made against Ledger,D'autres comptes peuvent être faites dans les groupes mais les entrées peuvent être faites contre Ledger
"Further accounts can be made under Groups, but entries can be made against Ledger",Frais de vente
Further nodes can be only created under 'Group' type nodes,D'autres nœuds peuvent être créées que sous les nœuds de type 'Groupe'
GL Entry,Entrée GL
Gantt Chart,Diagramme de Gantt
Gantt chart of all tasks.,Diagramme de Gantt de toutes les tâches.
Gender,Sexe
General,Général
General Ledger,General Ledger
Generate Description HTML,Générer HTML Description
Generate Material Requests (MRP) and Production Orders.,Lieu à des demandes de matériel (MRP) et de la procédure de production.
Generate Salary Slips,Générer les bulletins de salaire
Generate Schedule,Générer annexe
Generates HTML to include selected image in the description,Génère du code HTML pour inclure l&#39;image sélectionnée dans la description
Get Advances Paid,Obtenez Avances et acomptes versés
Get Advances Received,Obtenez Avances et acomptes reçus
Get Current Stock,Obtenez Stock actuel
Get Items,Obtenir les éléments
Get Items From Sales Orders,Obtenir des éléments de Sales Orders
Get Items from BOM,Obtenir des éléments de nomenclature
Get Last Purchase Rate,Obtenez Purchase Rate Dernière
Get Outstanding Invoices,Obtenez Factures en souffrance
Get Relevant Entries,Obtenez les entrées pertinentes
Get Sales Orders,Obtenez des commandes clients
Get Specification Details,Obtenez les détails Spécification
Get Stock and Rate,Obtenez stock et taux
Get Template,Obtenez modèle
Get Terms and Conditions,Obtenez Termes et Conditions
Get Unreconciled Entries,Obtenez non rapprochés entrées
Get Weekly Off Dates,Obtenez hebdomadaires Dates Off
"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.","Obtenez taux d&#39;évaluation et le stock disponible à la source / cible d&#39;entrepôt sur l&#39;affichage mentionné de date-heure. Si sérialisé article, s&#39;il vous plaît appuyez sur cette touche après avoir entré numéros de série."
Global Defaults,Par défaut mondiaux
Global POS Setting {0} already created for company {1},Monter : {0}
Global Settings,Paramètres globaux
"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account Ledger (by clicking on Add Child) of type ""Bank""",Aller au groupe approprié (habituellement utilisation des fonds > Actif à court terme > Comptes bancaires et créer un nouveau compte Ledger ( en cliquant sur Ajouter un enfant ) de type «Banque»
"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account Ledger (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",Aller au groupe approprié (généralement source de fonds > Passif à court terme > Impôts et taxes et créer un nouveau compte Ledger ( en cliquant sur Ajouter un enfant ) de type « impôt» et ne mentionnent le taux de l'impôt.
Goal,Objectif
Goals,Objectifs
Goods received from Suppliers.,Les marchandises reçues de fournisseurs.
Google Drive,Google Drive
Google Drive Access Allowed,Google Drive accès autorisé
Government,Si différente de l'adresse du client
Graduate,Diplômé
Grand Total,Grand Total
Grand Total (Company Currency),Total (Société Monnaie)
"Grid ""","grille """
Grocery,épicerie
Gross Margin %,Marge brute%
Gross Margin Value,Valeur Marge brute
Gross Pay,Salaire brut
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,Salaire brut + + Montant Montant échu Encaissement - Déduction totale
Gross Profit,Bénéfice brut
Gross Profit (%),Bénéfice brut (%)
Gross Weight,Poids brut
Gross Weight UOM,Emballage Poids brut
Group,Groupe
Group by Account,Groupe par compte
Group by Voucher,Règles pour ajouter les frais d'envoi .
Group or Ledger,Groupe ou Ledger
Groups,Groupes
HR Manager,Directeur des Ressources Humaines
HR Settings,Réglages RH
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.
Half Day,Demi-journée
Half Yearly,La moitié annuel
Half-yearly,Semestriel
Happy Birthday!,Joyeux anniversaire!
Hardware,Sales Person cible Variance article Groupe Sage
Has Batch No,A lot no
Has Child Node,A Node enfant
Has Serial No,N ° de série a
Head of Marketing and Sales,Responsable du marketing et des ventes
Header,En-tête
Health Care,soins de santé
Health Concerns,Préoccupations pour la santé
Health Details,Détails de santé
Held On,Tenu le
Help HTML,Aide HTML
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Aide: Pour lier à un autre enregistrement dans le système, utiliser &quot;# Form / Note / [Note Nom]», comme l&#39;URL du lien. (Ne pas utiliser &quot;http://&quot;)"
"Here you can maintain family details like name and occupation of parent, spouse and children","Ici vous pouvez conserver les détails de famille comme nom et la profession des parents, le conjoint et les enfants"
"Here you can maintain height, weight, allergies, medical concerns etc","Ici vous pouvez maintenir la hauteur, le poids, allergies, etc médicaux préoccupations"
Hide Currency Symbol,Masquer le symbole monétaire
High,Haut
History In Company,Dans l&#39;histoire de l&#39;entreprise
Hold,Tenir
Holiday,Vacances
Holiday List,Liste de vacances
Holiday List Name,Nom de la liste de vacances
Holiday master.,Débit doit être égal à crédit . La différence est {0}
Holidays,Fêtes
Home,Maison
Host,Hôte
"Host, Email and Password required if emails are to be pulled","D&#39;accueil, e-mail et mot de passe requis si les courriels sont d&#39;être tiré"
Hour,{0} ' {1}' pas l'Exercice {2}
Hour Rate,Taux heure
Hour Rate Labour,Travail heure Tarif
Hours,Heures
How Pricing Rule is applied?,Comment Prix règle est appliquée?
How frequently?,Quelle est la fréquence?
"How should this currency be formatted? If not set, will use system defaults","Comment cette monnaie est formaté? S&#39;il n&#39;est pas défini, utilisera par défaut du système"
Human Resources,Ressources humaines
Identification of the package for the delivery (for print),Identification de l&#39;emballage pour la livraison (pour l&#39;impression)
If Income or Expense,Si les produits ou charges
If Monthly Budget Exceeded,Si le budget mensuel dépassé
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order",N ° de série {0} Etat doit être «disponible» à livrer
"If Supplier Part Number exists for given Item, it gets stored here","Si le numéro de pièce fournisseur existe pour objet donné, il est stocké ici"
If Yearly Budget Exceeded,Si le budget annuel dépassé
"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.","Si elle est cochée, la nomenclature des sous-ensembles points seront examinés pour obtenir des matières premières. Sinon, tous les éléments du sous-ensemble sera traitée comme une matière première."
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Si elle est cochée, aucune totale. des jours de travail comprennent vacances, ce qui réduira la valeur de salaire par jour"
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Si elle est cochée, le montant de la taxe sera considéré comme déjà inclus dans le tarif Imprimer / Print Montant"
If different than customer address,Point {0} a déjà été renvoyé
"If disable, 'Rounded Total' field will not be visible in any transaction","Si désactiver, &#39;arrondi totale «champ ne sera pas visible dans toute transaction"
"If enabled, the system will post accounting entries for inventory automatically.","S&#39;il est activé, le système affichera les écritures comptables pour l&#39;inventaire automatiquement."
If more than one package of the same type (for print),Si plus d&#39;un paquet du même type (pour l&#39;impression)
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Si plusieurs règles de tarification continuent de prévaloir, les utilisateurs sont invités à définir manuellement la priorité à résoudre les conflits."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","Si aucun changement soit Quantité ou évaluation noter , laisser la cellule vide."
If not applicable please enter: NA,S&#39;il n&#39;est pas applicable s&#39;il vous plaît entrez: NA
"If not checked, the list will have to be added to each Department where it has to be applied.","Si ce n&#39;est pas cochée, la liste devra être ajouté à chaque département où il doit être appliqué."
"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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 Tarif choisi la règle est faite pour 'Prix', il va écraser Prix. Prix Prix de la règle est le prix définitif, donc pas de réduction supplémentaire doit être appliquée. Ainsi, dans les transactions comme des commandes clients, bons de commande, etc, il sera récupéré dans le champ «Taux», plutôt que le champ 'Prix List Noter »."
"If specified, send the newsletter using this email address","S&#39;il est spécifié, envoyer le bulletin en utilisant cette adresse e-mail"
"If the account is frozen, entries are allowed to restricted users.","Si le compte est gelé , les entrées sont autorisés pour les utilisateurs restreints ."
"If this Account represents a Customer, Supplier or Employee, set it here.","Si ce compte représente un client, fournisseur ou employé, l&#39;indiquer ici."
"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 on trouve deux ou plusieurs règles de tarification sur la base des conditions ci-dessus, la priorité est appliqué. Priorité est un nombre compris entre 0 à 20 alors que la valeur par défaut est zéro (blanc). Nombre plus élevé signifie qu'il sera prioritaire s'il existe plusieurs règles de tarification avec les mêmes conditions."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Si vous suivez contrôle de la qualité . Permet article AQ requis et AQ Pas de ticket de caisse
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,"Si vous avez équipe de vente et Partenaires Vente (Channel Partners), ils peuvent être marqués et maintenir leur contribution à l&#39;activité commerciale"
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Si vous avez créé un modèle standard de taxes à l&#39;achat et Master accusations, sélectionnez-le et cliquez sur le bouton ci-dessous."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Si vous avez créé un modèle standard en taxes de vente et les frais de Master, sélectionnez-le et cliquez sur le bouton ci-dessous."
"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page","Si vous avez longtemps imprimer des formats, cette fonction peut être utilisée pour diviser la page à imprimer sur plusieurs pages avec tous les en-têtes et pieds de page sur chaque page"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',Invalid Nom d'utilisateur Mot de passe ou de soutien . S'il vous plaît corriger et essayer à nouveau.
Ignore,Ignorer
Ignore Pricing Rule,Ignorer Prix règle
Ignored: ,Ignoré:
Image,Image
Image View,Voir l&#39;image
Implementation Partner,Partenaire de mise en œuvre
Import Attendance,Importer Participation
Import Failed!,Importation a échoué!
Import Log,Importer Connexion
Import Successful!,Importez réussie !
Imports,Importations
In Hours,Dans Heures
In Process,In Process
In Qty,Qté
In Value,Valeur
In Words,Dans les mots
In Words (Company Currency),En Words (Société Monnaie)
In Words (Export) will be visible once you save the Delivery Note.,Dans Words (Exportation) sera visible une fois que vous enregistrez le bon de livraison.
In Words will be visible once you save the Delivery Note.,Dans les mots seront visibles une fois que vous enregistrez le bon de livraison.
In Words will be visible once you save the Purchase Invoice.,Dans les mots seront visibles une fois que vous enregistrez la facture d&#39;achat.
In Words will be visible once you save the Purchase Order.,Dans les mots seront visibles une fois que vous enregistrez le bon de commande.
In Words will be visible once you save the Purchase Receipt.,Dans les mots seront visibles une fois que vous enregistrez le reçu d&#39;achat.
In Words will be visible once you save the Quotation.,Dans les mots seront visibles une fois que vous enregistrez le devis.
In Words will be visible once you save the Sales Invoice.,Dans les mots seront visibles une fois que vous enregistrez la facture de vente.
In Words will be visible once you save the Sales Order.,Dans les mots seront visibles une fois que vous enregistrez le bon de commande.
Incentives,Incitations
Include Reconciled Entries,Inclure les entrées rapprochées
Include holidays in Total no. of Working Days,Inclure les vacances en aucun totale. de jours de travail
Income,Extraire automatiquement les demandeurs d'emploi à partir d'une boîte aux lettres
Income / Expense,Produits / charges
Income Account,Compte de revenu
Income Booked,Revenu Réservé
Income Tax,Facteur de conversion UDM est nécessaire dans la ligne {0}
Income Year to Date,Année revenu à ce jour
Income booked for the digest period,Revenu réservée pour la période digest
Incoming,Nouveau
Incoming Rate,Taux d&#39;entrée
Incoming quality inspection.,Contrôle de la qualité entrant.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Nombre incorrect de General Ledger Entrées trouvées. Vous avez peut-être choisi le bon compte dans la transaction.
Incorrect or Inactive BOM {0} for Item {1} at row {2},Mauvaise ou inactif BOM {0} pour objet {1} à la ligne {2}
Indicates that the package is a part of this delivery (Only Draft),Indique que le package est une partie de cette livraison (Seuls les projets)
Indirect Expenses,N ° de série {0} créé
Indirect Income,{0} {1} statut est débouchées
Individual,Individuel
Industry,Industrie
Industry Type,Secteur d&#39;activité
Inspected By,Inspecté par
Inspection Criteria,Critères d&#39;inspection
Inspection Required,Inspection obligatoire
Inspection Type,Type d&#39;inspection
Installation Date,Date d&#39;installation
Installation Note,Note d&#39;installation
Installation Note Item,Article Remarque Installation
Installation Note {0} has already been submitted,Les demandes matérielles {0} créé
Installation Status,Etat de l&#39;installation
Installation Time,Temps d&#39;installation
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}
Installation record for a Serial No.,Dossier d&#39;installation d&#39;un n ° de série
Installed Qty,Qté installée
Instructions,Instructions
Integrate incoming support emails to Support Ticket,Intégrer des emails entrants soutien à l'appui de billets
Interested,Intéressé
Intern,interne
Internal,Interne
Internet Publishing,Publication Internet
Introduction,Introduction
Invalid Barcode,Barcode invalide
Invalid Barcode or Serial No,"Soldes de comptes de type "" banque "" ou "" Cash"""
Invalid Mail Server. Please rectify and try again.,électrique
Invalid Master Name,Invalid Nom du Maître
Invalid User Name or Support Password. Please rectify and try again.,Numéro de référence et date de référence est nécessaire pour {0}
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Quantité spécifiée non valide pour l'élément {0} . Quantité doit être supérieur à 0 .
Inventory,Inventaire
Inventory & Support,Inventaire & Support
Investment Banking,Banques d'investissement
Investments,Laisser Bill of Materials devrait être «oui» . Parce que un ou plusieurs nomenclatures actifs présents pour cet article
Invoice Date,Date de la facture
Invoice Details,Détails de la facture
Invoice No,Aucune facture
Invoice Number,Numéro de facture
Invoice Period From,Période facture de
Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Période facture et la période de facturation Pour les dates obligatoires pour la facture récurrente
Invoice Period To,Période facture Pour
Invoice Type,Type de facture
Invoice/Journal Voucher Details,Facture / Journal Chèques Détails
Invoiced Amount (Exculsive Tax),Montant facturé ( impôt Exculsive )
Is Active,Est active
Is Advance,Est-Advance
Is Cancelled,Est annulée
Is Carry Forward,Est-Report
Is Default,Est défaut
Is Encash,Est encaisser
Is Fixed Asset Item,Est- Fixed Asset article
Is LWP,Est-LWP
Is Opening,Est l&#39;ouverture
Is Opening Entry,Est l&#39;ouverture d&#39;entrée
Is POS,Est-POS
Is Primary Contact,Est-ressource principale
Is Purchase Item,Est-Item
Is Sales Item,Est-Point de vente
Is Service Item,Est-Point de service
Is Stock Item,Est Produit en stock
Is Sub Contracted Item,Est-Sub article à contrat
Is Subcontracted,Est en sous-traitance
Is this Tax included in Basic Rate?,Est-ce Taxes incluses dans le taux de base?
Issue,Question
Issue Date,Date d&#39;émission
Issue Details,Détails de la demande
Issued Items Against Production Order,Articles émis contre un ordre de fabrication
It can also be used to create opening stock entries and to fix stock value.,Il peut également être utilisé pour créer les entrées en stocks d'ouverture et de fixer la valeur des actions .
Item,article
Item Advanced,Article avancée
Item Barcode,Barcode article
Item Batch Nos,Nos lots d&#39;articles
Item Code,Code de l&#39;article
Item Code > Item Group > Brand,Code de l'article> Le groupe d'articles> Marque
Item Code and Warehouse should already exist.,Code article et entrepôt doivent déjà exister.
Item Code cannot be changed for Serial No.,Code article ne peut pas être modifié pour le numéro de série
Item Code is mandatory because Item is not automatically numbered,"Code de l'article est obligatoire, car l'article n'est pas numéroté automatiquement"
Item Code required at Row No {0},Aucun résultat
Item Customer Detail,Détail d&#39;article
Item Description,Description de l&#39;objet
Item Desription,Desription article
Item Details,Détails d&#39;article
Item Group,Groupe d&#39;éléments
Item Group Name,Nom du groupe d&#39;article
Item Group Tree,Point arborescence de groupe
Item Group not mentioned in item master for item {0},Le groupe d'articles ne sont pas mentionnés dans le maître de l'article pour l'article {0}
Item Groups in Details,Groupes d&#39;articles en détails
Item Image (if not slideshow),Image Article (si ce n&#39;est diaporama)
Item Name,Nom d&#39;article
Item Naming By,Point de noms en
Item Price,Prix ​​de l&#39;article
Item Prices,Prix ​​du lot
Item Quality Inspection Parameter,Paramètre d&#39;inspection Article de qualité
Item Reorder,Réorganiser article
Item Serial No,Point No de série
Item Serial Nos,Point n ° de série
Item Shortage Report,Point Pénurie rapport
Item Supplier,Fournisseur d&#39;article
Item Supplier Details,Détails de produit Point
Item Tax,Point d&#39;impôt
Item Tax Amount,Taxes article
Item Tax Rate,Taux d&#39;imposition article
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,avant-première
Item Tax1,Article impôts1
Item To Manufacture,Point à la fabrication de
Item UOM,Article Emballage
Item Website Specification,Spécification Site élément
Item Website Specifications,Spécifications Site du lot
Item Wise Tax Detail,Liste des Prix doit être applicable pour l'achat ou la vente d'
Item Wise Tax Detail ,Détail de l&#39;article de la taxe Wise
Item is required,Point n'est nécessaire
Item is updated,S'il vous plaît entrez prévue Quantité pour l'article {0} à la ligne {1}
Item master.,Maître d'objet .
"Item must be a purchase item, as it is present in one or many Active BOMs","L'article doit être un élément de l'achat , car il est présent dans un ou plusieurs nomenclatures actifs"
Item or Warehouse for row {0} does not match Material Request,Une autre entrée de clôture de la période {0} a été faite après {1}
Item table can not be blank,Tableau de l'article ne peut pas être vide
Item to be manufactured or repacked,Ce point doit être manufacturés ou reconditionnés
Item valuation updated,Utilisation des fonds ( actif)
Item will be saved by this name in the data base.,L&#39;article sera sauvé par ce nom dans la base de données.
Item {0} appears multiple times in Price List {1},S'il vous plaît indiquer Devise par défaut en maître de compagnie et par défaut mondiaux
Item {0} does not exist,Point {0} n'existe pas
Item {0} does not exist in the system or has expired,Point {0} n'existe pas dans le système ou a expiré
Item {0} does not exist in {1} {2},Applicable à partir du
Item {0} has already been returned,Nouveau Stock UDM doit être différent de stock actuel Emballage
Item {0} has been entered multiple times against same operation,Barcode {0} déjà utilisé dans l'article {1}
Item {0} has been entered multiple times with same description or date,Si vous impliquer dans l'activité manufacturière . Permet Point ' est fabriqué '
Item {0} has been entered multiple times with same description or date or warehouse,Nbre maxi
Item {0} has been entered twice,Point {0} doit être vente ou de service Point de {1}
Item {0} has reached its end of life on {1},dépenses
Item {0} ignored since it is not a stock item,S'il vous plaît mentionner pas de visites requises
Item {0} is cancelled,Nom de la campagne est nécessaire
Item {0} is not Purchase Item,Point {0} n'est pas acheter l'article
Item {0} is not a serialized Item,"Société Email ID introuvable , donc postez pas envoyé"
Item {0} is not a stock Item,Point {0} n'est pas un stock Article
Item {0} is not active or end of life has been reached,« À jour» est nécessaire
Item {0} is not setup for Serial Nos. Check Item master,Point {0} n'est pas configuré pour maître numéros de série Check Point
Item {0} is not setup for Serial Nos. Column must be blank,Point {0} n'est pas configuré pour Serial colonne n ° doit être vide
Item {0} must be Sales Item,Point {0} doit être objet de vente
Item {0} must be Sales or Service Item in {1},Ajouter au panier
Item {0} must be Service Item,Réglages pour le Module des ressources humaines
Item {0} must be a Purchase Item,Parent Site Route
Item {0} must be a Sales Item,Point {0} doit être un élément de ventes
Item {0} must be a Service Item.,Point {0} doit être un service Point .
Item {0} must be a Sub-contracted Item,Exercice Date de début
Item {0} must be a stock Item,Point {0} doit être un stock Article
Item {0} must be manufactured or sub-contracted,Point {0} doit être fabriqué ou sous-traité
Item {0} not found,Point {0} introuvable
Item {0} with Serial No {1} is already installed,Projets Système
Item {0} with same description entered twice,Centre de coûts est obligatoire pour objet {0}
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Item, Garantie, AMC (contrat d&#39;entretien annuel) détails seront automatiquement récupérées lorsque le numéro de série est sélectionnée."
Item-wise Price List Rate,Article sage Prix Tarif
Item-wise Purchase History,Historique des achats point-sage
Item-wise Purchase Register,S&#39;enregistrer Achat point-sage
Item-wise Sales History,Point-sage Historique des ventes
Item-wise Sales Register,Ventes point-sage S&#39;enregistrer
"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Article: {0} discontinu géré, ne peut être conciliée à l'aide \
 Stock réconciliation, au lieu d'utiliser Stock entrée"
Item: {0} not found in the system,Article : {0} introuvable dans le système
Items,Articles
Items To Be Requested,Articles à demander
Items required,produits
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty","Articles à être demandés, qui sont &quot;Out of Stock&quot; compte tenu de tous les entrepôts basés sur quantité projetée et qté minimum"
Items which do not exist in Item master can also be entered on customer's request,Les éléments qui n&#39;existent pas dans la maîtrise d&#39;article peut également être inscrits sur la demande du client
Itemwise Discount,Remise Itemwise
Itemwise Recommended Reorder Level,Itemwise recommandée SEUIL DE COMMANDE
Job Applicant,Demandeur d&#39;emploi
Job Opening,Offre d&#39;emploi
Job Profile,Droits et taxes
Job Title,Titre d&#39;emploi
"Job profile, qualifications required etc.",Non authroized depuis {0} dépasse les limites
Jobs Email Settings,Paramètres de messagerie Emploi
Journal Entries,Journal Entries
Journal Entry,Journal Entry
Journal Voucher,Bon Journal
Journal Voucher Detail,Détail pièce de journal
Journal Voucher Detail No,Détail Bon Journal No
Journal Voucher {0} does not have account {1} or already matched,Journal Bon {0} n'a pas encore compte {1} ou déjà identifié
Journal Vouchers {0} are un-linked,Date de livraison prévue ne peut pas être avant ventes Date de commande
Keep a track of communication related to this enquiry which will help for future reference.,Gardez une trace de la communication liée à cette enquête qui aidera pour référence future.
Keep it web friendly 900px (w) by 100px (h),Gardez web 900px amical ( w) par 100px ( h )
Key Performance Area,Zone de performance clé
Key Responsibility Area,Secteur de responsabilité clé
Kg,kg
LR Date,LR Date
LR No,LR Non
Label,Étiquette
Landed Cost Item,Article coût en magasin
Landed Cost Items,Articles prix au débarquement
Landed Cost Purchase Receipt,Landed Cost reçu d&#39;achat
Landed Cost Purchase Receipts,Landed Cost reçus d&#39;achat
Landed Cost Wizard,Assistant coût en magasin
Landed Cost updated successfully,Entrepôt réservés nécessaire pour stock Article {0} à la ligne {1}
Language,Langue
Last Name,Nom de famille
Last Purchase Rate,Purchase Rate Dernière
Latest,dernier
Lead,Conduire
Lead Details,Le plomb Détails
Lead Id,Id plomb
Lead Name,Nom du chef de
Lead Owner,Conduire du propriétaire
Lead Source,Source plomb
Lead Status,Lead Etat
Lead Time Date,Plomb Date Heure
Lead Time Days,Diriger jours Temps
Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,Diriger jours Temps est le nombre de jours dont cet article est prévu dans votre entrepôt. Ces jours sont récupérées dans la Demande de Matériel quand vous sélectionnez cette option.
Lead Type,Type de câbles
Lead must be set if Opportunity is made from Lead,Chef de file doit être réglée si l'occasion est composé de plomb
Leave Allocation,Laisser Allocation
Leave Allocation Tool,Laisser outil de répartition
Leave Application,Demande de congés
Leave Approver,Laisser approbateur
Leave Approvers,Laisser approbateurs
Leave Balance Before Application,Laisser Solde Avant d&#39;application
Leave Block List,Laisser Block List
Leave Block List Allow,Laisser Block List Autoriser
Leave Block List Allowed,Laisser Block List admis
Leave Block List Date,Laisser Date de Block List
Leave Block List Dates,Laisser Dates de listes rouges d&#39;
Leave Block List Name,Laisser Nom de la liste de blocage
Leave Blocked,Laisser Bloqué
Leave Control Panel,Laisser le Panneau de configuration
Leave Encashed?,Laisser encaissés?
Leave Encashment Amount,Laisser Montant Encaissement
Leave Type,Laisser Type d&#39;
Leave Type Name,Laisser Nom Type
Leave Without Pay,Congé sans solde
Leave application has been approved.,Demande d'autorisation a été approuvé .
Leave application has been rejected.,Demande d'autorisation a été rejetée .
Leave approver must be one of {0},Abréviation ne peut pas avoir plus de 5 caractères
Leave blank if considered for all branches,Laisser vide si cela est jugé pour toutes les branches
Leave blank if considered for all departments,Laisser vide si cela est jugé pour tous les ministères
Leave blank if considered for all designations,Laisser vide si cela est jugé pour toutes les désignations
Leave blank if considered for all employee types,Laisser vide si cela est jugé pour tous les types d&#39;employés
"Leave can be approved by users with Role, ""Leave Approver""",Le congé peut être approuvées par les utilisateurs avec le rôle «Laissez approbateur&quot;
Leave of type {0} cannot be longer than {1},Les entrées en stocks existent contre entrepôt {0} ne peut pas réaffecter ou modifier Maître Nom '
Leaves Allocated Successfully for {0},Forums
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Vous ne pouvez pas produire plus d'article {0} que la quantité de commande client {1}
Leaves must be allocated in multiples of 0.5,"Les feuilles doivent être alloués par multiples de 0,5"
Ledger,Grand livre
Ledgers,livres
Left,Gauche
Legal,juridique
Legal Expenses,Actifs stock
Letter Head,A en-tête
Letter Heads for print templates.,Journal Bon {0} n'a pas encore compte {1} .
Level,Niveau
Lft,Lft
Liability,responsabilité
List a few of your customers. They could be organizations or individuals.,Énumérer quelques-unes de vos clients . Ils pourraient être des organisations ou des individus .
List a few of your suppliers. They could be organizations or individuals.,Énumérer quelques-unes de vos fournisseurs . Ils pourraient être des organisations ou des individus .
List items that form the package.,Liste des articles qui composent le paquet.
List this Item in multiple groups on the website.,Liste cet article dans plusieurs groupes sur le site.
"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.",Référencez vos produits ou services que vous achetez ou vendez.
"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.","Inscrivez vos têtes d'impôt (par exemple, la TVA , accises , ils doivent avoir des noms uniques ) et leur taux standard."
Loading...,Chargement en cours ...
Loans (Liabilities),Prêts ( passif)
Loans and Advances (Assets),Prêts et avances ( actif)
Local,arrondis
Login,Connexion
Login with your new User ID,Connectez-vous avec votre nouveau nom d'utilisateur
Logo,Logo
Logo and Letter Heads,Logo et lettres chefs
Lost,perdu
Lost Reason,Raison perdu
Low,Bas
Lower Income,Basse revenu
MTN Details,Détails MTN
Main,Nombre de points pour tous les objectifs devraient être 100 . C'est {0}
Main Reports,Rapports principaux
Maintain Same Rate Throughout Sales Cycle,Maintenir même taux long cycle de vente
Maintain same rate throughout purchase cycle,Maintenir le taux de même tout au long du cycle d&#39;achat
Maintenance,Entretien
Maintenance Date,Date de l&#39;entretien
Maintenance Details,Détails de maintenance
Maintenance Schedule,Calendrier d&#39;entretien
Maintenance Schedule Detail,Détail calendrier d&#39;entretien
Maintenance Schedule Item,Article calendrier d&#39;entretien
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Sélectionnez à télécharger:
Maintenance Schedule {0} exists against {0},Champ {0} n'est pas sélectionnable.
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programme de maintenance {0} doit être annulée avant d'annuler cette commande client
Maintenance Schedules,Programmes d&#39;entretien
Maintenance Status,Statut d&#39;entretien
Maintenance Time,Temps de maintenance
Maintenance Type,Type d&#39;entretien
Maintenance Visit,Visite de maintenance
Maintenance Visit Purpose,But Visite d&#39;entretien
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Doublons {0} avec la même {1}
Maintenance start date can not be before delivery date for Serial No {0},Entretien date de début ne peut pas être avant la date de livraison pour série n ° {0}
Major/Optional Subjects,Sujets principaux / en option
Make ,
Make Accounting Entry For Every Stock Movement,Faites Entrée Comptabilité Pour chaque mouvement Stock
Make Bank Voucher,Assurez-Bon Banque
Make Credit Note,Assurez Note de crédit
Make Debit Note,Assurez- notes de débit
Make Delivery,Assurez- livraison
Make Difference Entry,Assurez Entrée Différence
Make Excise Invoice,Faire accise facture
Make Installation Note,Faire Installation Remarque
Make Invoice,Assurez- facture
Make Maint. Schedule,Assurez- Maint . calendrier
Make Maint. Visit,Assurez- Maint . Visiter
Make Maintenance Visit,Assurez visite d'entretien
Make Packing Slip,Faites le bordereau d'
Make Payment,Effectuer un paiement
Make Payment Entry,Effectuer un paiement d'entrée
Make Purchase Invoice,Faire la facture d'achat
Make Purchase Order,Faites bon de commande
Make Purchase Receipt,Assurez- ticket de caisse
Make Salary Slip,Faire fiche de salaire
Make Salary Structure,Faire structure salariale
Make Sales Invoice,Faire la facture de vente
Make Sales Order,Assurez- Commande
Make Supplier Quotation,Faire Fournisseur offre
Make Time Log Batch,Prenez le temps Connexion lot
Male,Masculin
Manage Customer Group Tree.,Gérer l'arborescence de groupe de clients .
Manage Sales Partners.,Gérer partenaires commerciaux.
Manage Sales Person Tree.,Gérer les ventes personne Arbre .
Manage Territory Tree.,"Un élément existe avec le même nom ( {0} ) , s'il vous plaît changer le nom du groupe de l'article ou renommer l'élément"
Manage cost of operations,Gérer les coûts d&#39;exploitation
Management,gestion
Manager,directeur
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",Obligatoire si le stock L&#39;article est &quot;Oui&quot;. Aussi l&#39;entrepôt par défaut où quantité réservée est fixé à partir de la commande client.
Manufacture against Sales Order,Fabrication à l&#39;encontre des commandes clients
Manufacture/Repack,Fabrication / Repack
Manufactured Qty,Quantité fabriquée
Manufactured quantity will be updated in this warehouse,Quantité fabriquée sera mis à jour dans cet entrepôt
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Quantité fabriquée {0} ne peut pas être supérieure à quanitity prévu {1} dans un ordre de fabrication {2}
Manufacturer,Fabricant
Manufacturer Part Number,Numéro de pièce du fabricant
Manufacturing,Fabrication
Manufacturing Quantity,Quantité de fabrication
Manufacturing Quantity is mandatory,Fabrication Quantité est obligatoire
Margin,Marge
Marital Status,État civil
Market Segment,Segment de marché
Marketing,commercialisation
Marketing Expenses,Dépenses de marketing
Married,Marié
Mass Mailing,Mailing de masse
Master Name,Nom de Maître
Master Name is mandatory if account type is Warehouse,Nom du Master est obligatoire si le type de compte est Entrepôt
Master Type,Type de Maître
Masters,Maîtres
Match non-linked Invoices and Payments.,Correspondre non liées factures et paiements.
Material Issue,Material Issue
Material Receipt,Réception matériau
Material Request,Demande de matériel
Material Request Detail No,Détail Demande Support Aucun
Material Request For Warehouse,Demande de matériel pour l&#39;entrepôt
Material Request Item,Article demande de matériel
Material Request Items,Articles Demande de matériel
Material Request No,Demande de Support Aucun
Material Request Type,Type de demande de matériel
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 objet {1} contre Commande {2}
Material Request used to make this Stock Entry,Demande de Matériel utilisé pour réaliser cette Stock Entrée
Material Request {0} is cancelled or stopped,Demande de Matériel {0} est annulé ou arrêté
Material Requests for which Supplier Quotations are not created,Les demandes significatives dont les cotes des fournisseurs ne sont pas créés
Material Requests {0} created,Devis {0} de type {1}
Material Requirement,Material Requirement
Material Transfer,De transfert de matériel
Materials,Matériels
Materials Required (Exploded),Matériel nécessaire (éclatée)
Max 5 characters,5 caractères maximum
Max Days Leave Allowed,Laisser jours Max admis
Max Discount (%),Max Réduction (%)
Max Qty,Vous ne pouvez pas Désactiver ou cancle BOM car elle est liée à d'autres nomenclatures
Max discount allowed for item: {0} is {1}%,Réduction de Max permis pour l'article: {0} {1} est%
Maximum Amount,Montant maximal
Maximum allowed credit is {0} days after posting date,Crédit maximum autorisé est de {0} jours après la date de report
Maximum {0} rows allowed,"Afficher / Masquer les caractéristiques de série comme nos , POS , etc"
Maxiumm discount for Item {0} is {1}%,Remise Maxiumm pour objet {0} {1} est %
Medical,Numéro de référence est obligatoire si vous avez entré date de référence
Medium,Moyen
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",La fusion n'est possible que si les propriétés suivantes sont les mêmes dans les deux registres .
Message,Message
Message Parameter,Paramètre message
Message Sent,Message envoyé
Message updated,un message de mise à jour
Messages,Messages
Messages greater than 160 characters will be split into multiple messages,Un message de plus de 160 caractères sera découpé en plusieurs mesage
Middle Income,Revenu intermédiaire
Milestone,Étape importante
Milestone Date,Date de Milestone
Milestones,Jalons
Milestones will be added as Events in the Calendar,Jalons seront ajoutées au fur événements dans le calendrier
Min Order Qty,Quantité de commande minimale
Min Qty,Compte {0} est gelé
Min Qty can not be greater than Max Qty,Quantité de minute ne peut être supérieure à Max Quantité
Minimum Amount,Montant minimum
Minimum Order Qty,Quantité de commande minimum
Minute,Le salaire net ne peut pas être négatif
Misc Details,Détails Divers
Miscellaneous Expenses,Nombre de mots
Miscelleneous,Miscelleneous
Mobile No,Aucun mobile
Mobile No.,Mobile n °
Mode of Payment,Mode de paiement
Modern,Moderne
Monday,Lundi
Month,Mois
Monthly,Mensuel
Monthly Attendance Sheet,Feuille de présence mensuel
Monthly Earning & Deduction,Revenu mensuel &amp; Déduction
Monthly Salary Register,S&#39;enregistrer Salaire mensuel
Monthly salary statement.,Fiche de salaire mensuel.
More Details,Plus de détails
More Info,Plus d&#39;infos
Motion Picture & Video,Motion Picture & Video
Moving Average,Moyenne mobile
Moving Average Rate,Moving Prix moyen
Mr,M.
Ms,Mme
Multiple Item prices.,Prix ​​des ouvrages multiples.
"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Multiple règle de prix existe avec les mêmes critères, s'il vous plaît résoudre \
 conflit en attribuant des priorités. Règles de prix: {0}"
Music,musique
Must be Whole Number,Doit être un nombre entier
Name,Nom
Name and Description,Nom et description
Name and Employee ID,Nom et ID employé
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Nom du nouveau compte . Note: S'il vous plaît ne créez pas de comptes pour les clients et les fournisseurs , ils sont créés automatiquement à partir du client et maître du fournisseur"
Name of person or organization that this address belongs to.,Nom de la personne ou de l&#39;organisation que cette adresse appartient.
Name of the Budget Distribution,Nom de la Répartition du budget
Naming Series,Nommer Série
Negative Quantity is not allowed,Quantité négatif n'est pas autorisé
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Facture de vente {0} doit être annulée avant d'annuler cette commande client
Negative Valuation Rate is not allowed,Négatif évaluation Taux n'est pas autorisé
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Coût Nom Centre existe déjà
Net Pay,Salaire net
Net Pay (in words) will be visible once you save the Salary Slip.,Salaire net (en lettres) sera visible une fois que vous enregistrez le bulletin de salaire.
Net Profit / Loss,Bénéfice net / perte nette
Net Total,Total net
Net Total (Company Currency),Total net (Société Monnaie)
Net Weight,Poids net
Net Weight UOM,Emballage Poids Net
Net Weight of each Item,Poids net de chaque article
Net pay cannot be negative,Landed Cost correctement mis à jour
Never,Jamais
New ,
New Account,nouveau compte
New Account Name,Nouveau compte Nom
New BOM,Nouvelle nomenclature
New Communications,Communications Nouveau-
New Company,nouvelle entreprise
New Cost Center,Nouveau centre de coût
New Cost Center Name,Nouveau centre de coûts Nom
New Delivery Notes,Nouveaux bons de livraison
New Enquiries,New Renseignements
New Leads,New Leads
New Leave Application,Nouvelle demande d&#39;autorisation
New Leaves Allocated,Nouvelle Feuilles alloué
New Leaves Allocated (In Days),Feuilles de nouveaux alloués (en jours)
New Material Requests,Demandes des matériaux nouveaux
New Projects,Nouveaux projets
New Purchase Orders,De nouvelles commandes
New Purchase Receipts,Reçus d&#39;achat de nouveaux
New Quotations,Citations de nouvelles
New Sales Orders,Nouvelles commandes clients
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,S'il vous plaît créer clientèle de plomb {0}
New Stock Entries,Entrées Stock nouvelles
New Stock UOM,Bourse de New UDM
New Stock UOM is required,{0} {1} a déjà été soumis
New Stock UOM must be different from current stock UOM,S'il vous plaît entrer nos mobiles valides
New Supplier Quotations,Citations Fournisseur de nouveaux
New Support Tickets,Support Tickets nouvelles
New UOM must NOT be of type Whole Number,Nouveau UDM doit pas être de type entier Nombre
New Workplace,Travail du Nouveau-
Newsletter,Bulletin
Newsletter Content,Newsletter Content
Newsletter Status,Statut newsletter
Newsletter has already been sent,Entrepôt requis pour stock Article {0}
"Newsletters to contacts, leads.","Bulletins aux contacts, prospects."
Newspaper Publishers,Éditeurs de journaux
Next,Nombre purchse de commande requis pour objet {0}
Next Contact By,Suivant Par
Next Contact Date,Date Contact Suivant
Next Date,Date d&#39;
Next email will be sent on:,Email sera envoyé le:
No,Aucun
No Customer Accounts found.,Aucun client ne représente trouvés.
No Customer or Supplier Accounts found,Encaisse
No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Compte {0} est inactif
No Item with Barcode {0},Bon de commande {0} ' arrêté '
No Item with Serial No {0},non autorisé
No Items to pack,Pas d'éléments pour emballer
No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Pas approbateurs congé. S'il vous plaît attribuer le rôle « congé approbateur » à atleast un utilisateur
No Permission,Aucune autorisation
No Production Orders created,Section de base
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Aucun fournisseur ne représente trouvés. Comptes fournisseurs sont identifiés sur la base de la valeur «Maître Type ' dans le compte rendu.
No accounting entries for the following warehouses,Pas d'entrées comptables pour les entrepôts suivants
No addresses created,Aucune adresse créés
No contacts created,Pas de contacts créés
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Aucune valeur par défaut Adresse modèle trouvé. S'il vous plaît créer un nouveau à partir de Configuration> Presse et Branding> Adresse modèle.
No default BOM exists for Item {0},services impressionnants
No description given,Le jour (s ) sur lequel vous postulez pour congé sont les vacances . Vous n'avez pas besoin de demander l'autorisation .
No employee found,Aucun employé
No employee found!,Aucun employé !
No of Requested SMS,Pas de SMS demandés
No of Sent SMS,Pas de SMS envoyés
No of Visits,Pas de visites
No permission,État d'approbation doit être « approuvé » ou « Rejeté »
No record found,Aucun enregistrement trouvé
No records found in the Invoice table,Aucun documents trouvés dans le tableau de la facture
No records found in the Payment table,Aucun documents trouvés dans le tableau de paiement
No salary slip found for month: ,Pas de bulletin de salaire trouvé en un mois:
Non Profit,À but non lucratif
Nos,Transaction non autorisée contre arrêté l'ordre de fabrication {0}
Not Active,Non actif
Not Applicable,Non applicable
Not Available,Indisponible
Not Billed,Non Facturé
Not Delivered,Non Livré
Not Set,non définie
Not allowed to update stock transactions older than {0},Non autorisé à mettre à jour les transactions boursières de plus que {0}
Not authorized to edit frozen Account {0},Message totale (s )
Not authroized since {0} exceeds limits,{0} {1} a été modifié . S'il vous plaît Actualiser
Not permitted,Sélectionnez à télécharger:
Note,Remarque
Note User,Remarque utilisateur
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Remarque: Les sauvegardes et les fichiers ne sont pas effacés de Dropbox, vous devrez supprimer manuellement."
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Remarque: Les sauvegardes et les fichiers ne sont pas supprimés de Google Drive, vous devrez supprimer manuellement."
Note: Due Date exceeds the allowed credit days by {0} day(s),Batch Log Time {0} doit être « déposés »
Note: Email will not be sent to disabled users,Remarque: E-mail ne sera pas envoyé aux utilisateurs handicapés
Note: Item {0} entered multiple times,Stock ne peut pas être mis à jour contre livraison Remarque {0}
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Casual congé
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érifie pas sur - livraison et la sur- réservation pour objet {0} que la quantité ou le montant est égal à 0
Note: There is not enough leave balance for Leave Type {0},S'il vous plaît spécifier un ID de ligne valide pour {0} en ligne {1}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Prix ​​règle pour l'escompte
Note: {0},Compte avec des nœuds enfants ne peut pas être converti en livre
Notes,Remarques
Notes:,notes:
Nothing to request,Rien à demander
Notice (days),Avis ( jours )
Notification Control,Contrôle de notification
Notification Email Address,Adresse e-mail de notification
Notify by Email on creation of automatic Material Request,Notification par courriel lors de la création de la demande de matériel automatique
Number Format,Format numérique
Offer Date,offre date
Office,Fonction
Office Equipments,Équipement de bureau
Office Maintenance Expenses,Date d'adhésion doit être supérieure à Date de naissance
Office Rent,POS Global Setting {0} déjà créé pour la compagnie {1}
Old Parent,Parent Vieux
On Net Total,Le total net
On Previous Row Amount,Le montant rangée précédente
On Previous Row Total,Le total de la rangée précédente
Online Auctions,Enchères en ligne
Only Leave Applications with status 'Approved' can be submitted,Date de livraison prévue ne peut pas être avant commande date
"Only Serial Nos with status ""Available"" can be delivered.","Seulement série n ° avec le statut "" disponible "" peut être livré ."
Only leaf nodes are allowed in transaction,Seuls les noeuds feuilles sont autorisées dans une transaction
Only the selected Leave Approver can submit this Leave Application,Seul le congé approbateur sélectionné peut soumettre cette demande de congé
Open,Ouvert
Open Production Orders,Commandes ouverte de production
Open Tickets,Open Billets
Opening (Cr),Ouverture ( Cr )
Opening (Dr),{0} doit être inférieur ou égal à {1}
Opening Date,Date d&#39;ouverture
Opening Entry,Entrée ouverture
Opening Qty,Quantité d'ouverture
Opening Time,Ouverture Heure
Opening Value,Valeur d'ouverture
Opening for a Job.,Ouverture d&#39;un emploi.
Operating Cost,Coût d&#39;exploitation
Operation Description,Description de l&#39;opération
Operation No,Opération No
Operation Time (mins),Temps de fonctionnement (min)
Operation {0} is repeated in Operations Table,S'il vous plaît sélectionner préfixe premier
Operation {0} not present in Operations Table,Opération {0} ne présente dans le tableau des opérations
Operations,Opérations
Opportunity,Occasion
Opportunity Date,Date de possibilité
Opportunity From,De opportunité
Opportunity Item,Article occasion
Opportunity Items,Articles Opportunité
Opportunity Lost,Une occasion manquée
Opportunity Type,Type d&#39;opportunité
Optional. This setting will be used to filter in various transactions.,Facultatif. Ce paramètre sera utilisé pour filtrer dans diverses opérations .
Order Type,Type d&#39;ordre
Order Type must be one of {0},type d'ordre doit être l'un des {0}
Ordered,ordonné
Ordered Items To Be Billed,Articles commandés à facturer
Ordered Items To Be Delivered,Articles commandés à livrer
Ordered Qty,commandé Quantité
"Ordered Qty: Quantity ordered for purchase, but not received.","Commandé Quantité: Quantité de commande pour l'achat , mais pas reçu ."
Ordered Quantity,Quantité commandée
Orders released for production.,Commandes validé pour la production.
Organization Name,Nom de l'organisme
Organization Profile,Maître de l'employé .
Organization branch master.,Point impôt Row {0} doit avoir un compte de type de l'impôt sur le revenu ou de dépenses ou ou taxé
Organization unit (department) master.,Unité d'organisation (département) maître .
Other,Autre
Other Details,Autres détails
Others,autres
Out Qty,out Quantité
Out Value,Dehors Valeur
Out of AMC,Sur AMC
Out of Warranty,Hors garantie
Outgoing,Sortant
Outstanding Amount,Encours
Outstanding for {0} cannot be less than zero ({1}),Participation pour les employés {0} est déjà marqué
Overhead,Au-dessus
Overheads,Les frais généraux
Overlapping conditions found between:,S'il vous plaît entrez l'adresse e-mail
Overview,vue d'ensemble
Owned,Détenue
Owner,propriétaire
P L A - Cess Portion,PLA - Cess Portion
PL or BS,PL ou BS
PO Date,date de PO
PO No,PO Non
POP3 Mail Server,Serveur de messagerie POP3
POP3 Mail Settings,Paramètres de messagerie POP3
POP3 mail server (e.g. pop.gmail.com),POP3 serveur de messagerie (par exemple pop.gmail.com)
POP3 server e.g. (pop.gmail.com),Serveur POP3 par exemple (pop.gmail.com)
POS Setting,Réglage POS
POS Setting required to make POS Entry,POS Réglage nécessaire pour faire POS Entrée
POS Setting {0} already created for user: {1} and company {2},Point {0} a été saisi deux fois
POS View,POS View
PR Detail,Détail PR
Package Item Details,Détails d&#39;article de l&#39;emballage
Package Items,Articles paquet
Package Weight Details,Détails Poids de l&#39;emballage
Packed Item,Article d&#39;emballage de livraison Note
Packed quantity must equal quantity for Item {0} in row {1},Emballé quantité doit être égale à la quantité pour l'article {0} à la ligne {1}
Packing Details,Détails d&#39;emballage
Packing List,Packing List
Packing Slip,Bordereau
Packing Slip Item,Emballage article Slip
Packing Slip Items,Emballage Articles Slip
Packing Slip(s) cancelled,Point {0} doit être un élément de sous- traitance
Page Break,Saut de page
Page Name,Nom de la page
Paid Amount,Montant payé
Paid amount + Write Off Amount can not be greater than Grand Total,Comptes provisoires ( passif)
Pair,Assistant de configuration
Parameter,Paramètre
Parent Account,Compte Parent
Parent Cost Center,Centre de coûts Parent
Parent Customer Group,Groupe Client parent
Parent Detail docname,DocName Détail Parent
Parent Item,Article Parent
Parent Item Group,Groupe d&#39;éléments Parent
Parent Item {0} must be not Stock Item and must be a Sales Item,Vous ne pouvez pas ouvrir par exemple lorsque son {0} est ouvert
Parent Party Type,S'il vous plaît entrez groupe compte parent pour le compte d'entrepôt
Parent Sales Person,Parent Sales Person
Parent Territory,Territoire Parent
Parent Website Page,«Sur la base » et « Regrouper par » ne peut pas être la même
Parent Website Route,Montant de l'impôt après réduction Montant
Parenttype,ParentType
Part-time,À temps partiel
Partially Completed,Partiellement réalisé
Partly Billed,Présentée en partie
Partly Delivered,Livré en partie
Partner Target Detail,Détail Cible partenaire
Partner Type,Type de partenaire
Partner's Website,Le site web du partenaire
Party,Intervenants
Party Account,Compte Parti
Party Type,Type de partie
Party Type Name,This Time Connexion conflit avec {0}
Passive,Passif
Passport Number,Numéro de passeport
Password,Mot de passe
Pay To / Recd From,Pay To / RECD De
Payable,Impôt sur le revenu
Payables,Dettes
Payables Group,Groupe Dettes
Payment Days,Jours de paiement
Payment Due Date,Date d'échéance
Payment Period Based On Invoice Date,Période de paiement basé sur Date de la facture
Payment Reconciliation,Rapprochement des paiements
Payment Reconciliation Invoice,Rapprochement des paiements de facture
Payment Reconciliation Invoices,Les factures de réconciliation de paiement
Payment Reconciliation Payment,Rapprochement des paiements Paiement
Payment Reconciliation Payments,Paiements de réconciliation de paiement
Payment Type,Type de paiement
Payment cannot be made for empty cart,Le paiement ne peut être fait pour le chariot vide
Payment of salary for the month {0} and year {1},Centre de coûts est nécessaire à la ligne {0} dans le tableau des impôts pour le type {1}
Payments,Paiements
Payments Made,Paiements effectués
Payments Received,Paiements reçus
Payments made during the digest period,Les paiements effectués au cours de la période digest
Payments received during the digest period,Les paiements reçus au cours de la période digest
Payroll Settings,Paramètres de la paie
Pending,En attendant
Pending Amount,Montant attente
Pending Items {0} updated,Machines et installations
Pending Review,Attente d&#39;examen
Pending SO Items For Purchase Request,"Articles en attente Donc, pour demande d&#39;achat"
Pension Funds,Les fonds de pension
Percent Complete,Pour cent complet
Percentage Allocation,Répartition en pourcentage
Percentage Allocation should be equal to 100%,Pourcentage allocation doit être égale à 100 %
Percentage variation in quantity to be allowed while receiving or delivering this item.,Pourcentage de variation de la quantité à être autorisé lors de la réception ou la livraison de cet article.
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 de livrer plus sur la quantité commandée. Par exemple: Si vous avez commandé 100 unités. et votre allocation est de 10% alors que vous êtes autorisé à recevoir 110 unités.
Performance appraisal.,L&#39;évaluation des performances.
Period,période
Period Closing Voucher,Bon clôture de la période
Periodicity,Périodicité
Permanent Address,Adresse permanente
Permanent Address Is,Adresse permanente est
Permission,Permission
Personal,Personnel
Personal Details,Données personnelles
Personal Email,Courriel personnel
Pharmaceutical,pharmaceutique
Pharmaceuticals,médicaments
Phone,Téléphone
Phone No,N ° de téléphone
Piecework,travail à la pièce
Pincode,Le code PIN
Place of Issue,Lieu d&#39;émission
Plan for maintenance visits.,Plan pour les visites de maintenance.
Planned Qty,Quantité planifiée
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Prévue Quantité: Quantité , pour qui , un ordre de fabrication a été soulevée , mais est en attente d' être fabriqué ."
Planned Quantity,Quantité planifiée
Planning,planification
Plant,Plante
Plant and Machinery,Facture d'achat {0} est déjà soumis
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,S&#39;il vous plaît Entrez Abréviation ou nom court correctement car il sera ajouté comme suffixe à tous les chefs de compte.
Please Update SMS Settings,S'il vous plaît Mettre à jour les paramètres de SMS
Please add expense voucher details,Attachez votre image
Please add to Modes of Payment from Setup.,S'il vous plaît ajoutez à Modes de paiement de configuration.
Please check 'Is Advance' against Account {0} if this is an advance entry.,Exercice / comptabilité .
Please click on 'Generate Schedule',"S'il vous plaît cliquer sur "" Générer annexe '"
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},"S'il vous plaît cliquer sur "" Générer annexe ' pour aller chercher de série n ° ajouté pour objet {0}"
Please click on 'Generate Schedule' to get schedule,"S'il vous plaît cliquer sur "" Générer annexe » pour obtenir le calendrier"
Please create Customer from Lead {0},Prix ​​/ Rabais
Please create Salary Structure for employee {0},« Date de début prévue » ne peut être supérieur à ' Date de fin prévue '
Please create new account from Chart of Accounts.,S'il vous plaît créer un nouveau compte de plan comptable .
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,S'il vous plaît ne créez pas de compte ( grands livres ) pour les clients et les fournisseurs . Ils sont créés directement par les maîtres clients / fournisseurs .
Please enter 'Expected Delivery Date',S'il vous plaît entrer « Date de livraison prévue '
Please enter 'Is Subcontracted' as Yes or No,{0} {1} contre facture {1}
Please enter 'Repeat on Day of Month' field value,1 devise = [ ? ] Fraction
Please enter Account Receivable/Payable group in company master,Les paramètres par défaut pour l'achat des transactions .
Please enter Approving Role or Approving User,S'il vous plaît entrer approuver ou approuver Rôle utilisateur
Please enter BOM for Item {0} at row {1},S'il vous plaît entrer nomenclature pour objet {0} à la ligne {1}
Please enter Company,S'il vous plaît entrer Société
Please enter Cost Center,S'il vous plaît entrer Centre de coûts
Please enter Delivery Note No or Sales Invoice No to proceed,S&#39;il vous plaît entrer livraison Remarque Aucune facture de vente ou Non pour continuer
Please enter Employee Id of this sales parson,S'il vous plaît entrer employés Id de ce pasteur de vente
Please enter Expense Account,S&#39;il vous plaît entrer Compte de dépenses
Please enter Item Code to get batch no,S'il vous plaît entrez le code d'article pour obtenir n ° de lot
Please enter Item Code.,S'il vous plaît entrez le code d'article .
Please enter Item first,S'il vous plaît entrer article premier
Please enter Maintaince Details first,S'il vous plaît entrer Maintaince Détails première
Please enter Master Name once the account is created.,S'il vous plaît entrer Maître Nom une fois le compte créé .
Please enter Planned Qty for Item {0} at row {1},Vous ne pouvez pas sélectionner le type de charge comme « Sur la ligne précédente Montant » ou « Le précédent Row totale » pour l'évaluation . Vous ne pouvez sélectionner que l'option «Total» pour le montant de la ligne précédente ou total de la ligne précédente
Please enter Production Item first,S'il vous plaît entrer en production l'article premier
Please enter Purchase Receipt No to proceed,S&#39;il vous plaît entrer Achat réception Non pour passer
Please enter Reference date,S'il vous plaît entrer Date de référence
Please enter Warehouse for which Material Request will be raised,S'il vous plaît entrer Entrepôt à qui demande de matériel sera porté
Please enter Write Off Account,S'il vous plaît entrer amortissent compte
Please enter atleast 1 invoice in the table,recevable
Please enter company first,S'il vous plaît entrez première entreprise
Please enter company name first,S'il vous plaît entrez le nom de l'entreprise d'abord
Please enter default Unit of Measure,Entrepôt de cible dans la ligne {0} doit être la même que la production de commande
Please enter default currency in Company Master,S'il vous plaît entrer devise par défaut en maître de compagnie
Please enter email address,Allouer des feuilles pour une période .
Please enter item details,"Pour signaler un problème, passez à"
Please enter message before sending,"Vous ne pouvez pas supprimer Aucune série {0} en stock . Première retirer du stock, puis supprimer ."
Please enter parent account group for warehouse account,Matière première
Please enter parent cost center,Le projet de loi n ° {0} déjà réservé dans la facture d'achat {1}
Please enter quantity for Item {0},Point {0} est annulée
Please enter relieving date.,Type de partie de Parent
Please enter sales order in the above table,S'il vous plaît entrez la commande client dans le tableau ci-dessus
Please enter valid Company Email,S'il vous plaît entrer une adresse valide Société Email
Please enter valid Email Id,Maître Organisation de branche .
Please enter valid Personal Email,S'il vous plaît entrer une adresse valide personnels
Please enter valid mobile nos,nos
Please find attached Sales Invoice #{0},S'il vous plaît trouver ci-joint la facture de vente # {0}
Please install dropbox python module,S&#39;il vous plaît installer Dropbox module Python
Please mention no of visits required,Paiement du salaire pour le mois {0} et {1} an
Please pull items from Delivery Note,POS- Cadre . #
Please save the Newsletter before sending,{0} {1} n'est pas soumis
Please save the document before generating maintenance schedule,S'il vous plaît enregistrer le document avant de générer le calendrier d'entretien
Please see attachment,S'il vous plaît voir la pièce jointe
Please select Bank Account,S&#39;il vous plaît sélectionner compte bancaire
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,S&#39;il vous plaît sélectionnez Report si vous souhaitez également inclure le solde de l&#39;exercice précédent ne laisse à cet exercice
Please select Category first,S'il vous plaît sélectionnez d'abord Catégorie
Please select Charge Type first,S'il vous plaît sélectionnez le type de Facturation de la première
Please select Fiscal Year,S'il vous plaît sélectionner l'Exercice
Please select Group or Ledger value,Nombre BOM pas permis non manufacturé article {0} à la ligne {1}
Please select Incharge Person's name,S'il vous plaît sélectionnez le nom de la personne Incharge
Please select Invoice Type and Invoice Number in atleast one row,S'il vous plaît sélectionnez facture type et numéro de facture dans atleast une rangée
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM",Contactez- maître .
Please select Price List,S&#39;il vous plaît sélectionnez Liste des Prix
Please select Start Date and End Date for Item {0},S'il vous plaît sélectionnez Date de début et date de fin de l'article {0}
Please select Time Logs.,S'il vous plaît sélectionner registres de temps.
Please select a csv file,S&#39;il vous plaît sélectionner un fichier csv
Please select a valid csv file with data,Date de liquidation ne peut pas être avant le check date dans la ligne {0}
Please select a value for {0} quotation_to {1},S'il vous plaît sélectionnez une valeur pour {0} {1} quotation_to
"Please select an ""Image"" first","S'il vous plaît sélectionnez ""Image "" première"
Please select charge type first,Immobilisations
Please select company first,S'il vous plaît sélectionnez première entreprise
Please select company first.,S'il vous plaît sélectionnez première entreprise.
Please select item code,Etes-vous sûr de vouloir unstop
Please select month and year,S&#39;il vous plaît sélectionner le mois et l&#39;année
Please select prefix first,nourriture
Please select the document type first,S&#39;il vous plaît sélectionner le type de document premier
Please select weekly off day,Laissez uniquement les applications ayant le statut « Approuvé » peut être soumis
Please select {0},S'il vous plaît sélectionnez {0}
Please select {0} first,S'il vous plaît sélectionnez {0} premier
Please select {0} first.,S'il vous plaît sélectionnez {0} en premier.
Please set Dropbox access keys in your site config,S'il vous plaît définir les clés d'accès Dropbox sur votre site config
Please set Google Drive access keys in {0},S'il vous plaît définir les clés d'accès Google lecteurs dans {0}
Please set default Cash or Bank account in Mode of Payment {0},Les frais de téléphone
Please set default value {0} in Company {0},tous les territoires
Please set {0},S'il vous plaît mettre {0}
Please setup Employee Naming System in Human Resource > HR Settings,S&#39;il vous plaît configuration Naming System employés en ressources humaines&gt; Paramètres RH
Please setup numbering series for Attendance via Setup > Numbering Series,S'il vous plaît configuration série de numérotation à la fréquentation via Configuration> Série de numérotation
Please setup your chart of accounts before you start Accounting Entries,S'il vous plaît configurer votre plan de comptes avant de commencer Écritures comptables
Please specify,S&#39;il vous plaît spécifier
Please specify Company,S&#39;il vous plaît préciser Company
Please specify Company to proceed,Veuillez indiquer Société de procéder
Please specify Default Currency in Company Master and Global Defaults,N ° de série {0} n'existe pas
Please specify a,S&#39;il vous plaît spécifier une
Please specify a valid 'From Case No.',S&#39;il vous plaît indiquer une valide »De Affaire n &#39;
Please specify a valid Row ID for {0} in row {1},Il s'agit d'un site d'exemple généré automatiquement à partir de ERPNext
Please specify either Quantity or Valuation Rate or both,S'il vous plaît spécifier Quantité ou l'évaluation des taux ou à la fois
Please submit to update Leave Balance.,S'il vous plaît soumettre à jour de congé balance .
Plot,terrain
Plot By,terrain par
Point of Sale,Point de vente
Point-of-Sale Setting,Point-of-Sale Réglage
Post Graduate,Message d&#39;études supérieures
Postal,Postal
Postal Expenses,Frais postaux
Posting Date,Date de publication
Posting Time,Affichage Temps
Posting date and posting time is mandatory,Date d'affichage et l'affichage est obligatoire
Posting timestamp must be after {0},Horodatage affichage doit être après {0}
Potential opportunities for selling.,Possibilités pour la vente.
Preferred Billing Address,Préféré adresse de facturation
Preferred Shipping Address,Preferred Adresse de livraison
Prefix,Préfixe
Present,Présent
Prevdoc DocType,Prevdoc DocType
Prevdoc Doctype,Prevdoc Doctype
Preview,dépenses diverses
Previous,Sérialisé article {0} ne peut pas être mis à jour Stock réconciliation
Previous Work Experience,L&#39;expérience de travail antérieure
Price,Profil de l'organisation
Price / Discount,Utilisateur Notes est obligatoire
Price List,Liste des Prix
Price List Currency,Devise Prix
Price List Currency not selected,Liste des Prix devise sélectionné
Price List Exchange Rate,Taux de change Prix de liste
Price List Name,Nom Liste des Prix
Price List Rate,Prix ​​Liste des Prix
Price List Rate (Company Currency),Tarifs Taux (Société Monnaie)
Price List master.,{0} n'appartient pas à la Société {1}
Price List must be applicable for Buying or Selling,Compte {0} doit être SAMES comme crédit du compte dans la facture d'achat en ligne {0}
Price List not selected,Barcode valide ou N ° de série
Price List {0} is disabled,Série {0} déjà utilisé dans {1}
Price or Discount,Frais d'administration
Pricing Rule,Provision pour plus - livraison / facturation excessive franchi pour objet {0}
Pricing Rule Help,Prix règle Aide
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Prix règle est d'abord sélectionné sur la base de «postuler en« champ, qui peut être l'article, groupe d'articles ou de marque."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Prix règle est faite pour remplacer la liste des prix / définir le pourcentage de remise, sur la base de certains critères."
Pricing Rules are further filtered based on quantity.,Les règles de tarification sont encore filtrés en fonction de la quantité.
Print Format Style,Format d&#39;impression style
Print Heading,Imprimer Cap
Print Without Amount,Imprimer Sans Montant
Print and Stationary,Appréciation {0} créé pour les employés {1} dans la plage de date donnée
Printing and Branding,équité
Priority,Priorité
Private Equity,Private Equity
Privilege Leave,Point {0} doit être fonction Point
Probation,probation
Process Payroll,Paie processus
Produced,produit
Produced Quantity,Quantité produite
Product Enquiry,Demande d&#39;information produit
Production,production
Production Order,Ordre de fabrication
Production Order status is {0},Feuilles alloué avec succès pour {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Tous les groupes de clients
Production Order {0} must be submitted,Client / Nom plomb
Production Orders,ordres de fabrication
Production Orders in Progress,Les commandes de produits en cours
Production Plan Item,Élément du plan de production
Production Plan Items,Éléments du plan de production
Production Plan Sales Order,Plan de Production Ventes Ordre
Production Plan Sales Orders,Vente Plan d&#39;ordres de production
Production Planning Tool,Outil de planification de la production
Products,Point {0} n'existe pas dans {1} {2}
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","Les produits seront triés par poids-âge dans les recherches par défaut. Plus le poids-âge, plus le produit apparaîtra dans la liste."
Professional Tax,Taxe Professionnelle
Profit and Loss,Pertes et profits
Profit and Loss Statement,Compte de résultat
Project,Projet
Project Costing,Des coûts de projet
Project Details,Détails du projet
Project Manager,Chef de projet
Project Milestone,Des étapes du projet
Project Milestones,Étapes du projet
Project Name,Nom du projet
Project Start Date,Date de début du projet
Project Type,Type de projet
Project Value,Valeur du projet
Project activity / task.,Activité de projet / tâche.
Project master.,Projet de master.
Project will get saved and will be searchable with project name given,Projet seront sauvegardés et sera consultable avec le nom de projet donné
Project wise Stock Tracking,Projet sage Stock Tracking
Project-wise data is not available for Quotation,alloué avec succès
Projected,Projection
Projected Qty,Qté projeté
Projects,Projets
Projects & System,Pas de commande de production créées
Prompt for Email on Submission of,Prompt for Email relative à la présentation des
Proposal Writing,Rédaction de propositions
Provide email id registered in company,Fournir id e-mail enregistrée dans la société
Provisional Profit / Loss (Credit),Résultat provisoire / Perte (crédit)
Public,Public
Published on website at: {0},Publié sur le site Web au: {0}
Publishing,édition
Pull sales orders (pending to deliver) based on the above criteria,Tirez les ordres de vente (en attendant de livrer) sur la base des critères ci-dessus
Purchase,Acheter
Purchase / Manufacture Details,Achat / Fabrication Détails
Purchase Analytics,Achat Analytics
Purchase Common,Achat commune
Purchase Details,Conditions de souscription
Purchase Discounts,Rabais sur l&#39;achat
Purchase Invoice,Achetez facture
Purchase Invoice Advance,Paiement à l&#39;avance Facture
Purchase Invoice Advances,Achat progrès facture
Purchase Invoice Item,Achat d&#39;article de facture
Purchase Invoice Trends,Achat Tendances facture
Purchase Invoice {0} is already submitted,Voulez-vous vraiment de soumettre tout bulletin de salaire pour le mois {0} et {1} an
Purchase Order,Bon de commande
Purchase Order Item,Achat Passer commande
Purchase Order Item No,Achetez article ordonnance n
Purchase Order Item Supplied,Point de commande fourni
Purchase Order Items,Achetez articles de la commande
Purchase Order Items Supplied,Articles commande fourni
Purchase Order Items To Be Billed,Purchase Order articles qui lui seront facturées
Purchase Order Items To Be Received,Articles de bons de commande pour être reçu
Purchase Order Message,Achat message Ordre
Purchase Order Required,Bon de commande requis
Purchase Order Trends,Bon de commande Tendances
Purchase Order number required for Item {0},Vous ne pouvez pas reporter {0}
Purchase Order {0} is 'Stopped',Poster n'existe pas . S'il vous plaît ajoutez poste !
Purchase Order {0} is not submitted,entrer une valeur
Purchase Orders given to Suppliers.,Achetez commandes faites aux fournisseurs.
Purchase Receipt,Achat Réception
Purchase Receipt Item,Achat d&#39;article de réception
Purchase Receipt Item Supplied,Article reçu d&#39;achat fournis
Purchase Receipt Item Supplieds,Achat Supplieds point de réception
Purchase Receipt Items,Acheter des articles reçus
Purchase Receipt Message,Achat message de réception
Purchase Receipt No,Achetez un accusé de réception
Purchase Receipt Required,Réception achat requis
Purchase Receipt Trends,Achat Tendances reçus
Purchase Receipt number required for Item {0},Numéro du bon de réception requis pour objet {0}
Purchase Receipt {0} is not submitted,Reçu d'achat {0} n'est pas soumis
Purchase Register,Achat S&#39;inscrire
Purchase Return,Achat de retour
Purchase Returned,Achetez retour
Purchase Taxes and Charges,Impôts achat et les frais
Purchase Taxes and Charges Master,Impôts achat et Master frais
Purchse Order number required for Item {0},Ordre de fabrication {0} doit être annulée avant d'annuler cette commande client
Purpose,But
Purpose must be one of {0},L'objectif doit être l'un des {0}
QA Inspection,QA inspection
Qty,Qté
Qty Consumed Per Unit,Quantité consommée par unité
Qty To Manufacture,Quantité à fabriquer
Qty as per Stock UOM,Qté en stock pour Emballage
Qty to Deliver,Quantité à livrer
Qty to Order,Quantité à commander
Qty to Receive,Quantité pour recevoir
Qty to Transfer,Quantité de Transfert
Qualification,Qualification
Quality,Qualité
Quality Inspection,Inspection de la Qualité
Quality Inspection Parameters,Paramètres inspection de la qualité
Quality Inspection Reading,Lecture d&#39;inspection de la qualité
Quality Inspection Readings,Lectures inspection de la qualité
Quality Inspection required for Item {0},Navigateur des ventes
Quality Management,Gestion de la qualité
Quantity,Quantité
Quantity Requested for Purchase,Quantité demandée pour l&#39;achat
Quantity and Rate,Quantité et taux
Quantity and Warehouse,Quantité et entrepôt
Quantity cannot be a fraction in row {0},accueil
Quantity for Item {0} must be less than {1},Quantité de l'article {0} doit être inférieur à {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Entrepôt ne peut pas être supprimé car il existe entrée stock registre pour cet entrepôt .
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
Quantity required for Item {0} in row {1},Quantité requise pour objet {0} à la ligne {1}
Quarter,Trimestre
Quarterly,Trimestriel
Quick Help,Aide rapide
Quotation,Citation
Quotation Item,Article devis
Quotation Items,Articles de devis
Quotation Lost Reason,Devis perdu la raison
Quotation Message,Devis message
Quotation To,Devis Pour
Quotation Trends,Devis Tendances
Quotation {0} is cancelled,Devis {0} est annulée
Quotation {0} not of type {1},Activer / désactiver les monnaies .
Quotations received from Suppliers.,Citations reçues des fournisseurs.
Quotes to Leads or Customers.,Citations à prospects ou clients.
Raise Material Request when stock reaches re-order level,Soulever demande de matériel lorsque le stock atteint le niveau de réapprovisionnement
Raised By,Raised By
Raised By (Email),Raised By (e-mail)
Random,Aléatoire
Range,Gamme
Rate,Taux
Rate ,Taux
Rate (%),S'il vous plaît entrer la date soulager .
Rate (Company Currency),Taux (Société Monnaie)
Rate Of Materials Based On,Taux de matériaux à base
Rate and Amount,Taux et le montant
Rate at which Customer Currency is converted to customer's base currency,Vitesse à laquelle la devise du client est converti en devise de base du client
Rate at which Price list currency is converted to company's base currency,Taux auquel la monnaie Liste de prix est converti en devise de base entreprise
Rate at which Price list currency is converted to customer's base currency,Taux auquel la monnaie Liste de prix est converti en devise de base du client
Rate at which customer's currency is converted to company's base currency,Vitesse à laquelle la devise du client est converti en devise de base entreprise
Rate at which supplier's currency is converted to company's base currency,Taux auquel la monnaie du fournisseur est converti en devise de base entreprise
Rate at which this tax is applied,Vitesse à laquelle cet impôt est appliqué
Raw Material,S'il vous plaît entrez la date et l'heure de l'événement !
Raw Material Item Code,Raw Code article Matière
Raw Materials Supplied,Des matières premières fournies
Raw Materials Supplied Cost,Coût des matières premières fournies
Raw material cannot be same as main Item,Point {0} ignoré car il n'est pas un article en stock
Re-Order Level,Re-Order niveau
Re-Order Qty,Re-Cdt
Re-order,Re-order
Re-order Level,Re-order niveau
Re-order Qty,Re-order Quantité
Read,Lire
Reading 1,Lecture 1
Reading 10,Lecture le 10
Reading 2,Lecture 2
Reading 3,Reading 3
Reading 4,Reading 4
Reading 5,Reading 5
Reading 6,Lecture 6
Reading 7,Lecture le 7
Reading 8,Lecture 8
Reading 9,Lectures suggérées 9
Real Estate,Immobilier
Reason,Raison
Reason for Leaving,Raison du départ
Reason for Resignation,Raison de la démission
Reason for losing,Raison pour perdre
Recd Quantity,Quantité recd
Receivable,Impression et image de marque
Receivable / Payable account will be identified based on the field Master Type,Compte à recevoir / payer sera identifié en fonction du champ Type de maître
Receivables,Créances
Receivables / Payables,Créances / dettes
Receivables Group,Groupe de créances
Received Date,Date de réception
Received Items To Be Billed,Articles reçus à être facturé
Received Qty,Quantité reçue
Received and Accepted,Reçus et acceptés
Receiver List,Liste des récepteurs
Receiver List is empty. Please create Receiver List,Soit quantité de cible ou le montant cible est obligatoire .
Receiver Parameter,Paramètre récepteur
Recipients,Récipiendaires
Reconcile,réconcilier
Reconciliation Data,Données de réconciliation
Reconciliation HTML,Réconciliation HTML
Reconciliation JSON,Réconciliation JSON
Record item movement.,Enregistrer le mouvement de l&#39;objet.
Recurring Id,Id récurrent
Recurring Invoice,Facture récurrente
Recurring Type,Type de courant
Reduce Deduction for Leave Without Pay (LWP),Réduire la déduction de congé sans solde (PLT)
Reduce Earning for Leave Without Pay (LWP),Réduire Gagner de congé sans solde (PLT)
Ref,Réf
Ref Code,Code de référence de
Ref SQ,Réf SQ
Reference,Référence
Reference #{0} dated {1},"Vous ne pouvez pas surfacturer pour objet {0} à la ligne {0} plus de {1} . Pour permettre la surfacturation , s'il vous plaît mettre dans 'Configuration '> ' par défaut globales'"
Reference Date,Date de Référence
Reference Name,Nom de référence
Reference No & Reference Date is required for {0},contacts
Reference No is mandatory if you entered Reference Date,"Centre de coûts est nécessaire pour compte » de profits et pertes "" {0}"
Reference Number,Numéro de référence
Reference Row #,"Ne peut directement fixer le montant . Pour le type de charge « réelle » , utilisez le champ de taux"
Refresh,Rafraîchir
Registration Details,Détails de l&#39;enregistrement
Registration Info,D&#39;informations Inscription
Rejected,Rejeté
Rejected Quantity,Quantité rejetée
Rejected Serial No,Rejeté N ° de série
Rejected Warehouse,Entrepôt rejetée
Rejected Warehouse is mandatory against regected item,Entrepôt rejeté est obligatoire contre l'article regected
Relation,Rapport
Relieving Date,Date de soulager
Relieving Date must be greater than Date of Joining,Vous n'êtes pas autorisé à ajouter ou mettre à jour les entrées avant {0}
Remark,Remarque
Remarks,Remarques
Remarks Custom,Remarques sur commande
Rename,rebaptiser
Rename Log,Renommez identifiez-vous
Rename Tool,Renommer l&#39;outil
Rent Cost,louer coût
Rent per hour,Louer par heure
Rented,Loué
Repeat on Day of Month,Répétez le Jour du Mois
Replace,Remplacer
Replace Item / BOM in all BOMs,Remplacer l&#39;élément / BOM dans toutes les nomenclatures
Replied,Répondu
Report Date,Date du rapport
Report Type,Rapport Genre
Report Type is mandatory,Bulletin de salaire de l'employé {0} déjà créé pour ce mois-ci
Reports to,Rapports au
Reqd By Date,Reqd par date
Reqd by Date,Reqd par date
Request Type,Type de demande
Request for Information,Demande de renseignements
Request for purchase.,Demande d&#39;achat.
Requested,demandé
Requested For,Pour demandée
Requested Items To Be Ordered,Articles demandés à commander
Requested Items To Be Transferred,Articles demandé à être transférés
Requested Qty,Quantité demandée
"Requested Qty: Quantity requested for purchase, but not ordered.","Demandé Quantité: Quantité demandée pour l'achat , mais pas ordonné ."
Requests for items.,Les demandes d&#39;articles.
Required By,Requis par
Required Date,Requis Date
Required Qty,Quantité requise
Required only for sample item.,Requis uniquement pour les articles de l&#39;échantillon.
Required raw materials issued to the supplier for producing a sub - contracted item.,Matières premières nécessaires délivrés au fournisseur pour la production d&#39;un élément sous - traitance.
Research,recherche
Research & Development,Recherche & Développement
Researcher,chercheur
Reseller,Revendeur
Reserved,réservé
Reserved Qty,Quantité réservés
"Reserved Qty: Quantity ordered for sale, but not delivered.","Réservés Quantité: Quantité de commande pour la vente , mais pas livré ."
Reserved Quantity,Quantité réservés
Reserved Warehouse,Réservé Entrepôt
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Entrepôt réservé à des commandes clients / entrepôt de produits finis
Reserved Warehouse is missing in Sales Order,Réservé entrepôt est manquant dans l&#39;ordre des ventes
Reserved Warehouse required for stock Item {0} in row {1},Centre de coûts par défaut de vente
Reserved warehouse required for stock item {0},Ajoutez à cela les restrictions de l'utilisateur
Reserves and Surplus,Réserves et de l'excédent
Reset Filters,réinitialiser les filtres
Resignation Letter Date,Date de lettre de démission
Resolution,Résolution
Resolution Date,Date de Résolution
Resolution Details,Détails de la résolution
Resolved By,Résolu par
Rest Of The World,revenu indirect
Retail,Détail
Retail & Wholesale,Retail & Wholesale
Retailer,Détaillant
Review Date,Date de revoir
Rgt,Rgt
Role Allowed to edit frozen stock,Rôle autorisés à modifier stock congelé
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.
Root Type,Type de Racine
Root Type is mandatory,Type de Root est obligatoire
Root account can not be deleted,Prix ​​ou à prix réduits
Root cannot be edited.,Racine ne peut pas être modifié.
Root cannot have a parent cost center,Racine ne peut pas avoir un centre de coûts parent
Rounded Off,Période est trop courte
Rounded Total,Totale arrondie
Rounded Total (Company Currency),Totale arrondie (Société Monnaie)
Row # ,Row #
Row # {0}: ,
Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Ligne # {0}: quantité Commandé ne peut pas moins que l'ordre minimum quantité de produit (défini dans le maître de l'article).
Row #{0}: Please specify Serial No for Item {1},Ligne # {0}: S'il vous plaît spécifier Pas de série pour objet {1}
"Row {0}: Account does not match with \
						Purchase Invoice Credit To account","Ligne {0}: compte ne correspond pas à \
 Facture d'achat crédit du compte"
"Row {0}: Account does not match with \
						Sales Invoice Debit To account","Ligne {0}: compte ne correspond pas à \
 la facture de vente de débit Pour tenir compte"
Row {0}: Conversion Factor is mandatory,Ligne {0}: facteur de conversion est obligatoire
Row {0}: Credit entry can not be linked with a Purchase Invoice,Ligne {0} : entrée de crédit ne peut pas être lié à une facture d'achat
Row {0}: Debit entry can not be linked with a Sales Invoice,Ligne {0} : entrée de débit ne peut pas être lié à une facture de vente
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Ligne {0}: Montant du paiement doit être inférieur ou égal montant de la facture exceptionnelle. S'il vous plaît se référer note ci-dessous.
Row {0}: Qty is mandatory,Ligne {0}: Quantité est obligatoire
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","Ligne {0}: Qté pas avalable dans l'entrepôt {1} sur {2} {3}.
 Disponible Quantité: {4}, Transfert Quantité: {5}"
"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Ligne {0}: Pour définir {1} périodicité, la différence entre de et à jour \
 doit être supérieur ou égal à {2}"
Row {0}:Start Date must be before End Date,Ligne {0} : Date de début doit être avant Date de fin
Rules for adding shipping costs.,S'il vous plaît entrer atleast une facture dans le tableau
Rules for applying pricing and discount.,Tous ces éléments ont déjà été facturés
Rules to calculate shipping amount for a sale,Règles de calcul du montant de l&#39;expédition pour une vente
S.O. No.,S.O. Non.
SHE Cess on Excise,ELLE CESS sur l'accise
SHE Cess on Service Tax,ELLE CESS sur des services fiscaux
SHE Cess on TDS,ELLE CESS sur TDS
SMS Center,Centre SMS
SMS Gateway URL,URL SMS Gateway
SMS Log,SMS Log
SMS Parameter,Paramètre SMS
SMS Sender Name,SMS Sender Nom
SMS Settings,Paramètres SMS
SO Date,SO Date
SO Pending Qty,SO attente Qté
SO Qty,SO Quantité
Salary,Salaire
Salary Information,Information sur le salaire
Salary Manager,Salaire Responsable
Salary Mode,Mode de rémunération
Salary Slip,Glissement des salaires
Salary Slip Deduction,Déduction bulletin de salaire
Salary Slip Earning,Slip Salaire Gagner
Salary Slip of employee {0} already created for this month,Entrepôt réservé requis pour l'article courant {0}
Salary Structure,Grille des salaires
Salary Structure Deduction,Déduction structure salariale
Salary Structure Earning,Structure salariale Gagner
Salary Structure Earnings,Bénéfice structure salariale
Salary breakup based on Earning and Deduction.,rupture des salaires basée sur l&#39;obtention et la déduction.
Salary components.,Éléments du salaire.
Salary template master.,Maître de modèle de salaires .
Sales,Ventes
Sales Analytics,Analytics Sales
Sales BOM,BOM ventes
Sales BOM Help,Aide nomenclature des ventes
Sales BOM Item,Article nomenclature des ventes
Sales BOM Items,Articles ventes de nomenclature
Sales Browser,Exceptionnelle pour {0} ne peut pas être inférieur à zéro ( {1} )
Sales Details,Détails ventes
Sales Discounts,Escomptes sur ventes
Sales Email Settings,Réglages Courriel Ventes
Sales Expenses,Fournisseur numéro de livraison en double dans {0}
Sales Extras,Extras ventes
Sales Funnel,Entonnoir des ventes
Sales Invoice,Facture de vente
Sales Invoice Advance,Advance facture de vente
Sales Invoice Item,Article facture de vente
Sales Invoice Items,Facture de vente Articles
Sales Invoice Message,Message facture de vente
Sales Invoice No,Aucune facture de vente
Sales Invoice Trends,Soldes Tendances de la facture
Sales Invoice {0} has already been submitted,BOM {0} n'est pas actif ou non soumis
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Montant du rabais
Sales Order,Commande
Sales Order Date,Date de Commande
Sales Order Item,Poste de commande client
Sales Order Items,Articles Sales Order
Sales Order Message,Message de commande client
Sales Order No,Ordonnance n ° de vente
Sales Order Required,Commande obligatoire
Sales Order Trends,Ventes Tendances des commandes
Sales Order required for Item {0},Commande requis pour objet {0}
Sales Order {0} is not submitted,Maximum {0} lignes autorisées
Sales Order {0} is not valid,Company ( pas client ou fournisseur ) maître .
Sales Order {0} is stopped,Commande {0} est arrêté
Sales Partner,Sales Partner
Sales Partner Name,Nom Sales Partner
Sales Partner Target,Cible Sales Partner
Sales Partners Commission,Partenaires Sales Commission
Sales Person,Sales Person
Sales Person Name,Nom Sales Person
Sales Person Target Variance Item Group-Wise,S'il vous plaît entrer un message avant de l'envoyer
Sales Person Targets,Personne objectifs de vente
Sales Person-wise Transaction Summary,Sales Person-sage Résumé de la transaction
Sales Register,Registre des ventes
Sales Return,Ventes de retour
Sales Returned,ventes renvoyé
Sales Taxes and Charges,Taxes de vente et frais
Sales Taxes and Charges Master,Taxes de vente et frais de Master
Sales Team,Équipe des ventes
Sales Team Details,Détails équipe de vente
Sales Team1,Ventes Equipe1
Sales and Purchase,Vente et achat
Sales campaigns.,Campagnes de vente .
Salutation,Salutation
Sample Size,Taille de l&#39;échantillon
Sanctioned Amount,Montant sanctionné
Saturday,Samedi
Schedule,Calendrier
Schedule Date,calendrier Date
Schedule Details,Planning Détails
Scheduled,Prévu
Scheduled Date,Date prévue
Scheduled to send to {0},Prévu pour envoyer à {0}
Scheduled to send to {0} recipients,Prévu pour envoyer à {0} bénéficiaires
Scheduler Failed Events,Events Calendrier perdus
School/University,Ecole / Université
Score (0-5),Score (0-5)
Score Earned,Score gagné
Score must be less than or equal to 5,Score doit être inférieur ou égal à 5
Scrap %,Scrap%
Seasonality for setting budgets.,Saisonnalité de l&#39;établissement des budgets.
Secretary,secrétaire
Secured Loans,Pas de nomenclature par défaut existe pour objet {0}
Securities & Commodity Exchanges,Valeurs mobilières et des bourses de marchandises
Securities and Deposits,Titres et des dépôts
"See ""Rate Of Materials Based On"" in Costing Section",Voir «Taux de matériaux à base de« coûts dans la section
"Select ""Yes"" for sub - contracting items",Sélectionnez &quot;Oui&quot; pour la sous - traitance articles
"Select ""Yes"" if this item is used for some internal purpose in your company.",Sélectionnez &quot;Oui&quot; si cet objet est utilisé à des fins internes de votre entreprise.
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Sélectionnez &quot;Oui&quot; si cet objet représente un travail comme la formation, la conception, la consultation, etc"
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Sélectionnez &quot;Oui&quot; si vous le maintien des stocks de cet article dans votre inventaire.
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Sélectionnez &quot;Oui&quot; si vous fournir des matières premières à votre fournisseur pour la fabrication de cet article.
Select Brand...,Sélectionnez une marque ...
Select Budget Distribution to unevenly distribute targets across months.,Sélectionnez Répartition du budget à répartir inégalement cibles à travers mois.
"Select Budget Distribution, if you want to track based on seasonality.","Sélectionnez Répartition du budget, si vous voulez suivre en fonction de la saisonnalité."
Select Company...,Sélectionnez Société ...
Select DocType,Sélectionnez DocType
Select Fiscal Year...,Sélectionnez Exercice ...
Select Items,Sélectionner les objets
Select Project...,Sélectionnez Projet ...
Select Purchase Receipts,Sélectionnez reçus d'achat
Select Sales Orders,Sélectionnez les commandes clients
Select Sales Orders from which you want to create Production Orders.,Sélectionnez les commandes clients à partir de laquelle vous souhaitez créer des ordres de fabrication.
Select Time Logs and Submit to create a new Sales Invoice.,Sélectionnez registres de temps et de soumettre à créer une nouvelle facture de vente.
Select Transaction,Sélectionnez Transaction
Select Warehouse...,Sélectionnez Entrepôt ...
Select Your Language,« Jours depuis la dernière commande» doit être supérieur ou égal à zéro
Select account head of the bank where cheque was deposited.,Sélectionnez tête compte de la banque où chèque a été déposé.
Select company name first.,Sélectionnez le nom de la première entreprise.
Select template from which you want to get the Goals,Sélectionnez le modèle à partir duquel vous souhaitez obtenir des Objectifs
Select the Employee for whom you are creating the Appraisal.,Sélectionnez l&#39;employé pour lequel vous créez l&#39;évaluation.
Select the period when the invoice will be generated automatically,Sélectionnez la période pendant laquelle la facture sera générée automatiquement
Select the relevant company name if you have multiple companies,Sélectionnez le nom de l&#39;entreprise concernée si vous avez de multiples entreprises
Select the relevant company name if you have multiple companies.,Sélectionnez le nom de l&#39;entreprise concernée si vous avez plusieurs sociétés.
Select who you want to send this newsletter to,Sélectionnez qui vous souhaitez envoyer ce bulletin à
Select your home country and check the timezone and currency.,Choisissez votre pays d'origine et vérifier le fuseau horaire et la monnaie .
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","La sélection de &quot;Oui&quot; permettra cet article à paraître dans bon de commande, facture d&#39;achat."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","La sélection de &quot;Oui&quot; permettra de comprendre cet article dans l&#39;ordonnance de vente, bon de livraison"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",La sélection de &quot;Oui&quot; vous permettra de créer des nomenclatures montrant des matières premières et des coûts d&#39;exploitation engagés pour la fabrication de cet article.
"Selecting ""Yes"" will allow you to make a Production Order for this item.",La sélection de &quot;Oui&quot; vous permettra de faire un ordre de fabrication pour cet article.
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",La sélection de &quot;Oui&quot; donner une identité unique à chaque entité de cet article qui peut être consulté dans le N ° de série maître.
Selling,Vente
Selling Settings,Réglages de vente
"Selling must be checked, if Applicable For is selected as {0}","Vente doit être vérifiée, si pour Applicable est sélectionné comme {0}"
Send,Envoyer
Send Autoreply,Envoyer Autoreply
Send Email,Envoyer un email
Send From,Envoyer partir de
Send Notifications To,Envoyer des notifications aux
Send Now,Envoyer maintenant
Send SMS,Envoyer un SMS
Send To,Send To
Send To Type,Envoyer à taper
Send mass SMS to your contacts,Envoyer un SMS en masse à vos contacts
Send to this list,Envoyer cette liste
Sender Name,Nom de l&#39;expéditeur
Sent On,Sur envoyé
Separate production order will be created for each finished good item.,Pour la production séparée sera créée pour chaque article produit fini.
Serial No,N ° de série
Serial No / Batch,N ° de série / lot
Serial No Details,Détails Pas de série
Serial No Service Contract Expiry,N ° de série expiration du contrat de service
Serial No Status,N ° de série Statut
Serial No Warranty Expiry,N ° de série expiration de garantie
Serial No is mandatory for Item {0},Pas de série est obligatoire pour objet {0}
Serial No {0} created,aucune autorisation
Serial No {0} does not belong to Delivery Note {1},N ° de série {0} ne fait pas partie de la livraison Remarque {1}
Serial No {0} does not belong to Item {1},compensatoire
Serial No {0} does not belong to Warehouse {1},Les paramètres par défaut pour les transactions boursières .
Serial No {0} does not exist,Maître d'adresses.
Serial No {0} has already been received,Négatif Stock erreur ( {6} ) pour le point {0} dans {1} Entrepôt sur ​​{2} {3} {4} en {5}
Serial No {0} is under maintenance contract upto {1},Budget ne peut être réglé pour les centres de coûts du Groupe
Serial No {0} is under warranty upto {1},Compte {0} n'appartient pas à la Société {1}
Serial No {0} not in stock,N ° de série {0} pas en stock
Serial No {0} quantity {1} cannot be a fraction,N ° de série {0} {1} quantité ne peut pas être une fraction
Serial No {0} status must be 'Available' to Deliver,Pour la liste de prix
Serial Nos Required for Serialized Item {0},Dupliquer entrée . S'il vous plaît vérifier une règle d'autorisation {0}
Serial Number Series,Série Série Nombre
Serial number {0} entered more than once,Numéro de série {0} est entré plus d'une fois
"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","Sérialisé article {0} ne peut pas être mis à jour \
 utilisant Stock réconciliation"
Series,série
Series List for this Transaction,Liste série pour cette transaction
Series Updated,Mise à jour de la série
Series Updated Successfully,prix règle
Series is mandatory,Congé de type {0} ne peut pas être plus long que {1}
Series {0} already used in {1},La date à laquelle la prochaine facture sera générée . Il est généré lors de la soumission .
Service,service
Service Address,Adresse du service
Service Tax,Service Tax
Services,Services
Set,Série est obligatoire
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Des valeurs par défaut comme la Compagnie , devise , année financière en cours , etc"
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Set Point du Groupe sages budgets sur ce territoire. Vous pouvez également inclure la saisonnalité en réglant la distribution.
Set Status as Available,Définir l'état comme disponible
Set as Default,Définir par défaut
Set as Lost,Définir comme perdu
Set prefix for numbering series on your transactions,Définir le préfixe de numérotation des séries sur vos transactions
Set targets Item Group-wise for this Sales Person.,Fixer des objectifs élément de groupe-sage pour cette personne des ventes.
Setting Account Type helps in selecting this Account in transactions.,Type de compte Configuration aide à sélectionner ce compte dans les transactions.
Setting this Address Template as default as there is no other default,"La définition de cette adresse modèle par défaut, car il n'ya pas d'autre défaut"
Setting up...,Mise en place ...
Settings,Réglages
Settings for HR Module,Utilisateur {0} est désactivé
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Paramètres pour extraire demandeurs d&#39;emploi à partir d&#39;une boîte aux lettres par exemple &quot;jobs@example.com&quot;
Setup,Installation
Setup Already Complete!!,Configuration déjà complet !
Setup Complete,installation terminée
Setup SMS gateway settings,paramètres de la passerelle SMS de configuration
Setup Series,Série de configuration
Setup Wizard,actif à court terme
Setup incoming server for jobs email id. (e.g. jobs@example.com),Configuration serveur entrant pour les emplois id e-mail . (par exemple jobs@example.com )
Setup incoming server for sales email id. (e.g. sales@example.com),Cas No (s ) en cours d'utilisation . Essayez de l'affaire n ° {0}
Setup incoming server for support email id. (e.g. support@example.com),Configuration serveur entrant de soutien id e-mail . (par exemple support@example.com )
Share,Partager
Share With,Partager avec
Shareholders Funds,actionnaires Fonds
Shipments to customers.,Les livraisons aux clients.
Shipping,Livraison
Shipping Account,Compte de livraison
Shipping Address,Adresse de livraison
Shipping Amount,Montant de livraison
Shipping Rule,Livraison règle
Shipping Rule Condition,Livraison Condition de règle
Shipping Rule Conditions,Règle expédition Conditions
Shipping Rule Label,Livraison règle étiquette
Shop,Magasiner
Shopping Cart,Panier
Short biography for website and other publications.,Courte biographie pour le site Web et d&#39;autres publications.
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Voir &quot;En stock&quot; ou &quot;Pas en stock» basée sur le stock disponible dans cet entrepôt.
"Show / Hide features like Serial Nos, POS etc.",commercial
Show In Website,Afficher dans un site Web
Show a slideshow at the top of the page,Afficher un diaporama en haut de la page
Show in Website,Afficher dans Site Web
Show rows with zero values,Afficher lignes avec des valeurs nulles
Show this slideshow at the top of the page,Voir ce diaporama en haut de la page
Sick Leave,{0} numéros de série valides pour objet {1}
Signature,Signature
Signature to be appended at the end of every email,Signature d&#39;être ajouté à la fin de chaque e-mail
Single,Unique
Single unit of an Item.,Une seule unité d&#39;un élément.
Sit tight while your system is being setup. This may take a few moments.,Asseyez-vous serré alors que votre système est en cours d' installation. Cela peut prendre quelques instants .
Slideshow,Diaporama
Soap & Detergent,Savons et de Détergents
Software,logiciel
Software Developer,Software Developer
"Sorry, Serial Nos cannot be merged","Désolé , série n ne peut pas être fusionné"
"Sorry, companies cannot be merged","Désolé , les entreprises ne peuvent pas être fusionnés"
Source,Source
Source File,magasins
Source Warehouse,Source d&#39;entrepôt
Source and target warehouse cannot be same for row {0},Frais juridiques
Source of Funds (Liabilities),Source des fonds ( Passif )
Source warehouse is mandatory for row {0},Entrepôt de Source est obligatoire pour la ligne {0}
Spartan,Spartan
"Special Characters except ""-"" and ""/"" not allowed in naming series","Caractères spéciaux sauf "" - "" et ""/"" pas autorisés à nommer série"
Specification Details,Détails Spécifications
Specifications,caractéristiques
"Specify a list of Territories, for which, this Price List is valid","Spécifiez une liste des territoires, pour qui, cette liste de prix est valable"
"Specify a list of Territories, for which, this Shipping Rule is valid","Spécifiez une liste des territoires, pour qui, cette règle d&#39;expédition est valide"
"Specify a list of Territories, for which, this Taxes Master is valid","Spécifiez une liste des territoires, pour qui, cette Taxes Master est valide"
"Specify the operations, operating cost and give a unique Operation no to your operations.","Précisez les activités, le coût d'exploitation et de donner une opération unique, non à vos opérations ."
Split Delivery Note into packages.,Séparer le bon de livraison dans des packages.
Sports,sportif
Sr,Sr
Standard,Standard
Standard Buying,achat standard
Standard Reports,Rapports standard
Standard Selling,vente standard
Standard contract terms for Sales or Purchase.,Date prévue d'achèvement ne peut pas être inférieure à projet Date de début
Start,Démarrer
Start Date,Date de début
Start date of current invoice's period,Date de début de la période de facturation en cours
Start date should be less than end date for Item {0},{0} budget pour compte {1} contre des centres de coûts {2} dépassera par {3}
State,État
Statement of Account,Relevé de compte
Static Parameters,Paramètres statiques
Status,Statut
Status must be one of {0},Le statut doit être l'un des {0}
Status of {0} {1} is now {2},Statut de {0} {1} est maintenant {2}
Status updated to {0},Etat mis à jour à {0}
Statutory info and other general information about your Supplier,Informations légales et autres informations générales au sujet de votre Fournisseur
Stay Updated,Point {0} apparaît plusieurs fois dans la liste des prix {1}
Stock,Stock
Stock Adjustment,Stock ajustement
Stock Adjustment Account,Compte d&#39;ajustement de stock
Stock Ageing,Stock vieillissement
Stock Analytics,Analytics stock
Stock Assets,payable
Stock Balance,Solde Stock
Stock Entries already created for Production Order ,
Stock Entry,Entrée Stock
Stock Entry Detail,Détail d&#39;entrée Stock
Stock Expenses,Facteur de conversion de l'unité de mesure par défaut doit être de 1 à la ligne {0}
Stock Frozen Upto,Stock Frozen Jusqu&#39;à
Stock Ledger,Stock Ledger
Stock Ledger Entry,Stock Ledger Entry
Stock Ledger entries balances updated,Stock Ledger entrées soldes à jour
Stock Level,Niveau de stock
Stock Liabilities,Passif stock
Stock Projected Qty,Stock projeté Quantité
Stock Queue (FIFO),Stock file d&#39;attente (FIFO)
Stock Received But Not Billed,Stock reçus mais non facturés
Stock Reconcilation Data,Stock Rapprochement des données
Stock Reconcilation Template,Stock Réconciliation modèle
Stock Reconciliation,Stock réconciliation
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.",talon
Stock Settings,Paramètres de stock
Stock UOM,Stock UDM
Stock UOM Replace Utility,Utilitaire Stock Remplacer Emballage
Stock UOM updatd for Item {0},Entrepôts .
Stock Uom,Stock UDM
Stock Value,Valeur de l&#39;action
Stock Value Difference,Stock Value Différence
Stock balances updated,"Profil de l' emploi , les qualifications requises , etc"
Stock cannot be updated against Delivery Note {0},désactiver
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Warehouse est obligatoire pour les stock Article {0} à la ligne {1}
Stock transactions before {0} are frozen,transactions d'actions avant {0} sont gelés
Stop,Stop
Stop Birthday Reminders,Arrêter anniversaire rappels
Stop Material Request,Matériel de demande d'arrêt
Stop users from making Leave Applications on following days.,"Empêcher les utilisateurs de faire des demandes d&#39;autorisation, les jours suivants."
Stop!,Stop!
Stopped,Arrêté
Stopped order cannot be cancelled. Unstop to cancel.,Compte des parents ne peut pas être un grand livre
Stores,Livraison Remarque {0} ne doit pas être soumis
Stub,Source et l'entrepôt cible ne peuvent pas être de même pour la ligne {0}
Sub Assemblies,sous assemblées
"Sub-currency. For e.g. ""Cent""",Sous-monnaie. Pour exemple: &quot;Cent&quot;
Subcontract,Sous-traiter
Subject,Sujet
Submit Salary Slip,Envoyer le bulletin de salaire
Submit all salary slips for the above selected criteria,Soumettre tous les bulletins de salaire pour les critères sélectionnés ci-dessus
Submit this Production Order for further processing.,Envoyer cette ordonnance de production pour un traitement ultérieur .
Submitted,Soumis
Subsidiary,Filiale
Successful: ,Succès:
Successfully Reconciled,Réconcilié avec succès
Suggestions,Suggestions
Sunday,Dimanche
Supplier,Fournisseur
Supplier (Payable) Account,Fournisseur compte (à payer)
Supplier (vendor) name as entered in supplier master,Fournisseur (vendeur) le nom saisi dans master fournisseur
Supplier > Supplier Type,Fournisseur> Type de fournisseur
Supplier Account Head,Fournisseur compte Head
Supplier Address,Adresse du fournisseur
Supplier Addresses and Contacts,Adresses des fournisseurs et contacts
Supplier Details,Détails de produit
Supplier Intro,Intro Fournisseur
Supplier Invoice Date,Date de la facture fournisseur
Supplier Invoice No,Fournisseur facture n
Supplier Name,Nom du fournisseur
Supplier Naming By,Fournisseur de nommage par
Supplier Part Number,Numéro de pièce fournisseur
Supplier Quotation,Devis Fournisseur
Supplier Quotation Item,Article Devis Fournisseur
Supplier Reference,Référence fournisseur
Supplier Type,Type de fournisseur
Supplier Type / Supplier,Fournisseur Type / Fournisseur
Supplier Type master.,Solde de compte {0} doit toujours être {1}
Supplier Warehouse,Entrepôt Fournisseur
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Peut se référer ligne que si le type de charge est « Le précédent Montant de la ligne » ou « Précédent Row Total»
Supplier database.,Base de données fournisseurs.
Supplier master.,Maître du fournisseur .
Supplier warehouse where you have issued raw materials for sub - contracting,Fournisseur entrepôt où vous avez émis des matières premières pour la sous - traitance
Supplier-Wise Sales Analytics,Fournisseur - Wise ventes Analytics
Support,Soutenir
Support Analtyics,Analtyics de soutien
Support Analytics,Analytics soutien
Support Email,Soutien Email
Support Email Settings,Soutien des paramètres de messagerie
Support Password,Mot de passe soutien
Support Ticket,Support Ticket
Support queries from customers.,En charge les requêtes des clients.
Symbol,Symbole
Sync Support Mails,Synchroniser mails de soutien
Sync with Dropbox,Synchroniser avec Dropbox
Sync with Google Drive,Synchronisation avec Google Drive
System,Système
System Settings,Paramètres système
"System User (login) ID. If set, it will become default for all HR forms.","L&#39;utilisateur du système (login) ID. S&#39;il est défini, il sera par défaut pour toutes les formes de ressources humaines."
TDS (Advertisement),TDS (Publicité)
TDS (Commission),TDS (Commission)
TDS (Contractor),TDS (entrepreneur)
TDS (Interest),TDS (Intérêts)
TDS (Rent),TDS (Location)
TDS (Salary),TDS (Salaire)
Target  Amount,Montant Cible
Target Detail,Détail cible
Target Details,Détails cibles
Target Details1,Cible Details1
Target Distribution,Distribution cible
Target On,cible sur
Target Qty,Qté cible
Target Warehouse,Cible d&#39;entrepôt
Target warehouse in row {0} must be same as Production Order,Bon de commande {0} n'est pas soumis
Target warehouse is mandatory for row {0},Entrepôt de cible est obligatoire pour la ligne {0}
Task,Tâche
Task Details,Détails de la tâche
Tasks,tâches
Tax,Impôt
Tax Amount After Discount Amount,Aucun article avec Barcode {0}
Tax Assets,avec les groupes
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Catégorie impôt ne peut pas être « évaluation » ou « évaluation et totale », comme tous les articles sont des articles hors stock"
Tax Rate,Taux d&#39;imposition
Tax and other salary deductions.,De l&#39;impôt et autres déductions salariales.
"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","table détail d'impôt alla chercher du maître de l'article sous forme de chaîne et stockée dans ce domaine.
 Utilisé pour les impôts et charges"
Tax template for buying transactions.,Modèle d'impôt pour l'achat d' opérations .
Tax template for selling transactions.,Modèle de la taxe pour la vente de transactions .
Taxable,Imposable
Taxes,Impôts
Taxes and Charges,Impôts et taxes
Taxes and Charges Added,Taxes et redevances Ajouté
Taxes and Charges Added (Company Currency),Les impôts et les frais supplémentaires (Société Monnaie)
Taxes and Charges Calculation,Taxes et frais de calcul
Taxes and Charges Deducted,Taxes et frais déduits
Taxes and Charges Deducted (Company Currency),Impôts et Charges déduites (Société Monnaie)
Taxes and Charges Total,Taxes et frais total
Taxes and Charges Total (Company Currency),Les impôts et les frais totaux (Société Monnaie)
Technology,technologie
Telecommunications,télécommunications
Telephone Expenses,Location de bureaux
Television,télévision
Template,Modèle
Template for performance appraisals.,Modèle pour l'évaluation du rendement .
Template of terms or contract.,Modèle de termes ou d&#39;un contrat.
Temporary Accounts (Assets),Évaluation Taux requis pour objet {0}
Temporary Accounts (Liabilities),"S'il vous plaît sélectionner Point où "" Est Stock Item"" est ""Non"" et "" Est- Point de vente "" est ""Oui"" et il n'y a pas d'autre nomenclature ventes"
Temporary Assets,actifs temporaires
Temporary Liabilities,Engagements temporaires
Term Details,Détails terme
Terms,termes
Terms and Conditions,Termes et Conditions
Terms and Conditions Content,Termes et Conditions de contenu
Terms and Conditions Details,Termes et Conditions Détails
Terms and Conditions Template,Termes et Conditions modèle
Terms and Conditions1,Termes et conditions1
Terretory,Terretory
Territory,Territoire
Territory / Customer,Territoire / client
Territory Manager,Territory Manager
Territory Name,Nom du territoire
Territory Target Variance Item Group-Wise,Entretien Visitez {0} doit être annulée avant d'annuler cette commande client
Territory Targets,Les objectifs du Territoire
Test,Test
Test Email Id,Id Test Email
Test the Newsletter,Testez la Newsletter
The BOM which will be replaced,La nomenclature qui sera remplacé
The First User: You,Le premier utilisateur: Vous
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",L&#39;article qui représente le package. Cet article doit avoir «Est Produit en stock&quot; comme &quot;No&quot; et &quot;Est Point de vente&quot; que &quot;Oui&quot;
The Organization,l'Organisation
"The account head under Liability, in which Profit/Loss will be booked","Le compte tête sous la responsabilité , dans lequel Bénéfice / perte sera comptabilisée"
"The date on which next invoice will be generated. It is generated on submit.
","La date à laquelle la prochaine facture sera générée. Il est généré lors de la soumission.
"
The date on which recurring invoice will be stop,La date à laquelle la facture récurrente sera arrêter
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Le jour du mois au cours duquel la facture automatique sera généré, par exemple 05, 28, etc"
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,S'il vous plaît entrer comptes débiteurs groupe / à payer en master de l'entreprise
The first Leave Approver in the list will be set as the default Leave Approver,Le premier congé approbateur dans la liste sera définie comme le congé approbateur de défaut
The first user will become the System Manager (you can change that later).,Le premier utilisateur deviendra le gestionnaire du système ( vous pouvez changer cela plus tard ) .
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&#39;emballage. (Pour l&#39;impression)
The name of your company for which you are setting up this system.,Le nom de votre entreprise pour laquelle vous configurez ce système .
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)
The new BOM after replacement,La nouvelle nomenclature après le remplacement
The rate at which Bill Currency is converted into company's base currency,La vitesse à laquelle le projet de loi Monnaie est convertie en monnaie de base entreprise
The unique id for tracking all recurring invoices. It is generated on submit.,L&#39;identifiant unique pour le suivi de toutes les factures récurrentes. Il est généré lors de la soumission.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Ensuite, les règles de tarification sont filtrés sur la base de clientèle, par groupe de clients, Territoire, fournisseur, le type de fournisseur, campagne, etc Sales Partner"
There are more holidays than working days this month.,Compte de capital
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Il ne peut y avoir une règle de livraison Etat avec 0 ou valeur vide pour "" To Value """
There is not enough leave balance for Leave Type {0},Il n'y a pas assez de solde de congés d'autorisation de type {0}
There is nothing to edit.,Il n'y a rien à modifier.
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 avait une erreur . Une raison probable pourrait être que vous n'avez pas enregistré le formulaire. S'il vous plaît contacter support@erpnext.com si le problème persiste .
There were errors.,Il y avait des erreurs .
This Currency is disabled. Enable to use in transactions,Cette devise est désactivé . Permettre d'utiliser dans les transactions
This Leave Application is pending approval. Only the Leave Apporver can update status.,Cette demande de congé est en attente d'approbation . Seul le congé Apporver peut mettre à jour le statut .
This Time Log Batch has been billed.,This Time Connexion lot a été facturé.
This Time Log Batch has been cancelled.,This Time Connexion lot a été annulé.
This Time Log conflicts with {0},N ° de série {0} ne fait pas partie de l'article {1}
This format is used if country specific format is not found,Ce format est utilisé si le format spécifique au pays n'est pas trouvé
This is a root account and cannot be edited.,Il s'agit d'un compte root et ne peut être modifié .
This is a root customer group and cannot be edited.,Il s'agit d'un groupe de clients de la racine et ne peut être modifié .
This is a root item group and cannot be edited.,Ceci est un groupe d'élément de racine et ne peut être modifié .
This is a root sales person and cannot be edited.,Il s'agit d'une personne de ventes de racines et ne peut être modifié .
This is a root territory and cannot be edited.,C'est un territoire de racine et ne peut être modifié .
This is an example website auto-generated from ERPNext,Par défaut Warehouse est obligatoire pour les stock Article .
This is the number of the last created transaction with this prefix,Il s&#39;agit du numéro de la dernière transaction créée par ce préfixe
This will be used for setting rule in HR module,Il sera utilisé pour la règle de réglage dans le module RH
Thread HTML,Discussion HTML
Thursday,Jeudi
Time Log,Temps Connexion
Time Log Batch,Temps connecter Batch
Time Log Batch Detail,Temps connecter Détail du lot
Time Log Batch Details,Le journal du temps les détails du lot
Time Log Batch {0} must be 'Submitted',Geler stocks Older Than [ jours]
Time Log Status must be Submitted.,Log Time Etat doit être soumis.
Time Log for tasks.,Le journal du temps pour les tâches.
Time Log is not billable,Heure du journal n'est pas facturable
Time Log {0} must be 'Submitted',« Pertes et profits » compte de type {0} n'est pas autorisé dans l'ouverture d'entrée
Time Zone,Fuseau horaire
Time Zones,Fuseaux horaires
Time and Budget,Temps et budget
Time at which items were delivered from warehouse,Heure à laquelle les articles ont été livrés à partir de l&#39;entrepôt
Time at which materials were received,Heure à laquelle les matériaux ont été reçues
Title,Titre
Titles for print templates e.g. Proforma Invoice.,Solde négatif dans le lot {0} pour objet {1} à {2} Entrepôt sur ​​{3} {4}
To,À
To Currency,Pour Devise
To Date,À ce jour
To Date should be same as From Date for Half Day leave,Pour la date doit être le même que Date d' autorisation pour une demi-journée
To Date should be within the Fiscal Year. Assuming To Date = {0},Pour la date doit être dans l'exercice. En supposant à ce jour = {0}
To Discuss,Pour discuter
To Do List,To Do List
To Package No.,Pour Emballer n °
To Produce,pour Produire
To Time,To Time
To Value,To Value
To Warehouse,Pour Entrepôt
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Pour ajouter des nœuds de l'enfant , explorer arborescence et cliquez sur le nœud sous lequel vous voulez ajouter d'autres nœuds ."
"To assign this issue, use the ""Assign"" button in the sidebar.","Pour attribuer ce problème, utilisez le bouton &quot;Affecter&quot; dans la barre latérale."
To create a Bank Account,Pour créer un compte bancaire
To create a Tax Account,Pour créer un compte d'impôt
"To create an Account Head under a different company, select the company and save customer.","Pour créer un compte Head en vertu d&#39;une autre entreprise, sélectionnez l&#39;entreprise et sauver client."
To date cannot be before from date,À ce jour ne peut pas être avant la date
To enable <b>Point of Sale</b> features,Pour permettre <b>Point de Vente</b> fonctionnalités
To enable <b>Point of Sale</b> view,Pour activer <b> point de vente < / b > vue
To get Item Group in details table,Pour obtenir Groupe d&#39;éléments dans le tableau de détails
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","D'inclure la taxe dans la ligne {0} dans le prix de l'article , les impôts dans les lignes {1} doivent également être inclus"
"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"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","De ne pas appliquer la règle Prix dans une transaction particulière, toutes les règles de tarification applicables doivent être désactivés."
"To set this Fiscal Year as Default, click on 'Set as Default'","Pour définir cette Année financière que par défaut , cliquez sur "" Définir par défaut """
To track any installation or commissioning related work after sales,Pour suivre toute installation ou mise en service après-vente des travaux connexes
"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No",Impossible de charge : {0}
To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,Pour suivre pièce documents de vente et d&#39;achat en fonction de leurs numéros de série. Ce n&#39;est peut également être utilisé pour suivre les détails de la garantie du produit.
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,"Pour suivre les articles de chiffre d&#39;affaires et des documents d&#39;achat avec nos lots <br> <b>Industrie préféré: produits chimiques, etc</b>"
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Pour suivre les éléments à l&#39;aide de code à barres. Vous serez en mesure d&#39;entrer dans les articles bon de livraison et la facture de vente par balayage de code à barres de l&#39;article.
Too many columns. Export the report and print it using a spreadsheet application.,Trop de colonnes. Exporter le rapport et l'imprimer à l'aide d'un tableur.
Tools,Outils
Total,Total
Total ({0}),Total ({0})
Total Advance,Advance totale
Total Amount,Montant total
Total Amount To Pay,Montant total à payer
Total Amount in Words,Montant total en mots
Total Billing This Year: ,Facturation totale de cette année:
Total Characters,Nombre de caractères
Total Claimed Amount,Montant total réclamé
Total Commission,Total de la Commission
Total Cost,Coût total
Total Credit,Crédit total
Total Debit,Débit total
Total Debit must be equal to Total Credit. The difference is {0},Débit total doit être égal au total du crédit .
Total Deduction,Déduction totale
Total Earning,Gains totale
Total Experience,Total Experience
Total Hours,Total des heures
Total Hours (Expected),Total des heures (prévue)
Total Invoiced Amount,Montant total facturé
Total Leave Days,Total des jours de congé
Total Leaves Allocated,Feuilles total alloué
Total Message(s),Comptes temporaires ( actif)
Total Operating Cost,Coût d&#39;exploitation total
Total Points,Total des points
Total Raw Material Cost,Coût total des matières premières
Total Sanctioned Amount,Montant total sanctionné
Total Score (Out of 5),Score total (sur 5)
Total Tax (Company Currency),Total des Taxes (Société Monnaie)
Total Taxes and Charges,Total Taxes et frais
Total Taxes and Charges (Company Currency),Total des taxes et charges (Société Monnaie)
Total allocated percentage for sales team should be 100,Pourcentage total alloué à l'équipe de vente devrait être de 100
Total amount of invoices received from suppliers during the digest period,Montant total des factures reçues des fournisseurs durant la période digest
Total amount of invoices sent to the customer during the digest period,Montant total des factures envoyées au client au cours de la période digest
Total cannot be zero,Total ne peut pas être zéro
Total in words,Total en mots
Total points for all goals should be 100. It is {0},Date de fin ne peut pas être inférieure à Date de début
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Évaluation totale pour article (s) sont manufacturés ou reconditionnés ne peut pas être inférieur à l'évaluation totale des matières premières
Total weightage assigned should be 100%. It is {0},Weightage totale attribuée devrait être de 100 % . Il est {0}
Totals,Totaux
Track Leads by Industry Type.,Piste mène par type d'industrie .
Track this Delivery Note against any Project,Suivre ce bon de livraison contre tout projet
Track this Sales Order against any Project,Suivre ce décret ventes contre tout projet
Transaction,Transaction
Transaction Date,Date de la transaction
Transaction not allowed against stopped Production Order {0},installation terminée
Transfer,Transférer
Transfer Material,transfert de matériel
Transfer Raw Materials,Transfert matières premières
Transferred Qty,transféré Quantité
Transportation,transport
Transporter Info,Infos Transporter
Transporter Name,Nom Transporter
Transporter lorry number,Numéro camion transporteur
Travel,Quantité ne peut pas être une fraction dans la ligne {0}
Travel Expenses,Code article nécessaire au rang n ° {0}
Tree Type,Type d' arbre
Tree of Item Groups.,Arbre de groupes des ouvrages .
Tree of finanial Cost Centers.,Il ne faut pas mettre à jour les entrées de plus que {0}
Tree of finanial accounts.,Titres à {0} doivent être annulées avant d'annuler cette commande client
Trial Balance,Balance
Tuesday,Mardi
Type,Type
Type of document to rename.,Type de document à renommer.
"Type of leaves like casual, sick etc.","Type de feuilles comme occasionnel, etc malades"
Types of Expense Claim.,Types de demande de remboursement.
Types of activities for Time Sheets,Types d&#39;activités pour les feuilles de temps
"Types of employment (permanent, contract, intern etc.).",S'il vous plaît vous connecter à Upvote !
UOM Conversion Detail,Détail de conversion Emballage
UOM Conversion Details,Détails conversion UOM
UOM Conversion Factor,Facteur de conversion Emballage
UOM Conversion factor is required in row {0},Point {0} a été saisi plusieurs fois avec la même description ou la date ou de l'entrepôt
UOM Name,Nom UDM
UOM coversion factor required for UOM: {0} in Item: {1},Facteur de coversion Emballage requis pour Emballage: {0} dans l'article: {1}
Under AMC,En vertu de l&#39;AMC
Under Graduate,Sous Graduate
Under Warranty,Sous garantie
Unit,unité
Unit of Measure,Unité de mesure
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unité de mesure {0} a été saisi plus d'une fois dans facteur de conversion de table
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Unité de mesure de cet article (Kg par exemple, unité, Non, Pair)."
Units/Hour,Unités / heure
Units/Shifts,Unités / Quarts de travail
Unpaid,Non rémunéré
Unreconciled Payment Details,Non rapprochés détails de paiement
Unscheduled,Non programmé
Unsecured Loans,Les prêts non garantis
Unstop,déboucher
Unstop Material Request,Unstop Demande de Matériel
Unstop Purchase Order,Unstop Commande
Unsubscribed,Désabonné
Update,Mettre à jour
Update Clearance Date,Mettre à jour Date de Garde
Update Cost,mise à jour des coûts
Update Finished Goods,Marchandises mise à jour terminée
Update Landed Cost,Mise à jour d'arrivée Coût
Update Series,Update Series
Update Series Number,Numéro de série mise à jour
Update Stock,Mise à jour Stock
Update bank payment dates with journals.,Mise à jour bancaire dates de paiement des revues.
Update clearance date of Journal Entries marked as 'Bank Vouchers',Date d'autorisation de mise à jour des entrées de journal marqué comme « Banque Bons »
Updated,Mise à jour
Updated Birthday Reminders,Mise à jour anniversaire rappels
Upload Attendance,Téléchargez Participation
Upload Backups to Dropbox,Téléchargez sauvegardes à Dropbox
Upload Backups to Google Drive,Téléchargez sauvegardes à Google Drive
Upload HTML,Téléchargez HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Télécharger un fichier csv avec deux colonnes:. L&#39;ancien nom et le nouveau nom. Max 500 lignes.
Upload attendance from a .csv file,Téléchargez la présence d&#39;un fichier. Csv
Upload stock balance via csv.,Téléchargez solde disponible via csv.
Upload your letter head and logo - you can edit them later.,Téléchargez votre tête et logo lettre - vous pouvez les modifier plus tard .
Upper Income,Revenu élevé
Urgent,Urgent
Use Multi-Level BOM,Utilisez Multi-Level BOM
Use SSL,Utiliser SSL
Used for Production Plan,Utilisé pour plan de production
User,Utilisateur
User ID,ID utilisateur
User ID not set for Employee {0},ID utilisateur non défini pour les employés {0}
User Name,Nom d&#39;utilisateur
User Name or Support Password missing. Please enter and try again.,Nom d'utilisateur ou mot de passe manquant de soutien . S'il vous plaît entrer et essayer à nouveau.
User Remark,Remarque l&#39;utilisateur
User Remark will be added to Auto Remark,Remarque l&#39;utilisateur sera ajouté à Remarque Auto
User Remarks is mandatory,recharger la page
User Specific,Achat et vente
User must always select,L&#39;utilisateur doit toujours sélectionner
User {0} is already assigned to Employee {1},Utilisateur {0} est déjà attribué à l'employé {1}
User {0} is disabled,Territoire cible Variance article Groupe Sage
Username,Nom d&#39;utilisateur
Users with this role are allowed to create / modify accounting entry before frozen date,Les utilisateurs ayant ce rôle sont autorisés à créer / modifier l'entrée de la comptabilité avant la date congelés
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 à fixer les comptes gelés et de créer / modifier des entrées comptables contre les comptes gelés
Utilities,Utilitaires
Utility Expenses,Commande {0} n'est pas soumis
Valid For Territories,Valable pour les territoires
Valid From,Aucun article avec Serial Non {0}
Valid Upto,Jusqu&#39;à valide
Valid for Territories,Valable pour les Territoires
Validate,Valider
Valuation,Évaluation
Valuation Method,Méthode d&#39;évaluation
Valuation Rate,Taux d&#39;évaluation
Valuation Rate required for Item {0},{0} {1} est l'état 'arrêté'
Valuation and Total,Valorisation et Total
Value,Valeur
Value or Qty,Valeur ou Quantité
Vehicle Dispatch Date,Date de véhicule Dispatch
Vehicle No,Aucun véhicule
Venture Capital,capital de risque
Verified By,Vérifié par
View Ledger,Voir Ledger
View Now,voir maintenant
Visit report for maintenance call.,Visitez le rapport de l&#39;appel d&#39;entretien.
Voucher #,bon #
Voucher Detail No,Détail volet n °
Voucher Detail Number,Bon nombre de Détail
Voucher ID,ID Bon
Voucher No,Bon Pas
Voucher Type,Type de Bon
Voucher Type and Date,Type de chèques et date
Walk In,Walk In
Warehouse,entrepôt
Warehouse Contact Info,Entrepôt Info Contact
Warehouse Detail,Détail d&#39;entrepôt
Warehouse Name,Nom d&#39;entrepôt
Warehouse and Reference,Entrepôt et référence
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Descendre : {0}
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Entrepôt ne peut être modifié via Stock Entrée / bon de livraison / reçu d'achat
Warehouse cannot be changed for Serial No.,Entrepôt ne peut être modifié pour le numéro de série
Warehouse is mandatory for stock Item {0} in row {1},Facteur de conversion ne peut pas être dans les fractions
Warehouse is missing in Purchase Order,Entrepôt est manquant dans la commande d'achat
Warehouse not found in the system,Entrepôt pas trouvé dans le système
Warehouse required for stock Item {0},{0} est obligatoire
Warehouse where you are maintaining stock of rejected items,Entrepôt où vous êtes maintenant le bilan des éléments rejetés
Warehouse {0} can not be deleted as quantity exists for Item {1},Entrepôt {0} ne peut pas être supprimé car il existe quantité pour objet {1}
Warehouse {0} does not belong to company {1},Entrepôt {0} n'appartient pas à la société {1}
Warehouse {0} does not exist,{0} n'est pas un courriel valide Identifiant
Warehouse {0}: Company is mandatory,Entrepôt {0}: Société est obligatoire
Warehouse {0}: Parent account {1} does not bolong to the company {2},Entrepôt {0}: compte de Parent {1} ne BOLONG à la société {2}
Warehouse-Wise Stock Balance,Warehouse-Wise Stock Solde
Warehouse-wise Item Reorder,Warehouse-sage Réorganiser article
Warehouses,Entrepôts
Warehouses.,applicable
Warn,Avertir
Warning: Leave application contains following block dates,Attention: la demande d&#39;autorisation contient les dates de blocs suivants
Warning: Material Requested Qty is less than Minimum Order Qty,Attention: Matériel requis Quantité est inférieure Quantité minimum à commander
Warning: Sales Order {0} already exists against same Purchase Order number,S'il vous plaît vérifier ' Est Advance' contre compte {0} si c'est une entrée avance .
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 depuis montant pour objet {0} dans {1} est nulle
Warranty / AMC Details,Garantie / AMC Détails
Warranty / AMC Status,Garantie / AMC Statut
Warranty Expiry Date,Date d&#39;expiration de garantie
Warranty Period (Days),Période de garantie (jours)
Warranty Period (in days),Période de garantie (en jours)
We buy this Item,Nous achetons cet article
We sell this Item,Nous vendons cet article
Website,Site Web
Website Description,Description du site Web
Website Item Group,Groupe Article Site
Website Item Groups,Groupes d&#39;articles Site web
Website Settings,Réglages Site web
Website Warehouse,Entrepôt site web
Wednesday,Mercredi
Weekly,Hebdomadaire
Weekly Off,Hebdomadaire Off
Weight UOM,Poids Emballage
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Le poids est indiqué , \ nVeuillez mentionne "" Poids Emballage « trop"
Weightage,Weightage
Weightage (%),Weightage (%)
Welcome,Taux (% )
Welcome to ERPNext. Over the next few minutes we will help you setup your ERPNext account. Try and fill in as much information as you have even if it takes a bit longer. It will save you a lot of time later. Good Luck!,"Bienvenue à ERPNext . Au cours des prochaines minutes, nous allons vous aider à configurer votre compte ERPNext . Essayez de remplir autant d'informations que vous avez même si cela prend un peu plus longtemps . Elle vous fera économiser beaucoup de temps plus tard . Bonne chance !"
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Tête de compte {0} créé
What does it do?,Que faut-il faire ?
"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 l&#39;une des opérations contrôlées sont «soumis», un e-mail pop-up s&#39;ouvre automatiquement pour envoyer un courrier électronique à l&#39;associé &quot;Contact&quot; dans cette transaction, la transaction en pièce jointe. L&#39;utilisateur peut ou ne peut pas envoyer l&#39;e-mail."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Lorsqu'il est utilisé, le système crée des entrées de différence pour définir le stock et l'évaluation donnée à cette date ."
Where items are stored.,Lorsque des éléments sont stockés.
Where manufacturing operations are carried out.,Lorsque les opérations de fabrication sont réalisées.
Widowed,Veuf
Will be calculated automatically when you enter the details,Seront calculés automatiquement lorsque vous entrez les détails
Will be updated after Sales Invoice is Submitted.,Sera mis à jour après la facture de vente est soumise.
Will be updated when batched.,Sera mis à jour lorsque lots.
Will be updated when billed.,Sera mis à jour lorsqu&#39;ils sont facturés.
Wire Transfer,Virement
With Operations,Avec des opérations
With Period Closing Entry,Avec l'entrée de clôture de la période
Work Details,Détails de travail
Work Done,Travaux effectués
Work In Progress,Work In Progress
Work-in-Progress Warehouse,Entrepôt Work-in-Progress
Work-in-Progress Warehouse is required before Submit,Les travaux en progrès entrepôt est nécessaire avant Soumettre
Working,De travail
Working Days,Jours ouvrables
Workstation,Workstation
Workstation Name,Nom de station de travail
Write Off Account,Ecrire Off compte
Write Off Amount,Ecrire Off Montant
Write Off Amount <=,Ecrire Off Montant &lt;=
Write Off Based On,Ecrire Off Basé sur
Write Off Cost Center,Ecrire Off Centre de coûts
Write Off Outstanding Amount,Ecrire Off Encours
Write Off Voucher,Ecrire Off Bon
Wrong Template: Unable to find head row.,Modèle tort: ​​Impossible de trouver la ligne de tête.
Year,Année
Year Closed,L&#39;année Fermé
Year End Date,Fin de l'exercice Date de
Year Name,Nom Année
Year Start Date,Date de début Année
Year of Passing,Année de passage
Yearly,Annuel
Yes,Oui
You are not authorized to add or update entries before {0},{0} est maintenant par défaut exercice. S'il vous plaît rafraîchir votre navigateur pour que le changement prenne effet .
You are not authorized to set Frozen value,Vous n'êtes pas autorisé à mettre en valeur Frozen
You are the Expense Approver for this record. Please Update the 'Status' and Save,Vous êtes l'approbateur de dépenses pour cet enregistrement . S'il vous plaît mettre à jour le «Status» et Save
You are the Leave Approver for this record. Please Update the 'Status' and Save,Vous êtes l'approbateur congé pour cet enregistrement . S'il vous plaît mettre à jour le «Status» et Save
You can enter any date manually,Vous pouvez entrer une date manuellement
You can enter the minimum quantity of this item to be ordered.,Vous pouvez entrer la quantité minimale de cet élément à commander.
You can not change rate if BOM mentioned agianst any item,Vous ne pouvez pas modifier le taux si BOM mentionné agianst un article
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Vous ne pouvez pas entrer à la fois bon de livraison et la facture de vente n ° n ° S'il vous plaît entrer personne.
You can not enter current voucher in 'Against Journal Voucher' column,"D'autres comptes peuvent être faites dans les groupes , mais les entrées peuvent être faites contre Ledger"
You can set Default Bank Account in Company master,Articles en attente {0} mise à jour
You can start by selecting backup frequency and granting access for sync,Vous pouvez commencer par sélectionner la fréquence de sauvegarde et d'accorder l'accès pour la synchronisation
You can submit this Stock Reconciliation.,Vous pouvez soumettre cette Stock réconciliation .
You can update either Quantity or Valuation Rate or both.,Vous pouvez mettre à jour soit Quantité ou l'évaluation des taux ou les deux.
You cannot credit and debit same account at the same time,Vous ne pouvez pas crédit et de débit même compte en même temps
You have entered duplicate items. Please rectify and try again.,Vous avez entré les doublons . S'il vous plaît corriger et essayer à nouveau.
You may need to update: {0},Vous devez mettre à jour : {0}
You must Save the form before proceeding,produits impressionnants
Your Customer's TAX registration numbers (if applicable) or any general information,Votre Client numéros d&#39;immatriculation fiscale (le cas échéant) ou toute autre information générale
Your Customers,vos clients
Your Login Id,Votre ID de connexion
Your Products or Services,Vos produits ou services
Your Suppliers,vos fournisseurs
Your email address,Frais indirects
Your financial year begins on,"Vous ne pouvez pas changer la devise par défaut de l'entreprise , car il ya des opérations existantes . Les opérations doivent être annulées pour changer la devise par défaut ."
Your financial year ends on,Votre exercice se termine le
Your sales person who will contact the customer in future,Votre personne de ventes qui prendra contact avec le client dans le futur
Your sales person will get a reminder on this date to contact the customer,Votre personne de ventes recevoir un rappel de cette date pour contacter le client
Your setup is complete. Refreshing...,Votre installation est terminée. Rafraîchissant ...
Your support email id - must be a valid email - this is where your emails will come!,Votre e-mail id soutien - doit être une adresse email valide - c&#39;est là que vos e-mails viendra!
[Error],[Error]
[Select],[Sélectionner ]
`Freeze Stocks Older Than` should be smaller than %d days.,Fichier source
and,et
are not allowed.,ne sont pas autorisés .
assigned by,attribué par
cannot be greater than 100,ne peut pas être supérieure à 100
"e.g. ""Build tools for builders""","par exemple "" Construire des outils pour les constructeurs """
"e.g. ""MC""","par exemple ""MC"""
"e.g. ""My Company LLC""","par exemple "" Mon Company LLC """
e.g. 5,par exemple 5
"e.g. Bank, Cash, Credit Card","par exemple, bancaire, Carte de crédit"
"e.g. Kg, Unit, Nos, m","kg par exemple, l&#39;unité, n, m"
e.g. VAT,par exemple TVA
eg. Cheque Number,par exemple. Numéro de chèque
example: Next Day Shipping,Exemple: Jour suivant Livraison
lft,lft
old_parent,old_parent
rgt,rgt
subject,sujet
to,à
website page link,Lien vers page web
{0} '{1}' not in Fiscal Year {2},Profil d'emploi
{0} Credit limit {0} crossed,N ° de série {0} ne fait pas partie d' entrepôt {1}
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} numéros de série requis pour objet {0} . Seulement {0} fournie .
{0} budget for Account {1} against Cost Center {2} will exceed by {3},Alternative lien de téléchargement
{0} can not be negative,{0} ne peut pas être négatif
{0} created,L'article est mis à jour
{0} does not belong to Company {1},joindre l'image
{0} entered twice in Item Tax,{0} est entré deux fois dans l'impôt de l'article
{0} is an invalid email address in 'Notification Email Address',{0} est une adresse e-mail valide dans 'Notification Email '
{0} is mandatory,Restrictions de l'utilisateur
{0} is mandatory for Item {1},{0} est obligatoire pour objet {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} est obligatoire. Peut-être que dossier de change n'est pas créé pour {1} et {2}.
{0} is not a stock Item,« De Date ' est nécessaire
{0} is not a valid Batch Number for Item {1},{0} n'est pas un numéro de lot valable pour objet {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} n'est pas un congé approbateur valide. Retrait rangée # {1}.
{0} is not a valid email id,S'il vous plaît sélectionner la valeur de groupe ou Ledger
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,matériel
{0} is required,{0} ne peut pas être acheté en utilisant Panier
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} doit être un article acheté ou sous-traitées à la ligne {1}
{0} must be reduced by {1} or you should increase overflow tolerance,{0} doit être réduite par {1} ou vous devez augmenter la tolérance de dépassement
{0} must have role 'Leave Approver',Nouveau Stock UDM est nécessaire
{0} valid serial nos for Item {1},BOM {0} pour objet {1} à la ligne {2} est inactif ou non soumis
{0} {1} against Bill {2} dated {3},S'il vous plaît entrer le titre !
{0} {1} against Invoice {2},investissements
{0} {1} has already been submitted,"S'il vous plaît entrer » est sous-traitée "" comme Oui ou Non"
{0} {1} has been modified. Please refresh.,Point ou Entrepôt à la ligne {0} ne correspond pas à la Demande de Matériel
{0} {1} is not submitted,Accepté Rejeté + Quantité doit être égale à la quantité reçue pour objet {0}
{0} {1} must be submitted,{0} {1} doit être soumis
{0} {1} not in any Fiscal Year,{0} {1} pas en cours d'un exercice
{0} {1} status is 'Stopped',Type Nom de la partie
{0} {1} status is Stopped,{0} {1} statut est arrêté
{0} {1} status is Unstopped,Vous ne pouvez pas reporter le numéro de rangée supérieure ou égale à numéro de la ligne actuelle pour ce type de charge
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: Centre de coûts est obligatoire pour objet {2}
{0}: {1} not found in Invoice Details table,{0}: {1} ne trouve pas dans la table Détails de la facture
