 (Half Day), (Mezza Giornata)
 and year: ,e anno:
""" does not exists","""Non esiste"
%  Delivered,%  Consegnato
% Amount Billed,% Importo Fatturato
% Billed,% Fatturato
% Completed,% Completato
% Delivered,Consegnato %
% Installed,% Installato
% Received,% Ricevuto
% of materials billed against this Purchase Order.,% di materiali fatturati su questo Ordine di Acquisto.
% of materials billed against this Sales Order,% di materiali fatturati su questo Ordine di Vendita
% of materials delivered against this Delivery Note,% dei materiali consegnati di questa Bolla di Consegna
% of materials delivered against this Sales Order,% dei materiali consegnati su questo Ordine di Vendita
% of materials ordered against this Material Request,% di materiali ordinati su questa Richiesta Materiale
% of materials received against this Purchase Order,di materiali ricevuti su questo Ordine di Acquisto
'Actual Start Date' can not be greater than 'Actual End Date',' Data Inizio effettivo ' non può essere maggiore di ' Data di fine effettiva '
'Based On' and 'Group By' can not be same,' Basato su ' e ' Group By ' non può essere lo stesso
'Days Since Last Order' must be greater than or equal to zero,' Giorni dall'ultima Ordina ' deve essere maggiore o uguale a zero
'Entries' cannot be empty,' Voci ' non può essere vuoto
'Expected Start Date' can not be greater than 'Expected End Date',' Data prevista di inizio ' non può essere maggiore di ' Data di fine prevista '
'From Date' is required,'From Date' è richiesto
'From Date' must be after 'To Date',' Dalla Data ' deve essere successiva 'To Date'
'Has Serial No' can not be 'Yes' for non-stock item,' Ha Serial No' non può essere ' Sì' per i non- articolo di
'Notification Email Addresses' not specified for recurring invoice,«Notifica indirizzi e-mail ' non specificati per fattura ricorrenti
'Profit and Loss' type account {0} not allowed in Opening Entry,' Economico ' tipo di account {0} non consentito in apertura di ingresso
'To Case No.' cannot be less than 'From Case No.','A Case N.' non puo essere minore di 'Da Case N.'
'To Date' is required,'To Date' è richiesto
'Update Stock' for Sales Invoice {0} must be set,'Aggiorna Archivio ' per Fattura {0} deve essere impostato
* Will be calculated in the transaction.,'A Case N.' non puo essere minore di 'Da Case N.'
"1 Currency = [?] Fraction
For e.g. 1 USD = 100 Cent","1 valuta = [?] Frazione 
 Per esempio 1 USD = 100 Cent"
1. To maintain the customer wise item code and to make them searchable based on their code use this option,1.Per mantenere la voce codice cliente e renderli ricercabili in base al loro codice usare questa opzione
"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group""> Aggiungi / Modifica < / a>"
"<a href=""#Sales Browser/Item Group"">Add / Edit</a>","<a href=""#Sales Browser/Item Group""> Aggiungi / Modifica < / a>"
"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory""> Aggiungi / Modifica < / 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> modello predefinito </ h4> 
 <p> Utilizza <a href=""http://jinja.pocoo.org/docs/templates/""> Jinja Templating </ a> e tutti i campi di indirizzo ( compresi i campi personalizzati se presenti) sarà disponibile </ p> 
 <pre> <code> {{address_line1}} <br> 
 {% se address_line2%} {{address_line2}} {<br> % endif -%} 
 {{city}} <br> 
 {% se lo stato%} {{stato}} <br> {% endif -%} 
 {% se pincode%} PIN: {{}} pincode <br> {% endif -%} 
 {{country}} <br> 
 {% se il telefono%} Telefono: {{phone}} {<br> % endif -}% 
 {% se il fax%} Fax: {{fax}} <br> {% endif -%} 
 {% se email_id%} Email: {{email_id}} <br> {% endif -%} 
 </ code> </ pre>"
A Customer Group exists with same name please change the Customer name or rename the Customer Group,Un Gruppo cliente esiste con lo stesso nome si prega di modificare il nome del cliente o rinominare il gruppo di clienti
A Customer exists with same name,Esiste un Cliente con lo stesso nome
A Lead with this email id should exist,Un Lead con questa e-mail dovrebbe esistere
A Product or Service,Un prodotto o servizio
A Supplier exists with same name,Esiste un Fornitore con lo stesso nome
A symbol for this currency. For e.g. $,Un simbolo per questa valuta. Per esempio $
AMC Expiry Date,AMC Data Scadenza
Abbr,Abbr
Abbreviation cannot have more than 5 characters,Abbreviazione non può avere più di 5 caratteri
Above Value,Sopra Valore
Absent,Assente
Acceptance Criteria,Criterio Accettazione
Accepted,Accettato
Accepted + Rejected Qty must be equal to Received quantity for Item {0},Accettato + Respinto quantità deve essere uguale al quantitativo ricevuto per la voce {0}
Accepted Quantity,Quantità Accettata
Accepted Warehouse,Magazzino Accettato
Account,conto
Account Balance,Bilancio Conto
Account Created: {0},Account Creato : {0}
Account Details,Dettagli conto
Account Head,Conto Capo
Account Name,Nome Conto
Account Type,Tipo Conto
"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'","Saldo del conto già in credito, non sei autorizzato a impostare 'saldo deve essere' come 'Debito'"
"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'","Saldo del conto già in debito, non ti è permesso di impostare 'saldo deve essere' come 'credito'"
Account for the warehouse (Perpetual Inventory) will be created under this Account.,Conto per il magazzino ( Perpetual Inventory) verrà creato con questo account .
Account head {0} created,Testa account {0} creato
Account must be a balance sheet account,Account deve essere un account di bilancio
Account with child nodes cannot be converted to ledger,Conto con nodi figlio non può essere convertito in contabilità
Account with existing transaction can not be converted to group.,Conto con transazione esistente non può essere convertito al gruppo .
Account with existing transaction can not be deleted,Conto con transazione esistente non può essere cancellato
Account with existing transaction cannot be converted to ledger,Conto con transazione esistente non può essere convertito in contabilità
Account {0} cannot be a Group,Account {0} non può essere un gruppo
Account {0} does not belong to Company {1},Account {0} non appartiene alla società {1}
Account {0} does not belong to company: {1},Account {0} non appartiene alla società: {1}
Account {0} does not exist,Account {0} non esiste
Account {0} has been entered more than once for fiscal year {1},Account {0} è stato inserito più di una volta per l'anno fiscale {1}
Account {0} is frozen,Account {0} è congelato
Account {0} is inactive,Account {0} è inattivo
Account {0} is not valid,Account {0} non è valido
Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,Account {0} deve essere di tipo ' Asset fisso ' come voce {1} è un Asset articolo
Account {0}: Parent account {1} can not be a ledger,Account {0}: conto Parent {1} non può essere un libro mastro
Account {0}: Parent account {1} does not belong to company: {2},Account {0}: conto Parent {1} non appartiene alla società: {2}
Account {0}: Parent account {1} does not exist,Account {0}: conto Parent {1} non esiste
Account {0}: You can not assign itself as parent account,Account {0}: Non è possibile assegnare stesso come conto principale
"Account: {0} can only be updated via \
					Stock Transactions","Account: {0} può essere aggiornato solo tramite \
 transazioni di magazzino"
Accountant,ragioniere
Accounting,Contabilità
"Accounting Entries can be made against leaf nodes, called","Scritture contabili può essere fatta contro nodi foglia , chiamato"
"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.","Registrazione contabile congelato fino a questa data, nessuno può / Modifica voce eccetto ruolo specificato di seguito."
Accounting journal entries.,Diario scritture contabili.
Accounts,Conti
Accounts Browser,conti Browser
Accounts Frozen Upto,Conti congelati Fino
Accounts Payable,Conti pagabili
Accounts Receivable,Conti esigibili
Accounts Settings,Impostazioni Conti
Active,Attivo
Active: Will extract emails from ,Attivo: Will estrarre le email da
Activity,Attività
Activity Log,Log Attività
Activity Log:,Registro attività :
Activity Type,Tipo Attività
Actual,Attuale
Actual Budget,Budget Attuale
Actual Completion Date,Data Completamento Attuale
Actual Date,Stato Corrente
Actual End Date,Attuale Data Fine
Actual Invoice Date,Actual Data fattura
Actual Posting Date,Data di registrazione effettiva
Actual Qty,Q.tà Reale
Actual Qty (at source/target),Q.tà Reale (sorgente/destinazione)
Actual Qty After Transaction,Q.tà Reale dopo la Transazione
Actual Qty: Quantity available in the warehouse.,Quantità effettivo: Quantità disponibile a magazzino.
Actual Quantity,Quantità Reale
Actual Start Date,Data Inizio Effettivo
Add,Aggiungi
Add / Edit Taxes and Charges,Aggiungere / Modificare Tasse e Costi
Add Child,Aggiungi ai bambini
Add Serial No,Aggiungi Serial No
Add Taxes,Aggiungi Imposte
Add Taxes and Charges,Aggiungere Tasse e spese
Add or Deduct,Aggiungere o dedurre
Add rows to set annual budgets on Accounts.,Aggiungere righe per impostare i budget annuali sui conti.
Add to Cart,Aggiungi al carrello
Add to calendar on this date,Aggiungi al calendario in questa data
Add/Remove Recipients,Aggiungere/Rimuovere Destinatario
Address,Indirizzo
Address & Contact,Indirizzo e Contatto
Address & Contacts,Indirizzi & Contatti
Address Desc,Desc. indirizzo
Address Details,Dettagli dell'indirizzo
Address HTML,Indirizzo HTML
Address Line 1,"Indirizzo, riga 1"
Address Line 2,"Indirizzo, riga 2"
Address Template,Indirizzo Template
Address Title,Titolo indirizzo
Address Title is mandatory.,Titolo Indirizzo è obbligatorio.
Address Type,Tipo di indirizzo
Address master.,Indirizzo master.
Administrative Expenses,Spese Amministrative
Administrative Officer,responsabile amministrativo
Advance Amount,Importo Anticipo
Advance amount,Importo anticipo
Advances,Avanzamenti
Advertisement,Pubblicità
Advertising,pubblicità
Aerospace,aerospaziale
After Sale Installations,Installazioni Post Vendita
Against,Previsione
Against Account,Previsione Conto
Against Bill {0} dated {1},Contro Bill {0} datato {1}
Against Docname,Per Nome Doc
Against Doctype,Per Doctype
Against Document Detail No,Per Dettagli Documento N
Against Document No,Per Documento N
Against Expense Account,Per Spesa Conto
Against Income Account,Per Reddito Conto
Against Journal Voucher,Per Buono Acquisto
Against Journal Voucher {0} does not have any unmatched {1} entry,Contro ufficiale Voucher {0} non ha alcun ineguagliata {1} entry
Against Purchase Invoice,Per Fattura Acquisto
Against Sales Invoice,Per Fattura Vendita
Against Sales Order,Contro Sales Order
Against Voucher,Per Tagliando
Against Voucher Type,Per tipo Tagliando
Ageing Based On,Invecchiamento Basato Su
Ageing Date is mandatory for opening entry,Data di invecchiamento è obbligatorio per l'apertura di ingresso
Ageing date is mandatory for opening entry,Data di invecchiamento è obbligatorio per l'apertura di ingresso
Agent,Agente
Aging Date,Data invecchiamento
Aging Date is mandatory for opening entry,Data di invecchiamento è obbligatorio per l'apertura di ingresso
Agriculture,agricoltura
Airline,linea aerea
All Addresses.,Tutti gli indirizzi.
All Contact,Tutti i contatti
All Contacts.,Tutti i contatti.
All Customer Contact,Tutti Contatti Clienti
All Customer Groups,Tutti i gruppi di clienti
All Day,Intera giornata
All Employee (Active),Tutti Dipendenti (Attivi)
All Item Groups,Tutti i gruppi di articoli
All Lead (Open),Tutti LEAD (Aperto)
All Products or Services.,Tutti i Prodotti o Servizi.
All Sales Partner Contact,Tutte i contatti Partner vendite
All Sales Person,Tutti i Venditori
All Supplier Contact,Tutti i Contatti Fornitori
All Supplier Types,Tutti i tipi di fornitori
All Territories,tutti i Territori
"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.","Campi Tutte le esportazioni correlati come valuta , il tasso di conversione , totale delle esportazioni , export gran etc totale sono disponibili nella nota di consegna , POS , Quotazione , fattura di vendita , ordini di vendita , ecc"
"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.","Tutti i campi importazione correlati come valuta , il tasso di conversione , totale import , importazione gran etc totale sono disponibili in Acquisto ricevuta , Quotazione fornitore , fattura di acquisto , ordine di acquisto , ecc"
All items have already been invoiced,Tutti gli articoli sono già stati fatturati
All these items have already been invoiced,Tutti questi elementi sono già stati fatturati
Allocate,Assegna
Allocate leaves for a period.,Allocare le foglie per un periodo .
Allocate leaves for the year.,Assegnare le foglie per l' anno.
Allocated Amount,Assegna Importo
Allocated Budget,Assegna Budget
Allocated amount,Assegna importo
Allocated amount can not be negative,Importo concesso non può essere negativo
Allocated amount can not greater than unadusted amount,Importo concesso può non superiore all'importo unadusted
Allow Bill of Materials,Consentire Distinta di Base
Allow Bill of Materials should be 'Yes'. Because one or many active BOMs present for this item,Lasciare distinte dei materiali dovrebbe essere ' sì ' . Perché uno o più distinte materiali attivi presenti per questo articolo
Allow Children,permettere ai bambini
Allow Dropbox Access,Consentire Accesso DropBox
Allow Google Drive Access,Consentire Accesso Google Drive
Allow Negative Balance,Consentire Bilancio Negativo
Allow Negative Stock,Consentire Magazzino Negativo
Allow Production Order,Consentire Ordine Produzione
Allow User,Consentire Utente
Allow Users,Consentire Utenti
Allow the following users to approve Leave Applications for block days.,Consentire i seguenti utenti per approvare le richieste per i giorni di blocco.
Allow user to edit Price List Rate in transactions,Consenti all&#39;utente di modificare Listino cambio nelle transazioni
Allowance Percent,Tolleranza Percentuale
Allowance for over-{0} crossed for Item {1},Indennità per over-{0} incrociate per la voce {1}
Allowance for over-{0} crossed for Item {1}.,Indennità per over-{0} attraversato per la voce {1}.
Allowed Role to Edit Entries Before Frozen Date,Ruolo permesso di modificare le voci prima congelato Data
Amended From,Corretto da
Amount,Importo
Amount (Company Currency),Importo (Valuta Azienda)
Amount Paid,Importo pagato
Amount to Bill,Importo da Bill
An Customer exists with same name,Esiste un cliente con lo stesso nome
"An Item Group exists with same name, please change the item name or rename the item group","Un gruppo di elementi esiste con lo stesso nome , si prega di cambiare il nome della voce o rinominare il gruppo di articoli"
"An item exists with same name ({0}), please change the item group name or rename the item","Un elemento esiste con lo stesso nome ( {0} ) , si prega di cambiare il nome del gruppo o di rinominare la voce"
Analyst,analista
Annual,annuale
Another Period Closing Entry {0} has been made after {1},Un'altra voce periodo di chiusura {0} è stato fatto dopo {1}
Another Salary Structure {0} is active for employee {0}. Please make its status 'Inactive' to proceed.,Un'altra struttura retributiva {0} è attivo per dipendente {0} . Si prega di fare il suo status di ' inattivo ' per procedere .
"Any other comments, noteworthy effort that should go in the records.","Altre osservazioni, degno di nota lo sforzo che dovrebbe andare nei registri."
Apparel & Accessories,Abbigliamento e accessori
Applicability,applicabilità
Applicable For,applicabile per
Applicable Holiday List,Lista Vacanze Applicabile
Applicable Territory,Territorio applicabile
Applicable To (Designation),Applicabile a (Designazione)
Applicable To (Employee),Applicabile a (Dipendente)
Applicable To (Role),Applicabile a (Ruolo)
Applicable To (User),Applicabile a (Utente)
Applicant Name,Nome del Richiedente
Applicant for a Job.,Richiedente per Lavoro.
Application of Funds (Assets),Applicazione dei fondi ( Assets )
Applications for leave.,Richieste di Ferie
Applies to Company,Applica ad Azienda
Apply On,applicare On
Appraisal,Valutazione
Appraisal Goal,Obiettivo di Valutazione
Appraisal Goals,Obiettivi di Valutazione
Appraisal Template,Valutazione Modello
Appraisal Template Goal,Valutazione Modello Obiettivo
Appraisal Template Title,Valutazione Titolo Modello
Appraisal {0} created for Employee {1} in the given date range,Valutazione {0} creato per Employee {1} nel determinato intervallo di date
Apprentice,apprendista
Approval Status,Stato Approvazione
Approval Status must be 'Approved' or 'Rejected',Stato approvazione deve essere ' Approvato ' o ' Rifiutato '
Approved,Approvato
Approver,Certificatore
Approving Role,Regola Approvazione
Approving Role cannot be same as role the rule is Applicable To,Approvazione ruolo non può essere lo stesso ruolo la regola è applicabile ad
Approving User,Utente Certificatore
Approving User cannot be same as user the rule is Applicable To,Approvazione utente non può essere uguale all'utente la regola è applicabile ad
Are you sure you want to STOP ,
Are you sure you want to UNSTOP ,
Arrear Amount,Importo posticipata
"As Production Order can be made for this item, it must be a stock item.","Come ordine di produzione può essere fatta per questo articolo , deve essere un elemento di magazzino ."
As per Stock UOM,Per Stock UOM
"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'","Come ci sono le transazioni di magazzino esistenti per questo articolo, non è possibile modificare i valori di ' Ha Serial No' , ' è articolo di ' e ' il metodo di valutazione '"
Asset,attività
Assistant,assistente
Associate,Associate
Atleast one of the Selling or Buying must be selected,", Almeno una delle vendere o acquistare deve essere selezionata"
Atleast one warehouse is mandatory,Almeno un Magazzino è obbligatorio
Attach Image,Allega immagine
Attach Letterhead,Allega intestata
Attach Logo,Allega Logo
Attach Your Picture,Allega la tua foto
Attendance,Presenze
Attendance Date,Data Presenza
Attendance Details,Dettagli presenze
Attendance From Date,Partecipazione Da Data
Attendance From Date and Attendance To Date is mandatory,La frequenza da Data e presenze A Data è obbligatoria
Attendance To Date,Partecipazione a Data
Attendance can not be marked for future dates,La Presenza non può essere inserita nel futuro
Attendance for employee {0} is already marked,Assistenza per dipendente {0} è già contrassegnata
Attendance record.,Archivio Presenze
Authorization Control,Controllo Autorizzazioni
Authorization Rule,Ruolo Autorizzazione
Auto Accounting For Stock Settings,Contabilità Auto Per Impostazioni Immagini
Auto Material Request,Richiesta Materiale Auto
Auto-raise Material Request if quantity goes below re-order level in a warehouse,Auto aumenta Materiale Richiesta se la quantità scende sotto il livello di riordino in un magazzino
Automatically compose message on submission of transactions.,Comporre automaticamente il messaggio di presentazione delle transazioni .
Automatically extract Job Applicants from a mail box ,
Automatically extract Leads from a mail box e.g.,Estrarre automaticamente Leads da una casella di posta elettronica ad esempio
Automatically updated via Stock Entry of type Manufacture/Repack,Aggiornato automaticamente via Archivio Entrata di tipo Produzione / Repack
Automotive,Automotive
Autoreply when a new mail is received,Auto-Rispondi quando si riceve una nuova mail
Available,Disponibile
Available Qty at Warehouse,Quantità Disponibile a magazzino
Available Stock for Packing Items,Disponibile Magazzino per imballaggio elementi
"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet","Disponibile in distinta , bolla di consegna , fattura di acquisto , ordine di produzione , ordine di acquisto , ricevuta d'acquisto , fattura di vendita , ordini di vendita , dell'entrata Stock , Timesheet"
Average Age,Età media
Average Commission Rate,Media della Commissione Tasso
Average Discount,Sconto Medio
Awesome Products,Prodotti impressionante
Awesome Services,impressionante Servizi
BOM Detail No,DIBA Dettagli N.
BOM Explosion Item,DIBA Articolo Esploso
BOM Item,DIBA Articolo
BOM No,N. DiBa
BOM No. for a Finished Good Item,DiBa N. per un buon articolo finito
BOM Operation,DiBa Operazione
BOM Operations,DiBa Operazioni
BOM Replace Tool,DiBa Sostituire Strumento
BOM number is required for manufactured Item {0} in row {1},È richiesto il numero BOM alla voce fabbricati {0} in riga {1}
BOM number not allowed for non-manufactured Item {0} in row {1},Numero BOM non consentito per la voce non fabbricati {0} in riga {1}
BOM recursion: {0} cannot be parent or child of {2},BOM ricorsione : {0} non può essere genitore o figlio di {2}
BOM replaced,DiBa Sostituire
BOM {0} for Item {1} in row {2} is inactive or not submitted,BOM {0} per la voce {1} in riga {2} è inattivo o non presentate
BOM {0} is not active or not submitted,BOM {0} non è attivo o non presentate
BOM {0} is not submitted or inactive BOM for Item {1},BOM {0} non è presentata o inattivo distinta per la voce {1}
Backup Manager,Gestione Backup
Backup Right Now,Backup ORA
Backups will be uploaded to,Backup verranno caricati su
Balance Qty,equilibrio Quantità
Balance Sheet,bilancio patrimoniale
Balance Value,saldo Valore
Balance for Account {0} must always be {1},Bilancia per conto {0} deve essere sempre {1}
Balance must be,Saldo deve essere
"Balances of Accounts of type ""Bank"" or ""Cash""","Saldi dei conti di tipo "" Banca"" o ""Cash """
Bank,Banca
Bank / Cash Account,Banca / Account Cash
Bank A/C No.,Bank A/C No.
Bank Account,Conto Banca
Bank Account No.,Conto Banca N.
Bank Accounts,Conti bancari
Bank Clearance Summary,Sintesi Liquidazione Banca
Bank Draft,Assegno Bancario
Bank Name,Nome Banca
Bank Overdraft Account,Scoperto di conto bancario
Bank Reconciliation,Conciliazione Banca
Bank Reconciliation Detail,Dettaglio Riconciliazione Banca
Bank Reconciliation Statement,Prospetto di Riconciliazione Banca
Bank Voucher,Buono Banca
Bank/Cash Balance,Banca/Contanti Saldo
Banking,bancario
Barcode,Codice a barre
Barcode {0} already used in Item {1},Barcode {0} già utilizzato alla voce {1}
Based On,Basato su
Basic,di base
Basic Info,Info Base
Basic Information,Informazioni di Base
Basic Rate,Tasso Base
Basic Rate (Company Currency),Tasso Base (Valuta Azienda)
Batch,Lotto
Batch (lot) of an Item.,Lotto di un articolo
Batch Finished Date,Data Termine Lotto
Batch ID,ID Lotto
Batch No,Lotto N.
Batch Started Date,Data inizio Lotto
Batch Time Logs for billing.,Registra Tempo Lotto per fatturazione.
Batch-Wise Balance History,Cronologia Bilanciamento Lotti-Wise
Batched for Billing,Raggruppati per la Fatturazione
Better Prospects,Prospettive Migliori
Bill Date,Data Fattura
Bill No,Fattura N.
Bill No {0} already booked in Purchase Invoice {1},Bill n {0} già prenotato in Acquisto fattura {1}
Bill of Material,Bill of Material
Bill of Material to be considered for manufacturing,Elenco dei materiali da considerare per la produzione
Bill of Materials (BOM),Distinta Materiali (DiBa)
Billable,Addebitabile
Billed,Addebbitato
Billed Amount,importo fatturato
Billed Amt,Adebbitato Amt
Billing,Fatturazione
Billing Address,Indirizzo Fatturazione
Billing Address Name,Nome Indirizzo Fatturazione
Billing Status,Stato Faturazione
Bills raised by Suppliers.,Fatture sollevate dai fornitori.
Bills raised to Customers.,Fatture sollevate dai Clienti.
Bin,Bin
Bio,Bio
Biotechnology,biotecnologia
Birthday,Compleanno
Block Date,Data Blocco
Block Days,Giorno Blocco
Block leave applications by department.,Blocco domande uscita da ufficio.
Blog Post,Articolo Blog
Blog Subscriber,Abbonati Blog
Blood Group,Gruppo Discendenza
Both Warehouse must belong to same Company,Entrambi Warehouse deve appartenere alla stessa Società
Box,scatola
Branch,Ramo
Brand,Marca
Brand Name,Nome Marca
Brand master.,Marchio Originale.
Brands,Marche
Breakdown,Esaurimento
Broadcasting,emittente
Brokerage,mediazione
Budget,Budget
Budget Allocated,Budget Assegnato
Budget Detail,Dettaglio Budget
Budget Details,Dettaglii Budget
Budget Distribution,Distribuzione Budget
Budget Distribution Detail,Dettaglio Distribuzione Budget
Budget Distribution Details,Dettagli Distribuzione Budget
Budget Variance Report,Report Variazione Budget
Budget cannot be set for Group Cost Centers,Bilancio non può essere impostato per centri di costo del Gruppo
Build Report,costruire Rapporto
Bundle items at time of sale.,Articoli Combinati e tempi di vendita.
Business Development Manager,Development Business Manager
Buying,Acquisto
Buying & Selling,Acquisto e vendita
Buying Amount,Importo Acquisto
Buying Settings,Impostazioni Acquisto
"Buying must be checked, if Applicable For is selected as {0}","L'acquisto deve essere controllato, se applicabile per è selezionato come {0}"
C-Form,C-Form
C-Form Applicable,C-Form Applicable
C-Form Invoice Detail,C-Form Detagli Fattura
C-Form No,C-Form N.
C-Form records,Record C -Form
CENVAT Capital Goods,CENVAT Beni
CENVAT Edu Cess,CENVAT Edu Cess
CENVAT SHE Cess,CENVAT SHE Cess
CENVAT Service Tax,CENVAT Tax Service
CENVAT Service Tax Cess 1,CENVAT Tax Service Cess 1
CENVAT Service Tax Cess 2,CENVAT Tax Service Cess 2
Calculate Based On,Calcola in base a
Calculate Total Score,Calcolare il punteggio totale
Calendar Events,Eventi del calendario
Call,Chiama
Calls,chiamate
Campaign,Campagna
Campaign Name,Nome Campagna
Campaign Name is required,È obbligatorio Nome campagna
Campaign Naming By,Campagna di denominazione
Campaign-.####,Campagna . # # # #
Can be approved by {0},Può essere approvato da {0}
"Can not filter based on Account, if grouped by Account","Non è possibile filtrare sulla base di conto , se raggruppati per conto"
"Can not filter based on Voucher No, if grouped by Voucher","Non è possibile filtrare sulla base di Voucher No , se raggruppati per Voucher"
Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',Può riferirsi fila solo se il tipo di carica è 'On Fila Indietro Importo ' o ' Indietro totale riga '
Cancel Material Visit {0} before cancelling this Customer Issue,Annulla Materiale Visita {0} prima di annullare questa edizione clienti
Cancel Material Visits {0} before cancelling this Maintenance Visit,Annulla Visite Materiale {0} prima di annullare questa visita di manutenzione
Cancelled,Annullato
Cancelling this Stock Reconciliation will nullify its effect.,Annullamento questo Stock Riconciliazione si annulla il suo effetto .
Cannot Cancel Opportunity as Quotation Exists,Non può annullare Opportunità come esiste Preventivo
Cannot approve leave as you are not authorized to approve leaves on Block Dates,Non può approvare congedo in quanto non si è autorizzati ad approvare foglie su Date Block
Cannot cancel because Employee {0} is already approved for {1},Impossibile annullare perché Employee {0} è già approvato per {1}
Cannot cancel because submitted Stock Entry {0} exists,Impossibile annullare perché {0} esiste presentata dell'entrata Stock
Cannot carry forward {0},Non è possibile portare avanti {0}
Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,Impossibile modificare Fiscal Year data di inizio e di fine anno fiscale una volta l'anno fiscale è stato salvato.
"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.","Non è possibile cambiare la valuta di default dell'azienda , perché ci sono le transazioni esistenti . Le operazioni devono essere cancellate per cambiare la valuta di default ."
Cannot convert Cost Center to ledger as it has child nodes,Impossibile convertire centro di costo a registro come ha nodi figlio
Cannot covert to Group because Master Type or Account Type is selected.,Non può convertirsi Gruppo in quanto è stato selezionato Tipo di master o Tipo di account .
Cannot deactive or cancle BOM as it is linked with other BOMs,Non è possibile disattivarla o cancle distinta in quanto è collegata con altre distinte materiali
"Cannot declare as lost, because Quotation has been made.","Non è possibile dichiarare come perduto , perché Preventivo è stato fatto ."
Cannot deduct when category is for 'Valuation' or 'Valuation and Total',Non può dedurre quando categoria è di ' valutazione ' o ' Valutazione e Total '
"Cannot delete Serial No {0} in stock. First remove from stock, then delete.","Impossibile eliminare Serial No {0} in magazzino. Prima di tutto rimuovere dal magazzino , quindi eliminare ."
"Cannot directly set amount. For 'Actual' charge type, use the rate field","Non è possibile impostare direttamente importo. Per il tipo di carica ' effettivo ' , utilizzare il campo tasso"
"Cannot overbill for Item {0} in row {0} more than {1}. To allow overbilling, please set in Stock Settings","Non può overbill per la voce {0} in riga {0} più {1}. Per consentire la fatturazione eccessiva, si prega di impostare in Impostazioni Immagini"
Cannot produce more Item {0} than Sales Order quantity {1},Non può produrre più Voce {0} di Sales Order quantità {1}
Cannot refer row number greater than or equal to current row number for this Charge type,Non può consultare numero di riga maggiore o uguale al numero di riga corrente per questo tipo di carica
Cannot return more than {0} for Item {1},Impossibile restituire più di {0} per la voce {1}
Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,Non è possibile selezionare il tipo di carica come 'On Fila Indietro Importo ' o 'On Precedente totale riga ' per la prima fila
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,Non è possibile selezionare il tipo di carica come 'On Fila Indietro Importo ' o 'On Precedente totale riga ' per la valutazione . È possibile selezionare l'opzione ' totale ' per la quantità di riga precedente o precedente totale di riga
Cannot set as Lost as Sales Order is made.,Impossibile impostare come persa come è fatto Sales Order .
Cannot set authorization on basis of Discount for {0},Impossibile impostare autorizzazione sulla base di Sconto per {0}
Capacity,Capacità
Capacity Units,Unità Capacità
Capital Account,conto capitale
Capital Equipments,Attrezzature Capital
Carry Forward,Portare Avanti
Carry Forwarded Leaves,Portare Avanti Autorizzazione
Case No(s) already in use. Try from Case No {0},Caso n ( s) già in uso . Prova da Caso n {0}
Case No. cannot be 0,Caso No. Non può essere 0
Cash,Contante
Cash In Hand,Cash In Hand
Cash Voucher,Buono Contanti
Cash or Bank Account is mandatory for making payment entry,Contanti o conto bancario è obbligatoria per effettuare il pagamento voce
Cash/Bank Account,Conto Contanti/Banca
Casual Leave,Casual Leave
Cell Number,Numero di Telefono
Change UOM for an Item.,Cambia UOM per l'articolo.
Change the starting / current sequence number of an existing series.,Cambia l'inizio/numero sequenza corrente per una serie esistente
Channel Partner,Canale Partner
Charge of type 'Actual' in row {0} cannot be included in Item Rate,Carica di tipo ' Actual ' in riga {0} non può essere incluso nella voce Tasso
Chargeable,Addebitabile
Charity and Donations,Carità e donazioni
Chart Name,Nome grafico
Chart of Accounts,Grafico dei Conti
Chart of Cost Centers,Grafico Centro di Costo
Check how the newsletter looks in an email by sending it to your email.,Verificare come la newsletter si vede in una e-mail inviandola alla tua e-mail.
"Check if recurring invoice, uncheck to stop recurring or put proper End Date","Seleziona se fattura ricorrente, deseleziona per fermare ricorrenti o mettere corretta Data di Fine"
"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.","Seleziona se necessiti di fattura ricorrente periodica. Dopo aver inserito ogni fattura vendita, la sezione Ricorrenza diventa visibile."
Check if you want to send salary slip in mail to each employee while submitting salary slip,"Seleziona se si desidera inviare busta paga in posta a ciascun dipendente, mentre la presentazione foglio paga"
Check this if you want to force the user to select a series before saving. There will be no default if you check this.,Seleziona se vuoi forzare l'utente a selezionare una serie prima di salvare. Altrimenti sarà NO di default.
Check this if you want to show in website,Seleziona se vuoi mostrare nel sito
Check this to disallow fractions. (for Nos),Seleziona per disabilitare frazioni. (per NOS)
Check this to pull emails from your mailbox,Seleziona per scaricare la posta dal tuo account
Check to activate,Seleziona per attivare
Check to make Shipping Address,Seleziona per fare Spedizione Indirizzo
Check to make primary address,Seleziona per impostare indirizzo principale
Chemical,chimico
Cheque,Assegno
Cheque Date,Data Assegno
Cheque Number,Controllo Numero
Child account exists for this account. You can not delete this account.,Conto Child esiste per questo account . Non è possibile eliminare questo account .
City,Città
City/Town,Città/Paese
Claim Amount,Importo Reclamo
Claims for company expense.,Reclami per spese dell'azienda.
Class / Percentage,Classe / Percentuale
Classic,Classico
Clear Table,Pulisci Tabella
Clearance Date,Data Liquidazione
Clearance Date not mentioned,Liquidazione data non menzionato
Clearance date cannot be before check date in row {0},Data di Liquidazione non può essere prima della data di arrivo in riga {0}
Click on 'Make Sales Invoice' button to create a new Sales Invoice.,Clicca sul pulsante 'Crea Fattura Vendita' per creare una nuova Fattura di Vendita
Click on a link to get options to expand get options ,
Client,Intestatario
Close Balance Sheet and book Profit or Loss.,Chiudere Stato Patrimoniale e il libro utile o perdita .
Closed,Chiuso
Closing (Cr),Chiusura (Cr)
Closing (Dr),Chiusura (Dr)
Closing Account Head,Chiudere Conto Primario
Closing Account {0} must be of type 'Liability',Chiusura del conto {0} deve essere di tipo ' responsabilità '
Closing Date,Data Chiusura
Closing Fiscal Year,Chiusura Anno Fiscale
Closing Qty,Chiusura Quantità
Closing Value,Valore di chiusura
CoA Help,Aiuto CoA
Code,Codice
Cold Calling,Chiamata Fredda
Color,Colore
Column Break,Interruzione Colonna
Comma separated list of email addresses,Lista separata da virgola degli indirizzi email
Comment,Commento
Comments,Commenti
Commercial,commerciale
Commission,commissione
Commission Rate,Tasso Commissione
Commission Rate (%),Tasso Commissione (%)
Commission on Sales,Commissione sulle vendite
Commission rate cannot be greater than 100,Tasso Commissione non può essere superiore a 100
Communication,Comunicazione
Communication HTML,Comunicazione HTML
Communication History,Storico Comunicazioni
Communication log.,Log comunicazione
Communications,comunicazioni
Company,Azienda
Company (not Customer or Supplier) master.,Azienda ( non cliente o fornitore ) master.
Company Abbreviation,Abbreviazione Società
Company Details,Dettagli Azienda
Company Email,azienda Email
"Company Email ID not found, hence mail not sent","Azienda Email ID non trovato , quindi posta non inviato"
Company Info,Info Azienda
Company Name,Nome Azienda
Company Settings,Impostazioni Azienda
Company is missing in warehouses {0},Azienda è presente nei magazzini {0}
Company is required,È necessaria Azienda
Company registration numbers for your reference. Example: VAT Registration Numbers etc.,"Numeri di registrazione dell'azienda per il vostro riferimento. Esempio: IVA numeri di registrazione, ecc"
Company registration numbers for your reference. Tax numbers etc.,"Numeri di registrazione dell'azienda per il vostro riferimento. numero Tassa, ecc"
"Company, Month and Fiscal Year is mandatory","Società , mese e anno fiscale è obbligatoria"
Compensatory Off,compensativa Off
Complete,Completare
Complete Setup,installazione completa
Completed,Completato
Completed Production Orders,Completati gli ordini di produzione
Completed Qty,Q.tà Completata
Completion Date,Data Completamento
Completion Status,Stato Completamento
Computer,computer
Computers,computer
Confirmation Date,conferma Data
Confirmed orders from Customers.,Ordini Confermati da Clienti.
Consider Tax or Charge for,Cnsidera Tasse o Cambio per
Considered as Opening Balance,Considerato come Apertura Saldo
Considered as an Opening Balance,Considerato come Apertura Saldo
Consultant,Consulente
Consulting,Consulting
Consumable,consumabili
Consumable Cost,Costo consumabili
Consumable cost per hour,Costo consumabili per ora
Consumed Qty,Q.tà Consumata
Consumer Products,Prodotti di consumo
Contact,Contatto
Contact Control,Controllo Contatto
Contact Desc,Desc Contatto
Contact Details,Dettagli Contatto
Contact Email,Email Contatto
Contact HTML,Contatto HTML
Contact Info,Info Contatto
Contact Mobile No,Cellulare Contatto
Contact Name,Nome Contatto
Contact No.,Contatto N.
Contact Person,Persona Contatto
Contact Type,Tipo Contatto
Contact master.,Contatto master.
Contacts,Contatti
Content,Contenuto
Content Type,Tipo Contenuto
Contra Voucher,Contra Voucher
Contract,contratto
Contract End Date,Data fine Contratto
Contract End Date must be greater than Date of Joining,Data fine contratto deve essere maggiore di Data di giunzione
Contribution (%),Contributo (%)
Contribution to Net Total,Contributo sul totale netto
Conversion Factor,Fattore di Conversione
Conversion Factor is required,È necessario fattore di conversione
Conversion factor cannot be in fractions,Fattore di conversione non può essere in frazioni
Conversion factor for default Unit of Measure must be 1 in row {0},Fattore di conversione per unità di misura predefinita deve essere 1 in riga {0}
Conversion rate cannot be 0 or 1,Il tasso di conversione non può essere 0 o 1
Convert into Recurring Invoice,Convertire in fattura ricorrente
Convert to Group,Convert to Group
Convert to Ledger,Converti Ledger
Converted,Convertito
Copy From Item Group,Copiare da elemento Gruppo
Cosmetics,cosmetici
Cost Center,Centro di Costo
Cost Center Details,Dettaglio Centro di Costo
Cost Center Name,Nome Centro di Costo
Cost Center is required for 'Profit and Loss' account {0},È necessaria Centro di costo per ' economico ' conto {0}
Cost Center is required in row {0} in Taxes table for type {1},Centro di costo è richiesto in riga {0} nella tabella Tasse per il tipo {1}
Cost Center with existing transactions can not be converted to group,Centro di costo con le transazioni esistenti non può essere convertito in gruppo
Cost Center with existing transactions can not be converted to ledger,Centro di costo con le transazioni esistenti non può essere convertito in contabilità
Cost Center {0} does not belong to Company {1},Centro di costo {0} non appartiene alla società {1}
Cost of Goods Sold,Costo del venduto
Costing,Valutazione Costi
Country,Nazione
Country Name,Nome Nazione
Country wise default Address Templates,Modelli Country saggio di default Indirizzo
"Country, Timezone and Currency","Paese , Fuso orario e valuta"
Create Bank Voucher for the total salary paid for the above selected criteria,Crea Buono Bancario per il totale dello stipendio da pagare per i seguenti criteri
Create Customer,Crea clienti
Create Material Requests,Creare Richieste Materiale
Create New,Crea nuovo
Create Opportunity,creare Opportunità
Create Production Orders,Crea Ordine Prodotto
Create Quotation,Crea Preventivo
Create Receiver List,Crea Elenco Ricezione
Create Salary Slip,Creare busta paga
Create Stock Ledger Entries when you submit a Sales Invoice,Creare scorta voci registro quando inserisci una fattura vendita
"Create and manage daily, weekly and monthly email digests.","Creare e gestire giornalieri , settimanali e mensili digerisce email ."
Create rules to restrict transactions based on values.,Creare regole per limitare le transazioni in base ai valori .
Created By,Creato da
Creates salary slip for above mentioned criteria.,Crea busta paga per i criteri sopra menzionati.
Creation Date,Data di creazione
Creation Document No,Creazione di documenti No
Creation Document Type,Creazione tipo di documento
Creation Time,Tempo di creazione
Credentials,Credenziali
Credit,Credit
Credit Amt,Credit Amt
Credit Card,carta di credito
Credit Card Voucher,Carta Buono di credito
Credit Controller,Controllare Credito
Credit Days,Giorni Credito
Credit Limit,Limite Credito
Credit Note,Nota Credito
Credit To,Credito a
Currency,Valuta
Currency Exchange,Cambio Valuta
Currency Name,Nome Valuta
Currency Settings,Impostazioni Valuta
Currency and Price List,Valuta e Lista Prezzi
Currency exchange rate master.,Maestro del tasso di cambio di valuta .
Current Address,Indirizzo Corrente
Current Address Is,Indirizzo attuale è
Current Assets,Attività correnti
Current BOM,DiBa Corrente
Current BOM and New BOM can not be same,BOM corrente e New BOM non può essere lo stesso
Current Fiscal Year,Anno Fiscale Corrente
Current Liabilities,Passività correnti
Current Stock,Scorta Corrente
Current Stock UOM,Scorta Corrente UOM
Current Value,Valore Corrente
Custom,Personalizzato
Custom Autoreply Message,Auto rispondi Messaggio Personalizzato
Custom Message,Messaggio Personalizzato
Customer,Cliente
Customer (Receivable) Account,Cliente (Ricevibile) Account
Customer / Item Name,Cliente / Nome voce
Customer / Lead Address,Clienti / Lead Indirizzo
Customer / Lead Name,Cliente / Nome di piombo
Customer > Customer Group > Territory,Clienti> Gruppi clienti> Territorio
Customer Account Head,Conto Cliente Principale
Customer Acquisition and Loyalty,Acquisizione e fidelizzazione dei clienti
Customer Address,Indirizzo Cliente
Customer Addresses And Contacts,Indirizzi e Contatti Cliente
Customer Addresses and Contacts,Indirizzi Clienti e Contatti
Customer Code,Codice Cliente
Customer Codes,Codici Cliente
Customer Details,Dettagli Cliente
Customer Feedback,Opinione Cliente
Customer Group,Gruppo Cliente
Customer Group / Customer,Gruppi clienti / clienti
Customer Group Name,Nome Gruppo Cliente
Customer Intro,Intro Cliente
Customer Issue,Questione Cliente
Customer Issue against Serial No.,Questione Cliente per Seriale N.
Customer Name,Nome Cliente
Customer Naming By,Cliente nominato di
Customer Service,Servizio clienti
Customer database.,Database Cliente.
Customer is required,Il Cliente è tenuto
Customer master.,Maestro del cliente .
Customer required for 'Customerwise Discount',Cliente richiesto per ' Customerwise Discount '
Customer {0} does not belong to project {1},Cliente {0} non appartiene a proiettare {1}
Customer {0} does not exist,{0} non esiste clienti
Customer's Item Code,Codice elemento Cliente
Customer's Purchase Order Date,Data ordine acquisto Cliente
Customer's Purchase Order No,Ordine Acquisto Cliente N.
Customer's Purchase Order Number,Numero Ordine di Acquisto del Cliente
Customer's Vendor,Fornitore del Cliente
Customers Not Buying Since Long Time,Clienti non acquisto da molto tempo
Customerwise Discount,Sconto Cliente saggio
Customize,Personalizza
Customize the Notification,Personalizzare Notifica
Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,Personalizza testo di introduzione che andrà nell'email. Ogni transazione ha un introduzione distinta.
DN Detail,Dettaglio DN
Daily,Giornaliero
Daily Time Log Summary,Registro Giornaliero Tempo
Database Folder ID,ID Cartella Database
Database of potential customers.,Database Potenziali Clienti.
Date,Data
Date Format,Formato Data
Date Of Retirement,Data di Ritiro
Date Of Retirement must be greater than Date of Joining,Data del pensionamento deve essere maggiore di Data di giunzione
Date is repeated,La Data si Ripete
Date of Birth,Data Compleanno
Date of Issue,Data Pubblicazione
Date of Joining,Data Adesione
Date of Joining must be greater than Date of Birth,Data di adesione deve essere maggiore di Data di nascita
Date on which lorry started from supplier warehouse,Data in cui camion partito da magazzino fornitore
Date on which lorry started from your warehouse,Data in cui camion partito da nostro magazzino
Dates,Date
Days Since Last Order,Giorni dall'ultimo ordine
Days for which Holidays are blocked for this department.,Giorni per i quali le festività sono bloccati per questo reparto.
Dealer,Commerciante
Debit,Debito
Debit Amt,Ammontare Debito
Debit Note,Nota Debito
Debit To,Addebito a
Debit and Credit not equal for this voucher. Difference is {0}.,Debito e di credito non uguale per questo voucher . La differenza è {0} .
Deduct,Detrarre
Deduction,Deduzioni
Deduction Type,Tipo Deduzione
Deduction1,Deduzione1
Deductions,Deduzioni
Default,Predefinito
Default Account,Account Predefinito
Default Address Template cannot be deleted,Indirizzo modello predefinito non può essere eliminato
Default Amount,Importo di default
Default BOM,BOM Predefinito
Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,Conto predefinito Banca / Contante  aggiornato automaticamente in Fatture POS quando selezioni questo metodo
Default Bank Account,Conto Banca Predefinito
Default Buying Cost Center,Comprare Centro di costo predefinito
Default Buying Price List,Predefinito acquisto Prezzo di listino
Default Cash Account,Conto Monete predefinito
Default Company,Azienda Predefinita
Default Currency,Valuta Predefinito
Default Customer Group,Gruppo Clienti Predefinito
Default Expense Account,Account Spese Predefinito
Default Income Account,Conto Predefinito Entrate
Default Item Group,Gruppo elemento Predefinito
Default Price List,Listino Prezzi Predefinito
Default Purchase Account in which cost of the item will be debited.,Conto acquisto Predefinito dove addebitare i costi.
Default Selling Cost Center,Centro di costo di vendita di default
Default Settings,Impostazioni Predefinite
Default Source Warehouse,Magazzino Origine Predefinito
Default Stock UOM,Scorta UOM predefinita
Default Supplier,Predefinito Fornitore
Default Supplier Type,Tipo Fornitore Predefinito
Default Target Warehouse,Magazzino Destinazione Predefinito
Default Territory,Territorio Predefinito
Default Unit of Measure,Unità di Misura Predefinito
"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à di misura predefinita non può essere modificata direttamente perché avete già fatto qualche transazione ( s ) con un altro UOM . Per cambiare UOM predefinito , utilizzare ' UOM Sostituire Utility' strumento di sotto del modulo magazzino."
Default Valuation Method,Metodo Valutazione Predefinito
Default Warehouse,Magazzino Predefinito
Default Warehouse is mandatory for stock Item.,Galleria di default è obbligatoria per magazzino articolo .
Default settings for accounting transactions.,Impostazioni predefinite per le operazioni contabili.
Default settings for buying transactions.,Impostazioni predefinite per operazioni di acquisto .
Default settings for selling transactions.,Impostazioni predefinite per la vendita di transazioni.
Default settings for stock transactions.,Impostazioni predefinite per le transazioni di magazzino .
Defense,difesa
"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","Definire Budget per questo centro di costo. Per impostare l&#39;azione di bilancio, vedi <a href=""#!List/Company"">Azienda Maestro</a>"
Del,Del
Delete,Elimina
Delete {0} {1}?,Eliminare {0} {1} ?
Delivered,Consegnato
Delivered Items To Be Billed,Gli Articoli consegnati da Fatturare
Delivered Qty,Q.tà Consegnata
Delivered Serial No {0} cannot be deleted,Trasportato d'ordine {0} non può essere cancellato
Delivery Date,Data Consegna
Delivery Details,Dettagli Consegna
Delivery Document No,Documento Consegna N.
Delivery Document Type,Tipo Documento Consegna
Delivery Note,Nota Consegna
Delivery Note Item,Nota articolo Consegna
Delivery Note Items,Nota Articoli Consegna
Delivery Note Message,Nota Messaggio Consegna
Delivery Note No,Nota Consegna N.
Delivery Note Required,Nota Consegna Richiesta
Delivery Note Trends,Nota Consegna Tendenza
Delivery Note {0} is not submitted,Consegna Note {0} non è presentata
Delivery Note {0} must not be submitted,Consegna Note {0} non deve essere presentata
Delivery Notes {0} must be cancelled before cancelling this Sales Order,Note di consegna {0} devono essere cancellate prima di annullare questo ordine di vendita
Delivery Status,Stato Consegna
Delivery Time,Tempo Consegna
Delivery To,Consegna a
Department,Dipartimento
Department Stores,Grandi magazzini
Depends on LWP,Dipende da LWP
Depreciation,ammortamento
Description,Descrizione
Description HTML,Descrizione HTML
Designation,Designazione
Designer,designer
Detailed Breakup of the totals,Breakup dettagliato dei totali
Details,Dettagli
Difference (Dr - Cr),Differenza ( Dr - Cr )
Difference Account,account differenza
"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry","Account differenza deve essere un account di tipo ' responsabilità ' , dal momento che questo Archivio riconciliazione è una voce di apertura"
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.,Diverso UOM per gli elementi porterà alla non corretta ( Total) Valore di peso netto . Assicurarsi che il peso netto di ogni articolo è nella stessa UOM .
Direct Expenses,spese dirette
Direct Income,reddito diretta
Disable,Disattiva
Disable Rounded Total,Disabilita Arrotondamento su Totale
Disabled,Disabilitato
Discount  %,Sconto %
Discount %,% sconto
Discount (%),(%) Sconto
Discount Amount,Importo sconto
"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice","Il Campo Sconto sarà abilitato in Ordine di acquisto, ricevuta di acquisto, Fattura Acquisto"
Discount Percentage,Percentuale di sconto
Discount Percentage can be applied either against a Price List or for all Price List.,Percentuale di sconto può essere applicato sia contro un listino prezzi o per tutti Listino.
Discount must be less than 100,Sconto deve essere inferiore a 100
Discount(%),Sconto(%)
Dispatch,spedizione
Display all the individual items delivered with the main items,Visualizzare tutti gli elementi singoli spediti con articoli principali
Distribute transport overhead across items.,Distribuire in testa trasporto attraverso articoli.
Distribution,Distribuzione
Distribution Id,ID Distribuzione
Distribution Name,Nome Distribuzione
Distributor,Distributore
Divorced,Divorced
Do Not Contact,Non Contattaci
Do not show any symbol like $ etc next to currencies.,Non visualizzare nessun simbolo tipo € dopo le Valute.
Do really want to unstop production order: ,
Do you really want to STOP ,
Do you really want to STOP this Material Request?,Vuoi davvero fermare questo materiale Request ?
Do you really want to Submit all Salary Slip for month {0} and year {1},Vuoi davvero a presentare tutti foglio paga per il mese {0} e l'anno {1}
Do you really want to UNSTOP ,
Do you really want to UNSTOP this Material Request?,Vuoi davvero a stappare questa Materiale Richiedi ?
Do you really want to stop production order: ,
Doc Name,Nome Doc
Doc Type,Tipo Doc
Document Description,Descrizione del documento
Document Type,Tipo di documento
Documents,Documenti
Domain,Dominio
Don't send Employee Birthday Reminders,Non inviare Dipendente Birthday Reminders
Download Materials Required,Scaricare Materiali Richiesti
Download Reconcilation Data,Scarica Riconciliazione dei dati
Download Template,Scarica Modello
Download a report containing all raw materials with their latest inventory status,Scaricare un report contenete tutte le materie prime con il loro recente stato di inventario
"Download the Template, fill appropriate data and attach the modified file.","Scarica il modello , compilare i dati appropriati e allegare il file modificato ."
"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","Scarica il modello, compilare i dati appropriati e allegare il file modificato.
 Tutte le date e la combinazione dei dipendenti nel periodo selezionato entreranno nel modello, con record di presenze esistenti"
Draft,Bozza
Dropbox,Dropbox
Dropbox Access Allowed,Consentire accesso Dropbox
Dropbox Access Key,Chiave Accesso Dropbox
Dropbox Access Secret,Accesso Segreto Dropbox
Due Date,Data di scadenza
Due Date cannot be after {0},Data di scadenza non può essere successiva {0}
Due Date cannot be before Posting Date,Data di scadenza non può essere precedente Data di registrazione
Duplicate Entry. Please check Authorization Rule {0},Duplicate Entry. Si prega di controllare Autorizzazione Regola {0}
Duplicate Serial No entered for Item {0},Duplicare Numero d'ordine è entrato per la voce {0}
Duplicate entry,Duplicate entry
Duplicate row {0} with same {1},Fila Duplicate {0} con lo stesso {1}
Duties and Taxes,Dazi e tasse
ERPNext Setup,Setup ERPNext
Earliest,Apertura
Earnest Money,caparra
Earning,Rendimento
Earning & Deduction,Guadagno & Detrazione
Earning Type,Tipo Rendimento
Earning1,Rendimento1
Edit,Modifica
Edu. Cess on Excise,Edu. Cess su accise
Edu. Cess on Service Tax,Edu. Cess sul servizio Tax
Edu. Cess on TDS,Edu. Cess su TDS
Education,educazione
Educational Qualification,Titolo di studio
Educational Qualification Details,Titolo di studio Dettagli
Eg. smsgateway.com/api/send_sms.cgi,Ad es. smsgateway.com / api / send_sms.cgi
Either debit or credit amount is required for {0},È obbligatorio debito o importo del credito per {0}
Either target qty or target amount is mandatory,Sia qty destinazione o importo obiettivo è obbligatoria
Either target qty or target amount is mandatory.,Sia qty destinazione o importo obiettivo è obbligatoria .
Electrical,elettrico
Electricity Cost,elettricità Costo
Electricity cost per hour,Costo dell'energia elettrica per ora
Electronics,elettronica
Email,Email
Email Digest,Email di massa
Email Digest Settings,Impostazioni Email di Massa
Email Digest: ,
Email Id,ID Email
"Email Id where a job applicant will email e.g. ""jobs@example.com""","Email del candidato deve essere del tipo ""jobs@example.com"""
Email Notifications,Notifiche e-mail
Email Sent?,Invio Email?
"Email id must be unique, already exists for {0}","Email id deve essere unico , esiste già per {0}"
Email ids separated by commas.,ID Email separati da virgole.
"Email settings to extract Leads from sales email id e.g. ""sales@example.com""","Impostazioni email per Estrarre LEADS dall' email venditore es. ""sales@example.com"""
Emergency Contact,Contatto di emergenza
Emergency Contact Details,Dettagli Contatto Emergenza
Emergency Phone,Telefono di emergenza
Employee,Dipendenti
Employee Birthday,Compleanno Dipendente
Employee Details,Dettagli Dipendente
Employee Education,Istruzione Dipendente
Employee External Work History,Cronologia Lavoro Esterno Dipendente
Employee Information,Informazioni Dipendente
Employee Internal Work History,Cronologia Lavoro Interno Dipendente
Employee Internal Work Historys,Cronologia Lavoro Interno Dipendente
Employee Leave Approver,Dipendente Lascia Approvatore
Employee Leave Balance,Approvazione Bilancio Dipendete
Employee Name,Nome Dipendete
Employee Number,Numero Dipendenti
Employee Records to be created by,Record dei dipendenti di essere creati da
Employee Settings,Impostazioni per i dipendenti
Employee Type,Tipo Dipendenti
"Employee designation (e.g. CEO, Director etc.).","Designazione dei dipendenti (ad esempio amministratore delegato , direttore , ecc.)"
Employee master.,Maestro dei dipendenti .
Employee record is created using selected field. ,Record dipendente viene creato utilizzando campo selezionato.
Employee records.,Registrazione Dipendente.
Employee relieved on {0} must be set as 'Left',Dipendente sollevato su {0} deve essere impostato come ' Sinistra '
Employee {0} has already applied for {1} between {2} and {3},Employee {0} ha già presentato domanda di {1} tra {2} e {3}
Employee {0} is not active or does not exist,Employee {0} non è attiva o non esiste
Employee {0} was on leave on {1}. Cannot mark attendance.,Employee {0} era in aspettativa per {1} . Impossibile segnare presenze .
Employees Email Id,Email Dipendente
Employment Details,Dettagli Dipendente
Employment Type,Tipo Dipendente
Enable / disable currencies.,Abilitare / disabilitare valute .
Enabled,Attivo
Encashment Date,Data Incasso
End Date,Data di Fine
End Date can not be less than Start Date,Data finale non può essere inferiore a Data di inizio
End date of current invoice's period,Data di fine del periodo di fatturazione corrente
End of Life,Fine Vita
Energy,energia
Engineer,ingegnere
Enter Verification Code,Inserire codice Verifica
Enter campaign name if the source of lead is campaign.,Inserisci nome Campagna se la sorgente del LEAD e una campagna.
Enter department to which this Contact belongs,Inserisci reparto a cui appartiene questo contatto
Enter designation of this Contact,Inserisci designazione di questo contatto
"Enter email id separated by commas, invoice will be mailed automatically on particular date","Inserisci email separate da virgola, le fatture saranno inviate automaticamente in una data particolare"
Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,Inserisci articoli e q.tà programmate per i quali si desidera raccogliere gli ordini di produzione o scaricare materie prime per l'analisi.
Enter name of campaign if source of enquiry is campaign,Inserisci il nome della Campagna se la sorgente di indagine è la campagna
"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)","Inserisci parametri statici della url qui (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)"
Enter the company name under which Account Head will be created for this Supplier,Immettere il nome della società in cui Conto Principale sarà creato per questo Fornitore
Enter url parameter for message,Inserisci parametri url per il messaggio
Enter url parameter for receiver nos,Inserisci parametri url per NOS ricevuti
Entertainment & Leisure,Intrattenimento e tempo libero
Entertainment Expenses,Spese di rappresentanza
Entries,Voci
Entries against ,
Entries are not allowed against this Fiscal Year if the year is closed.,Voci non permesse in confronto ad un Anno Fiscale già chiuso.
Equity,equità
Error: {0} > {1},Errore: {0} > {1}
Estimated Material Cost,Stima costo materiale
"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:","Anche se ci sono più regole sui prezzi con la priorità più alta, si applicano quindi le seguenti priorità interne:"
Everyone can read,Tutti possono leggere
"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.",". Esempio: ABCD # # # # # 
 Se serie è ambientata e Serial No non è menzionato nelle transazioni, verrà creato il numero di serie quindi automatico basato su questa serie. Se si vuole sempre parlare esplicitamente di serie nn per questo articolo. lasciare vuoto."
Exchange Rate,Tasso di cambio:
Excise Duty 10,Excise Duty 10
Excise Duty 14,Excise Duty 14
Excise Duty 4,Excise Duty 4
Excise Duty 8,Excise Duty 8
Excise Duty @ 10,Excise Duty @ 10
Excise Duty @ 14,Excise Duty @ 14
Excise Duty @ 4,Excise Duty @ 4
Excise Duty @ 8,Excise Duty @ 8
Excise Duty Edu Cess 2,Excise Duty Edu Cess 2
Excise Duty SHE Cess 1,Excise Duty SHE Cess 1
Excise Page Number,Accise Numero Pagina
Excise Voucher,Buono Accise
Execution,esecuzione
Executive Search,executive Search
Exemption Limit,Limite Esenzione
Exhibition,Esposizione
Existing Customer,Cliente Esistente
Exit,Esci
Exit Interview Details,Uscire Dettagli Intervista
Expected,Previsto
Expected Completion Date can not be less than Project Start Date,Prevista Data di completamento non può essere inferiore a Progetto Data inizio
Expected Date cannot be before Material Request Date,Data prevista non può essere precedente Material Data richiesta
Expected Delivery Date,Data prevista di consegna
Expected Delivery Date cannot be before Purchase Order Date,Data prevista di consegna non può essere un ordine di acquisto Data
Expected Delivery Date cannot be before Sales Order Date,Data prevista di consegna non può essere precedente Sales Order Data
Expected End Date,Data prevista di fine
Expected Start Date,Data prevista di inizio
Expense,spese
Expense / Difference account ({0}) must be a 'Profit or Loss' account,Expense / account Differenza ({0}) deve essere un 'utile o perdita' conto
Expense Account,Conto uscite
Expense Account is mandatory,Conto spese è obbligatorio
Expense Claim,Rimborso Spese
Expense Claim Approved,Rimborso Spese Approvato
Expense Claim Approved Message,Messaggio Rimborso Spese Approvato
Expense Claim Detail,Dettaglio Rimborso Spese
Expense Claim Details,Dettagli Rimborso Spese
Expense Claim Rejected,Rimborso Spese Rifiutato
Expense Claim Rejected Message,Messaggio Rimborso Spese Rifiutato
Expense Claim Type,Tipo Rimborso Spese
Expense Claim has been approved.,Expense Claim è stato approvato .
Expense Claim has been rejected.,Expense Claim è stato respinto.
Expense Claim is pending approval. Only the Expense Approver can update status.,Expense Claim è in attesa di approvazione . Solo il Responsabile approvazione spesa può aggiornare lo stato .
Expense Date,Expense Data
Expense Details,Dettagli spese
Expense Head,Expense Capo
Expense account is mandatory for item {0},Conto spese è obbligatoria per l'elemento {0}
Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,Spesa o Differenza conto è obbligatorio per la voce {0} come impatti valore azionario complessivo
Expenses,spese
Expenses Booked,Spese Prenotazione
Expenses Included In Valuation,Spese incluse nella Valutazione
Expenses booked for the digest period,Spese Prenotazione per periodo di smistamento
Expiry Date,Data Scadenza
Exports,Esportazioni
External,Esterno
Extract Emails,Estrarre email
FCFS Rate,FCFS Rate
Failed: ,Impossibile:
Family Background,Sfondo Famiglia
Fax,Fax
Features Setup,Configurazione Funzioni
Feed,Fonte
Feed Type,Tipo Fonte
Feedback,Riscontri
Female,Femmina
Fetch exploded BOM (including sub-assemblies),Fetch BOM esplosa ( inclusi sottoassiemi )
"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order","Campo disponibile nella Bolla di consegna, preventivi, fatture di vendita, ordini di vendita"
Files Folder ID,ID Cartella File
Fill the form and save it,Compila il form e salvarlo
Filter based on customer,Filtro basato sul cliente
Filter based on item,Filtro basato sul articolo
Financial / accounting year.,Esercizio finanziario / contabile .
Financial Analytics,Analisi Finanziaria
Financial Services,Servizi finanziari
Financial Year End Date,Data di Esercizio di fine
Financial Year Start Date,Esercizio Data di inizio
Finished Goods,Beni finiti
First Name,Nome
First Responded On,Ha risposto prima su
Fiscal Year,Anno Fiscale
Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},Anno fiscale Data di inizio e Data Fine dell'anno fiscale sono già impostati nel Fiscal Year {0}
Fiscal Year Start Date and Fiscal Year End Date cannot be more than a year apart.,Fiscal Year Data di inizio e Data Fine esercizio fiscale non può essere più di un anno di distanza.
Fiscal Year Start Date should not be greater than Fiscal Year End Date,Anno fiscale Data di inizio non deve essere maggiore di Data Fine dell'anno fiscale
Fixed Asset,Asset fisso
Fixed Assets,immobilizzazioni
Follow via Email,Seguire via Email
"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.","Seguendo tabella mostrerà i valori, se i capi sono sub - contratto. Questi valori saranno prelevati dal maestro del &quot;Bill of Materials&quot; di sub - elementi contrattuali."
Food,cibo
"Food, Beverage & Tobacco","Prodotti alimentari , bevande e tabacco"
"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.","Per gli articoli «Le vendite delle distinte», Warehouse, Serial No e Batch No sarà considerata dalla tavola del 'Packing List'. Se Warehouse e Batch No sono uguali per tutti gli articoli imballaggio per tutto l'articolo 'Vendite distinta', questi valori possono essere inseriti nella tabella principale Item, i valori vengono copiati tabella 'Packing List'."
For Company,Per Azienda
For Employee,Per Dipendente
For Employee Name,Per Nome Dipendente
For Price List,Per Listino Prezzi
For Production,Per la produzione
For Reference Only.,Solo di Riferimento
For Sales Invoice,Per Fattura di Vendita
For Server Side Print Formats,Per Formato Stampa lato Server
For Supplier,per Fornitore
For Warehouse,Per Magazzino
For Warehouse is required before Submit,Per è necessario Warehouse prima Submit
"For e.g. 2012, 2012-13","Per es. 2012, 2012-13"
For reference,Per riferimento
For reference only.,Solo per riferimento.
"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes","Per la comodità dei clienti, questi codici possono essere utilizzati in formati di stampa, come fatture e bolle di consegna"
Fraction,Frazione
Fraction Units,Unità Frazione
Freeze Stock Entries,Congela scorta voci
Freeze Stocks Older Than [Days],Congelare Stocks Older Than [ giorni]
Freight and Forwarding Charges,Freight Forwarding e spese
Friday,Venerdì
From,Da
From Bill of Materials,Da Bill of Materials
From Company,Da Azienda
From Currency,Da Valuta
From Currency and To Currency cannot be same,Da Valuta e A Valuta non possono essere gli stessi
From Customer,Da Cliente
From Customer Issue,Da Issue clienti
From Date,Da Data
From Date cannot be greater than To Date,Dalla data non può essere maggiore di A Data
From Date must be before To Date,Da Data deve essere prima di A Data
From Date should be within the Fiscal Year. Assuming From Date = {0},Dalla data deve essere entro l'anno fiscale. Assumendo Dalla Data = {0}
From Delivery Note,Nota di Consegna
From Employee,Da Dipendente
From Lead,Da LEAD
From Maintenance Schedule,Dal Programma di manutenzione
From Material Request,Da Material Request
From Opportunity,da Opportunity
From Package No.,Da Pacchetto N.
From Purchase Order,Da Ordine di Acquisto
From Purchase Receipt,Da Ricevuta di Acquisto
From Quotation,da Preventivo
From Sales Order,Da Ordine di Vendita
From Supplier Quotation,Da Quotazione fornitore
From Time,Da Periodo
From Value,Da Valore
From and To dates required,Da e Per le date richieste
From value must be less than to value in row {0},Dal valore deve essere inferiore al valore nella riga {0}
Frozen,Congelato
Frozen Accounts Modifier,Congelati conti Modifier
Fulfilled,Adempiuto
Full Name,Nome Completo
Full-time,Full-time
Fully Billed,Completamente Fatturato
Fully Completed,Debitamente compilato
Fully Delivered,Completamente Consegnato
Furniture and Fixture,Mobili e Fixture
Further accounts can be made under Groups but entries can be made against Ledger,"Ulteriori conti possono essere fatti in Gruppi , ma le voci possono essere fatte contro Ledger"
"Further accounts can be made under Groups, but entries can be made against Ledger","Ulteriori conti possono essere fatti in Gruppi , ma le voci possono essere fatte contro Ledger"
Further nodes can be only created under 'Group' type nodes,Ulteriori nodi possono essere creati solo sotto i nodi di tipo ' Gruppo '
GL Entry,GL Entry
Gantt Chart,Diagramma di Gantt
Gantt chart of all tasks.,Diagramma di Gantt di tutte le attività.
Gender,Genere
General,Generale
General Ledger,Libro mastro generale
Generate Description HTML,Genera descrizione HTML
Generate Material Requests (MRP) and Production Orders.,Generare richieste di materiali (MRP) e ordini di produzione.
Generate Salary Slips,Generare buste paga
Generate Schedule,Genera Programma
Generates HTML to include selected image in the description,Genera HTML per includere immagine selezionata nella descrizione
Get Advances Paid,Ottenere anticipo pagamento
Get Advances Received,ottenere anticipo Ricevuto
Get Current Stock,Richiedi Disponibilità
Get Items,Ottieni articoli
Get Items From Sales Orders,Ottieni elementi da ordini di vendita
Get Items from BOM,Ottenere elementi dal BOM
Get Last Purchase Rate,Ottieni ultima quotazione acquisto
Get Outstanding Invoices,Ottieni fatture non saldate
Get Relevant Entries,Prendi le voci rilevanti
Get Sales Orders,Ottieni Ordini di Vendita
Get Specification Details,Ottieni Specifiche Dettagli
Get Stock and Rate,Ottieni Residui e Tassi
Get Template,Ottieni Modulo
Get Terms and Conditions,Ottieni Termini e Condizioni
Get Unreconciled Entries,Get non riconciliati Entries
Get Weekly Off Dates,Get settimanali Date 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.","Ottieni tasso di valutazione e disposizione di magazzino sorgente/destinazione su magazzino menzionati distacco data-ora. Se voce serializzato, si prega di premere questo tasto dopo aver inserito i numeri di serie."
Global Defaults,Predefiniti Globali
Global POS Setting {0} already created for company {1},Impostazione globale POS {0} già creato per la compagnia {1}
Global Settings,Impostazioni globali
"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""","Vai al gruppo appropriato ( di solito Applicazione dei Fondi > Attività Correnti > Conti bancari e creare un nuovo account Ledger ( cliccando su Add Child ) di tipo ""Banca"""
"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.","Vai al gruppo appropriato ( di solito fonte di finanziamento > Passività correnti > Tasse e imposte e creare un nuovo account Ledger ( cliccando su Add Child ) di tipo "" fiscale "" e non parlare del tasso di imposta ."
Goal,Obiettivo
Goals,Obiettivi
Goods received from Suppliers.,Merci ricevute dai fornitori.
Google Drive,Google Drive
Google Drive Access Allowed,Google Accesso unità domestici
Government,governo
Graduate,Laureato:
Grand Total,Totale Generale
Grand Total (Company Currency),Totale generale (valuta Azienda)
"Grid ""","grid """
Grocery,drogheria
Gross Margin %,Margine Lordo %
Gross Margin Value,Valore Margine Lordo
Gross Pay,Retribuzione lorda
Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,retribuzione lorda + Importo posticipata + Importo incasso - Deduzione totale
Gross Profit,Utile lordo
Gross Profit (%),Utile Lordo (%)
Gross Weight,Peso Lordo
Gross Weight UOM,Peso Lordo UOM
Group,Gruppo
Group by Account,Raggruppa per conto
Group by Voucher,Gruppo da Voucher
Group or Ledger,Gruppo o Registro
Groups,Gruppi
HR Manager,HR Manager
HR Settings,Impostazioni HR
HTML / Banner that will show on the top of product list.,HTML / Banner verrà mostrato sulla parte superiore della lista dei prodotti.
Half Day,Mezza Giornata
Half Yearly,Semestrale
Half-yearly,Seme-strale
Happy Birthday!,Buon compleanno!
Hardware,hardware
Has Batch No,Ha Lotto N.
Has Child Node,Ha un Nodo Figlio
Has Serial No,Ha Serial No
Head of Marketing and Sales,Responsabile Marketing e Vendite
Header,Intestazione
Health Care,Health Care
Health Concerns,Preoccupazioni per la salute
Health Details,Dettagli Salute
Held On,Held On
Help HTML,Aiuto HTML
"Help: To link to another record in the system, use ""#Form/Note/[Note Name]"" as the Link URL. (don't use ""http://"")","Aiuto: Per creare un collegamento a un altro record nel sistema, utilizzare &quot;# Form / Note / [Nota Nome]&quot;, come il collegamento URL. (Non usare &quot;http://&quot;)"
"Here you can maintain family details like name and occupation of parent, spouse and children","Qui è possibile mantenere i dettagli della famiglia come il nome e l'occupazione del genitore, coniuge e figli"
"Here you can maintain height, weight, allergies, medical concerns etc","Qui è possibile mantenere l'altezza, il peso, le allergie, le preoccupazioni mediche ecc"
Hide Currency Symbol,Nascondi Simbolo Valuta
High,Alto
History In Company,Cronologia Aziendale
Hold,Trattieni
Holiday,Vacanza
Holiday List,Elenco Vacanza
Holiday List Name,Nome Elenco Vacanza
Holiday master.,Maestro di vacanza .
Holidays,Vacanze
Home,Home
Host,Host
"Host, Email and Password required if emails are to be pulled","Host, e-mail e la password necessari se le email sono di essere tirato"
Hour,ora
Hour Rate,Vota ora
Hour Rate Labour,Ora Vota Labour
Hours,Ore
How Pricing Rule is applied?,Come regola tariffaria viene applicata?
How frequently?,Con quale frequenza?
"How should this currency be formatted? If not set, will use system defaults","Come dovrebbe essere formattata questa valuta? Se non impostato, userà valori predefiniti di sistema"
Human Resources,Risorse umane
Identification of the package for the delivery (for print),Identificazione del pacchetto per la consegna (per la stampa)
If Income or Expense,Se proventi od oneri
If Monthly Budget Exceeded,Se Budget mensile superato
"If Sale BOM is defined, the actual BOM of the Pack is displayed as table. Available in Delivery Note and Sales Order","Se Sale BOM è definito , l'attuale BOM del pacchetto viene visualizzato come tabella . Disponibile in Consegna Nota e Sales Order"
"If Supplier Part Number exists for given Item, it gets stored here","Se il numero di parte del fornitore esiste per dato voce, che viene memorizzato qui"
If Yearly Budget Exceeded,Se Budget annuale superato
"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.","Se selezionato, distinta per gli elementi sub-assemblaggio sarà considerato per ottenere materie prime. In caso contrario, tutti gli elementi sub-assemblaggio saranno trattati come materia prima."
"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day","Se selezionato, non totale. di giorni lavorativi includerà vacanze, e questo ridurrà il valore di salario per ogni giorno"
"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount","Se selezionato, l&#39;importo della tassa sarà considerata già inclusa nel Stampa Valuta / Stampa Importo"
If different than customer address,Se diverso da indirizzo del cliente
"If disable, 'Rounded Total' field will not be visible in any transaction","Se disabilitare, &#39;Rounded totale&#39; campo non sarà visibile in qualsiasi transazione"
"If enabled, the system will post accounting entries for inventory automatically.","Se abilitato, il sistema pubblicherà le scritture contabili per l&#39;inventario automatico."
If more than one package of the same type (for print),Se più di un pacchetto dello stesso tipo (per la stampa)
"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.","Se più regole dei prezzi continuano a prevalere, gli utenti sono invitati a impostare manualmente la priorità per risolvere il conflitto."
"If no change in either Quantity or Valuation Rate, leave the cell blank.","Se non cambia né Quantitativo o Tasso di valutazione , lasciare vuota la cella."
If not applicable please enter: NA,Se non applicabile Inserisci: NA
"If not checked, the list will have to be added to each Department where it has to be applied.","Se non controllati, la lista dovrà essere aggiunto a ciascun Dipartimento dove deve essere applicato."
"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.","Se Regola Prezzi selezionato è fatta per 'Prezzo', si sovrascriverà listino prezzi. Prezzo Regola dei prezzi è il prezzo finale, in modo che nessun ulteriore sconto deve essere applicato. Quindi, in operazioni come ordini di vendita, ordine di acquisto, ecc, verrà prelevato in campo 'Tasso', piuttosto che il campo 'Prezzo di listino Rate'."
"If specified, send the newsletter using this email address","Se specificato, inviare la newsletter tramite questo indirizzo e-mail"
"If the account is frozen, entries are allowed to restricted users.","Se l'account viene bloccato , le voci sono autorizzati a utenti con restrizioni ."
"If this Account represents a Customer, Supplier or Employee, set it here.","Se questo account rappresenta un cliente, fornitore o dipendente, impostare qui."
"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.","Se due o più regole dei prezzi si trovano in base alle condizioni di cui sopra, si applica priorità. La priorità è un numero compreso tra 0 e 20, mentre il valore di default è zero (blank). Numero più alto significa che avrà la precedenza se ci sono più regole dei prezzi con le stesse condizioni."
If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,Se si seguono Controllo Qualità . Abilita Voce QA necessari e QA No in Acquisto Ricevuta
If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,Se si dispone di team di vendita e vendita Partners (Partner di canale) possono essere taggati e mantenere il loro contributo per l&#39;attività di vendita
"If you have created a standard template in Purchase Taxes and Charges Master, select one and click on the button below.","Se è stato creato un modello standard in Acquisto tasse e le spese master, selezionarne uno e fare clic sul pulsante qui sotto."
"If you have created a standard template in Sales Taxes and Charges Master, select one and click on the button below.","Se è stato creato un modello standard in tasse sulla vendita e Spese master, selezionarne uno e fare clic sul pulsante qui sotto."
"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","Se si è a lungo stampare formati, questa funzione può essere usato per dividere la pagina da stampare su più pagine con tutte le intestazioni e piè di pagina in ogni pagina"
If you involve in manufacturing activity. Enables Item 'Is Manufactured',Se si coinvolgono in attività di produzione . Abilita Voce ' è prodotto '
Ignore,Ignora
Ignore Pricing Rule,Ignora regola tariffaria
Ignored: ,Ignorato:
Image,Immagine
Image View,Visualizza immagine
Implementation Partner,Partner di implementazione
Import Attendance,Import presenze
Import Failed!,Importazione non riuscita !
Import Log,Importa Log
Import Successful!,Importazione di successo!
Imports,Importazioni
In Hours,In Hours
In Process,In Process
In Qty,Qtà
In Value,in Valore
In Words,In Parole
In Words (Company Currency),In Parole (Azienda valuta)
In Words (Export) will be visible once you save the Delivery Note.,In Parole (Export) sarà visibile una volta che si salva il DDT.
In Words will be visible once you save the Delivery Note.,In parole saranno visibili una volta che si salva il DDT.
In Words will be visible once you save the Purchase Invoice.,In parole saranno visibili una volta che si salva la Fattura di Acquisto.
In Words will be visible once you save the Purchase Order.,In parole saranno visibili una volta che si salva di Acquisto.
In Words will be visible once you save the Purchase Receipt.,In parole saranno visibili una volta che si salva la ricevuta di acquisto.
In Words will be visible once you save the Quotation.,In parole saranno visibili una volta che si salva il preventivo.
In Words will be visible once you save the Sales Invoice.,In parole saranno visibili una volta che si salva la fattura di vendita.
In Words will be visible once you save the Sales Order.,In parole saranno visibili una volta che si salva l&#39;ordine di vendita.
Incentives,Incentivi
Include Reconciled Entries,Includi Voci riconciliati
Include holidays in Total no. of Working Days,Includi vacanze in totale n. dei giorni lavorativi
Income,reddito
Income / Expense,Proventi / oneri
Income Account,Conto Conto
Income Booked,Reddito Prenotato
Income Tax,Income Tax
Income Year to Date,Reddito da inizio anno
Income booked for the digest period,Reddito prenotato per il periodo digest
Incoming,In arrivo
Incoming Rate,Rate in ingresso
Incoming quality inspection.,Controllo di qualità in arrivo.
Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,Numero errato di contabilità generale dell `trovato. Potreste aver selezionato un conto sbagliato nella transazione.
Incorrect or Inactive BOM {0} for Item {1} at row {2},Errata o Inattivo BOM {0} per la voce {1} alla riga {2}
Indicates that the package is a part of this delivery (Only Draft),Indica che il pacchetto è una parte di questa consegna (solo Bozza)
Indirect Expenses,spese indirette
Indirect Income,reddito indiretta
Individual,Individuale
Industry,Industria
Industry Type,Tipo Industria
Inspected By,Verifica a cura di
Inspection Criteria,Criteri di ispezione
Inspection Required,Ispezione Obbligatorio
Inspection Type,Tipo di ispezione
Installation Date,Data di installazione
Installation Note,Installazione Nota
Installation Note Item,Installazione Nota articolo
Installation Note {0} has already been submitted,Installazione Nota {0} è già stato presentato
Installation Status,Stato di installazione
Installation Time,Tempo di installazione
Installation date cannot be before delivery date for Item {0},Data di installazione non può essere prima della data di consegna per la voce {0}
Installation record for a Serial No.,Record di installazione per un numero di serie
Installed Qty,Qtà installata
Instructions,Istruzione
Integrate incoming support emails to Support Ticket,Integrare le email di sostegno in arrivo per il supporto Ticket
Interested,Interessati
Intern,interno
Internal,Interno
Internet Publishing,Internet Publishing
Introduction,Introduzione
Invalid Barcode,Codice a barre valido
Invalid Barcode or Serial No,Codice a barre valido o Serial No
Invalid Mail Server. Please rectify and try again.,Server di posta valido . Si prega di correggere e riprovare .
Invalid Master Name,Valido Master Nome
Invalid User Name or Support Password. Please rectify and try again.,Nome utente non valido o supporto password . Si prega di correggere e riprovare .
Invalid quantity specified for item {0}. Quantity should be greater than 0.,Quantità non valido specificato per l'elemento {0} . Quantità dovrebbe essere maggiore di 0 .
Inventory,Inventario
Inventory & Support,Inventario e supporto
Investment Banking,Investment Banking
Investments,investimenti
Invoice Date,Data fattura
Invoice Details,Dettagli Fattura
Invoice No,Fattura n
Invoice Number,Numero di fattura
Invoice Period From,Fattura Periodo Da
Invoice Period From and Invoice Period To dates mandatory for recurring invoice,Fattura Periodo Da e fattura Periodo Per le date obbligatorie per la fattura ricorrenti
Invoice Period To,Periodo fattura per
Invoice Type,Tipo Fattura
Invoice/Journal Voucher Details,Fattura / Journal Voucher Dettagli
Invoiced Amount (Exculsive Tax),Importo fatturato ( Exculsive Tax)
Is Active,È attivo
Is Advance,È Advance
Is Cancelled,Viene Annullato
Is Carry Forward,È portare avanti
Is Default,È Default
Is Encash,È incassare
Is Fixed Asset Item,È Asset fisso Voce
Is LWP,È LWP
Is Opening,Sta aprendo
Is Opening Entry,Sta aprendo Entry
Is POS,È POS
Is Primary Contact,È primario di contatto
Is Purchase Item,È Acquisto Voce
Is Sales Item,È Voce vendite
Is Service Item,È il servizio Voce
Is Stock Item,È Stock articolo
Is Sub Contracted Item,È sub articolo Contrattato
Is Subcontracted,Di subappalto
Is this Tax included in Basic Rate?,È questa tassa inclusi nel prezzo base?
Issue,Questione
Issue Date,Data di Emissione
Issue Details,Dettagli del problema
Issued Items Against Production Order,Articoli emesso contro Ordine di produzione
It can also be used to create opening stock entries and to fix stock value.,Può anche essere utilizzato per creare aprono le entrate nelle scorte e di fissare valore azionario .
Item,articolo
Item Advanced,Voce Avanzata
Item Barcode,Barcode articolo
Item Batch Nos,Nn batch Voce
Item Code,Codice Articolo
Item Code > Item Group > Brand,Codice Articolo> Articolo Group> Brand
Item Code and Warehouse should already exist.,Articolo Codice e Magazzino dovrebbero già esistere.
Item Code cannot be changed for Serial No.,Codice Articolo non può essere modificato per Serial No.
Item Code is mandatory because Item is not automatically numbered,Codice Articolo è obbligatoria in quanto articolo non è numerato automaticamente
Item Code required at Row No {0},Codice Articolo richiesto al Fila n {0}
Item Customer Detail,Dettaglio articolo cliente
Item Description,Voce Descrizione
Item Desription,Desription articolo
Item Details,Dettagli articolo
Item Group,Gruppo articoli
Item Group Name,Articolo Group
Item Group Tree,Voce Gruppo Albero
Item Group not mentioned in item master for item {0},Voce Gruppo non menzionato nella voce principale per l'elemento {0}
Item Groups in Details,Gruppi di articoli in Dettagli
Item Image (if not slideshow),Articolo Immagine (se non slideshow)
Item Name,Nome dell&#39;articolo
Item Naming By,Articolo Naming By
Item Price,Articolo Prezzo
Item Prices,Voce Prezzi
Item Quality Inspection Parameter,Voce di controllo di qualità dei parametri
Item Reorder,Articolo riordino
Item Serial No,Articolo N. d&#39;ordine
Item Serial Nos,Voce n ° di serie
Item Shortage Report,Voce Carenza Rapporto
Item Supplier,Articolo Fornitore
Item Supplier Details,Voce Fornitore Dettagli
Item Tax,Tax articolo
Item Tax Amount,Articolo fiscale Ammontare
Item Tax Rate,Articolo Tax Rate
Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,Voce fiscale Row {0} deve avere un account di tipo fiscale o di reddito o spese o addebitabile
Item Tax1,Articolo Imposta1
Item To Manufacture,Articolo per la fabbricazione
Item UOM,Articolo UOM
Item Website Specification,Specifica Sito
Item Website Specifications,Articolo Specifiche Website
Item Wise Tax Detail,Voce Wise fiscale Dettaglio
Item Wise Tax Detail ,Articolo Wise Particolare fiscale
Item is required,È necessaria Item
Item is updated,L'articolo è aggiornato
Item master.,Maestro Item .
"Item must be a purchase item, as it is present in one or many Active BOMs","L'articolo deve essere un elemento dell'acquisto , in quanto è presente in uno o più distinte materiali attivi"
Item or Warehouse for row {0} does not match Material Request,Voce o Magazzino per riga {0} non corrisponde Material Request
Item table can not be blank,Tavolo articolo non può essere vuoto
Item to be manufactured or repacked,Voce da fabbricati o nuovamente imballati
Item valuation updated,Valutazione Articolo aggiornato
Item will be saved by this name in the data base.,L&#39;oggetto sarà salvato con questo nome nella banca dati.
Item {0} appears multiple times in Price List {1},Voce {0} compare più volte nel listino {1}
Item {0} does not exist,Voce {0} non esiste
Item {0} does not exist in the system or has expired,Voce {0} non esiste nel sistema o è scaduto
Item {0} does not exist in {1} {2},Voce {0} non esiste in {1} {2}
Item {0} has already been returned,Voce {0} è già stata restituita
Item {0} has been entered multiple times against same operation,Voce {0} è stato inserito più volte contro la stessa operazione
Item {0} has been entered multiple times with same description or date,Voce {0} è stato inserito più volte con la stessa descrizione o data
Item {0} has been entered multiple times with same description or date or warehouse,Voce {0} è stato inserito più volte con la stessa descrizione o data o in un deposito
Item {0} has been entered twice,Voce {0} è stato inserito due volte
Item {0} has reached its end of life on {1},Voce {0} ha raggiunto la fine della sua vita su {1}
Item {0} ignored since it is not a stock item,Voce {0} ignorata poiché non è un articolo di riserva
Item {0} is cancelled,Voce {0} viene annullato
Item {0} is not Purchase Item,Voce {0} non è Acquistare articolo
Item {0} is not a serialized Item,Voce {0} non è un elemento serializzato
Item {0} is not a stock Item,Voce {0} non è un articolo di
Item {0} is not active or end of life has been reached,Voce {0} non è attivo o la fine della vita è stato raggiunto
Item {0} is not setup for Serial Nos. Check Item master,Voce {0} non è configurato per maestro nn Serial Elemento
Item {0} is not setup for Serial Nos. Column must be blank,Voce {0} non è configurato per Serial nn colonna deve essere vuoto
Item {0} must be Sales Item,Voce {0} deve essere Voce di vendita
Item {0} must be Sales or Service Item in {1},Voce {0} deve essere vendite o servizio Voce in {1}
Item {0} must be Service Item,Voce {0} deve essere servizio Voce
Item {0} must be a Purchase Item,Voce {0} deve essere un acquisto Item
Item {0} must be a Sales Item,Voce {0} deve essere un elemento di vendita
Item {0} must be a Service Item.,Voce {0} deve essere un servizio Voce .
Item {0} must be a Sub-contracted Item,Voce {0} deve essere un elemento sub- contratto
Item {0} must be a stock Item,Voce {0} deve essere un articolo di
Item {0} must be manufactured or sub-contracted,Voce {0} deve essere fabbricato o sub- contratto
Item {0} not found,Voce {0} non trovato
Item {0} with Serial No {1} is already installed,Voce {0} con n ° di serie è già installato {1}
Item {0} with same description entered twice,Voce {0} con la stessa descrizione inserita due volte
"Item, Warranty, AMC (Annual Maintenance Contract) details will be automatically fetched when Serial Number is selected.","Item, Garanzia, AMC (annuale Contratto di Manutenzione) Dettagli viene prelevato automaticamente quando si seleziona il numero di serie."
Item-wise Price List Rate,Articolo -saggio Listino Tasso
Item-wise Purchase History,Articolo-saggio Cronologia acquisti
Item-wise Purchase Register,Articolo-saggio Acquisto Registrati
Item-wise Sales History,Articolo-saggio Storia Vendite
Item-wise Sales Register,Vendite articolo-saggio Registrati
"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","Voce: {0} gestiti saggio-batch, non può conciliarsi con \
 Riconciliazione Archivio invece utilizzare dell'entrata Stock"
Item: {0} not found in the system,Voce : {0} non trovato nel sistema
Items,Articoli
Items To Be Requested,Articoli da richiedere
Items required,elementi richiesti
"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",Articoli da richieste che sono &quot;out of stock&quot; considerando tutti i magazzini in base qty proiettata e qty minimo di ordine
Items which do not exist in Item master can also be entered on customer's request,Voci che non esistono in master articolo possono essere inseriti su richiesta del cliente
Itemwise Discount,Sconto Itemwise
Itemwise Recommended Reorder Level,Itemwise consigliata riordino Livello
Job Applicant,Candidato di lavoro
Job Opening,Apertura di lavoro
Job Profile,Profilo di lavoro
Job Title,Professione
"Job profile, qualifications required etc.","Profilo del lavoro , qualifiche richieste ecc"
Jobs Email Settings,Impostazioni email Lavoro
Journal Entries,Prime note
Journal Entry,Journal Entry
Journal Voucher,Journal Voucher
Journal Voucher Detail,Journal Voucher Detail
Journal Voucher Detail No,Journal Voucher Detail No
Journal Voucher {0} does not have account {1} or already matched,Journal Voucher {0} non ha conto {1} o già abbinate
Journal Vouchers {0} are un-linked,Diario Buoni {0} sono non- linked
Keep a track of communication related to this enquiry which will help for future reference.,Tenere una traccia delle comunicazioni relative a questa indagine che contribuirà per riferimento futuro.
Keep it web friendly 900px (w) by 100px (h),Keep it web amichevole 900px ( w ) di 100px ( h )
Key Performance Area,Area Key Performance
Key Responsibility Area,Area Responsabilità Chiave
Kg,kg
LR Date,LR Data
LR No,LR No
Label,Etichetta
Landed Cost Item,Landed Cost articolo
Landed Cost Items,Landed voci di costo
Landed Cost Purchase Receipt,Landed Cost ricevuta di acquisto
Landed Cost Purchase Receipts,Sbarcati costo di acquisto Receipts
Landed Cost Wizard,Wizard Landed Cost
Landed Cost updated successfully,Landed Cost aggiornato correttamente
Language,Lingua
Last Name,Cognome
Last Purchase Rate,Ultimo Purchase Rate
Latest,ultimo
Lead,Portare
Lead Details,Piombo dettagli
Lead Id,piombo Id
Lead Name,Piombo Nome
Lead Owner,Piombo Proprietario
Lead Source,Piombo Fonte
Lead Status,Senza piombo
Lead Time Date,Piombo Ora Data
Lead Time Days,Portare il tempo Giorni
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.,Piombo giorni Tempo è il numero di giorni per cui questa voce è previsto nel vostro magazzino. Questi giorni vengono recuperati in Materiale Richiesta quando si seleziona questa voce.
Lead Type,Piombo Tipo
Lead must be set if Opportunity is made from Lead,Piombo deve essere impostato se Opportunity è fatto da piombo
Leave Allocation,Lascia Allocazione
Leave Allocation Tool,Lascia strumento Allocazione
Leave Application,Lascia Application
Leave Approver,Lascia Approvatore
Leave Approvers,Lascia Approvatori
Leave Balance Before Application,Lascia equilibrio prima applicazione
Leave Block List,Lascia Block List
Leave Block List Allow,Lascia Block List Consentire
Leave Block List Allowed,Lascia Block List ammessi
Leave Block List Date,Lascia Block List Data
Leave Block List Dates,Lascia Blocco Elenco date
Leave Block List Name,Lascia Block List Nome
Leave Blocked,Lascia Bloccato
Leave Control Panel,Lascia il Pannello di controllo
Leave Encashed?,Lascia incassati?
Leave Encashment Amount,Lascia Incasso Importo
Leave Type,Lascia Tipo
Leave Type Name,Lascia Tipo Nome
Leave Without Pay,Lascia senza stipendio
Leave application has been approved.,Lascia domanda è stata approvata .
Leave application has been rejected.,Lascia domanda è stata respinta .
Leave approver must be one of {0},Lascia dell'approvazione deve essere uno dei {0}
Leave blank if considered for all branches,Lasciare vuoto se considerato per tutti i rami
Leave blank if considered for all departments,Lasciare vuoto se considerato per tutti i reparti
Leave blank if considered for all designations,Lasciare vuoto se considerato per tutte le designazioni
Leave blank if considered for all employee types,Lasciare vuoto se considerato per tutti i tipi dipendenti
"Leave can be approved by users with Role, ""Leave Approver""","Lascia può essere approvato dagli utenti con il ruolo, &quot;Leave Approvatore&quot;"
Leave of type {0} cannot be longer than {1},Lascia di tipo {0} non può essere superiore a {1}
Leaves Allocated Successfully for {0},Foglie allocata con successo per {0}
Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},Parte per il tipo {0} già stanziato per Employee {1} per l'anno fiscale {0}
Leaves must be allocated in multiples of 0.5,"Le foglie devono essere assegnati in multipli di 0,5"
Ledger,Ledger
Ledgers,registri
Left,Sinistra
Legal,legale
Legal Expenses,Spese legali
Letter Head,Carta intestata
Letter Heads for print templates.,Lettera Teste per modelli di stampa .
Level,Livello
Lft,Lft
Liability,responsabilità
List a few of your customers. They could be organizations or individuals.,Elencare alcuni dei vostri clienti . Potrebbero essere organizzazioni o individui .
List a few of your suppliers. They could be organizations or individuals.,Elencare alcuni dei vostri fornitori . Potrebbero essere organizzazioni o individui .
List items that form the package.,Voci di elenco che formano il pacchetto.
List this Item in multiple groups on the website.,Elenco questo articolo a più gruppi sul sito.
"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.",Inserisci i tuoi prodotti o servizi che si acquistano o vendono .
"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.","Elencate le vostre teste fiscali ( ad esempio IVA , accise , che devono avere nomi univoci ) e le loro tariffe standard ."
Loading...,Caricamento in corso ...
Loans (Liabilities),Prestiti (passività )
Loans and Advances (Assets),Crediti ( Assets )
Local,locale
Login,Entra
Login with your new User ID,Accedi con il tuo nuovo ID Utente
Logo,Logo
Logo and Letter Heads,Logo e Letter Heads
Lost,perso
Lost Reason,Perso Motivo
Low,Basso
Lower Income,Reddito più basso
MTN Details,MTN Dettagli
Main,principale
Main Reports,Rapporti principali
Maintain Same Rate Throughout Sales Cycle,Mantenere la stessa velocità per tutto il ciclo di vendita
Maintain same rate throughout purchase cycle,Mantenere la stessa velocità per tutto il ciclo di acquisto
Maintenance,Manutenzione
Maintenance Date,Manutenzione Data
Maintenance Details,Dettagli di manutenzione
Maintenance Schedule,Programma di manutenzione
Maintenance Schedule Detail,Programma di manutenzione Dettaglio
Maintenance Schedule Item,Programma di manutenzione Voce
Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',Programma di manutenzione non viene generato per tutte le voci . Si prega di cliccare su ' Generate Schedule '
Maintenance Schedule {0} exists against {0},Programma di manutenzione {0} esiste contro {0}
Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,Programma di manutenzione {0} deve essere cancellato prima di annullare questo ordine di vendita
Maintenance Schedules,Programmi di manutenzione
Maintenance Status,Stato di manutenzione
Maintenance Time,Tempo di Manutenzione
Maintenance Type,Tipo di manutenzione
Maintenance Visit,Visita di manutenzione
Maintenance Visit Purpose,Visita di manutenzione Scopo
Maintenance Visit {0} must be cancelled before cancelling this Sales Order,Manutenzione Visita {0} deve essere cancellato prima di annullare questo ordine di vendita
Maintenance start date can not be before delivery date for Serial No {0},Manutenzione data di inizio non può essere prima della data di consegna per Serial No {0}
Major/Optional Subjects,Principali / Opzionale Soggetti
Make ,
Make Accounting Entry For Every Stock Movement,Fai Entry Accounting per ogni Archivio Movimento
Make Bank Voucher,Fai Voucher Banca
Make Credit Note,Fai la nota di credito
Make Debit Note,Fai la nota di addebito
Make Delivery,effettuare la consegna
Make Difference Entry,Fai la Differenza Entry
Make Excise Invoice,Fai Excise Fattura
Make Installation Note,Fai Installazione Nota
Make Invoice,la fattura
Make Maint. Schedule,Fai Maint . piano
Make Maint. Visit,Fai Maint . visita
Make Maintenance Visit,Effettuare la manutenzione Visita
Make Packing Slip,Rendere la distinta di imballaggio
Make Payment,Fai di pagamento
Make Payment Entry,Fai Pagamento Entry
Make Purchase Invoice,Fai Acquisto Fattura
Make Purchase Order,Fai Ordine di Acquisto
Make Purchase Receipt,Fai la ricevuta d'acquisto
Make Salary Slip,Fai Stipendio slittamento
Make Salary Structure,Fai la struttura salariale
Make Sales Invoice,Fai la fattura di vendita
Make Sales Order,Fai Sales Order
Make Supplier Quotation,Fai Quotazione fornitore
Make Time Log Batch,Fai Tempo Log Batch
Male,Maschio
Manage Customer Group Tree.,Gestire Gruppi clienti Tree.
Manage Sales Partners.,Gestire partner commerciali.
Manage Sales Person Tree.,Gestire Sales Person Tree.
Manage Territory Tree.,Gestione Territorio Tree.
Manage cost of operations,Gestione dei costi delle operazioni di
Management,gestione
Manager,direttore
"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",Obbligatorio se Disponibile Articolo è &quot;Sì&quot;. Anche il magazzino di default in cui quantitativo riservato è impostato da ordine di vendita.
Manufacture against Sales Order,Produzione contro Ordine di vendita
Manufacture/Repack,Fabbricazione / Repack
Manufactured Qty,Quantità Prodotto
Manufactured quantity will be updated in this warehouse,Quantità prodotta sarà aggiornato in questo magazzino
Manufactured quantity {0} cannot be greater than planned quanitity {1} in Production Order {2},Quantità prodotta {0} non può essere maggiore di quanitity previsto {1} in ordine di produzione {2}
Manufacturer,Fabbricante
Manufacturer Part Number,Codice produttore
Manufacturing,Produzione
Manufacturing Quantity,Produzione Quantità
Manufacturing Quantity is mandatory,Produzione La quantità è obbligatoria
Margin,Margine
Marital Status,Stato civile
Market Segment,Segmento di Mercato
Marketing,marketing
Marketing Expenses,Spese di marketing
Married,Sposato
Mass Mailing,Mailing di massa
Master Name,Maestro Nome
Master Name is mandatory if account type is Warehouse,Master Nome è obbligatorio se il tipo di account è Warehouse
Master Type,Master
Masters,Masters
Match non-linked Invoices and Payments.,Partita Fatture non collegati e pagamenti.
Material Issue,Material Issue
Material Receipt,Materiale Ricevuta
Material Request,Materiale Richiesta
Material Request Detail No,Materiale richiesta dettaglio No
Material Request For Warehouse,Richiesta di materiale per il magazzino
Material Request Item,Materiale Richiesta articolo
Material Request Items,Materiale Richiesta Articoli
Material Request No,Materiale Richiesta No
Material Request Type,Materiale Tipo di richiesta
Material Request of maximum {0} can be made for Item {1} against Sales Order {2},Richiesta materiale di massimo {0} può essere fatto per la voce {1} contro Sales Order {2}
Material Request used to make this Stock Entry,Richiesta di materiale usato per fare questo Stock Entry
Material Request {0} is cancelled or stopped,Richiesta materiale {0} viene annullato o interrotto
Material Requests for which Supplier Quotations are not created,Richieste di materiale con le quotazioni dei fornitori non sono creati
Material Requests {0} created,Richieste di materiale {0} creato
Material Requirement,Material Requirement
Material Transfer,Material Transfer
Materials,Materiali
Materials Required (Exploded),Materiali necessari (esploso)
Max 5 characters,Max 5 caratteri
Max Days Leave Allowed,Max giorni di ferie domestici
Max Discount (%),Sconto Max (%)
Max Qty,Qtà max
Max discount allowed for item: {0} is {1}%,Sconto massimo consentito per la voce: {0} {1}%
Maximum Amount,Importo Massimo
Maximum allowed credit is {0} days after posting date,Credito massimo consentito è {0} giorni dalla data di registrazione
Maximum {0} rows allowed,Massimo {0} righe ammessi
Maxiumm discount for Item {0} is {1}%,Sconto Maxiumm per la voce {0} {1} %
Medical,medico
Medium,Media
"Merging is only possible if following properties are same in both records. Group or Ledger, Root Type, Company",La fusione è possibile solo se seguenti proprietà sono uguali in entrambi i record .
Message,Messaggio
Message Parameter,Messaggio Parametro
Message Sent,messaggio inviato
Message updated,messaggio aggiornato
Messages,Messaggi
Messages greater than 160 characters will be split into multiple messages,Messaggio maggiore di 160 caratteri verrà divisa in mesage multipla
Middle Income,Reddito Medio
Milestone,Milestone
Milestone Date,Milestone Data
Milestones,Milestones
Milestones will be added as Events in the Calendar,Pietre miliari saranno aggiunti come eventi nel calendario
Min Order Qty,Qtà ordine minimo
Min Qty,Qty
Min Qty can not be greater than Max Qty,Min quantità non può essere maggiore di Max Qtà
Minimum Amount,Importo Minimo
Minimum Order Qty,Qtà ordine minimo
Minute,minuto
Misc Details,Varie Dettagli
Miscellaneous Expenses,spese varie
Miscelleneous,Miscelleneous
Mobile No,Cellulare No
Mobile No.,Cellulare No.
Mode of Payment,Modalità di Pagamento
Modern,Moderna
Monday,Lunedi
Month,Mese
Monthly,Mensile
Monthly Attendance Sheet,Foglio presenze mensile
Monthly Earning & Deduction,Guadagno mensile &amp; Deduzione
Monthly Salary Register,Stipendio mensile Registrati
Monthly salary statement.,Certificato di salario mensile.
More Details,Maggiori dettagli
More Info,Ulteriori informazioni
Motion Picture & Video,Motion Picture & Video
Moving Average,Media mobile
Moving Average Rate,Media mobile Vota
Mr,Sig.
Ms,Ms
Multiple Item prices.,Molteplici i prezzi articolo.
"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","Multipla Regola Prezzo esiste con gli stessi criteri, si prega di risolvere \
 conflitto assegnando priorità. Regole Prezzo: {0}"
Music,musica
Must be Whole Number,Devono essere intere Numero
Name,Nome
Name and Description,Nome e descrizione
Name and Employee ID,Nome e ID dipendente
"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master","Nome del nuovo account . Nota : Si prega di non creare account per i Clienti e Fornitori , vengono creati automaticamente dal cliente e maestro fornitore"
Name of person or organization that this address belongs to.,Nome della persona o organizzazione che questo indirizzo appartiene.
Name of the Budget Distribution,Nome della distribuzione del bilancio
Naming Series,Naming Series
Negative Quantity is not allowed,Quantità negative non è consentito
Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},Negativo Archivio Error ( {6} ) per la voce {0} in Magazzino {1} su {2} {3} {4} {5}
Negative Valuation Rate is not allowed,Negativo Tasso valutazione non è consentito
Negative balance in Batch {0} for Item {1} at Warehouse {2} on {3} {4},Saldo negativo Lotto {0} per la voce {1} a Warehouse {2} su {3} {4}
Net Pay,Retribuzione netta
Net Pay (in words) will be visible once you save the Salary Slip.,Pay netto (in lettere) sarà visibile una volta che si salva il foglio paga.
Net Profit / Loss,Utile / Perdita
Net Total,Total Net
Net Total (Company Currency),Totale netto (Azienda valuta)
Net Weight,Peso netto
Net Weight UOM,UOM Peso netto
Net Weight of each Item,Peso netto di ogni articolo
Net pay cannot be negative,Retribuzione netta non può essere negativo
Never,Mai
New ,
New Account,nuovo account
New Account Name,Nuovo nome account
New BOM,Nuovo BOM
New Communications,New Communications
New Company,New Company
New Cost Center,Nuovo Centro di costo
New Cost Center Name,Nuovo Centro di costo Nome
New Delivery Notes,Nuovi Consegna Note
New Enquiries,Nuove Richieste
New Leads,New Leads
New Leave Application,Nuovo Lascia Application
New Leaves Allocated,Nuove foglie allocato
New Leaves Allocated (In Days),Nuove foglie attribuiti (in giorni)
New Material Requests,Nuovo materiale Richieste
New Projects,Nuovi Progetti
New Purchase Orders,Nuovi Ordini di acquisto
New Purchase Receipts,Nuovo acquisto Ricevute
New Quotations,Nuove citazioni
New Sales Orders,Nuovi Ordini di vendita
New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,New Serial No non può avere Warehouse . Warehouse deve essere impostato da dell'entrata Stock o ricevuta d'acquisto
New Stock Entries,Nuove entrate nelle scorte
New Stock UOM,Nuovo UOM Archivio
New Stock UOM is required,Nuovo Archivio UOM è necessaria
New Stock UOM must be different from current stock UOM,Nuovo Archivio UOM deve essere diverso da stock attuale UOM
New Supplier Quotations,Nuove citazioni Fornitore
New Support Tickets,Nuovi biglietti di supporto
New UOM must NOT be of type Whole Number,New UOM NON deve essere di tipo numero intero
New Workplace,Nuovo posto di lavoro
Newsletter,Newsletter
Newsletter Content,Newsletter Contenuto
Newsletter Status,Newsletter di stato
Newsletter has already been sent,Newsletter è già stato inviato
"Newsletters to contacts, leads.","Newsletter ai contatti, lead."
Newspaper Publishers,Editori Giornali
Next,prossimo
Next Contact By,Avanti Contatto Con
Next Contact Date,Avanti Contact Data
Next Date,Avanti Data
Next email will be sent on:,Email prossimo verrà inviato:
No,No
No Customer Accounts found.,Nessun account dei clienti trovata .
No Customer or Supplier Accounts found,Nessun cliente o fornitore Conti trovati
No Expense Approvers. Please assign 'Expense Approver' Role to atleast one user,Nessun approvazioni di spesa . Assegnare ruoli ' Expense Approvatore ' per atleast un utente
No Item with Barcode {0},Nessun articolo con codice a barre {0}
No Item with Serial No {0},Nessun articolo con Serial No {0}
No Items to pack,Non ci sono elementi per il confezionamento
No Leave Approvers. Please assign 'Leave Approver' Role to atleast one user,Nessun Lascia le approvazioni . Assegnare ruoli ' Lascia Approvatore ' per atleast un utente
No Permission,Nessuna autorizzazione
No Production Orders created,Nessun ordini di produzione creati
No Supplier Accounts found. Supplier Accounts are identified based on 'Master Type' value in account record.,Nessun account Fornitore trovato. Contabilità fornitori sono identificati in base al valore ' Master ' in conto record.
No accounting entries for the following warehouses,Nessuna scritture contabili per le seguenti magazzini
No addresses created,Nessun indirizzi creati
No contacts created,No contatti creati
No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,Nessun valore predefinito Indirizzo Template trovato. Si prega di crearne uno nuovo da Setup> Stampa e Branding> Indirizzo Template.
No default BOM exists for Item {0},Non esiste BOM predefinito per la voce {0}
No description given,Nessuna descrizione fornita
No employee found,Nessun dipendente trovato
No employee found!,Nessun dipendente trovata!
No of Requested SMS,No di SMS richiesto
No of Sent SMS,No di SMS inviati
No of Visits,No di visite
No permission,Nessuna autorizzazione
No record found,Nessun record trovato
No records found in the Invoice table,Nessun record trovati nella tabella Fattura
No records found in the Payment table,Nessun record trovati nella tabella di pagamento
No salary slip found for month: ,Nessun foglio paga trovato per mese:
Non Profit,non Profit
Nos,nos
Not Active,Non attivo
Not Applicable,Non Applicabile
Not Available,Non disponibile
Not Billed,Non fatturata
Not Delivered,Non consegnati
Not Set,non impostato
Not allowed to update stock transactions older than {0},Non è permesso di aggiornare le transazioni di magazzino di età superiore a {0}
Not authorized to edit frozen Account {0},Non autorizzato a modificare account congelati {0}
Not authroized since {0} exceeds limits,Non authroized dal {0} supera i limiti
Not permitted,non consentito
Note,Nota
Note User,Nota User
"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.","Nota: I backup ei file non vengono eliminati da Dropbox, sarà necessario eliminarli manualmente."
"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.","Nota: I backup ei file non vengono eliminati da Google Drive, sarà necessario eliminarli manualmente."
Note: Due Date exceeds the allowed credit days by {0} day(s),Nota : Data di scadenza supera le giornate di credito consentite dalla {0} giorni (s )
Note: Email will not be sent to disabled users,Nota: E-mail non sarà inviato agli utenti disabili
Note: Item {0} entered multiple times,Nota : L'articolo {0} entrato più volte
Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,Nota : non verrà creato pagamento Entry poiche ' in contanti o conto bancario ' non è stato specificato
Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,Nota : Il sistema non controlla over - consegna e over -booking per la voce {0} come la quantità o la quantità è 0
Note: There is not enough leave balance for Leave Type {0},Nota : Non c'è equilibrio congedo sufficiente per Leave tipo {0}
Note: This Cost Center is a Group. Cannot make accounting entries against groups.,Nota : Questo centro di costo è un gruppo . Non può fare scritture contabili contro i gruppi .
Note: {0},Nota : {0}
Notes,Note
Notes:,Note:
Nothing to request,Niente da chiedere
Notice (days),Avviso ( giorni )
Notification Control,Controllo di notifica
Notification Email Address,Indirizzo e-mail di notifica
Notify by Email on creation of automatic Material Request,Notifica tramite e-mail sulla creazione di Richiesta automatica Materiale
Number Format,Formato numero
Offer Date,offerta Data
Office,Ufficio
Office Equipments,ufficio Equipments
Office Maintenance Expenses,Spese di manutenzione degli uffici
Office Rent,Affitto Ufficio
Old Parent,Vecchio genitore
On Net Total,Sul totale netto
On Previous Row Amount,Sul Fila Indietro Importo
On Previous Row Total,Sul Fila Indietro totale
Online Auctions,Aste online
Only Leave Applications with status 'Approved' can be submitted,Lasciare solo applicazioni con stato ' approvato ' possono essere presentate
"Only Serial Nos with status ""Available"" can be delivered.",Possono essere consegnati solo i numeri seriali con stato &quot;Disponibile&quot;.
Only leaf nodes are allowed in transaction,Solo i nodi foglia sono ammessi nelle transazioni
Only the selected Leave Approver can submit this Leave Application,Solo il selezionato Lascia Approver può presentare questo Leave applicazione
Open,Aprire
Open Production Orders,Aprire ordini di produzione
Open Tickets,Biglietti Open
Opening (Cr),Opening ( Cr )
Opening (Dr),Opening ( Dr)
Opening Date,Data di apertura
Opening Entry,Apertura Entry
Opening Qty,Quantità di apertura
Opening Time,Tempo di apertura
Opening Value,Valore di apertura
Opening for a Job.,Apertura di un lavoro.
Operating Cost,Costo di gestione
Operation Description,Operazione Descrizione
Operation No,Operazione No
Operation Time (mins),Tempo di funzionamento (min)
Operation {0} is repeated in Operations Table,Operazione {0} è ripetuto in Operations tabella
Operation {0} not present in Operations Table,Operazione {0} non presente in Operations tabella
Operations,Operazioni
Opportunity,Opportunità
Opportunity Date,Opportunity Data
Opportunity From,Opportunità da
Opportunity Item,Opportunità articolo
Opportunity Items,Articoli Opportunità
Opportunity Lost,Occasione persa
Opportunity Type,Tipo di Opportunità
Optional. This setting will be used to filter in various transactions.,Facoltativo. Questa impostazione verrà utilizzato per filtrare in diverse operazioni .
Order Type,Tipo di ordine
Order Type must be one of {0},Tipo ordine deve essere uno dei {0}
Ordered,ordinato
Ordered Items To Be Billed,Articoli ordinati da fatturare
Ordered Items To Be Delivered,Articoli ordinati da consegnare
Ordered Qty,Quantità ordinato
"Ordered Qty: Quantity ordered for purchase, but not received.","Quantità ordinata: Quantità ordinato per l'acquisto , ma non ricevuto ."
Ordered Quantity,Ordinato Quantità
Orders released for production.,Gli ordini rilasciati per la produzione.
Organization Name,Nome organizzazione
Organization Profile,Profilo dell'organizzazione
Organization branch master.,Ramo Organizzazione master.
Organization unit (department) master.,Unità organizzativa ( dipartimento) master.
Other,Altro
Other Details,Altri dettagli
Others,altrui
Out Qty,out Quantità
Out Value,out Valore
Out of AMC,Fuori di AMC
Out of Warranty,Fuori garanzia
Outgoing,In partenza
Outstanding Amount,Eccezionale Importo
Outstanding for {0} cannot be less than zero ({1}),Eccezionale per {0} non può essere inferiore a zero ( {1} )
Overhead,Overhead
Overheads,Spese generali
Overlapping conditions found between:,Condizioni sovrapposti trovati tra :
Overview,Panoramica
Owned,Di proprietà
Owner,proprietario
P L A - Cess Portion,PLA - Cess Porzione
PL or BS,PL o BS
PO Date,PO Data
PO No,PO No
POP3 Mail Server,POP3 Mail Server
POP3 Mail Settings,Impostazioni di posta POP3
POP3 mail server (e.g. pop.gmail.com),POP3 server di posta (ad esempio pop.gmail.com)
POP3 server e.g. (pop.gmail.com),Server POP3 per esempio (pop.gmail.com)
POS Setting,POS Impostazione
POS Setting required to make POS Entry,Impostazione POS necessario per rendere POS Entry
POS Setting {0} already created for user: {1} and company {2},POS Ambito {0} già creato per l'utente : {1} e della società {2}
POS View,POS View
PR Detail,PR Dettaglio
Package Item Details,Confezione Articolo Dettagli
Package Items,Articoli della confezione
Package Weight Details,Pacchetto peso
Packed Item,Nota Consegna Imballaggio articolo
Packed quantity must equal quantity for Item {0} in row {1},Pranzo quantità deve essere uguale quantità per articolo {0} in riga {1}
Packing Details,Particolari dell&#39;imballaggio
Packing List,Lista di imballaggio
Packing Slip,Documento di trasporto
Packing Slip Item,Distinta di imballaggio articolo
Packing Slip Items,Imballaggio elementi slittamento
Packing Slip(s) cancelled,Bolla di accompagnamento ( s ) annullato
Page Break,Interruzione di pagina
Page Name,Nome pagina
Paid Amount,Importo pagato
Paid amount + Write Off Amount can not be greater than Grand Total,Importo versato + Scrivi Off importo non può essere superiore a Grand Total
Pair,coppia
Parameter,Parametro
Parent Account,Account principale
Parent Cost Center,Parent Centro di costo
Parent Customer Group,Parent Gruppo clienti
Parent Detail docname,Parent Dettaglio docname
Parent Item,Parent Item
Parent Item Group,Capogruppo Voce
Parent Item {0} must be not Stock Item and must be a Sales Item,Parent Item {0} deve essere non Fotografico articolo e deve essere un elemento di vendita
Parent Party Type,Tipo Partito Parent
Parent Sales Person,Parent Sales Person
Parent Territory,Territorio genitore
Parent Website Page,Parent Sito Pagina
Parent Website Route,Parent Sito Percorso
Parenttype,ParentType
Part-time,A tempo parziale
Partially Completed,Parzialmente completato
Partly Billed,Parzialmente Fatturato
Partly Delivered,Parzialmente Consegnato
Partner Target Detail,Partner di destinazione Dettaglio
Partner Type,Tipo di partner
Partner's Website,Sito del Partner
Party,Partito
Party Account,Account partito
Party Type,Tipo partito
Party Type Name,Tipo Parte Nome
Passive,Passive
Passport Number,Numero di passaporto
Password,Parola d&#39;ordine
Pay To / Recd From,Pay To / RECD Da
Payable,pagabile
Payables,Debiti
Payables Group,Debiti Gruppo
Payment Days,Giorni di Pagamento
Payment Due Date,Pagamento Due Date
Payment Period Based On Invoice Date,Periodo di pagamento basati su Data fattura
Payment Reconciliation,Pagamento Riconciliazione
Payment Reconciliation Invoice,Pagamento Riconciliazione fattura
Payment Reconciliation Invoices,Fatture di pagamento riconciliazione
Payment Reconciliation Payment,Pagamento Riconciliazione di pagamento
Payment Reconciliation Payments,Pagamento riconciliazione Pagamenti
Payment Type,Tipo di pagamento
Payment cannot be made for empty cart,Il pagamento non può essere effettuato per carrello vuoto
Payment of salary for the month {0} and year {1},Il pagamento dello stipendio del mese {0} e l'anno {1}
Payments,Pagamenti
Payments Made,Pagamenti effettuati
Payments Received,Pagamenti ricevuti
Payments made during the digest period,I pagamenti effettuati nel periodo digest
Payments received during the digest period,I pagamenti ricevuti durante il periodo di digest
Payroll Settings,Impostazioni Payroll
Pending,In attesa
Pending Amount,In attesa di Importo
Pending Items {0} updated,Elementi in sospeso {0} aggiornato
Pending Review,In attesa recensione
Pending SO Items For Purchase Request,Elementi in sospeso così per Richiesta di Acquisto
Pension Funds,Fondi Pensione
Percent Complete,Percentuale completamento
Percentage Allocation,Percentuale di allocazione
Percentage Allocation should be equal to 100%,Percentuale di ripartizione dovrebbe essere pari al 100 %
Percentage variation in quantity to be allowed while receiving or delivering this item.,Variazione percentuale della quantità di essere consentito durante la ricezione o la consegna di questo oggetto.
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.,Percentuale si è permesso di ricevere o consegnare di più contro la quantità ordinata. Per esempio: Se avete ordinato 100 unità. e il vostro assegno è 10% poi si è permesso di ricevere 110 unità.
Performance appraisal.,Valutazione delle prestazioni.
Period,periodo
Period Closing Voucher,Periodo di chiusura Voucher
Periodicity,Periodicità
Permanent Address,Indirizzo permanente
Permanent Address Is,Indirizzo permanente è
Permission,Autorizzazione
Personal,Personale
Personal Details,Dettagli personali
Personal Email,Personal Email
Pharmaceutical,farmaceutico
Pharmaceuticals,Pharmaceuticals
Phone,Telefono
Phone No,N. di telefono
Piecework,lavoro a cottimo
Pincode,PINCODE
Place of Issue,Luogo di emissione
Plan for maintenance visits.,Piano per le visite di manutenzione.
Planned Qty,Qtà Planned
"Planned Qty: Quantity, for which, Production Order has been raised, but is pending to be manufactured.","Planned Quantità : Quantità , per il quale , ordine di produzione è stata sollevata , ma è in attesa di essere lavorati."
Planned Quantity,Prevista Quantità
Planning,pianificazione
Plant,Impianto
Plant and Machinery,Impianti e macchinari
Please Enter Abbreviation or Short Name properly as it will be added as Suffix to all Account Heads.,Inserisci Abbreviazione o Nome breve correttamente in quanto verrà aggiunto come suffisso a tutti i Capi account.
Please Update SMS Settings,Si prega di aggiornare le impostazioni SMS
Please add expense voucher details,Si prega di aggiungere spese dettagli promozionali
Please add to Modes of Payment from Setup.,Si prega di aggiungere Modalità di pagamento da Setup.
Please check 'Is Advance' against Account {0} if this is an advance entry.,Si prega di verificare 'È Advance ' contro Account {0} se questa è una voce di anticipo.
Please click on 'Generate Schedule',Si prega di cliccare su ' Generate Schedule '
Please click on 'Generate Schedule' to fetch Serial No added for Item {0},Si prega di cliccare su ' Generate Schedule ' a prendere Serial No aggiunto per la voce {0}
Please click on 'Generate Schedule' to get schedule,Si prega di cliccare su ' Generate Schedule ' per ottenere pianificazione
Please create Customer from Lead {0},Si prega di creare Cliente da piombo {0}
Please create Salary Structure for employee {0},Si prega di creare struttura salariale per dipendente {0}
Please create new account from Chart of Accounts.,Si prega di creare un nuovo account dal Piano dei conti .
Please do NOT create Account (Ledgers) for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,Si prega di non creare account ( Registri ) per Clienti e Fornitori . Essi sono creati direttamente dai maestri cliente / fornitore .
Please enter 'Expected Delivery Date',Inserisci il ' Data prevista di consegna '
Please enter 'Is Subcontracted' as Yes or No,Si prega di inserire ' è appaltata ' come Yes o No
Please enter 'Repeat on Day of Month' field value,Inserisci ' Ripetere il giorno del mese ' valore di campo
Please enter Account Receivable/Payable group in company master,Inserisci Account Crediti / Debiti gruppo in compagnia maestro
Please enter Approving Role or Approving User,Inserisci Approvazione ruolo o Approvazione utente
Please enter BOM for Item {0} at row {1},Inserisci distinta per la voce {0} alla riga {1}
Please enter Company,Inserisci Società
Please enter Cost Center,Inserisci Centro di costo
Please enter Delivery Note No or Sales Invoice No to proceed,Inserisci il DDT o fattura di vendita No No per procedere
Please enter Employee Id of this sales parson,Inserisci Id dipendente di questa Parson vendite
Please enter Expense Account,Inserisci il Conto uscite
Please enter Item Code to get batch no,Inserisci il codice Item per ottenere lotto non
Please enter Item Code.,Inserisci il codice dell'articolo.
Please enter Item first,Inserisci articolo prima
Please enter Maintaince Details first,Inserisci Maintaince dettagli prima
Please enter Master Name once the account is created.,Inserisci il Master Nome una volta creato l'account .
Please enter Planned Qty for Item {0} at row {1},Inserisci pianificato quantità per la voce {0} alla riga {1}
Please enter Production Item first,Inserisci Produzione articolo prima
Please enter Purchase Receipt No to proceed,Inserisci Acquisto Ricevuta No per procedere
Please enter Reference date,Inserisci Data di riferimento
Please enter Warehouse for which Material Request will be raised,Inserisci il Magazzino per cui Materiale richiesta sarà sollevata
Please enter Write Off Account,Inserisci Scrivi Off conto
Please enter atleast 1 invoice in the table,Inserisci atleast 1 fattura nella tabella
Please enter company first,Inserisci prima azienda
Please enter company name first,Inserisci il nome della società prima
Please enter default Unit of Measure,Inserisci unità di misura predefinita
Please enter default currency in Company Master,Inserisci valuta predefinita in Azienda Maestro
Please enter email address,Si prega di inserire l'indirizzo email
Please enter item details,Inserisci il dettaglio articolo
Please enter message before sending,Inserisci il messaggio prima di inviarlo
Please enter parent account group for warehouse account,Inserisci il gruppo di conti principale per conto di magazzino
Please enter parent cost center,Inserisci il centro di costo genitore
Please enter quantity for Item {0},Inserite la quantità per articolo {0}
Please enter relieving date.,Inserisci la data alleviare .
Please enter sales order in the above table,Inserisci ordine di vendita nella tabella sopra
Please enter valid Company Email,Inserisci valido Mail
Please enter valid Email Id,Inserisci valido Email Id
Please enter valid Personal Email,Inserisci valido Email Personal
Please enter valid mobile nos,Inserisci nos mobili validi
Please find attached Sales Invoice #{0},Si trasmette in allegato Fattura # {0}
Please install dropbox python module,Si prega di installare dropbox modulo python
Please mention no of visits required,Si prega di citare nessuna delle visite richieste
Please pull items from Delivery Note,Si prega di tirare oggetti da DDT
Please save the Newsletter before sending,Si prega di salvare la Newsletter prima di inviare
Please save the document before generating maintenance schedule,Si prega di salvare il documento prima di generare il programma di manutenzione
Please see attachment,Si prega di vedere allegato
Please select Bank Account,Seleziona conto bancario
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,Si prega di selezionare il riporto se anche voi volete includere equilibrio precedente anno fiscale di parte per questo anno fiscale
Please select Category first,Si prega di selezionare Categoria prima
Please select Charge Type first,Seleziona il tipo di carica prima
Please select Fiscal Year,Si prega di selezionare l'anno fiscale
Please select Group or Ledger value,Si prega di selezionare un valore di gruppo o Ledger
Please select Incharge Person's name,Si prega di selezionare il nome del Incharge persona
Please select Invoice Type and Invoice Number in atleast one row,Si prega di selezionare Fattura Tipo e numero di fattura in atleast una riga
"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM","Si prega di selezionare Item dove "" è articolo di "" è "" No"" e ""La Voce di vendita "" è "" Sì"" e non c'è nessun altro BOM vendite"
Please select Price List,Seleziona Listino Prezzi
Please select Start Date and End Date for Item {0},Scegliere una data di inizio e di fine per la voce {0}
Please select Time Logs.,Si prega di selezionare Registri di tempo.
Please select a csv file,Seleziona un file csv
Please select a valid csv file with data,Selezionare un file csv valido con i dati
Please select a value for {0} quotation_to {1},Si prega di selezionare un valore per {0} quotation_to {1}
"Please select an ""Image"" first","Seleziona ""Immagine "" prima"
Please select charge type first,Si prega di selezionare il tipo di carica prima
Please select company first,Si prega di selezionare prima azienda
Please select company first.,Si prega di selezionare prima azienda .
Please select item code,Si prega di selezionare il codice articolo
Please select month and year,Si prega di selezionare mese e anno
Please select prefix first,Si prega di selezionare il prefisso prima
Please select the document type first,Si prega di selezionare il tipo di documento prima
Please select weekly off day,Seleziona il giorno di riposo settimanale
Please select {0},Si prega di selezionare {0}
Please select {0} first,Si prega di selezionare {0} prima
Please select {0} first.,Si prega di selezionare {0} prima.
Please set Dropbox access keys in your site config,Si prega di impostare tasti di accesso Dropbox nel tuo sito config
Please set Google Drive access keys in {0},Si prega di impostare le chiavi di accesso di Google Drive in {0}
Please set default Cash or Bank account in Mode of Payment {0},Si prega di impostare di default Contanti o conto bancario in Modalità di pagamento {0}
Please set default value {0} in Company {0},Si prega di impostare il valore predefinito {0} in Società {0}
Please set {0},Impostare {0}
Please setup Employee Naming System in Human Resource > HR Settings,Si prega di impostazione dei dipendenti sistema di nomi delle risorse umane&gt; Impostazioni HR
Please setup numbering series for Attendance via Setup > Numbering Series,Si prega serie di numerazione di installazione per presenze tramite Setup > Numerazione Series
Please setup your chart of accounts before you start Accounting Entries,Si prega di configurare il piano dei conti prima di iniziare scritture contabili
Please specify,Si prega di specificare
Please specify Company,Si prega di specificare Azienda
Please specify Company to proceed,Si prega di specificare Società di procedere
Please specify Default Currency in Company Master and Global Defaults,Siete pregati di specificare Valuta predefinita in azienda Maestro e predefiniti globali
Please specify a,Si prega di specificare una
Please specify a valid 'From Case No.',Si prega di specificare una valida &#39;Dalla sentenza n&#39;
Please specify a valid Row ID for {0} in row {1},Si prega di specificare un ID fila valido per {0} in riga {1}
Please specify either Quantity or Valuation Rate or both,Si prega di specificare Quantitativo o Tasso di valutazione o di entrambi
Please submit to update Leave Balance.,Si prega di inviare per aggiornare Lascia Balance.
Plot,trama
Plot By,Plot By
Point of Sale,Punto di vendita
Point-of-Sale Setting,Point-of-Sale Setting
Post Graduate,Post Laurea
Postal,Postale
Postal Expenses,spese postali
Posting Date,Data di registrazione
Posting Time,Tempo Distacco
Posting date and posting time is mandatory,Data di registrazione e il distacco ora è obbligatorio
Posting timestamp must be after {0},Distacco timestamp deve essere successiva {0}
Potential opportunities for selling.,Potenziali opportunità di vendita.
Preferred Billing Address,Preferito Indirizzo di fatturazione
Preferred Shipping Address,Preferito Indirizzo spedizione
Prefix,Prefisso
Present,Presente
Prevdoc DocType,Prevdoc DocType
Prevdoc Doctype,Prevdoc Doctype
Preview,anteprima
Previous,precedente
Previous Work Experience,Lavoro precedente esperienza
Price,prezzo
Price / Discount,Prezzo / Sconto
Price List,Listino Prezzi
Price List Currency,Prezzo di listino Valuta
Price List Currency not selected,Listino Prezzi Valuta non selezionati
Price List Exchange Rate,Listino Prezzi Tasso di Cambio
Price List Name,Prezzo di listino Nome
Price List Rate,Prezzo di listino Vota
Price List Rate (Company Currency),Prezzo di listino Prezzo (Azienda valuta)
Price List master.,Maestro listino prezzi.
Price List must be applicable for Buying or Selling,Prezzo di listino deve essere applicabile per l'acquisto o la vendita di
Price List not selected,Listino Prezzi non selezionati
Price List {0} is disabled,Prezzo di listino {0} è disattivato
Price or Discount,Prezzo o Sconto
Pricing Rule,Regola Prezzi
Pricing Rule Help,Regola Prezzi Aiuto
"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.","Regola Prezzi viene prima selezionato in base al 'applicare sul campo', che può essere prodotto, Articolo di gruppo o di marca."
"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.","Regola Pricing è fatto per sovrascrivere Listino Prezzi / definire la percentuale di sconto, sulla base di alcuni criteri."
Pricing Rules are further filtered based on quantity.,Regole dei prezzi sono ulteriormente filtrati in base alla quantità.
Print Format Style,Formato Stampa Style
Print Heading,Stampa Rubrica
Print Without Amount,Stampare senza Importo
Print and Stationary,Stampa e Fermo
Printing and Branding,Stampa e Branding
Priority,Priorità
Private Equity,private Equity
Privilege Leave,Lascia Privilege
Probation,prova
Process Payroll,Processo Payroll
Produced,prodotto
Produced Quantity,Prodotto Quantità
Product Enquiry,Prodotto Inchiesta
Production,produzione
Production Order,Ordine di produzione
Production Order status is {0},Stato ordine di produzione è {0}
Production Order {0} must be cancelled before cancelling this Sales Order,Ordine di produzione {0} deve essere cancellato prima di annullare questo ordine di vendita
Production Order {0} must be submitted,Ordine di produzione {0} deve essere presentata
Production Orders,Ordini di produzione
Production Orders in Progress,Ordini di produzione in corso
Production Plan Item,Produzione Piano Voce
Production Plan Items,Produzione Piano Articoli
Production Plan Sales Order,Produzione Piano di ordini di vendita
Production Plan Sales Orders,Produzione piano di vendita Ordini
Production Planning Tool,Production Planning Tool
Products,prodotti
"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.","I prodotti saranno ordinati in peso-età nelle ricerche predefinite. Più il peso-età, più alto è il prodotto verrà visualizzato nell&#39;elenco."
Professional Tax,Tasse professionale
Profit and Loss,Economico
Profit and Loss Statement,Conto Economico
Project,Progetto
Project Costing,Progetto Costing
Project Details,Dettagli del progetto
Project Manager,Project Manager
Project Milestone,Progetto Milestone
Project Milestones,Tappe del progetto
Project Name,Nome del progetto
Project Start Date,Data di inizio del progetto
Project Type,Tipo di progetto
Project Value,Valore di progetto
Project activity / task.,Attività / attività del progetto.
Project master.,Progetto Master.
Project will get saved and will be searchable with project name given,Progetto avranno salvato e sarà consultabile con il nome di progetto dato
Project wise Stock Tracking,Progetto saggio Archivio monitoraggio
Project-wise data is not available for Quotation,Dati di progetto -saggio non è disponibile per Preventivo
Projected,proiettata
Projected Qty,Qtà Proiettata
Projects,Progetti
Projects & System,Progetti & Sistema
Prompt for Email on Submission of,Richiedi Email su presentazione di
Proposal Writing,Scrivere proposta
Provide email id registered in company,Fornire id-mail registrato in azienda
Provisional Profit / Loss (Credit),Risultato provvisorio / Perdita (credito)
Public,Pubblico
Published on website at: {0},Pubblicato il sito web all'indirizzo: {0}
Publishing,editoria
Pull sales orders (pending to deliver) based on the above criteria,Tirare ordini di vendita (in attesa di consegnare) sulla base dei criteri di cui sopra
Purchase,Acquisto
Purchase / Manufacture Details,Acquisto / Produzione Dettagli
Purchase Analytics,Acquisto Analytics
Purchase Common,Comuni di acquisto
Purchase Details,"Acquisto, i dati"
Purchase Discounts,Acquisto Sconti
Purchase Invoice,Acquisto Fattura
Purchase Invoice Advance,Acquisto Advance Fattura
Purchase Invoice Advances,Acquisto anticipi fatture
Purchase Invoice Item,Acquisto Articolo Fattura
Purchase Invoice Trends,Acquisto Tendenze Fattura
Purchase Invoice {0} is already submitted,Acquisto Fattura {0} è già presentato
Purchase Order,Ordine di acquisto
Purchase Order Item,Ordine di acquisto dell&#39;oggetto
Purchase Order Item No,Acquisto fig
Purchase Order Item Supplied,Ordine di acquisto Articolo inserito
Purchase Order Items,Acquisto Ordine Articoli
Purchase Order Items Supplied,Ordine di Acquisto Standard di fornitura
Purchase Order Items To Be Billed,Ordine di Acquisto Articoli da fatturare
Purchase Order Items To Be Received,Ordine di Acquisto Oggetti da ricevere
Purchase Order Message,Ordine di acquisto Message
Purchase Order Required,Ordine di Acquisto Obbligatorio
Purchase Order Trends,Acquisto Tendenze Ordine
Purchase Order number required for Item {0},Numero ordine di acquisto richiesto per la voce {0}
Purchase Order {0} is 'Stopped',Ordine di acquisto {0} ' smesso '
Purchase Order {0} is not submitted,Purchase Order {0} non è presentata
Purchase Orders given to Suppliers.,Ordini di acquisto prestate a fornitori.
Purchase Receipt,RICEVUTA
Purchase Receipt Item,RICEVUTA articolo
Purchase Receipt Item Supplied,Acquisto Ricevuta Articolo inserito
Purchase Receipt Item Supplieds,RICEVUTA Voce Supplieds
Purchase Receipt Items,Acquistare oggetti Receipt
Purchase Receipt Message,RICEVUTA Messaggio
Purchase Receipt No,RICEVUTA No
Purchase Receipt Required,Acquisto necessaria la ricevuta
Purchase Receipt Trends,Acquisto Tendenze Receipt
Purchase Receipt number required for Item {0},Acquisto Ricevuta richiesta per la voce {0}
Purchase Receipt {0} is not submitted,Acquisto Ricevuta {0} non è presentata
Purchase Register,Acquisto Registrati
Purchase Return,Acquisto Ritorno
Purchase Returned,Acquisto restituito
Purchase Taxes and Charges,Acquisto Tasse e Costi
Purchase Taxes and Charges Master,Acquisto Tasse e Spese master
Purchse Order number required for Item {0},Numero Purchse ordine richiesto per la voce {0}
Purpose,Scopo
Purpose must be one of {0},Scopo deve essere uno dei {0}
QA Inspection,Ispezione QA
Qty,Qtà
Qty Consumed Per Unit,Quantità consumata per unità
Qty To Manufacture,Quantità di fabbricare
Qty as per Stock UOM,Quantità come da UOM Archivio
Qty to Deliver,Qtà di Consegna
Qty to Order,Qty di ordinazione
Qty to Receive,Qtà per ricevere
Qty to Transfer,Qtà Trasferire
Qualification,Qualifica
Quality,Qualità
Quality Inspection,Controllo Qualità
Quality Inspection Parameters,Parametri di controllo qualità
Quality Inspection Reading,Lettura Controllo Qualità
Quality Inspection Readings,Letture di controllo di qualità
Quality Inspection required for Item {0},Controllo qualità richiesta per la voce {0}
Quality Management,Gestione della qualità
Quantity,Quantità
Quantity Requested for Purchase,Quantità a fini di acquisto
Quantity and Rate,Quantità e Prezzo
Quantity and Warehouse,Quantità e Magazzino
Quantity cannot be a fraction in row {0},Quantità non può essere una frazione in riga {0}
Quantity for Item {0} must be less than {1},Quantità per la voce {0} deve essere inferiore a {1}
Quantity in row {0} ({1}) must be same as manufactured quantity {2},Quantità in riga {0} ( {1} ) deve essere uguale quantità prodotta {2}
Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,Quantità di prodotto ottenuto dopo la produzione / reimballaggio da determinati quantitativi di materie prime
Quantity required for Item {0} in row {1},Quantità necessaria per la voce {0} in riga {1}
Quarter,Quartiere
Quarterly,Trimestrale
Quick Help,Guida rapida
Quotation,Quotazione
Quotation Item,Quotazione articolo
Quotation Items,Voci di quotazione
Quotation Lost Reason,Quotazione Perso Motivo
Quotation Message,Quotazione Messaggio
Quotation To,Preventivo A
Quotation Trends,Tendenze di quotazione
Quotation {0} is cancelled,Quotazione {0} viene annullato
Quotation {0} not of type {1},Quotazione {0} non di tipo {1}
Quotations received from Suppliers.,Citazioni ricevute dai fornitori.
Quotes to Leads or Customers.,Citazioni a clienti o contatti.
Raise Material Request when stock reaches re-order level,Sollevare Materiale Richiesta quando le azione raggiunge il livello di riordino
Raised By,Sollevata dal
Raised By (Email),Sollevata da (e-mail)
Random,Casuale
Range,Gamma
Rate,Vota
Rate ,Vota
Rate (%),Tasso ( % )
Rate (Company Currency),Vota (Azienda valuta)
Rate Of Materials Based On,Tasso di materiali a base di
Rate and Amount,Aliquota e importo
Rate at which Customer Currency is converted to customer's base currency,Velocità con cui valuta Cliente viene convertito in valuta di base del cliente
Rate at which Price list currency is converted to company's base currency,Tasso al quale Listino valuta viene convertita in valuta di base dell&#39;azienda
Rate at which Price list currency is converted to customer's base currency,Tasso al quale Listino valuta viene convertita in valuta di base del cliente
Rate at which customer's currency is converted to company's base currency,Tasso al quale la valuta del cliente viene convertito in valuta di base dell&#39;azienda
Rate at which supplier's currency is converted to company's base currency,Tasso al quale la valuta del fornitore viene convertito in valuta di base dell&#39;azienda
Rate at which this tax is applied,Tasso a cui viene applicata questa tassa
Raw Material,Materia prima
Raw Material Item Code,Materia Codice Articolo
Raw Materials Supplied,Materie prime fornite
Raw Materials Supplied Cost,Materie prime fornite Costo
Raw material cannot be same as main Item,La materia prima non può essere lo stesso come voce principale
Re-Order Level,Re-Order Livello
Re-Order Qty,Re-Order Qty
Re-order,Re-order
Re-order Level,Livello di riordino
Re-order Qty,Re-order Qtà
Read,Leggi
Reading 1,Lettura 1
Reading 10,Reading 10
Reading 2,Lettura 2
Reading 3,Reading 3
Reading 4,Reading 4
Reading 5,Lettura 5
Reading 6,Lettura 6
Reading 7,Leggendo 7
Reading 8,Lettura 8
Reading 9,Lettura 9
Real Estate,real Estate
Reason,Motivo
Reason for Leaving,Ragione per lasciare
Reason for Resignation,Motivo della Dimissioni
Reason for losing,Motivo per perdere
Recd Quantity,RECD Quantità
Receivable,ricevibile
Receivable / Payable account will be identified based on the field Master Type,Conto da ricevere / pagare sarà identificato in base al campo Master
Receivables,Crediti
Receivables / Payables,Crediti / Debiti
Receivables Group,Gruppo Crediti
Received Date,Data Received
Received Items To Be Billed,Oggetti ricevuti da fatturare
Received Qty,Quantità ricevuta
Received and Accepted,Ricevuti e accettati
Receiver List,Lista Ricevitore
Receiver List is empty. Please create Receiver List,Lista Receiver è vuoto . Si prega di creare List Ricevitore
Receiver Parameter,Ricevitore Parametro
Recipients,Destinatari
Reconcile,conciliare
Reconciliation Data,Dati Riconciliazione
Reconciliation HTML,Riconciliazione HTML
Reconciliation JSON,Riconciliazione JSON
Record item movement.,Registrare il movimento dell&#39;oggetto.
Recurring Id,Id ricorrente
Recurring Invoice,Fattura ricorrente
Recurring Type,Tipo ricorrente
Reduce Deduction for Leave Without Pay (LWP),Ridurre Deduzione per aspettativa senza assegni (LWP)
Reduce Earning for Leave Without Pay (LWP),Ridurre Guadagnare in aspettativa senza assegni (LWP)
Ref,Arbitro
Ref Code,Rif. Codice
Ref SQ,Rif. SQ
Reference,Riferimento
Reference #{0} dated {1},Riferimento # {0} datato {1}
Reference Date,Data di riferimento
Reference Name,Nome di riferimento
Reference No & Reference Date is required for {0},N. di riferimento & Reference Data è necessario per {0}
Reference No is mandatory if you entered Reference Date,N. di riferimento è obbligatoria se hai inserito Reference Data
Reference Number,Numero di riferimento
Reference Row #,Riferimento Row #
Refresh,Refresh
Registration Details,Dettagli di registrazione
Registration Info,Informazioni di Registrazione
Rejected,Rifiutato
Rejected Quantity,Rifiutato Quantità
Rejected Serial No,Rifiutato Serial No
Rejected Warehouse,Magazzino Rifiutato
Rejected Warehouse is mandatory against regected item,Warehouse Respinto è obbligatoria alla voce regected
Relation,Relazione
Relieving Date,Alleviare Data
Relieving Date must be greater than Date of Joining,Data Alleviare deve essere maggiore di Data di giunzione
Remark,Osservazioni
Remarks,Osservazioni
Remarks Custom,Annotazioni Custom
Rename,rinominare
Rename Log,Rinominare Entra
Rename Tool,Rename Tool
Rent Cost,Affitto Costo
Rent per hour,Affittare all'ora
Rented,Affittato
Repeat on Day of Month,Ripetere il Giorno del mese
Replace,Sostituire
Replace Item / BOM in all BOMs,Sostituire Voce / BOM in tutte le distinte base
Replied,Ha risposto
Report Date,Data Segnala
Report Type,Tipo di rapporto
Report Type is mandatory,Tipo di rapporto è obbligatoria
Reports to,Relazioni al
Reqd By Date,Reqd Per Data
Reqd by Date,Reqd per Data
Request Type,Tipo di richiesta
Request for Information,Richiesta di Informazioni
Request for purchase.,Richiesta di acquisto.
Requested,richiesto
Requested For,richiesto Per
Requested Items To Be Ordered,Elementi richiesti da ordinare
Requested Items To Be Transferred,Voci si chiede il trasferimento
Requested Qty,richiesto Quantità
"Requested Qty: Quantity requested for purchase, but not ordered.","Richiesto Quantità : Quantità richiesto per l'acquisto , ma non ordinato."
Requests for items.,Le richieste di articoli.
Required By,Richiesto da
Required Date,Data richiesta
Required Qty,Quantità richiesta
Required only for sample item.,Richiesto solo per la voce di esempio.
Required raw materials issued to the supplier for producing a sub - contracted item.,Materie prime necessarie rilasciate al fornitore per la produzione di un sotto - voce contratta.
Research,ricerca
Research & Development,Ricerca & Sviluppo
Researcher,ricercatore
Reseller,Rivenditore
Reserved,riservato
Reserved Qty,Riservato Quantità
"Reserved Qty: Quantity ordered for sale, but not delivered.","Riservato Quantità : quantità ordinata in vendita , ma non consegnati ."
Reserved Quantity,Riservato Quantità
Reserved Warehouse,Riservato Warehouse
Reserved Warehouse in Sales Order / Finished Goods Warehouse,Warehouse Riservato a ordini di vendita / Magazzino prodotti finiti
Reserved Warehouse is missing in Sales Order,Riservato Warehouse manca in ordine di vendita
Reserved Warehouse required for stock Item {0} in row {1},Magazzino Riservato richiesto per magazzino Voce {0} in riga {1}
Reserved warehouse required for stock item {0},Magazzino Riservato richiesto per l'articolo di {0}
Reserves and Surplus,Riserve e Surplus
Reset Filters,Azzera i filtri
Resignation Letter Date,Lettera di dimissioni Data
Resolution,Risoluzione
Resolution Date,Risoluzione Data
Resolution Details,Dettagli risoluzione
Resolved By,Deliberato dall&#39;Assemblea
Rest Of The World,Resto del Mondo
Retail,Vendita al dettaglio
Retail & Wholesale,Retail & Wholesale
Retailer,Dettagliante
Review Date,Data di revisione
Rgt,Rgt
Role Allowed to edit frozen stock,Ruolo ammessi da modificare stock congelato
Role that is allowed to submit transactions that exceed credit limits set.,Ruolo che è consentito di presentare le transazioni che superano i limiti di credito stabiliti.
Root Type,Root Tipo
Root Type is mandatory,Root Type è obbligatorio
Root account can not be deleted,Account root non può essere eliminato
Root cannot be edited.,Root non può essere modificato .
Root cannot have a parent cost center,Root non può avere un centro di costo genitore
Rounded Off,arrotondato
Rounded Total,Totale arrotondato
Rounded Total (Company Currency),Totale arrotondato (Azienda valuta)
Row # ,Row #
Row # {0}: ,
Row #{0}: Ordered qty can not less than item's minimum order qty (defined in item master).,Row # {0}: quantità ordinata non può a meno di quantità di ordine minimo dell'elemento (definito al punto master).
Row #{0}: Please specify Serial No for Item {1},Row # {0}: Si prega di specificare Numero d'ordine per la voce {1}
"Row {0}: Account does not match with \
						Purchase Invoice Credit To account","Riga {0}: Account non corrisponde con \
 Acquisto fattura accreditare sul suo conto"
"Row {0}: Account does not match with \
						Sales Invoice Debit To account","Riga {0}: Account non corrisponde con \
 Fattura Debito Per tenere conto"
Row {0}: Conversion Factor is mandatory,Riga {0}: fattore di conversione è obbligatoria
Row {0}: Credit entry can not be linked with a Purchase Invoice,Riga {0} : ingresso credito non può essere collegato con una fattura di acquisto
Row {0}: Debit entry can not be linked with a Sales Invoice,Riga {0} : ingresso debito non può essere collegato con una fattura di vendita
Row {0}: Payment amount must be less than or equals to invoice outstanding amount. Please refer Note below.,Riga {0}: importo pagamento deve essere inferiore o uguale a fatturare importo residuo. Si prega di fare riferimento Nota di seguito.
Row {0}: Qty is mandatory,Riga {0}: Quantità è obbligatorio
"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","Riga {0}: Quantità non avalable in magazzino {1} su {2} {3}.
 Disponibile Quantità: {4}, Quantità di trasferimento: {5}"
"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","Riga {0}: Per impostare {1} periodicità, differenza tra da e per data \
 deve essere maggiore o uguale a {2}"
Row {0}:Start Date must be before End Date,Riga {0} : Data di inizio deve essere precedente Data di fine
Rules for adding shipping costs.,Regole per l'aggiunta di spese di spedizione .
Rules for applying pricing and discount.,Le modalità di applicazione di prezzi e sconti .
Rules to calculate shipping amount for a sale,Regole per il calcolo dell&#39;importo di trasporto per una vendita
S.O. No.,S.O. No.
SHE Cess on Excise,SHE Cess su accise
SHE Cess on Service Tax,SHE Cess sul servizio Tax
SHE Cess on TDS,SHE Cess su TDS
SMS Center,Centro SMS
SMS Gateway URL,SMS Gateway URL
SMS Log,SMS Log
SMS Parameter,SMS Parametro
SMS Sender Name,SMS Sender Nome
SMS Settings,Impostazioni SMS
SO Date,SO Data
SO Pending Qty,SO attesa Qtà
SO Qty,SO Quantità
Salary,Stipendio
Salary Information,Informazioni stipendio
Salary Manager,Stipendio Direttore
Salary Mode,Modalità di stipendio
Salary Slip,Stipendio slittamento
Salary Slip Deduction,Stipendio slittamento Deduzione
Salary Slip Earning,Stipendio slittamento Guadagnare
Salary Slip of employee {0} already created for this month,Salario Slip of dipendente {0} già creato per questo mese
Salary Structure,Struttura salariale
Salary Structure Deduction,Struttura salariale Deduzione
Salary Structure Earning,Struttura salariale Guadagnare
Salary Structure Earnings,Utile struttura salariale
Salary breakup based on Earning and Deduction.,Stipendio rottura basato sul guadagno e di deduzione.
Salary components.,Componenti stipendio.
Salary template master.,Modello Stipendio master.
Sales,Vendite
Sales Analytics,Analisi dei dati di vendita
Sales BOM,BOM Vendite
Sales BOM Help,Vendite BOM Aiuto
Sales BOM Item,Vendite BOM articolo
Sales BOM Items,Vendite BOM Articoli
Sales Browser,Browser vendite
Sales Details,Dettagli di vendita
Sales Discounts,Sconti di vendita
Sales Email Settings,Vendite E-mail Impostazioni
Sales Expenses,Spese di vendita
Sales Extras,Extra di vendita
Sales Funnel,imbuto di vendita
Sales Invoice,Fattura Commerciale
Sales Invoice Advance,Fattura Advance
Sales Invoice Item,Fattura Voce
Sales Invoice Items,Fattura di vendita Articoli
Sales Invoice Message,Fattura Messaggio
Sales Invoice No,Fattura Commerciale No
Sales Invoice Trends,Fattura di vendita Tendenze
Sales Invoice {0} has already been submitted,{0} è già stato presentato fattura di vendita
Sales Invoice {0} must be cancelled before cancelling this Sales Order,Fattura di vendita {0} deve essere cancellato prima di annullare questo ordine di vendita
Sales Order,Ordine di vendita
Sales Order Date,Ordine di vendita Data
Sales Order Item,Sales Order Item
Sales Order Items,Ordini di vendita Articoli
Sales Order Message,Sales Order Messaggio
Sales Order No,Ordine di vendita No
Sales Order Required,Ordine di vendita richiesto
Sales Order Trends,Tendenze Sales Order
Sales Order required for Item {0},Ordine di vendita necessaria per la voce {0}
Sales Order {0} is not submitted,Sales Order {0} non è presentata
Sales Order {0} is not valid,Sales Order {0} non è valido
Sales Order {0} is stopped,Sales Order {0} viene arrestato
Sales Partner,Partner di vendita
Sales Partner Name,Vendite Partner Nome
Sales Partner Target,Vendite Partner di destinazione
Sales Partners Commission,Vendite Partners Commissione
Sales Person,Addetto alle vendite
Sales Person Name,Vendite Nome persona
Sales Person Target Variance Item Group-Wise,Sales Person target Varianza articolo Group- Wise
Sales Person Targets,Sales Person Obiettivi
Sales Person-wise Transaction Summary,Sales Person-saggio Sintesi dell&#39;Operazione
Sales Register,Commerciale Registrati
Sales Return,Ritorno di vendite
Sales Returned,Vendite restituiti
Sales Taxes and Charges,Tasse di vendita e oneri
Sales Taxes and Charges Master,Tasse di vendita e oneri master
Sales Team,Team di vendita
Sales Team Details,Vendite team Dettagli
Sales Team1,Vendite Team1
Sales and Purchase,Vendita e Acquisto
Sales campaigns.,Campagne di vendita .
Salutation,Appellativo
Sample Size,Dimensione del campione
Sanctioned Amount,Importo sanzionato
Saturday,Sabato
Schedule,Pianificare
Schedule Date,Programma Data
Schedule Details,Dettagli di pianificazione
Scheduled,Pianificate
Scheduled Date,Data prevista
Scheduled to send to {0},Programmato per inviare {0}
Scheduled to send to {0} recipients,Programmato per inviare {0} destinatari
Scheduler Failed Events,Events Calendario falliti
School/University,Scuola / Università
Score (0-5),Punteggio (0-5)
Score Earned,Punteggio Earned
Score must be less than or equal to 5,Punteggio deve essere minore o uguale a 5
Scrap %,Scrap%
Seasonality for setting budgets.,Stagionalità di impostazione budget.
Secretary,segretario
Secured Loans,Prestiti garantiti
Securities & Commodity Exchanges,Securities & borse merci
Securities and Deposits,I titoli e depositi
"See ""Rate Of Materials Based On"" in Costing Section",Vedere &quot;tasso di materiali a base di&quot; in Costing Sezione
"Select ""Yes"" for sub - contracting items",Selezionare &quot;Sì&quot; per i sub - articoli contraenti
"Select ""Yes"" if this item is used for some internal purpose in your company.",Selezionare &quot;Sì&quot; se l&#39;oggetto è utilizzato per uno scopo interno nella vostra azienda.
"Select ""Yes"" if this item represents some work like training, designing, consulting etc.","Selezionare &quot;Sì&quot; se l&#39;oggetto rappresenta un lavoro come la formazione, progettazione, consulenza, ecc"
"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",Selezionare &quot;Sì&quot; se si sta mantenendo magazzino di questo articolo nel tuo inventario.
"Select ""Yes"" if you supply raw materials to your supplier to manufacture this item.",Selezionare &quot;Sì&quot; se si forniscono le materie prime per il vostro fornitore per la fabbricazione di questo oggetto.
Select Brand...,Seleziona Marca ...
Select Budget Distribution to unevenly distribute targets across months.,Selezionare Budget Distribution per distribuire uniformemente gli obiettivi in ​​tutta mesi.
"Select Budget Distribution, if you want to track based on seasonality.","Selezionare Budget distribuzione, se si desidera tenere traccia in base a stagionalità."
Select Company...,Seleziona Company ...
Select DocType,Selezionare DocType
Select Fiscal Year...,Selezionare l'anno fiscale ...
Select Items,Selezionare Elementi
Select Project...,Selezionare Progetto ...
Select Purchase Receipts,Selezionare ricevute di acquisto
Select Sales Orders,Selezionare Ordini di vendita
Select Sales Orders from which you want to create Production Orders.,Selezionare gli ordini di vendita da cui si desidera creare gli ordini di produzione.
Select Time Logs and Submit to create a new Sales Invoice.,Selezionare Time Diari e Invia per creare una nuova fattura di vendita.
Select Transaction,Selezionare Transaction
Select Warehouse...,Seleziona Warehouse ...
Select Your Language,Seleziona la tua lingua
Select account head of the bank where cheque was deposited.,Selezionare conto capo della banca in cui assegno è stato depositato.
Select company name first.,Selezionare il nome della società prima.
Select template from which you want to get the Goals,Selezionare modello da cui si desidera ottenere gli Obiettivi
Select the Employee for whom you are creating the Appraisal.,Selezionare il dipendente per il quale si sta creando la valutazione.
Select the period when the invoice will be generated automatically,Selezionare il periodo in cui la fattura viene generato automaticamente
Select the relevant company name if you have multiple companies,"Selezionare il relativo nome della società, se si dispone di più le aziende"
Select the relevant company name if you have multiple companies.,"Selezionare il relativo nome della società, se si dispone di più aziende."
Select who you want to send this newsletter to,Selezionare a chi si desidera inviare questa newsletter ad
Select your home country and check the timezone and currency.,Seleziona il tuo paese di origine e controllare il fuso orario e la valuta .
"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.","Selezionando &quot;Sì&quot;, consentirà a questa voce di apparire in ordine di acquisto, ricevuta di acquisto."
"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note","Selezionando &quot;Sì&quot; permetterà questo elemento per capire in ordine di vendita, di consegna Note"
"Selecting ""Yes"" will allow you to create Bill of Material showing raw material and operational costs incurred to manufacture this item.",Selezionando &quot;Sì&quot; vi permetterà di creare distinta base che mostra delle materie prime e dei costi operativi sostenuti per la produzione di questo elemento.
"Selecting ""Yes"" will allow you to make a Production Order for this item.",Selezionando &quot;Sì&quot; vi permetterà di fare un ordine di produzione per questo articolo.
"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",Selezionando &quot;Sì&quot; darà una identità unica di ciascun soggetto di questa voce che può essere visualizzato nel Serial Nessun maestro.
Selling,Vendere
Selling Settings,Vendere Impostazioni
"Selling must be checked, if Applicable For is selected as {0}","Vendita deve essere controllato, se applicabile per è selezionato come {0}"
Send,Invia
Send Autoreply,Invia Autoreply
Send Email,Invia Email
Send From,Invia Dalla
Send Notifications To,Inviare notifiche ai
Send Now,Invia Ora
Send SMS,Invia SMS
Send To,Invia a
Send To Type,Send To Type
Send mass SMS to your contacts,Invia SMS di massa ai tuoi contatti
Send to this list,Invia a questa lista
Sender Name,Nome mittente
Sent On,Inviata il
Separate production order will be created for each finished good item.,Ordine di produzione separata verrà creato per ogni buon prodotto finito.
Serial No,Serial No
Serial No / Batch,Serial n / Batch
Serial No Details,Serial No Dettagli
Serial No Service Contract Expiry,Serial No Contratto di Servizio di scadenza
Serial No Status,Serial No Stato
Serial No Warranty Expiry,Serial No Garanzia di scadenza
Serial No is mandatory for Item {0},Numero d'ordine è obbligatorio per la voce {0}
Serial No {0} created,Serial No {0} creato
Serial No {0} does not belong to Delivery Note {1},Serial No {0} non appartiene alla Consegna Nota {1}
Serial No {0} does not belong to Item {1},Serial No {0} non appartiene alla voce {1}
Serial No {0} does not belong to Warehouse {1},Serial No {0} non appartiene al Warehouse {1}
Serial No {0} does not exist,Serial No {0} non esiste
Serial No {0} has already been received,Serial No {0} è già stato ricevuto
Serial No {0} is under maintenance contract upto {1},Serial No {0} è sotto contratto di manutenzione fino a {1}
Serial No {0} is under warranty upto {1},Serial No {0} è in garanzia fino a {1}
Serial No {0} not in stock,Serial No {0} non in magazzino
Serial No {0} quantity {1} cannot be a fraction,Serial No {0} {1} quantità non può essere una frazione
Serial No {0} status must be 'Available' to Deliver,Serial No {0} Stato deve essere ' disponibili' a consegnare
Serial Nos Required for Serialized Item {0},Serial Nos Obbligatorio per la voce Serialized {0}
Serial Number Series,Serial Number Series
Serial number {0} entered more than once,Numero di serie {0} è entrato più di una volta
"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","Voce Serialized {0} non può essere aggiornato \
 usando Riconciliazione Archivio"
Series,serie
Series List for this Transaction,Lista Serie per questa transazione
Series Updated,serie Aggiornato
Series Updated Successfully,Serie Aggiornato con successo
Series is mandatory,Series è obbligatorio
Series {0} already used in {1},Serie {0} già utilizzata in {1}
Service,servizio
Service Address,Service Indirizzo
Service Tax,Servizio fiscale
Services,Servizi
Set,set
"Set Default Values like Company, Currency, Current Fiscal Year, etc.","Impostare i valori predefiniti , come Società , valuta , corrente anno fiscale , ecc"
Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,Impostare la voce del budget di Gruppo-saggi su questo territorio. È inoltre possibile includere la stagionalità impostando la distribuzione.
Set Status as Available,Imposta stato come Disponibile
Set as Default,Imposta come predefinito
Set as Lost,Imposta come persa
Set prefix for numbering series on your transactions,Impostare prefisso per numerazione serie sulle transazioni
Set targets Item Group-wise for this Sales Person.,Fissare obiettivi Item Group-saggio per questo venditore.
Setting Account Type helps in selecting this Account in transactions.,Impostazione Tipo di account aiuta nella scelta questo account nelle transazioni.
Setting this Address Template as default as there is no other default,L'impostazione di questo modello di indirizzo di default perché non c'è altro difetto
Setting up...,Impostazione ...
Settings,Impostazioni
Settings for HR Module,Impostazioni per il modulo HR
"Settings to extract Job Applicants from a mailbox e.g. ""jobs@example.com""",Impostazioni per estrarre richiedenti lavoro di una casella di posta ad esempio &quot;jobs@example.com&quot;
Setup,Setup
Setup Already Complete!!,Setup già completo !
Setup Complete,installazione completa
Setup SMS gateway settings,Impostazioni del gateway configurazione di SMS
Setup Series,Serie Setup
Setup Wizard,Setup Wizard
Setup incoming server for jobs email id. (e.g. jobs@example.com),Configurazione del server in arrivo per i lavori di id-mail . ( ad esempio jobs@example.com )
Setup incoming server for sales email id. (e.g. sales@example.com),Configurazione del server per la posta elettronica in entrata vendite id . ( ad esempio sales@example.com )
Setup incoming server for support email id. (e.g. support@example.com),Configurazione del server in arrivo per il supporto e-mail id . ( ad esempio support@example.com )
Share,Condividi
Share With,Condividi
Shareholders Funds,azionisti Fondi
Shipments to customers.,Le spedizioni verso i clienti.
Shipping,Spedizione
Shipping Account,Account Spedizione
Shipping Address,Indirizzo di spedizione
Shipping Amount,Importo spedizione
Shipping Rule,Spedizione Rule
Shipping Rule Condition,Spedizione Regola Condizioni
Shipping Rule Conditions,Spedizione condizioni regola
Shipping Rule Label,Spedizione Etichetta Regola
Shop,Negozio
Shopping Cart,Carrello spesa
Short biography for website and other publications.,Breve biografia per il sito web e altre pubblicazioni.
"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",Mostra &quot;Disponibile&quot; o &quot;Non disponibile&quot; sulla base di scorte disponibili in questo magazzino.
"Show / Hide features like Serial Nos, POS etc.","Mostra / Nascondi caratteristiche come Serial Nos, POS ecc"
Show In Website,Mostra Nel Sito
Show a slideshow at the top of the page,Visualizzare una presentazione in cima alla pagina
Show in Website,Mostra nel Sito
Show rows with zero values,Mostra righe con valori pari a zero
Show this slideshow at the top of the page,Mostra questo slideshow in cima alla pagina
Sick Leave,Sick Leave
Signature,Firma
Signature to be appended at the end of every email,Firma da aggiungere alla fine di ogni e-mail
Single,Singolo
Single unit of an Item.,Unità singola di un articolo.
Sit tight while your system is being setup. This may take a few moments.,Tenere duro mentre il sistema è in corso di installazione . Questa operazione potrebbe richiedere alcuni minuti .
Slideshow,Slideshow
Soap & Detergent,Soap & Detergente
Software,software
Software Developer,Software Developer
"Sorry, Serial Nos cannot be merged","Siamo spiacenti , Serial Nos non può essere fusa"
"Sorry, companies cannot be merged","Siamo spiacenti , le aziende non possono essere unite"
Source,Fonte
Source File,File di origine
Source Warehouse,Fonte Warehouse
Source and target warehouse cannot be same for row {0},Origine e magazzino target non possono essere uguali per riga {0}
Source of Funds (Liabilities),Fonte di Fondi ( Passivo )
Source warehouse is mandatory for row {0},Magazzino Source è obbligatorio per riga {0}
Spartan,Spartan
"Special Characters except ""-"" and ""/"" not allowed in naming series","Caratteri speciali tranne "" - "" e "" / "" non ammessi nella denominazione serie"
Specification Details,Specifiche Dettagli
Specifications,specificazioni
"Specify a list of Territories, for which, this Price List is valid","Specifica una lista di territori, per il quale, questo listino prezzi è valido"
"Specify a list of Territories, for which, this Shipping Rule is valid","Specifica una lista di territori, per la quale, questa regola di trasporto è valido"
"Specify a list of Territories, for which, this Taxes Master is valid","Specifica una lista di territori, per il quale, questo Tasse Master è valido"
"Specify the operations, operating cost and give a unique Operation no to your operations.","Specificare le operazioni, costi operativi e dare una gestione unica di no a vostre operazioni."
Split Delivery Note into packages.,Split di consegna Nota in pacchetti.
Sports,sportivo
Sr,Sr
Standard,Standard
Standard Buying,Comprare standard
Standard Reports,Rapporti standard
Standard Selling,Selling standard
Standard contract terms for Sales or Purchase.,Condizioni contrattuali standard per la vendita o di acquisto.
Start,Inizio
Start Date,Data di inizio
Start date of current invoice's period,Data finale del periodo di fatturazione corrente Avviare
Start date should be less than end date for Item {0},Data di inizio dovrebbe essere inferiore a quella di fine per la voce {0}
State,Stato
Statement of Account,Estratto conto
Static Parameters,Parametri statici
Status,Stato
Status must be one of {0},Stato deve essere uno dei {0}
Status of {0} {1} is now {2},Stato di {0} {1} ora è {2}
Status updated to {0},Stato aggiornato per {0}
Statutory info and other general information about your Supplier,Sindaco informazioni e altre informazioni generali sulla tua Fornitore
Stay Updated,Rimani aggiornato
Stock,Azione
Stock Adjustment,Regolazione della
Stock Adjustment Account,Conto di regolazione Archivio
Stock Ageing,Invecchiamento Archivio
Stock Analytics,Analytics Archivio
Stock Assets,Attivo Immagini
Stock Balance,Archivio Balance
Stock Entries already created for Production Order ,
Stock Entry,Archivio Entry
Stock Entry Detail,Dell&#39;entrata Stock Detail
Stock Expenses,Spese Immagini
Stock Frozen Upto,Archivio Congelati Fino
Stock Ledger,Ledger Archivio
Stock Ledger Entry,Ledger Archivio Entry
Stock Ledger entries balances updated,Ledger Archivio voci saldi aggiornati
Stock Level,Stock Level
Stock Liabilities,Passività Immagini
Stock Projected Qty,Disponibile Qtà proiettata
Stock Queue (FIFO),Coda Archivio (FIFO)
Stock Received But Not Billed,Archivio ricevuti ma non Fatturati
Stock Reconcilation Data,Riconciliazione Archivio dati
Stock Reconcilation Template,Riconciliazione Archivio Template
Stock Reconciliation,Riconciliazione Archivio
"Stock Reconciliation can be used to update the stock on a particular date, usually as per physical inventory.","Riconciliazione Stock può essere utilizzato per aggiornare il titolo in una data particolare , di solito come da inventario fisico ."
Stock Settings,Impostazioni immagini
Stock UOM,UOM Archivio
Stock UOM Replace Utility,Archivio UOM Replace Utility
Stock UOM updatd for Item {0},Archivio UOM updatd per la voce {0}
Stock Uom,UOM Archivio
Stock Value,Archivio Valore
Stock Value Difference,Valore Archivio Differenza
Stock balances updated,Saldi archivi aggiornati
Stock cannot be updated against Delivery Note {0},Stock non può essere aggiornata contro Consegna Nota {0}
Stock entries exist against warehouse {0} cannot re-assign or modify 'Master Name',Esistono le entrate nelle scorte di magazzino contro {0} non può ri- assegnare o modificare 'Master Nome'
Stock transactions before {0} are frozen,Operazioni azione prima {0} sono congelati
Stop,Arresto
Stop Birthday Reminders,Arresto Compleanno Promemoria
Stop Material Request,Arresto Materiale Richiesta
Stop users from making Leave Applications on following days.,Impedire agli utenti di effettuare Lascia le applicazioni in giorni successivi.
Stop!,Stop!
Stopped,Arrestato
Stopped order cannot be cancelled. Unstop to cancel.,Arrestato ordine non può essere cancellato . Stappare per annullare.
Stores,negozi
Stub,mozzicone
Sub Assemblies,sub Assemblies
"Sub-currency. For e.g. ""Cent""","Sub-valuta. Per esempio, &quot;Cent&quot;"
Subcontract,Subappaltare
Subject,Soggetto
Submit Salary Slip,Invia Stipendio slittamento
Submit all salary slips for the above selected criteria,Inviare tutti i fogli paga per i criteri sopra selezionati
Submit this Production Order for further processing.,Invia questo ordine di produzione per l'ulteriore elaborazione .
Submitted,Inserito
Subsidiary,Sussidiario
Successful: ,Successo:
Successfully Reconciled,Riconciliati con successo
Suggestions,Suggerimenti
Sunday,Domenica
Supplier,Fornitore
Supplier (Payable) Account,Fornitore (da pagare) Conto
Supplier (vendor) name as entered in supplier master,Nome del fornitore (venditore) come è entrato in master fornitore
Supplier > Supplier Type,Fornitore> Fornitore Tipo
Supplier Account Head,Fornitore Account testa
Supplier Address,Fornitore Indirizzo
Supplier Addresses and Contacts,Indirizzi e contatti Fornitore
Supplier Details,Fornitore Dettagli
Supplier Intro,Intro Fornitore
Supplier Invoice Date,Fornitore Data fattura
Supplier Invoice No,Fornitore fattura n
Supplier Name,Nome fornitore
Supplier Naming By,Fornitore di denominazione
Supplier Part Number,Numero di parte del fornitore
Supplier Quotation,Quotazione Fornitore
Supplier Quotation Item,Fornitore Quotazione articolo
Supplier Reference,Fornitore di riferimento
Supplier Type,Tipo Fornitore
Supplier Type / Supplier,Fornitore Tipo / fornitore
Supplier Type master.,Fornitore Tipo master.
Supplier Warehouse,Magazzino Fornitore
Supplier Warehouse mandatory for sub-contracted Purchase Receipt,Magazzino Fornitore obbligatorio per subappaltato ricevuta d'acquisto
Supplier database.,Banca dati dei fornitori.
Supplier master.,Maestro del fornitore .
Supplier warehouse where you have issued raw materials for sub - contracting,Magazzino del fornitore in cui è stato rilasciato materie prime per la sub - contraente
Supplier-Wise Sales Analytics,Fornitore - Wise vendita Analytics
Support,Sostenere
Support Analtyics,Analtyics supporto
Support Analytics,Analytics Support
Support Email,Supporto Email
Support Email Settings,Supporto Impostazioni e-mail
Support Password,Supporto password
Support Ticket,Support Ticket
Support queries from customers.,Supportare le query da parte dei clienti.
Symbol,Simbolo
Sync Support Mails,Sincronizza mail di sostegno
Sync with Dropbox,Sincronizzazione con Dropbox
Sync with Google Drive,Sincronizzazione con Google Drive
System,Sistema
System Settings,Impostazioni di sistema
"System User (login) ID. If set, it will become default for all HR forms.","Utente di sistema (login) ID. Se impostato, esso diventerà di default per tutti i moduli HR."
TDS (Advertisement),TDS (Pubblicità)
TDS (Commission),TDS (Commissione)
TDS (Contractor),TDS (Contractor)
TDS (Interest),TDS (Interest)
TDS (Rent),TDS (Affitto)
TDS (Salary),TDS (Salario)
Target  Amount,L&#39;importo previsto
Target Detail,Obiettivo Particolare
Target Details,Dettagli di destinazione
Target Details1,Obiettivo Dettagli1
Target Distribution,Distribuzione di destinazione
Target On,obiettivo On
Target Qty,Obiettivo Qtà
Target Warehouse,Obiettivo Warehouse
Target warehouse in row {0} must be same as Production Order,Magazzino Target in riga {0} deve essere uguale ordine di produzione
Target warehouse is mandatory for row {0},Magazzino di destinazione è obbligatoria per riga {0}
Task,Task
Task Details,Attività Dettagli
Tasks,compiti
Tax,Tax
Tax Amount After Discount Amount,Fiscale Ammontare Dopo Sconto Importo
Tax Assets,Attività fiscali
Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,"Tasse categoria non può essere ' valutazione ' o ' di valutazione e Total ', come tutti gli articoli sono elementi non-azione"
Tax Rate,Aliquota fiscale
Tax and other salary deductions.,Fiscale e di altre deduzioni salariali.
"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","Tabella di dettaglio fiscale prelevato dalla voce principale come una stringa e memorizzato in questo campo.
 Usato per imposte e oneri"
Tax template for buying transactions.,Modello fiscale per l'acquisto di transazioni.
Tax template for selling transactions.,Modello fiscale per la vendita di transazioni.
Taxable,Imponibile
Taxes,Tassazione.
Taxes and Charges,Tasse e Costi
Taxes and Charges Added,Tasse e spese aggiuntive
Taxes and Charges Added (Company Currency),Tasse e spese aggiuntive (Azienda valuta)
Taxes and Charges Calculation,Tasse e le spese di calcolo
Taxes and Charges Deducted,Tasse e oneri dedotti
Taxes and Charges Deducted (Company Currency),Tasse e oneri dedotti (Azienda valuta)
Taxes and Charges Total,Tasse e oneri Totale
Taxes and Charges Total (Company Currency),Tasse e oneri Totale (Azienda valuta)
Technology,tecnologia
Telecommunications,Telecomunicazioni
Telephone Expenses,spese telefoniche
Television,televisione
Template,Modelli
Template for performance appraisals.,Modello per la valutazione delle prestazioni .
Template of terms or contract.,Template di termini o di contratto.
Temporary Accounts (Assets),Conti temporanee ( Assets )
Temporary Accounts (Liabilities),Conti temporanee ( Passivo )
Temporary Assets,Le attività temporanee
Temporary Liabilities,Passivo temporanee
Term Details,Dettagli termine
Terms,condizioni
Terms and Conditions,Termini e Condizioni
Terms and Conditions Content,Termini e condizioni contenuti
Terms and Conditions Details,Termini e condizioni dettagli
Terms and Conditions Template,Termini e condizioni Template
Terms and Conditions1,Termini e Condizioni 1
Terretory,Terretory
Territory,Territorio
Territory / Customer,Territorio / clienti
Territory Manager,Territory Manager
Territory Name,Territorio Nome
Territory Target Variance Item Group-Wise,Territorio di destinazione Varianza articolo Group- Wise
Territory Targets,Obiettivi Territorio
Test,Prova
Test Email Id,Prova Email Id
Test the Newsletter,Provare la Newsletter
The BOM which will be replaced,La distinta base che sarà sostituito
The First User: You,Il primo utente : è
"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",L&#39;articolo che rappresenta il pacchetto. Questo elemento deve avere &quot;è Stock Item&quot; come &quot;No&quot; e &quot;Is Voce di vendita&quot; come &quot;Yes&quot;
The Organization,l'Organizzazione
"The account head under Liability, in which Profit/Loss will be booked","La testa account con responsabilità, in cui sarà prenotato Utile / Perdita"
"The date on which next invoice will be generated. It is generated on submit.
","La data in cui verrà generato prossima fattura. Viene generato su Invia.
"
The date on which recurring invoice will be stop,La data in cui fattura ricorrente sarà ferma
"The day of the month on which auto invoice will be generated e.g. 05, 28 etc ","Il giorno del mese in cui verrà generato fattura auto ad esempio 05, 28, ecc"
The day(s) on which you are applying for leave are holiday. You need not apply for leave.,Il giorno ( s ) in cui si stanno applicando per ferie sono vacanze . Non c'è bisogno di domanda per il congedo .
The first Leave Approver in the list will be set as the default Leave Approver,Lascia il primo responsabile approvazione della lista sarà impostato come predefinito Lascia Approver
The first user will become the System Manager (you can change that later).,Il primo utente diventerà il System Manager ( si può cambiare in seguito ) .
The gross weight of the package. Usually net weight + packaging material weight. (for print),Il peso lordo del pacchetto. Di solito peso netto + peso materiale di imballaggio. (Per la stampa)
The name of your company for which you are setting up this system.,Il nome della vostra azienda per la quale si sta configurando questo sistema.
The net weight of this package. (calculated automatically as sum of net weight of items),Il peso netto di questo pacchetto. (Calcolato automaticamente come somma del peso netto delle partite)
The new BOM after replacement,Il nuovo BOM dopo la sostituzione
The rate at which Bill Currency is converted into company's base currency,La velocità con cui Bill valuta viene convertita in valuta di base dell&#39;azienda
The unique id for tracking all recurring invoices. It is generated on submit.,L&#39;ID univoco per il monitoraggio tutte le fatture ricorrenti. Si è generato su submit.
"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.","Poi Regole dei prezzi vengono filtrati in base a cliente, Gruppo Cliente, Territorio, Fornitore, Fornitore Tipo, Campagna, Partner di vendita ecc"
There are more holidays than working days this month.,Ci sono più feste di giorni di lavoro di questo mese .
"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""","Ci può essere una sola regola spedizione Circostanza con 0 o il valore vuoto per "" To Value """
There is not enough leave balance for Leave Type {0},Non c'è equilibrio congedo sufficiente per Leave tipo {0}
There is nothing to edit.,Non c'è nulla da modificare.
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.,Si è verificato un errore . Una ragione probabile potrebbe essere che non si è salvato il modulo. Si prega di contattare support@erpnext.com se il problema persiste .
There were errors.,Ci sono stati degli errori .
This Currency is disabled. Enable to use in transactions,Questa valuta è disabilitata . Attiva da utilizzare nelle transazioni
This Leave Application is pending approval. Only the Leave Apporver can update status.,Questo Lascia applicazione è in attesa di approvazione . Solo l' Lascia Apporver può aggiornare lo stato .
This Time Log Batch has been billed.,Questo Log Batch Ora è stato fatturato.
This Time Log Batch has been cancelled.,Questo Log Batch Ora è stato annullato.
This Time Log conflicts with {0},This Time Log in conflitto con {0}
This format is used if country specific format is not found,Questo formato viene utilizzato se il formato specifico per il Paese non viene trovata
This is a root account and cannot be edited.,Questo è un account di root e non può essere modificato .
This is a root customer group and cannot be edited.,Si tratta di un gruppo di clienti root e non può essere modificato .
This is a root item group and cannot be edited.,Questo è un gruppo elemento principale e non può essere modificato .
This is a root sales person and cannot be edited.,Si tratta di una persona di vendita di root e non può essere modificato .
This is a root territory and cannot be edited.,Questo è un territorio root e non può essere modificato .
This is an example website auto-generated from ERPNext,Questo è un sito esempio generata automaticamente da ERPNext
This is the number of the last created transaction with this prefix,Questo è il numero dell&#39;ultimo transazione creata con questo prefisso
This will be used for setting rule in HR module,Questo verrà utilizzato per regola impostazione nel modulo HR
Thread HTML,HTML Discussione
Thursday,Giovedi
Time Log,Tempo di Log
Time Log Batch,Tempo Log Batch
Time Log Batch Detail,Ora Dettaglio Batch Log
Time Log Batch Details,Tempo Log Dettagli batch
Time Log Batch {0} must be 'Submitted',Tempo Log Lotto {0} deve essere ' inoltrata '
Time Log Status must be Submitted.,Tempo Log Stato deve essere presentata.
Time Log for tasks.,Tempo di log per le attività.
Time Log is not billable,Il tempo log non è fatturabile
Time Log {0} must be 'Submitted',Tempo di log {0} deve essere ' inoltrata '
Time Zone,Time Zone
Time Zones,Time Zones
Time and Budget,Tempo e budget
Time at which items were delivered from warehouse,Ora in cui gli elementi sono stati consegnati dal magazzino
Time at which materials were received,Ora in cui sono stati ricevuti i materiali
Title,Titolo
Titles for print templates e.g. Proforma Invoice.,Titoli di modelli di stampa ad esempio Fattura Proforma .
To,A
To Currency,Per valuta
To Date,Di sesso
To Date should be same as From Date for Half Day leave,Per data deve essere lo stesso Dalla Data per il congedo mezza giornata
To Date should be within the Fiscal Year. Assuming To Date = {0},Per data deve essere entro l'anno fiscale. Assumendo A Data = {0}
To Discuss,Per Discutere
To Do List,To Do List
To Package No.,A Pacchetto no
To Produce,per produrre
To Time,Per Tempo
To Value,Per Valore
To Warehouse,A Magazzino
"To add child nodes, explore tree and click on the node under which you want to add more nodes.","Per aggiungere nodi figlio , esplorare albero e fare clic sul nodo in cui si desidera aggiungere più nodi ."
"To assign this issue, use the ""Assign"" button in the sidebar.","Per assegnare questo problema, utilizzare il pulsante &quot;Assegna&quot; nella barra laterale."
To create a Bank Account,Per creare un conto bancario
To create a Tax Account,Per creare un Account Tax
"To create an Account Head under a different company, select the company and save customer.","Per creare un account in testa una società diversa, selezionare l&#39;azienda e salvare cliente."
To date cannot be before from date,Fino ad oggi non può essere prima dalla data
To enable <b>Point of Sale</b> features,Per abilitare la funzionalità <b>Point of Sale</b>
To enable <b>Point of Sale</b> view,Per attivare <b> punto di vendita < / b > Vista
To get Item Group in details table,Per ottenere Gruppo di elementi in dettaglio tabella
"To include tax in row {0} in Item rate, taxes in rows {1} must also be included","Per includere fiscale in riga {0} in rate articolo , tasse nelle righe {1} devono essere inclusi"
"To merge, following properties must be same for both items","Per unire , seguenti proprietà devono essere uguali per entrambe le voci"
"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.","Per non applicare l'articolo Pricing in una determinata operazione, tutte le norme sui prezzi applicabili devono essere disabilitati."
"To set this Fiscal Year as Default, click on 'Set as Default'","Per impostare questo anno fiscale come predefinito , clicca su ' Imposta come predefinito'"
To track any installation or commissioning related work after sales,Per tenere traccia di alcuna installazione o messa in attività collegate post-vendita
"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","Per tenere traccia di marca nelle seguenti documenti di consegna Note , Opportunità , richiedere materiale , articolo , ordine di acquisto , Buono Acquisto , l'Acquirente Scontrino fiscale, preventivo , fattura di vendita , vendite BOM , ordini di vendita , Serial No"
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.,Per tenere traccia di voce in documenti di vendita e di acquisto in base alle loro n ° di serie. Questo è può anche usato per rintracciare informazioni sulla garanzia del prodotto.
To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,"Per tenere traccia di elementi in documenti di vendita e acquisto con nos lotti <br> <b>Industria preferita: Chimica, ecc</b>"
To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,Per tenere traccia di elementi con codice a barre. Si sarà in grado di inserire articoli nel DDT e fattura di vendita attraverso la scansione del codice a barre del prodotto.
Too many columns. Export the report and print it using a spreadsheet application.,Troppe colonne. Esportare il report e stamparlo utilizzando un foglio di calcolo.
Tools,Strumenti
Total,Totale
Total ({0}),Totale ({0})
Total Advance,Totale Advance
Total Amount,Totale Importo
Total Amount To Pay,Importo totale da pagare
Total Amount in Words,Importo totale in parole
Total Billing This Year: ,Fatturazione questo Anno:
Total Characters,Totale Personaggi
Total Claimed Amount,Totale importo richiesto
Total Commission,Commissione Totale
Total Cost,Costo totale
Total Credit,Totale credito
Total Debit,Debito totale
Total Debit must be equal to Total Credit. The difference is {0},Debito totale deve essere pari al totale credito .
Total Deduction,Deduzione totale
Total Earning,Guadagnare totale
Total Experience,Esperienza totale
Total Hours,Totale ore
Total Hours (Expected),Totale ore (prevista)
Total Invoiced Amount,Totale Importo fatturato
Total Leave Days,Totale Lascia Giorni
Total Leaves Allocated,Totale Foglie allocati
Total Message(s),Messaggio Total ( s )
Total Operating Cost,Totale costi di esercizio
Total Points,Totale Punti
Total Raw Material Cost,Raw Material Total Cost
Total Sanctioned Amount,Totale importo sanzionato
Total Score (Out of 5),Punteggio totale (i 5)
Total Tax (Company Currency),Totale IVA (Azienda valuta)
Total Taxes and Charges,Totale imposte e oneri
Total Taxes and Charges (Company Currency),Totale tasse e spese (Azienda valuta)
Total allocated percentage for sales team should be 100,Totale percentuale assegnato per il team di vendita dovrebbe essere di 100
Total amount of invoices received from suppliers during the digest period,Importo totale delle fatture ricevute dai fornitori durante il periodo di digest
Total amount of invoices sent to the customer during the digest period,Importo totale delle fatture inviate al cliente durante il periodo di digest
Total cannot be zero,Totale non può essere zero
Total in words,Totale in parole
Total points for all goals should be 100. It is {0},Punti totali per tutti gli obiettivi dovrebbero essere 100. È {0}
Total valuation for manufactured or repacked item(s) can not be less than total valuation of raw materials,Valutazione totale di fabbricati o nuovamente imballati item (s) non può essere inferiore al valore totale delle materie prime
Total weightage assigned should be 100%. It is {0},Weightage totale assegnato dovrebbe essere al 100 % . E ' {0}
Totals,Totali
Track Leads by Industry Type.,Pista Leads per settore Type.
Track this Delivery Note against any Project,Sottoscrivi questa bolla di consegna contro ogni progetto
Track this Sales Order against any Project,Traccia questo ordine di vendita nei confronti di qualsiasi progetto
Transaction,Transazioni
Transaction Date,Transaction Data
Transaction not allowed against stopped Production Order {0},Operazione non ammessi contro Production smesso di ordine {0}
Transfer,Trasferimento
Transfer Material,Material Transfer
Transfer Raw Materials,Trasferimento materie prime
Transferred Qty,Quantità trasferito
Transportation,Trasporti
Transporter Info,Info Transporter
Transporter Name,Trasportatore Nome
Transporter lorry number,Numero di camion Transporter
Travel,viaggi
Travel Expenses,Spese di viaggio
Tree Type,albero Type
Tree of Item Groups.,Albero di gruppi di articoli .
Tree of finanial Cost Centers.,Albero dei centri di costo finanial .
Tree of finanial accounts.,Albero dei conti finanial .
Trial Balance,Bilancio di verifica
Tuesday,Martedì
Type,Tipo
Type of document to rename.,Tipo di documento da rinominare.
"Type of leaves like casual, sick etc.","Tipo di foglie come casuale, malati ecc"
Types of Expense Claim.,Tipi di Nota Spese.
Types of activities for Time Sheets,Tipi di attività per i fogli Tempo
"Types of employment (permanent, contract, intern etc.).","Tipi di occupazione (permanente , contratti , ecc intern ) ."
UOM Conversion Detail,UOM Dettaglio di conversione
UOM Conversion Details,UM Dettagli di conversione
UOM Conversion Factor,Fattore di Conversione UOM
UOM Conversion factor is required in row {0},Fattore UOM conversione è necessaria in riga {0}
UOM Name,UOM Nome
UOM coversion factor required for UOM: {0} in Item: {1},Fattore coversion UOM richiesto per Confezionamento: {0} alla voce: {1}
Under AMC,Sotto AMC
Under Graduate,Sotto Laurea
Under Warranty,Sotto Garanzia
Unit,unità
Unit of Measure,Unità di misura
Unit of Measure {0} has been entered more than once in Conversion Factor Table,Unità di misura {0} è stato inserito più di una volta Factor Tabella di conversione
"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).","Unità di misura di questo oggetto (es. Kg, Unità, No, coppia)."
Units/Hour,Unità / Hour
Units/Shifts,Unità / turni
Unpaid,Non pagata
Unreconciled Payment Details,Non riconciliate Particolari di pagamento
Unscheduled,Non in programma
Unsecured Loans,I prestiti non garantiti
Unstop,stappare
Unstop Material Request,Stappare Materiale Richiesta
Unstop Purchase Order,Stappare Ordine di Acquisto
Unsubscribed,Sottoscritte
Update,Aggiornare
Update Clearance Date,Aggiornare Liquidazione Data
Update Cost,aggiornamento dei costi
Update Finished Goods,Merci aggiornamento finiti
Update Landed Cost,Aggiornamento Landed Cost
Update Series,Update
Update Series Number,Aggiornamento Numero di Serie
Update Stock,Aggiornare Archivio
Update bank payment dates with journals.,Risale aggiornamento versamento bancario con riviste.
Update clearance date of Journal Entries marked as 'Bank Vouchers',"Data di aggiornamento della respinta corta di voci di diario contrassegnato come "" Buoni Banca '"
Updated,Aggiornato
Updated Birthday Reminders,Aggiornato Compleanno Promemoria
Upload Attendance,Carica presenze
Upload Backups to Dropbox,Carica backup di Dropbox
Upload Backups to Google Drive,Carica backup di Google Drive
Upload HTML,Carica HTML
Upload a .csv file with two columns: the old name and the new name. Max 500 rows.,Carica un file csv con due colonne:. L&#39;antico nome e il nuovo nome. Max 500 righe.
Upload attendance from a .csv file,Carica presenze da un file. Csv
Upload stock balance via csv.,Carica equilibrio magazzino tramite csv.
Upload your letter head and logo - you can edit them later.,Carica la tua testa lettera e logo - è possibile modificare in un secondo momento .
Upper Income,Reddito superiore
Urgent,Urgente
Use Multi-Level BOM,Utilizzare BOM Multi-Level
Use SSL,Usa SSL
Used for Production Plan,Usato per Piano di Produzione
User,Utente
User ID,ID utente
User ID not set for Employee {0},ID utente non è impostato per Employee {0}
User Name,Nome Utente
User Name or Support Password missing. Please enter and try again.,Nome utente o password mancanti Support . Inserisci e riprovare.
User Remark,Osservazioni utenti
User Remark will be added to Auto Remark,Osservazioni utente verrà aggiunto al Remark Auto
User Remarks is mandatory,Utente Note è obbligatorio
User Specific,specifiche dell'utente
User must always select,L&#39;utente deve sempre selezionare
User {0} is already assigned to Employee {1},Utente {0} è già assegnato a Employee {1}
User {0} is disabled,Utente {0} è disattivato
Username,Nome utente
Users with this role are allowed to create / modify accounting entry before frozen date,Gli utenti con questo ruolo possono creare / modificare registrazione contabile prima della data congelati
Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,Gli utenti con questo ruolo sono autorizzati a impostare conti congelati e creare / modificare le voci contabili nei confronti di conti congelati
Utilities,Utilità
Utility Expenses,Spese Utility
Valid For Territories,Valido per i territori
Valid From,valido dal
Valid Upto,Valido Fino
Valid for Territories,Valido per Territori
Validate,Convalida
Valuation,Valorizzazione
Valuation Method,Metodo di valutazione
Valuation Rate,Valorizzazione Vota
Valuation Rate required for Item {0},Tasso di valutazione richiesti per la voce {0}
Valuation and Total,Valutazione e Total
Value,Valore
Value or Qty,Valore o Quantità
Vehicle Dispatch Date,Veicolo Spedizione Data
Vehicle No,Veicolo No
Venture Capital,capitale a rischio
Verified By,Verificato da
View Ledger,vista Ledger
View Now,Guarda ora
Visit report for maintenance call.,Visita rapporto per chiamata di manutenzione.
Voucher #,Voucher #
Voucher Detail No,Voucher Detail No
Voucher Detail Number,Voucher Number Dettaglio
Voucher ID,ID Voucher
Voucher No,Voucher No
Voucher Type,Voucher Tipo
Voucher Type and Date,Tipo di Voucher e Data
Walk In,Walk In
Warehouse,magazzino
Warehouse Contact Info,Magazzino contatto
Warehouse Detail,Magazzino Dettaglio
Warehouse Name,Magazzino Nome
Warehouse and Reference,Magazzino e di riferimento
Warehouse can not be deleted as stock ledger entry exists for this warehouse.,Warehouse non può essere eliminato come esiste iscrizione libro soci per questo magazzino .
Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,Warehouse può essere modificato solo tramite dell&#39;entrata Stock / DDT / ricevuta di acquisto
Warehouse cannot be changed for Serial No.,Magazzino non può essere modificato per Serial No.
Warehouse is mandatory for stock Item {0} in row {1},Warehouse è obbligatorio per magazzino Voce {0} in riga {1}
Warehouse is missing in Purchase Order,Warehouse manca in ordine d'acquisto
Warehouse not found in the system,Warehouse non trovato nel sistema
Warehouse required for stock Item {0},Magazzino richiesto per magazzino Voce {0}
Warehouse where you are maintaining stock of rejected items,Magazzino dove si sta mantenendo magazzino di articoli rifiutati
Warehouse {0} can not be deleted as quantity exists for Item {1},Warehouse {0} non può essere soppresso in quanto esiste la quantità per articolo {1}
Warehouse {0} does not belong to company {1},Warehouse {0} non appartiene a società {1}
Warehouse {0} does not exist,Warehouse {0} non esiste
Warehouse {0}: Company is mandatory,Warehouse {0}: Società è obbligatoria
Warehouse {0}: Parent account {1} does not bolong to the company {2},Warehouse {0}: conto Parent {1} non Bolong alla società {2}
Warehouse-Wise Stock Balance,Magazzino-saggio Stock Balance
Warehouse-wise Item Reorder,Magazzino-saggio Voce riordino
Warehouses,Magazzini
Warehouses.,Magazzini .
Warn,Avvisa
Warning: Leave application contains following block dates,Attenzione: Lascia applicazione contiene seguenti date di blocco
Warning: Material Requested Qty is less than Minimum Order Qty,Attenzione : Materiale Qty richiesto è inferiore minima quantità
Warning: Sales Order {0} already exists against same Purchase Order number,Attenzione : Sales Order {0} esiste già contro lo stesso numero di ordine di acquisto
Warning: System will not check overbilling since amount for Item {0} in {1} is zero,Attenzione : Il sistema non controlla fatturazione eccessiva poiché importo per la voce {0} in {1} è zero
Warranty / AMC Details,Garanzia / AMC Dettagli
Warranty / AMC Status,Garanzia / AMC Stato
Warranty Expiry Date,Garanzia Data di scadenza
Warranty Period (Days),Periodo di garanzia (Giorni)
Warranty Period (in days),Periodo di garanzia (in giorni)
We buy this Item,Compriamo questo articolo
We sell this Item,Vendiamo questo articolo
Website,Sito
Website Description,Descrizione del sito
Website Item Group,Sito Gruppo Articolo
Website Item Groups,Sito gruppi di articoli
Website Settings,Impostazioni Sito
Website Warehouse,Magazzino sito web
Wednesday,Mercoledì
Weekly,Settimanale
Weekly Off,Settimanale Off
Weight UOM,Peso UOM
"Weight is mentioned,\nPlease mention ""Weight UOM"" too","Il peso è detto, \ nPer favore citare "" Peso UOM "" troppo"
Weightage,Weightage
Weightage (%),Weightage (%)
Welcome,benvenuto
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!,"Benvenuti a ERPNext . Nel corso dei prossimi minuti vi aiuteremo a configurare il tuo account ERPNext . Prova a inserire quante più informazioni si hanno , anche se ci vuole un po 'di più . Ti farà risparmiare un sacco di tempo dopo . Buona fortuna !"
Welcome to ERPNext. Please select your language to begin the Setup Wizard.,Benvenuti a ERPNext . Si prega di selezionare la lingua per avviare l'installazione guidata .
What does it do?,Che cosa fa ?
"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.","Quando una qualsiasi delle operazioni controllate sono &quot;inviati&quot;, una e-mail a comparsa visualizzata automaticamente per inviare una e-mail agli associati &quot;Contatto&quot; in tale operazione, con la transazione come allegato. L&#39;utente può o non può inviare l&#39;e-mail."
"When submitted, the system creates difference entries to set the given stock and valuation on this date.","Quando presentata , il sistema crea le voci di differenza per impostare il magazzino e valutazione data in questa data ."
Where items are stored.,Dove gli elementi vengono memorizzati.
Where manufacturing operations are carried out.,Qualora le operazioni di produzione sono effettuate.
Widowed,Vedovo
Will be calculated automatically when you enter the details,Vengono calcolati automaticamente quando si entra nei dettagli
Will be updated after Sales Invoice is Submitted.,Saranno aggiornate dopo fattura di vendita sia presentata.
Will be updated when batched.,Verrà aggiornato quando dosati.
Will be updated when billed.,Verrà aggiornato quando fatturati.
Wire Transfer,Bonifico bancario
With Operations,Con operazioni
With Period Closing Entry,Con Entry periodo di chiusura
Work Details,Dettagli lavoro
Work Done,Attività svolta
Work In Progress,Work In Progress
Work-in-Progress Warehouse,Work-in-Progress Warehouse
Work-in-Progress Warehouse is required before Submit,Work- in- Progress Warehouse è necessario prima Submit
Working,Lavoro
Working Days,Giorni lavorativi
Workstation,Stazione di lavoro
Workstation Name,Nome workstation
Write Off Account,Scrivi Off account
Write Off Amount,Scrivi Off Importo
Write Off Amount <=,Scrivi Off Importo &lt;=
Write Off Based On,Scrivi Off Basato Su
Write Off Cost Center,Scrivi Off Centro di costo
Write Off Outstanding Amount,Scrivi Off eccezionale Importo
Write Off Voucher,Scrivi Off Voucher
Wrong Template: Unable to find head row.,Template Sbagliato: Impossibile trovare la linea di testa.
Year,Anno
Year Closed,Anno Chiuso
Year End Date,Data di Fine Anno
Year Name,Anno Nome
Year Start Date,Anno Data di inizio
Year of Passing,Anni dal superamento
Yearly,Annuale
Yes,Sì
You are not authorized to add or update entries before {0},Non sei autorizzato a aggiungere o aggiornare le voci prima di {0}
You are not authorized to set Frozen value,Non sei autorizzato a impostare il valore Congelato
You are the Expense Approver for this record. Please Update the 'Status' and Save,Tu sei il Responsabile approvazione di spesa per questo record . Si prega di aggiornare il 'Stato' e Save
You are the Leave Approver for this record. Please Update the 'Status' and Save,Tu sei il Lascia Responsabile approvazione per questo record . Si prega di aggiornare il 'Stato' e Save
You can enter any date manually,È possibile immettere qualsiasi data manualmente
You can enter the minimum quantity of this item to be ordered.,È possibile inserire la quantità minima di questo oggetto da ordinare.
You can not change rate if BOM mentioned agianst any item,Non è possibile modificare tariffa se BOM menzionato agianst tutto l'articolo
You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,Non è possibile inserire sia Consegna Nota n e Fattura n Inserisci nessuno.
You can not enter current voucher in 'Against Journal Voucher' column,Non è possibile immettere voucher di corrente in ' Contro ufficiale Voucher ' colonna
You can set Default Bank Account in Company master,È possibile impostare di default conto bancario in master Società
You can start by selecting backup frequency and granting access for sync,È possibile avviare selezionando la frequenza di backup e di concedere l'accesso per la sincronizzazione
You can submit this Stock Reconciliation.,Puoi inviare questo Archivio Riconciliazione.
You can update either Quantity or Valuation Rate or both.,È possibile aggiornare sia Quantitativo o Tasso di valutazione o di entrambi .
You cannot credit and debit same account at the same time,"Non si può di credito e debito stesso conto , allo stesso tempo"
You have entered duplicate items. Please rectify and try again.,Hai inserito gli elementi duplicati . Si prega di correggere e riprovare .
You may need to update: {0},Potrebbe essere necessario aggiornare : {0}
You must Save the form before proceeding,È necessario Salvare il modulo prima di procedere
Your Customer's TAX registration numbers (if applicable) or any general information,FISCALI numeri di registrazione del vostro cliente (se applicabile) o qualsiasi informazione generale
Your Customers,I vostri clienti
Your Login Id,Il tuo ID di accesso
Your Products or Services,I vostri prodotti o servizi
Your Suppliers,I vostri fornitori
Your email address,Il tuo indirizzo email
Your financial year begins on,Il tuo anno finanziario comincia
Your financial year ends on,Il tuo anno finanziario termina il
Your sales person who will contact the customer in future,Il vostro agente di commercio che si metterà in contatto il cliente in futuro
Your sales person will get a reminder on this date to contact the customer,Il rivenditore avrà un ricordo in questa data per contattare il cliente
Your setup is complete. Refreshing...,La configurazione è completa. Rinfrescante ...
Your support email id - must be a valid email - this is where your emails will come!,Il vostro supporto e-mail id - deve essere un indirizzo email valido - questo è dove i vostri messaggi di posta elettronica verranno!
[Error],[Error]
[Select],[Seleziona ]
`Freeze Stocks Older Than` should be smaller than %d days.,` Stocks Blocca Anziani Than ` dovrebbero essere inferiori % d giorni .
and,e
are not allowed.,non sono ammessi .
assigned by,assegnato da
cannot be greater than 100,non può essere superiore a 100
"e.g. ""Build tools for builders""","ad esempio "" Costruire strumenti per i costruttori """
"e.g. ""MC""","ad esempio "" MC """
"e.g. ""My Company LLC""","ad esempio ""My Company LLC """
e.g. 5,ad esempio 5
"e.g. Bank, Cash, Credit Card","per esempio bancario, contanti, carta di credito"
"e.g. Kg, Unit, Nos, m","ad esempio Kg, unità, nn, m"
e.g. VAT,ad esempio IVA
eg. Cheque Number,ad es. Numero Assegno
example: Next Day Shipping,esempio: Next Day spedizione
lft,LFT
old_parent,old_parent
rgt,rgt
subject,soggetto
to,a
website page link,sito web link alla pagina
{0} '{1}' not in Fiscal Year {2},{0} ' {1}' non in Fiscal Year {2}
{0} Credit limit {0} crossed,{0} Limite di credito {0} attraversato
{0} Serial Numbers required for Item {0}. Only {0} provided.,{0} numeri di serie necessari per la voce {0} . Solo {0} disponibile .
{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0} budget per conto {1} contro il centro di costo {2} supererà da {3}
{0} can not be negative,{0} non può essere negativo
{0} created,{0} creato
{0} does not belong to Company {1},{0} non appartiene alla società {1}
{0} entered twice in Item Tax,{0} entrato due volte in Tax articolo
{0} is an invalid email address in 'Notification Email Address',{0} è un indirizzo email valido in ' Notifica Indirizzo e-mail '
{0} is mandatory,{0} è obbligatoria
{0} is mandatory for Item {1},{0} è obbligatorio per la voce {1}
{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0} è obbligatoria. Forse record di cambio di valuta non è stato creato per {1} {2}.
{0} is not a stock Item,{0} non è un articolo di
{0} is not a valid Batch Number for Item {1},{0} non è un valido numero di lotto per la voce {1}
{0} is not a valid Leave Approver. Removing row #{1}.,{0} non è un valido Leave approvazione. Rimozione di fila # {1}.
{0} is not a valid email id,{0} non è un id e-mail valido
{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0} ora è l'impostazione predefinita anno fiscale . Si prega di aggiornare il browser per la modifica abbia effetto .
{0} is required,{0} è richiesto
{0} must be a Purchased or Sub-Contracted Item in row {1},{0} deve essere un articolo acquistato o in subappalto in riga {1}
{0} must be reduced by {1} or you should increase overflow tolerance,{0} deve essere ridotto di {1} o si dovrebbe aumentare la tolleranza di overflow
{0} must have role 'Leave Approver',{0} deve avere ruolo di ' Lascia Approvatore '
{0} valid serial nos for Item {1},{0} nos seriali validi per Voce {1}
{0} {1} against Bill {2} dated {3},{0} {1} contro Bill {2} del {3}
{0} {1} against Invoice {2},{0} {1} contro fattura {2}
{0} {1} has already been submitted,{0} {1} è già stata presentata
{0} {1} has been modified. Please refresh.,{0} {1} è stato modificato . Si prega di aggiornare .
{0} {1} is not submitted,{0} {1} non è presentata
{0} {1} must be submitted,{0} {1} deve essere presentato
{0} {1} not in any Fiscal Year,{0} {1} non è in alcun dell'anno fiscale
{0} {1} status is 'Stopped',{0} {1} stato è ' Arrestato '
{0} {1} status is Stopped,{0} {1} stato è Interrotto
{0} {1} status is Unstopped,{0} {1} stato è unstopped
{0} {1}: Cost Center is mandatory for Item {2},{0} {1}: centro di costo è obbligatoria per la voce {2}
{0}: {1} not found in Invoice Details table,{0}: {1} non trovato in fattura tabella Dettagli
